BaseTools: Fixed BuildOptions bug.

[mirror_edk2.git] / BaseTools / Source / Python / Workspace / WorkspaceDatabase.py

## @file\r
# This file is used to create a database used by build tool\r
#\r
# Copyright (c) 2008 - 2015, Intel Corporation. All rights reserved.<BR>\r
# This program and the accompanying materials\r
# are licensed and made available under the terms and conditions of the BSD License\r
# which accompanies this distribution.  The full text of the license may be found at\r
# http://opensource.org/licenses/bsd-license.php\r
#\r
# THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,\r
# WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.\r
#\r
\r
##\r
# Import Modules\r
#\r
import sqlite3\r
import Common.LongFilePathOs as os\r
import pickle\r
import uuid\r
\r
import Common.EdkLogger as EdkLogger\r
import Common.GlobalData as GlobalData\r
\r
from Common.String import *\r
from Common.DataType import *\r
from Common.Misc import *\r
from types import *\r
\r
from CommonDataClass.CommonClass import SkuInfoClass\r
\r
from MetaDataTable import *\r
from MetaFileTable import *\r
from MetaFileParser import *\r
from BuildClassObject import *\r
from WorkspaceCommon import GetDeclaredPcd\r
from Common.Misc import AnalyzeDscPcd\r
from Common.Misc import ProcessDuplicatedInf\r
import re\r
from Common.Parsing import IsValidWord\r
from Common.VariableAttributes import VariableAttributes\r
import Common.GlobalData as GlobalData\r
\r
## Platform build information from DSC file\r
#\r
#  This class is used to retrieve information stored in database and convert them\r
# into PlatformBuildClassObject form for easier use for AutoGen.\r
#\r
class DscBuildData(PlatformBuildClassObject):\r
    # dict used to convert PCD type in database to string used by build tool\r
    _PCD_TYPE_STRING_ = {\r
        MODEL_PCD_FIXED_AT_BUILD        :   "FixedAtBuild",\r
        MODEL_PCD_PATCHABLE_IN_MODULE   :   "PatchableInModule",\r
        MODEL_PCD_FEATURE_FLAG          :   "FeatureFlag",\r
        MODEL_PCD_DYNAMIC               :   "Dynamic",\r
        MODEL_PCD_DYNAMIC_DEFAULT       :   "Dynamic",\r
        MODEL_PCD_DYNAMIC_HII           :   "DynamicHii",\r
        MODEL_PCD_DYNAMIC_VPD           :   "DynamicVpd",\r
        MODEL_PCD_DYNAMIC_EX            :   "DynamicEx",\r
        MODEL_PCD_DYNAMIC_EX_DEFAULT    :   "DynamicEx",\r
        MODEL_PCD_DYNAMIC_EX_HII        :   "DynamicExHii",\r
        MODEL_PCD_DYNAMIC_EX_VPD        :   "DynamicExVpd",\r
    }\r
\r
    # dict used to convert part of [Defines] to members of DscBuildData directly\r
    _PROPERTY_ = {\r
        #\r
        # Required Fields\r
        #\r
        TAB_DSC_DEFINES_PLATFORM_NAME           :   "_PlatformName",\r
        TAB_DSC_DEFINES_PLATFORM_GUID           :   "_Guid",\r
        TAB_DSC_DEFINES_PLATFORM_VERSION        :   "_Version",\r
        TAB_DSC_DEFINES_DSC_SPECIFICATION       :   "_DscSpecification",\r
        #TAB_DSC_DEFINES_OUTPUT_DIRECTORY        :   "_OutputDirectory",\r
        #TAB_DSC_DEFINES_SUPPORTED_ARCHITECTURES :   "_SupArchList",\r
        #TAB_DSC_DEFINES_BUILD_TARGETS           :   "_BuildTargets",\r
        TAB_DSC_DEFINES_SKUID_IDENTIFIER        :   "_SkuName",\r
        #TAB_DSC_DEFINES_FLASH_DEFINITION        :   "_FlashDefinition",\r
        TAB_DSC_DEFINES_BUILD_NUMBER            :   "_BuildNumber",\r
        TAB_DSC_DEFINES_MAKEFILE_NAME           :   "_MakefileName",\r
        TAB_DSC_DEFINES_BS_BASE_ADDRESS         :   "_BsBaseAddress",\r
        TAB_DSC_DEFINES_RT_BASE_ADDRESS         :   "_RtBaseAddress",\r
        #TAB_DSC_DEFINES_RFC_LANGUAGES           :   "_RFCLanguages",\r
        #TAB_DSC_DEFINES_ISO_LANGUAGES           :   "_ISOLanguages",\r
    }\r
\r
    # used to compose dummy library class name for those forced library instances\r
    _NullLibraryNumber = 0\r
\r
    ## Constructor of DscBuildData\r
    #\r
    #  Initialize object of DscBuildData\r
    #\r
    #   @param      FilePath        The path of platform description file\r
    #   @param      RawData         The raw data of DSC file\r
    #   @param      BuildDataBase   Database used to retrieve module/package information\r
    #   @param      Arch            The target architecture\r
    #   @param      Platform        (not used for DscBuildData)\r
    #   @param      Macros          Macros used for replacement in DSC file\r
    #\r
    def __init__(self, FilePath, RawData, BuildDataBase, Arch='COMMON', Target=None, Toolchain=None):\r
        self.MetaFile = FilePath\r
        self._RawData = RawData\r
        self._Bdb = BuildDataBase\r
        self._Arch = Arch\r
        self._Target = Target\r
        self._Toolchain = Toolchain\r
        self._Clear()\r
        self._HandleOverridePath()\r
\r
    ## XXX[key] = value\r
    def __setitem__(self, key, value):\r
        self.__dict__[self._PROPERTY_[key]] = value\r
\r
    ## value = XXX[key]\r
    def __getitem__(self, key):\r
        return self.__dict__[self._PROPERTY_[key]]\r
\r
    ## "in" test support\r
    def __contains__(self, key):\r
        return key in self._PROPERTY_\r
\r
    ## Set all internal used members of DscBuildData to None\r
    def _Clear(self):\r
        self._Header            = None\r
        self._PlatformName      = None\r
        self._Guid              = None\r
        self._Version           = None\r
        self._DscSpecification  = None\r
        self._OutputDirectory   = None\r
        self._SupArchList       = None\r
        self._BuildTargets      = None\r
        self._SkuName           = None\r
        self._SkuIdentifier     = None\r
        self._AvilableSkuIds = None\r
        self._PcdInfoFlag       = None\r
        self._VarCheckFlag = None\r
        self._FlashDefinition   = None\r
        self._BuildNumber       = None\r
        self._MakefileName      = None\r
        self._BsBaseAddress     = None\r
        self._RtBaseAddress     = None\r
        self._SkuIds            = None\r
        self._Modules           = None\r
        self._LibraryInstances  = None\r
        self._LibraryClasses    = None\r
        self._Pcds              = None\r
        self._DecPcds           = None\r
        self._BuildOptions      = None\r
        self._ModuleTypeOptions = None\r
        self._LoadFixAddress    = None\r
        self._RFCLanguages      = None\r
        self._ISOLanguages      = None\r
        self._VpdToolGuid       = None\r
        self.__Macros            = None\r
\r
\r
    ## handle Override Path of Module\r
    def _HandleOverridePath(self):\r
        RecordList = self._RawData[MODEL_META_DATA_COMPONENT, self._Arch]\r
        Macros = self._Macros\r
        Macros["EDK_SOURCE"] = GlobalData.gEcpSource\r
        for Record in RecordList:\r
            ModuleId = Record[5]\r
            LineNo = Record[6]\r
            ModuleFile = PathClass(NormPath(Record[0]), GlobalData.gWorkspace, Arch=self._Arch)\r
            RecordList = self._RawData[MODEL_META_DATA_COMPONENT_SOURCE_OVERRIDE_PATH, self._Arch, None, ModuleId]\r
            if RecordList != []:\r
                SourceOverridePath = os.path.join(GlobalData.gWorkspace, NormPath(RecordList[0][0]))\r
\r
                # Check if the source override path exists\r
                if not os.path.isdir(SourceOverridePath):\r
                    EdkLogger.error('build', FILE_NOT_FOUND, Message='Source override path does not exist:', File=self.MetaFile, ExtraData=SourceOverridePath, Line=LineNo)\r
\r
                #Add to GlobalData Variables\r
                GlobalData.gOverrideDir[ModuleFile.Key] = SourceOverridePath\r
\r
    ## Get current effective macros\r
    def _GetMacros(self):\r
        if self.__Macros == None:\r
            self.__Macros = {}\r
            self.__Macros.update(GlobalData.gPlatformDefines)\r
            self.__Macros.update(GlobalData.gGlobalDefines)\r
            self.__Macros.update(GlobalData.gCommandLineDefines)\r
        return self.__Macros\r
\r
    ## Get architecture\r
    def _GetArch(self):\r
        return self._Arch\r
\r
    ## Set architecture\r
    #\r
    #   Changing the default ARCH to another may affect all other information\r
    # because all information in a platform may be ARCH-related. That's\r
    # why we need to clear all internal used members, in order to cause all\r
    # information to be re-retrieved.\r
    #\r
    #   @param  Value   The value of ARCH\r
    #\r
    def _SetArch(self, Value):\r
        if self._Arch == Value:\r
            return\r
        self._Arch = Value\r
        self._Clear()\r
\r
    ## Retrieve all information in [Defines] section\r
    #\r
    #   (Retriving all [Defines] information in one-shot is just to save time.)\r
    #\r
    def _GetHeaderInfo(self):\r
        RecordList = self._RawData[MODEL_META_DATA_HEADER, self._Arch]\r
        for Record in RecordList:\r
            Name = Record[1]\r
            # items defined _PROPERTY_ don't need additional processing\r
            \r
            # some special items in [Defines] section need special treatment\r
            if Name == TAB_DSC_DEFINES_OUTPUT_DIRECTORY:\r
                self._OutputDirectory = NormPath(Record[2], self._Macros)\r
                if ' ' in self._OutputDirectory:\r
                    EdkLogger.error("build", FORMAT_NOT_SUPPORTED, "No space is allowed in OUTPUT_DIRECTORY",\r
                                    File=self.MetaFile, Line=Record[-1],\r
                                    ExtraData=self._OutputDirectory)\r
            elif Name == TAB_DSC_DEFINES_FLASH_DEFINITION:\r
                self._FlashDefinition = PathClass(NormPath(Record[2], self._Macros), GlobalData.gWorkspace)\r
                ErrorCode, ErrorInfo = self._FlashDefinition.Validate('.fdf')\r
                if ErrorCode != 0:\r
                    EdkLogger.error('build', ErrorCode, File=self.MetaFile, Line=Record[-1],\r
                                    ExtraData=ErrorInfo)\r
            elif Name == TAB_DSC_DEFINES_SUPPORTED_ARCHITECTURES:\r
                self._SupArchList = GetSplitValueList(Record[2], TAB_VALUE_SPLIT)\r
            elif Name == TAB_DSC_DEFINES_BUILD_TARGETS:\r
                self._BuildTargets = GetSplitValueList(Record[2])\r
            elif Name == TAB_DSC_DEFINES_SKUID_IDENTIFIER:\r
                if self._SkuName == None:\r
                    self._SkuName = Record[2]\r
                self._SkuIdentifier = Record[2]\r
                self._AvilableSkuIds = Record[2]\r
            elif Name == TAB_DSC_DEFINES_PCD_INFO_GENERATION:\r
                self._PcdInfoFlag = Record[2]\r
            elif Name == TAB_DSC_DEFINES_PCD_VAR_CHECK_GENERATION:\r
                self._VarCheckFlag = Record[2]\r
            elif Name == TAB_FIX_LOAD_TOP_MEMORY_ADDRESS:\r
                try:\r
                    self._LoadFixAddress = int (Record[2], 0)\r
                except:\r
                    EdkLogger.error("build", PARAMETER_INVALID, "FIX_LOAD_TOP_MEMORY_ADDRESS %s is not valid dec or hex string" % (Record[2]))\r
            elif Name == TAB_DSC_DEFINES_RFC_LANGUAGES:\r
                if not Record[2] or Record[2][0] != '"' or Record[2][-1] != '"' or len(Record[2]) == 1:\r
                    EdkLogger.error('build', FORMAT_NOT_SUPPORTED, 'language code for RFC_LANGUAGES must have double quotes around it, for example: RFC_LANGUAGES = "en-us;zh-hans"',\r
                                    File=self.MetaFile, Line=Record[-1])\r
                LanguageCodes = Record[2][1:-1]\r
                if not LanguageCodes:\r
                    EdkLogger.error('build', FORMAT_NOT_SUPPORTED, 'one or more RFC4646 format language code must be provided for RFC_LANGUAGES statement',\r
                                    File=self.MetaFile, Line=Record[-1])                \r
                LanguageList = GetSplitValueList(LanguageCodes, TAB_SEMI_COLON_SPLIT)\r
                # check whether there is empty entries in the list\r
                if None in LanguageList:\r
                    EdkLogger.error('build', FORMAT_NOT_SUPPORTED, 'one or more empty language code is in RFC_LANGUAGES statement',\r
                                    File=self.MetaFile, Line=Record[-1])                      \r
                self._RFCLanguages = LanguageList\r
            elif Name == TAB_DSC_DEFINES_ISO_LANGUAGES:\r
                if not Record[2] or Record[2][0] != '"' or Record[2][-1] != '"' or len(Record[2]) == 1:\r
                    EdkLogger.error('build', FORMAT_NOT_SUPPORTED, 'language code for ISO_LANGUAGES must have double quotes around it, for example: ISO_LANGUAGES = "engchn"',\r
                                    File=self.MetaFile, Line=Record[-1])\r
                LanguageCodes = Record[2][1:-1]\r
                if not LanguageCodes:\r
                    EdkLogger.error('build', FORMAT_NOT_SUPPORTED, 'one or more ISO639-2 format language code must be provided for ISO_LANGUAGES statement',\r
                                    File=self.MetaFile, Line=Record[-1])                    \r
                if len(LanguageCodes)%3:\r
                    EdkLogger.error('build', FORMAT_NOT_SUPPORTED, 'bad ISO639-2 format for ISO_LANGUAGES',\r
                                    File=self.MetaFile, Line=Record[-1])\r
                LanguageList = []\r
                for i in range(0, len(LanguageCodes), 3):\r
                    LanguageList.append(LanguageCodes[i:i+3])\r
                self._ISOLanguages = LanguageList               \r
            elif Name == TAB_DSC_DEFINES_VPD_TOOL_GUID:\r
                #\r
                # try to convert GUID to a real UUID value to see whether the GUID is format \r
                # for VPD_TOOL_GUID is correct.\r
                #\r
                try:\r
                    uuid.UUID(Record[2])\r
                except:\r
                    EdkLogger.error("build", FORMAT_INVALID, "Invalid GUID format for VPD_TOOL_GUID", File=self.MetaFile)\r
                self._VpdToolGuid = Record[2]                   \r
            elif Name in self:\r
                self[Name] = Record[2]                 \r
        # set _Header to non-None in order to avoid database re-querying\r
        self._Header = 'DUMMY'\r
\r
    ## Retrieve platform name\r
    def _GetPlatformName(self):\r
        if self._PlatformName == None:\r
            if self._Header == None:\r
                self._GetHeaderInfo()\r
            if self._PlatformName == None:\r
                EdkLogger.error('build', ATTRIBUTE_NOT_AVAILABLE, "No PLATFORM_NAME", File=self.MetaFile)\r
        return self._PlatformName\r
\r
    ## Retrieve file guid\r
    def _GetFileGuid(self):\r
        if self._Guid == None:\r
            if self._Header == None:\r
                self._GetHeaderInfo()\r
            if self._Guid == None:\r
                EdkLogger.error('build', ATTRIBUTE_NOT_AVAILABLE, "No PLATFORM_GUID", File=self.MetaFile)\r
        return self._Guid\r
\r
    ## Retrieve platform version\r
    def _GetVersion(self):\r
        if self._Version == None:\r
            if self._Header == None:\r
                self._GetHeaderInfo()\r
            if self._Version == None:\r
                EdkLogger.error('build', ATTRIBUTE_NOT_AVAILABLE, "No PLATFORM_VERSION", File=self.MetaFile)\r
        return self._Version\r
\r
    ## Retrieve platform description file version\r
    def _GetDscSpec(self):\r
        if self._DscSpecification == None:\r
            if self._Header == None:\r
                self._GetHeaderInfo()\r
            if self._DscSpecification == None:\r
                EdkLogger.error('build', ATTRIBUTE_NOT_AVAILABLE, "No DSC_SPECIFICATION", File=self.MetaFile)                \r
        return self._DscSpecification\r
\r
    ## Retrieve OUTPUT_DIRECTORY\r
    def _GetOutpuDir(self):\r
        if self._OutputDirectory == None:\r
            if self._Header == None:\r
                self._GetHeaderInfo()\r
            if self._OutputDirectory == None:\r
                self._OutputDirectory = os.path.join("Build", self._PlatformName)\r
        return self._OutputDirectory\r
\r
    ## Retrieve SUPPORTED_ARCHITECTURES\r
    def _GetSupArch(self):\r
        if self._SupArchList == None:\r
            if self._Header == None:\r
                self._GetHeaderInfo()\r
            if self._SupArchList == None:\r
                EdkLogger.error('build', ATTRIBUTE_NOT_AVAILABLE, "No SUPPORTED_ARCHITECTURES", File=self.MetaFile)\r
        return self._SupArchList\r
\r
    ## Retrieve BUILD_TARGETS\r
    def _GetBuildTarget(self):\r
        if self._BuildTargets == None:\r
            if self._Header == None:\r
                self._GetHeaderInfo()\r
            if self._BuildTargets == None:\r
                EdkLogger.error('build', ATTRIBUTE_NOT_AVAILABLE, "No BUILD_TARGETS", File=self.MetaFile)\r
        return self._BuildTargets\r
    \r
    def _GetPcdInfoFlag(self):\r
        if self._PcdInfoFlag == None or self._PcdInfoFlag.upper() == 'FALSE':\r
            return False\r
        elif self._PcdInfoFlag.upper() == 'TRUE':\r
            return True\r
        else:\r
            return False\r
    def _GetVarCheckFlag(self):  \r
        if self._VarCheckFlag == None or self._VarCheckFlag.upper() == 'FALSE':\r
            return False\r
        elif self._VarCheckFlag.upper() == 'TRUE':\r
            return True\r
        else:\r
            return False\r
    def _GetAviableSkuIds(self):\r
        if self._AvilableSkuIds:\r
            return self._AvilableSkuIds\r
        return self.SkuIdentifier\r
    def _GetSkuIdentifier(self):\r
        if self._SkuName:\r
            return self._SkuName\r
        if self._SkuIdentifier == None:\r
            if self._Header == None:\r
                self._GetHeaderInfo()\r
        return self._SkuIdentifier\r
    ## Retrieve SKUID_IDENTIFIER\r
    def _GetSkuName(self):\r
        if self._SkuName == None:\r
            if self._Header == None:\r
                self._GetHeaderInfo()\r
            if (self._SkuName == None or self._SkuName not in self.SkuIds):\r
                self._SkuName = 'DEFAULT'\r
        return self._SkuName\r
\r
    ## Override SKUID_IDENTIFIER\r
    def _SetSkuName(self, Value):\r
        self._SkuName = Value\r
        self._Pcds = None\r
\r
    def _GetFdfFile(self):\r
        if self._FlashDefinition == None:\r
            if self._Header == None:\r
                self._GetHeaderInfo()\r
            if self._FlashDefinition == None:\r
                self._FlashDefinition = ''\r
        return self._FlashDefinition\r
\r
    ## Retrieve FLASH_DEFINITION\r
    def _GetBuildNumber(self):\r
        if self._BuildNumber == None:\r
            if self._Header == None:\r
                self._GetHeaderInfo()\r
            if self._BuildNumber == None:\r
                self._BuildNumber = ''\r
        return self._BuildNumber\r
\r
    ## Retrieve MAKEFILE_NAME\r
    def _GetMakefileName(self):\r
        if self._MakefileName == None:\r
            if self._Header == None:\r
                self._GetHeaderInfo()\r
            if self._MakefileName == None:\r
                self._MakefileName = ''\r
        return self._MakefileName\r
\r
    ## Retrieve BsBaseAddress\r
    def _GetBsBaseAddress(self):\r
        if self._BsBaseAddress == None:\r
            if self._Header == None:\r
                self._GetHeaderInfo()\r
            if self._BsBaseAddress == None:\r
                self._BsBaseAddress = ''\r
        return self._BsBaseAddress\r
\r
    ## Retrieve RtBaseAddress\r
    def _GetRtBaseAddress(self):\r
        if self._RtBaseAddress == None:\r
            if self._Header == None:\r
                self._GetHeaderInfo()\r
            if self._RtBaseAddress == None:\r
                self._RtBaseAddress = ''\r
        return self._RtBaseAddress\r
\r
    ## Retrieve the top address for the load fix address\r
    def _GetLoadFixAddress(self):\r
        if self._LoadFixAddress == None:\r
            if self._Header == None:\r
                self._GetHeaderInfo()\r
\r
            if self._LoadFixAddress == None:\r
                self._LoadFixAddress = self._Macros.get(TAB_FIX_LOAD_TOP_MEMORY_ADDRESS, '0')\r
\r
            try:\r
                self._LoadFixAddress = int (self._LoadFixAddress, 0)\r
            except:\r
                EdkLogger.error("build", PARAMETER_INVALID, "FIX_LOAD_TOP_MEMORY_ADDRESS %s is not valid dec or hex string" % (self._LoadFixAddress))\r
         \r
        #\r
        # If command line defined, should override the value in DSC file.\r
        #\r
        if 'FIX_LOAD_TOP_MEMORY_ADDRESS' in GlobalData.gCommandLineDefines.keys():\r
            try:\r
                self._LoadFixAddress = int(GlobalData.gCommandLineDefines['FIX_LOAD_TOP_MEMORY_ADDRESS'], 0)\r
            except:\r
                EdkLogger.error("build", PARAMETER_INVALID, "FIX_LOAD_TOP_MEMORY_ADDRESS %s is not valid dec or hex string" % (GlobalData.gCommandLineDefines['FIX_LOAD_TOP_MEMORY_ADDRESS']))\r
                \r
        if self._LoadFixAddress < 0:\r
            EdkLogger.error("build", PARAMETER_INVALID, "FIX_LOAD_TOP_MEMORY_ADDRESS is set to the invalid negative value 0x%x" % (self._LoadFixAddress))\r
        if self._LoadFixAddress != 0xFFFFFFFFFFFFFFFF and self._LoadFixAddress % 0x1000 != 0:\r
            EdkLogger.error("build", PARAMETER_INVALID, "FIX_LOAD_TOP_MEMORY_ADDRESS is set to the invalid unaligned 4K value 0x%x" % (self._LoadFixAddress))\r
            \r
        return self._LoadFixAddress\r
\r
    ## Retrieve RFCLanguage filter\r
    def _GetRFCLanguages(self):\r
        if self._RFCLanguages == None:\r
            if self._Header == None:\r
                self._GetHeaderInfo()\r
            if self._RFCLanguages == None:\r
                self._RFCLanguages = []\r
        return self._RFCLanguages\r
\r
    ## Retrieve ISOLanguage filter\r
    def _GetISOLanguages(self):\r
        if self._ISOLanguages == None:\r
            if self._Header == None:\r
                self._GetHeaderInfo()\r
            if self._ISOLanguages == None:\r
                self._ISOLanguages = []\r
        return self._ISOLanguages\r
    ## Retrieve the GUID string for VPD tool\r
    def _GetVpdToolGuid(self):\r
        if self._VpdToolGuid == None:\r
            if self._Header == None:\r
                self._GetHeaderInfo()\r
            if self._VpdToolGuid == None:\r
                self._VpdToolGuid = ''\r
        return self._VpdToolGuid\r
      \r
    ## Retrieve [SkuIds] section information\r
    def _GetSkuIds(self):\r
        if self._SkuIds == None:\r
            self._SkuIds = sdict()\r
            RecordList = self._RawData[MODEL_EFI_SKU_ID, self._Arch]\r
            for Record in RecordList:\r
                if Record[0] in [None, '']:\r
                    EdkLogger.error('build', FORMAT_INVALID, 'No Sku ID number',\r
                                    File=self.MetaFile, Line=Record[-1])\r
                if Record[1] in [None, '']:\r
                    EdkLogger.error('build', FORMAT_INVALID, 'No Sku ID name',\r
                                    File=self.MetaFile, Line=Record[-1])\r
                self._SkuIds[Record[1]] = Record[0]\r
            if 'DEFAULT' not in self._SkuIds:\r
                self._SkuIds['DEFAULT'] = '0'\r
            if 'COMMON' not in self._SkuIds:\r
                self._SkuIds['COMMON'] = '0'\r
        return self._SkuIds\r
\r
    ## Retrieve [Components] section information\r
    def _GetModules(self):\r
        if self._Modules != None:\r
            return self._Modules\r
\r
        self._Modules = sdict()\r
        RecordList = self._RawData[MODEL_META_DATA_COMPONENT, self._Arch]\r
        Macros = self._Macros\r
        Macros["EDK_SOURCE"] = GlobalData.gEcpSource\r
        for Record in RecordList:\r
            DuplicatedFile = False\r
            ModuleFile = PathClass(NormPath(Record[0], Macros), GlobalData.gWorkspace, Arch=self._Arch)\r
            ModuleId = Record[5]\r
            LineNo = Record[6]\r
\r
            # check the file validation\r
            ErrorCode, ErrorInfo = ModuleFile.Validate('.inf')\r
            if ErrorCode != 0:\r
                EdkLogger.error('build', ErrorCode, File=self.MetaFile, Line=LineNo,\r
                                ExtraData=ErrorInfo)\r
            # Check duplication\r
            # If arch is COMMON, no duplicate module is checked since all modules in all component sections are selected\r
            if self._Arch != 'COMMON' and ModuleFile in self._Modules:\r
                DuplicatedFile = True\r
\r
            Module = ModuleBuildClassObject()\r
            Module.MetaFile = ModuleFile\r
\r
            # get module private library instance\r
            RecordList = self._RawData[MODEL_EFI_LIBRARY_CLASS, self._Arch, None, ModuleId]\r
            for Record in RecordList:\r
                LibraryClass = Record[0]\r
                LibraryPath = PathClass(NormPath(Record[1], Macros), GlobalData.gWorkspace, Arch=self._Arch)\r
                LineNo = Record[-1]\r
\r
                # check the file validation\r
                ErrorCode, ErrorInfo = LibraryPath.Validate('.inf')\r
                if ErrorCode != 0:\r
                    EdkLogger.error('build', ErrorCode, File=self.MetaFile, Line=LineNo,\r
                                    ExtraData=ErrorInfo)\r
\r
                if LibraryClass == '' or LibraryClass == 'NULL':\r
                    self._NullLibraryNumber += 1\r
                    LibraryClass = 'NULL%d' % self._NullLibraryNumber\r
                    EdkLogger.verbose("Found forced library for %s\n\t%s [%s]" % (ModuleFile, LibraryPath, LibraryClass))\r
                Module.LibraryClasses[LibraryClass] = LibraryPath\r
                if LibraryPath not in self.LibraryInstances:\r
                    self.LibraryInstances.append(LibraryPath)\r
\r
            # get module private PCD setting\r
            for Type in [MODEL_PCD_FIXED_AT_BUILD, MODEL_PCD_PATCHABLE_IN_MODULE, \\r
                         MODEL_PCD_FEATURE_FLAG, MODEL_PCD_DYNAMIC, MODEL_PCD_DYNAMIC_EX]:\r
                RecordList = self._RawData[Type, self._Arch, None, ModuleId]\r
                for TokenSpaceGuid, PcdCName, Setting, Dummy1, Dummy2, Dummy3, Dummy4 in RecordList:\r
                    TokenList = GetSplitValueList(Setting)\r
                    DefaultValue = TokenList[0]\r
                    if len(TokenList) > 1:\r
                        MaxDatumSize = TokenList[1]\r
                    else:\r
                        MaxDatumSize = ''\r
                    TypeString = self._PCD_TYPE_STRING_[Type]\r
                    Pcd = PcdClassObject(\r
                            PcdCName,\r
                            TokenSpaceGuid,\r
                            TypeString,\r
                            '',\r
                            DefaultValue,\r
                            '',\r
                            MaxDatumSize,\r
                            {},\r
                            False,\r
                            None\r
                            )\r
                    Module.Pcds[PcdCName, TokenSpaceGuid] = Pcd\r
\r
            # get module private build options\r
            RecordList = self._RawData[MODEL_META_DATA_BUILD_OPTION, self._Arch, None, ModuleId]\r
            for ToolChainFamily, ToolChain, Option, Dummy1, Dummy2, Dummy3, Dummy4 in RecordList:\r
                if (ToolChainFamily, ToolChain) not in Module.BuildOptions:\r
                    Module.BuildOptions[ToolChainFamily, ToolChain] = Option\r
                else:\r
                    OptionString = Module.BuildOptions[ToolChainFamily, ToolChain]\r
                    Module.BuildOptions[ToolChainFamily, ToolChain] = OptionString + " " + Option\r
\r
            RecordList = self._RawData[MODEL_META_DATA_HEADER, self._Arch, None, ModuleId]\r
            if DuplicatedFile and not RecordList:\r
                EdkLogger.error('build', FILE_DUPLICATED, File=self.MetaFile, ExtraData=str(ModuleFile), Line=LineNo)\r
            if RecordList:\r
                if len(RecordList) != 1:\r
                    EdkLogger.error('build', OPTION_UNKNOWN, 'Only FILE_GUID can be listed in <Defines> section.',\r
                                    File=self.MetaFile, ExtraData=str(ModuleFile), Line=LineNo)\r
                ModuleFile = ProcessDuplicatedInf(ModuleFile, RecordList[0][2], GlobalData.gWorkspace)\r
                ModuleFile.Arch = self._Arch\r
\r
            self._Modules[ModuleFile] = Module\r
        return self._Modules\r
\r
    ## Retrieve all possible library instances used in this platform\r
    def _GetLibraryInstances(self):\r
        if self._LibraryInstances == None:\r
            self._GetLibraryClasses()\r
        return self._LibraryInstances\r
\r
    ## Retrieve [LibraryClasses] information\r
    def _GetLibraryClasses(self):\r
        if self._LibraryClasses == None:\r
            self._LibraryInstances = []\r
            #\r
            # tdict is a special dict kind of type, used for selecting correct\r
            # library instance for given library class and module type\r
            #\r
            LibraryClassDict = tdict(True, 3)\r
            # track all library class names\r
            LibraryClassSet = set()\r
            RecordList = self._RawData[MODEL_EFI_LIBRARY_CLASS, self._Arch, None, -1]\r
            Macros = self._Macros\r
            for Record in RecordList:\r
                LibraryClass, LibraryInstance, Dummy, Arch, ModuleType, Dummy, LineNo = Record\r
                if LibraryClass == '' or LibraryClass == 'NULL':\r
                    self._NullLibraryNumber += 1\r
                    LibraryClass = 'NULL%d' % self._NullLibraryNumber\r
                    EdkLogger.verbose("Found forced library for arch=%s\n\t%s [%s]" % (Arch, LibraryInstance, LibraryClass))\r
                LibraryClassSet.add(LibraryClass)\r
                LibraryInstance = PathClass(NormPath(LibraryInstance, Macros), GlobalData.gWorkspace, Arch=self._Arch)\r
                # check the file validation\r
                ErrorCode, ErrorInfo = LibraryInstance.Validate('.inf')\r
                if ErrorCode != 0:\r
                    EdkLogger.error('build', ErrorCode, File=self.MetaFile, Line=LineNo,\r
                                    ExtraData=ErrorInfo)\r
\r
                if ModuleType != 'COMMON' and ModuleType not in SUP_MODULE_LIST:\r
                    EdkLogger.error('build', OPTION_UNKNOWN, "Unknown module type [%s]" % ModuleType,\r
                                    File=self.MetaFile, ExtraData=LibraryInstance, Line=LineNo)\r
                LibraryClassDict[Arch, ModuleType, LibraryClass] = LibraryInstance\r
                if LibraryInstance not in self._LibraryInstances:\r
                    self._LibraryInstances.append(LibraryInstance)\r
\r
            # resolve the specific library instance for each class and each module type\r
            self._LibraryClasses = tdict(True)\r
            for LibraryClass in LibraryClassSet:\r
                # try all possible module types\r
                for ModuleType in SUP_MODULE_LIST:\r
                    LibraryInstance = LibraryClassDict[self._Arch, ModuleType, LibraryClass]\r
                    if LibraryInstance == None:\r
                        continue\r
                    self._LibraryClasses[LibraryClass, ModuleType] = LibraryInstance\r
\r
            # for Edk style library instances, which are listed in different section\r
            Macros["EDK_SOURCE"] = GlobalData.gEcpSource\r
            RecordList = self._RawData[MODEL_EFI_LIBRARY_INSTANCE, self._Arch]\r
            for Record in RecordList:\r
                File = PathClass(NormPath(Record[0], Macros), GlobalData.gWorkspace, Arch=self._Arch)\r
                LineNo = Record[-1]\r
                # check the file validation\r
                ErrorCode, ErrorInfo = File.Validate('.inf')\r
                if ErrorCode != 0:\r
                    EdkLogger.error('build', ErrorCode, File=self.MetaFile, Line=LineNo,\r
                                    ExtraData=ErrorInfo)\r
                if File not in self._LibraryInstances:\r
                    self._LibraryInstances.append(File)\r
                #\r
                # we need the module name as the library class name, so we have\r
                # to parse it here. (self._Bdb[] will trigger a file parse if it\r
                # hasn't been parsed)\r
                #\r
                Library = self._Bdb[File, self._Arch, self._Target, self._Toolchain]\r
                self._LibraryClasses[Library.BaseName, ':dummy:'] = Library\r
        return self._LibraryClasses\r
\r
    def _ValidatePcd(self, PcdCName, TokenSpaceGuid, Setting, PcdType, LineNo):\r
        if self._DecPcds == None:\r
            self._DecPcds = GetDeclaredPcd(self, self._Bdb, self._Arch, self._Target, self._Toolchain)\r
            FdfInfList = []\r
            if GlobalData.gFdfParser:\r
                FdfInfList = GlobalData.gFdfParser.Profile.InfList\r
\r
            PkgSet = set()\r
            for Inf in FdfInfList:\r
                ModuleFile = PathClass(NormPath(Inf), GlobalData.gWorkspace, Arch=self._Arch)\r
                if ModuleFile in self._Modules:\r
                    continue\r
                ModuleData = self._Bdb[ModuleFile, self._Arch, self._Target, self._Toolchain]\r
                PkgSet.update(ModuleData.Packages)\r
            DecPcds = {}\r
            for Pkg in PkgSet:\r
                for Pcd in Pkg.Pcds:\r
                    DecPcds[Pcd[0], Pcd[1]] = Pkg.Pcds[Pcd]\r
            self._DecPcds.update(DecPcds)\r
\r
        if (PcdCName, TokenSpaceGuid) not in self._DecPcds:\r
            EdkLogger.error('build', PARSER_ERROR,\r
                            "Pcd (%s.%s) defined in DSC is not declared in DEC files. Arch: ['%s']" % (TokenSpaceGuid, PcdCName, self._Arch),\r
                            File=self.MetaFile, Line=LineNo)\r
        ValueList, IsValid, Index = AnalyzeDscPcd(Setting, PcdType, self._DecPcds[PcdCName, TokenSpaceGuid].DatumType)\r
        if not IsValid and PcdType not in [MODEL_PCD_FEATURE_FLAG, MODEL_PCD_FIXED_AT_BUILD]:\r
            EdkLogger.error('build', FORMAT_INVALID, "Pcd format incorrect.", File=self.MetaFile, Line=LineNo,\r
                            ExtraData="%s.%s|%s" % (TokenSpaceGuid, PcdCName, Setting))\r
        if ValueList[Index] and PcdType not in [MODEL_PCD_FEATURE_FLAG, MODEL_PCD_FIXED_AT_BUILD]:\r
            try:\r
                ValueList[Index] = ValueExpression(ValueList[Index], GlobalData.gPlatformPcds)(True)\r
            except WrnExpression, Value:\r
                ValueList[Index] = Value.result\r
            except EvaluationException, Excpt:\r
                if hasattr(Excpt, 'Pcd'):\r
                    if Excpt.Pcd in GlobalData.gPlatformOtherPcds:\r
                        EdkLogger.error('Parser', FORMAT_INVALID, "Cannot use this PCD (%s) in an expression as"\r
                                        " it must be defined in a [PcdsFixedAtBuild] or [PcdsFeatureFlag] section"\r
                                        " of the DSC file" % Excpt.Pcd,\r
                                        File=self.MetaFile, Line=LineNo)\r
                    else:\r
                        EdkLogger.error('Parser', FORMAT_INVALID, "PCD (%s) is not defined in DSC file" % Excpt.Pcd,\r
                                        File=self.MetaFile, Line=LineNo)\r
                else:\r
                    EdkLogger.error('Parser', FORMAT_INVALID, "Invalid expression: %s" % str(Excpt),\r
                                    File=self.MetaFile, Line=LineNo)\r
            if ValueList[Index] == 'True':\r
                ValueList[Index] = '1'\r
            elif ValueList[Index] == 'False':\r
                ValueList[Index] = '0'\r
        if ValueList[Index]:\r
            Valid, ErrStr = CheckPcdDatum(self._DecPcds[PcdCName, TokenSpaceGuid].DatumType, ValueList[Index])\r
            if not Valid:\r
                EdkLogger.error('build', FORMAT_INVALID, ErrStr, File=self.MetaFile, Line=LineNo,\r
                                ExtraData="%s.%s" % (TokenSpaceGuid, PcdCName))\r
        return ValueList\r
\r
    ## Retrieve all PCD settings in platform\r
    def _GetPcds(self):\r
        if self._Pcds == None:\r
            self._Pcds = sdict()\r
            self._Pcds.update(self._GetPcd(MODEL_PCD_FIXED_AT_BUILD))\r
            self._Pcds.update(self._GetPcd(MODEL_PCD_PATCHABLE_IN_MODULE))\r
            self._Pcds.update(self._GetPcd(MODEL_PCD_FEATURE_FLAG))\r
            self._Pcds.update(self._GetDynamicPcd(MODEL_PCD_DYNAMIC_DEFAULT))\r
            self._Pcds.update(self._GetDynamicHiiPcd(MODEL_PCD_DYNAMIC_HII))\r
            self._Pcds.update(self._GetDynamicVpdPcd(MODEL_PCD_DYNAMIC_VPD))\r
            self._Pcds.update(self._GetDynamicPcd(MODEL_PCD_DYNAMIC_EX_DEFAULT))\r
            self._Pcds.update(self._GetDynamicHiiPcd(MODEL_PCD_DYNAMIC_EX_HII))\r
            self._Pcds.update(self._GetDynamicVpdPcd(MODEL_PCD_DYNAMIC_EX_VPD))\r
        return self._Pcds\r
\r
    ## Retrieve [BuildOptions]\r
    def _GetBuildOptions(self):\r
        if self._BuildOptions == None:\r
            self._BuildOptions = sdict()\r
            #\r
            # Retrieve build option for EDKII and EDK style module\r
            #\r
            for CodeBase in (EDKII_NAME, EDK_NAME):\r
                RecordList = self._RawData[MODEL_META_DATA_BUILD_OPTION, self._Arch, CodeBase]\r
                for ToolChainFamily, ToolChain, Option, Dummy1, Dummy2, Dummy3, Dummy4 in RecordList:\r
                    CurKey = (ToolChainFamily, ToolChain, CodeBase)\r
                    #\r
                    # Only flags can be appended\r
                    #\r
                    if CurKey not in self._BuildOptions or not ToolChain.endswith('_FLAGS') or Option.startswith('='):\r
                        self._BuildOptions[CurKey] = Option\r
                    else:\r
                        self._BuildOptions[CurKey] += ' ' + Option\r
        return self._BuildOptions\r
\r
    def GetBuildOptionsByModuleType(self, Edk, ModuleType):\r
        if self._ModuleTypeOptions == None:\r
            self._ModuleTypeOptions = sdict()\r
        if (Edk, ModuleType) not in self._ModuleTypeOptions:\r
            options = sdict()\r
            self._ModuleTypeOptions[Edk, ModuleType] = options\r
            DriverType = '%s.%s' % (Edk, ModuleType)\r
            RecordList = self._RawData[MODEL_META_DATA_BUILD_OPTION, self._Arch, DriverType]\r
            for ToolChainFamily, ToolChain, Option, Arch, Type, Dummy3, Dummy4 in RecordList:\r
                if Type == DriverType:\r
                    Key = (ToolChainFamily, ToolChain, Edk)\r
                    if Key not in options or not ToolChain.endswith('_FLAGS') or Option.startswith('='):\r
                        options[Key] = Option\r
                    else:\r
                        options[Key] += ' ' + Option\r
        return self._ModuleTypeOptions[Edk, ModuleType]\r
\r
    ## Retrieve non-dynamic PCD settings\r
    #\r
    #   @param  Type    PCD type\r
    #\r
    #   @retval a dict object contains settings of given PCD type\r
    #\r
    def _GetPcd(self, Type):\r
        Pcds = sdict()\r
        #\r
        # tdict is a special dict kind of type, used for selecting correct\r
        # PCD settings for certain ARCH\r
        #\r
        \r
        SkuObj = SkuClass(self.SkuIdentifier,self.SkuIds)\r
        \r
        PcdDict = tdict(True, 3)\r
        PcdSet = set()\r
        # Find out all possible PCD candidates for self._Arch\r
        RecordList = self._RawData[Type, self._Arch]\r
        PcdValueDict = sdict()\r
        for TokenSpaceGuid, PcdCName, Setting, Arch, SkuName, Dummy3, Dummy4 in RecordList:\r
            if SkuName in (SkuObj.SystemSkuId,'DEFAULT','COMMON'):\r
                PcdSet.add((PcdCName, TokenSpaceGuid, SkuName,Dummy4))\r
                PcdDict[Arch, PcdCName, TokenSpaceGuid,SkuName] = Setting\r
        \r
        #handle pcd value override        \r
        for PcdCName, TokenSpaceGuid, SkuName,Dummy4 in PcdSet:\r
            Setting = PcdDict[self._Arch, PcdCName, TokenSpaceGuid,SkuName]\r
            if Setting == None:\r
                continue\r
            PcdValue, DatumType, MaxDatumSize = self._ValidatePcd(PcdCName, TokenSpaceGuid, Setting, Type, Dummy4)\r
            if (PcdCName, TokenSpaceGuid) in PcdValueDict:\r
                PcdValueDict[PcdCName, TokenSpaceGuid][SkuName] = (PcdValue,DatumType,MaxDatumSize) \r
            else:\r
                PcdValueDict[PcdCName, TokenSpaceGuid] = {SkuName:(PcdValue,DatumType,MaxDatumSize)}       \r
        \r
        PcdsKeys = PcdValueDict.keys()\r
        for PcdCName,TokenSpaceGuid in PcdsKeys:\r
            \r
            PcdSetting = PcdValueDict[PcdCName, TokenSpaceGuid]\r
            PcdValue = None\r
            DatumType = None\r
            MaxDatumSize = None\r
            if 'COMMON' in PcdSetting:\r
                PcdValue,DatumType,MaxDatumSize = PcdSetting['COMMON']\r
            if 'DEFAULT' in PcdSetting:\r
                PcdValue,DatumType,MaxDatumSize = PcdSetting['DEFAULT']\r
            if SkuObj.SystemSkuId in PcdSetting:\r
                PcdValue,DatumType,MaxDatumSize = PcdSetting[SkuObj.SystemSkuId]\r
                \r
            Pcds[PcdCName, TokenSpaceGuid] = PcdClassObject(\r
                                                PcdCName,\r
                                                TokenSpaceGuid,\r
                                                self._PCD_TYPE_STRING_[Type],\r
                                                DatumType,\r
                                                PcdValue,\r
                                                '',\r
                                                MaxDatumSize,\r
                                                {},\r
                                                False,\r
                                                None\r
                                                )\r
        return Pcds\r
\r
    ## Retrieve dynamic PCD settings\r
    #\r
    #   @param  Type    PCD type\r
    #\r
    #   @retval a dict object contains settings of given PCD type\r
    #\r
    def _GetDynamicPcd(self, Type):\r
        \r
        SkuObj = SkuClass(self.SkuIdentifier,self.SkuIds)\r
        \r
        Pcds = sdict()\r
        #\r
        # tdict is a special dict kind of type, used for selecting correct\r
        # PCD settings for certain ARCH and SKU\r
        #\r
        PcdDict = tdict(True, 4)\r
        PcdList = []\r
        # Find out all possible PCD candidates for self._Arch\r
        RecordList = self._RawData[Type, self._Arch]\r
        AvailableSkuIdSet = SkuObj.AvailableSkuIdSet.copy()\r
        \r
        AvailableSkuIdSet.update({'DEFAULT':0,'COMMON':0})\r
        for TokenSpaceGuid, PcdCName, Setting, Arch, SkuName, Dummy3, Dummy4 in RecordList:\r
            if SkuName not in AvailableSkuIdSet:\r
                continue\r
            \r
            PcdList.append((PcdCName, TokenSpaceGuid, SkuName,Dummy4))\r
            PcdDict[Arch, SkuName, PcdCName, TokenSpaceGuid] = Setting\r
        # Remove redundant PCD candidates, per the ARCH and SKU\r
        for PcdCName, TokenSpaceGuid, SkuName, Dummy4 in PcdList:\r
            \r
            Setting = PcdDict[self._Arch, SkuName, PcdCName, TokenSpaceGuid]\r
            if Setting == None:\r
                continue\r
                      \r
            PcdValue, DatumType, MaxDatumSize = self._ValidatePcd(PcdCName, TokenSpaceGuid, Setting, Type, Dummy4)\r
            SkuInfo = SkuInfoClass(SkuName, self.SkuIds[SkuName], '', '', '', '', '', PcdValue)\r
            if (PcdCName,TokenSpaceGuid) in Pcds.keys(): \r
                pcdObject = Pcds[PcdCName,TokenSpaceGuid]\r
                pcdObject.SkuInfoList[SkuName] = SkuInfo\r
                if MaxDatumSize.strip():\r
                    CurrentMaxSize = int(MaxDatumSize.strip(),0)\r
                else:\r
                    CurrentMaxSize = 0\r
                if pcdObject.MaxDatumSize:\r
                    PcdMaxSize = int(pcdObject.MaxDatumSize,0)\r
                else:\r
                    PcdMaxSize = 0\r
                if CurrentMaxSize > PcdMaxSize:\r
                    pcdObject.MaxDatumSize = str(CurrentMaxSize)\r
            else:               \r
                Pcds[PcdCName, TokenSpaceGuid] = PcdClassObject(\r
                                                    PcdCName,\r
                                                    TokenSpaceGuid,\r
                                                    self._PCD_TYPE_STRING_[Type],\r
                                                    DatumType,\r
                                                    PcdValue,\r
                                                    '',\r
                                                    MaxDatumSize,\r
                                                    {SkuName : SkuInfo},\r
                                                    False,\r
                                                    None\r
                                                    )\r
        \r
        for pcd in Pcds.values():\r
            pcdDecObject = self._DecPcds[pcd.TokenCName,pcd.TokenSpaceGuidCName]\r
            if 'DEFAULT' not in pcd.SkuInfoList.keys() and 'COMMON' not in pcd.SkuInfoList.keys():                \r
                valuefromDec = pcdDecObject.DefaultValue\r
                SkuInfo = SkuInfoClass('DEFAULT', '0', '', '', '', '', '', valuefromDec)\r
                pcd.SkuInfoList['DEFAULT'] = SkuInfo\r
            elif 'DEFAULT' not in pcd.SkuInfoList.keys() and 'COMMON' in pcd.SkuInfoList.keys():\r
                pcd.SkuInfoList['DEFAULT'] = pcd.SkuInfoList['COMMON']\r
                del(pcd.SkuInfoList['COMMON'])\r
            elif 'DEFAULT' in pcd.SkuInfoList.keys() and 'COMMON' in pcd.SkuInfoList.keys():\r
                del(pcd.SkuInfoList['COMMON'])\r
            if SkuObj.SkuUsageType == SkuObj.SINGLE:\r
                if 'DEFAULT' in pcd.SkuInfoList.keys() and SkuObj.SystemSkuId not in pcd.SkuInfoList.keys():\r
                    pcd.SkuInfoList[SkuObj.SystemSkuId] = pcd.SkuInfoList['DEFAULT']\r
                del(pcd.SkuInfoList['DEFAULT'])\r
               \r
        return Pcds\r
\r
    def CompareVarAttr(self, Attr1, Attr2):\r
        if not Attr1 or not Attr2:  # for empty string\r
            return True\r
        Attr1s = [attr.strip() for attr in Attr1.split(",")]\r
        Attr1Set = set(Attr1s)\r
        Attr2s = [attr.strip() for attr in Attr2.split(",")]\r
        Attr2Set = set(Attr2s)\r
        if Attr2Set == Attr1Set:\r
            return True\r
        else:\r
            return False\r
    ## Retrieve dynamic HII PCD settings\r
    #\r
    #   @param  Type    PCD type\r
    #\r
    #   @retval a dict object contains settings of given PCD type\r
    #\r
    def _GetDynamicHiiPcd(self, Type):\r
        \r
        SkuObj = SkuClass(self.SkuIdentifier,self.SkuIds)\r
        VariableAttrs = {}\r
        \r
        Pcds = sdict()\r
        #\r
        # tdict is a special dict kind of type, used for selecting correct\r
        # PCD settings for certain ARCH and SKU\r
        #\r
        PcdDict = tdict(True, 4)\r
        PcdSet = set()\r
        RecordList = self._RawData[Type, self._Arch]\r
        # Find out all possible PCD candidates for self._Arch\r
        AvailableSkuIdSet = SkuObj.AvailableSkuIdSet.copy()\r
        \r
        AvailableSkuIdSet.update({'DEFAULT':0,'COMMON':0})\r
        for TokenSpaceGuid, PcdCName, Setting, Arch, SkuName, Dummy3, Dummy4 in RecordList:\r
            if SkuName not in AvailableSkuIdSet:\r
                continue\r
            PcdSet.add((PcdCName, TokenSpaceGuid, SkuName,Dummy4))\r
            PcdDict[Arch, SkuName, PcdCName, TokenSpaceGuid] = Setting\r
        # Remove redundant PCD candidates, per the ARCH and SKU\r
        for PcdCName, TokenSpaceGuid,SkuName, Dummy4 in PcdSet:\r
            \r
            Setting = PcdDict[self._Arch, SkuName, PcdCName, TokenSpaceGuid]\r
            if Setting == None:\r
                continue\r
            VariableName, VariableGuid, VariableOffset, DefaultValue, VarAttribute = self._ValidatePcd(PcdCName, TokenSpaceGuid, Setting, Type, Dummy4)\r
            \r
            rt, Msg = VariableAttributes.ValidateVarAttributes(VarAttribute)\r
            if not rt:\r
                EdkLogger.error("build", PCD_VARIABLE_ATTRIBUTES_ERROR, "Variable attributes settings for %s is incorrect.\n %s" % (".".join((TokenSpaceGuid, PcdCName)), Msg),\r
                        ExtraData = "[%s]" % VarAttribute)\r
            ExceedMax = False\r
            FormatCorrect = True\r
            if VariableOffset.isdigit():\r
                if int(VariableOffset,10) > 0xFFFF:\r
                    ExceedMax = True\r
            elif re.match(r'[\t\s]*0[xX][a-fA-F0-9]+$',VariableOffset):\r
                if int(VariableOffset,16) > 0xFFFF:\r
                    ExceedMax = True\r
            # For Offset written in "A.B"\r
            elif VariableOffset.find('.') > -1:\r
                VariableOffsetList = VariableOffset.split(".")\r
                if not (len(VariableOffsetList) == 2\r
                        and IsValidWord(VariableOffsetList[0])\r
                        and IsValidWord(VariableOffsetList[1])):\r
                    FormatCorrect = False\r
            else:\r
                FormatCorrect = False\r
            if not FormatCorrect:\r
                EdkLogger.error('Build', FORMAT_INVALID, "Invalid syntax or format of the variable offset value is incorrect for %s." % ".".join((TokenSpaceGuid,PcdCName)))\r
            \r
            if ExceedMax:\r
                EdkLogger.error('Build', OPTION_VALUE_INVALID, "The variable offset value must not exceed the maximum value of 0xFFFF (UINT16) for %s." % ".".join((TokenSpaceGuid,PcdCName)))\r
            if (VariableName, VariableGuid) not in VariableAttrs:\r
                VariableAttrs[(VariableName, VariableGuid)] = VarAttribute\r
            else:\r
                if not self.CompareVarAttr(VariableAttrs[(VariableName, VariableGuid)], VarAttribute):\r
                    EdkLogger.error('Build', PCD_VARIABLE_ATTRIBUTES_CONFLICT_ERROR, "The variable %s.%s for DynamicHii PCDs has conflicting attributes [%s] and [%s] " % (VariableGuid, VariableName, VarAttribute, VariableAttrs[(VariableName, VariableGuid)]))\r
            \r
            SkuInfo = SkuInfoClass(SkuName, self.SkuIds[SkuName], VariableName, VariableGuid, VariableOffset, DefaultValue, VariableAttribute = VarAttribute)\r
            pcdDecObject = self._DecPcds[PcdCName, TokenSpaceGuid]\r
            if (PcdCName,TokenSpaceGuid) in Pcds.keys():  \r
                pcdObject = Pcds[PcdCName,TokenSpaceGuid]\r
                pcdObject.SkuInfoList[SkuName] = SkuInfo\r
            else:\r
                Pcds[PcdCName, TokenSpaceGuid] = PcdClassObject(\r
                                                PcdCName,\r
                                                TokenSpaceGuid,\r
                                                self._PCD_TYPE_STRING_[Type],\r
                                                '',\r
                                                DefaultValue,\r
                                                '',\r
                                                '',\r
                                                {SkuName : SkuInfo},\r
                                                False,\r
                                                None,\r
                                                pcdDecObject.validateranges,\r
                                                pcdDecObject.validlists,\r
                                                pcdDecObject.expressions\r
                                                )\r
                \r
\r
        for pcd in Pcds.values():\r
            SkuInfoObj = pcd.SkuInfoList.values()[0]\r
            pcdDecObject = self._DecPcds[pcd.TokenCName,pcd.TokenSpaceGuidCName]\r
            # Only fix the value while no value provided in DSC file.\r
            for sku in pcd.SkuInfoList.values():\r
                if (sku.HiiDefaultValue == "" or sku.HiiDefaultValue==None):\r
                    sku.HiiDefaultValue = pcdDecObject.DefaultValue\r
            if 'DEFAULT' not in pcd.SkuInfoList.keys() and 'COMMON' not in pcd.SkuInfoList.keys():              \r
                valuefromDec = pcdDecObject.DefaultValue\r
                SkuInfo = SkuInfoClass('DEFAULT', '0', SkuInfoObj.VariableName, SkuInfoObj.VariableGuid, SkuInfoObj.VariableOffset, valuefromDec)\r
                pcd.SkuInfoList['DEFAULT'] = SkuInfo\r
            elif 'DEFAULT' not in pcd.SkuInfoList.keys() and 'COMMON' in pcd.SkuInfoList.keys():\r
                pcd.SkuInfoList['DEFAULT'] = pcd.SkuInfoList['COMMON']\r
                del(pcd.SkuInfoList['COMMON'])\r
            elif 'DEFAULT' in pcd.SkuInfoList.keys() and 'COMMON' in pcd.SkuInfoList.keys():\r
                del(pcd.SkuInfoList['COMMON'])\r
                \r
            if SkuObj.SkuUsageType == SkuObj.SINGLE:\r
                if 'DEFAULT' in pcd.SkuInfoList.keys() and SkuObj.SystemSkuId not in pcd.SkuInfoList.keys():\r
                    pcd.SkuInfoList[SkuObj.SystemSkuId] = pcd.SkuInfoList['DEFAULT']\r
                del(pcd.SkuInfoList['DEFAULT'])\r
            \r
            \r
            if pcd.MaxDatumSize.strip(): \r
                MaxSize = int(pcd.MaxDatumSize,0)\r
            else:\r
                MaxSize = 0\r
            if pcdDecObject.DatumType == 'VOID*':\r
                for (skuname,skuobj) in pcd.SkuInfoList.items():\r
                    datalen = 0\r
                    if skuobj.HiiDefaultValue.startswith("L"):\r
                        datalen = (len(skuobj.HiiDefaultValue)- 3 + 1) * 2\r
                    elif skuobj.HiiDefaultValue.startswith("{"):\r
                        datalen = len(skuobj.HiiDefaultValue.split(","))\r
                    else:\r
                        datalen = len(skuobj.HiiDefaultValue) -2 + 1 \r
                    if datalen>MaxSize:\r
                        MaxSize = datalen\r
                pcd.MaxDatumSize = str(MaxSize)\r
        return Pcds\r
\r
    ## Retrieve dynamic VPD PCD settings\r
    #\r
    #   @param  Type    PCD type\r
    #\r
    #   @retval a dict object contains settings of given PCD type\r
    #\r
    def _GetDynamicVpdPcd(self, Type):\r
        \r
        SkuObj = SkuClass(self.SkuIdentifier,self.SkuIds)\r
        \r
        Pcds = sdict()\r
        #\r
        # tdict is a special dict kind of type, used for selecting correct\r
        # PCD settings for certain ARCH and SKU\r
        #\r
        PcdDict = tdict(True, 4)\r
        PcdList = []\r
        # Find out all possible PCD candidates for self._Arch\r
        RecordList = self._RawData[Type, self._Arch]\r
        AvailableSkuIdSet = SkuObj.AvailableSkuIdSet.copy()\r
        \r
        AvailableSkuIdSet.update({'DEFAULT':0,'COMMON':0})\r
        for TokenSpaceGuid, PcdCName, Setting, Arch, SkuName, Dummy3, Dummy4 in RecordList:\r
            if SkuName not in AvailableSkuIdSet:\r
                continue\r
\r
            PcdList.append((PcdCName, TokenSpaceGuid,SkuName, Dummy4))\r
            PcdDict[Arch, SkuName, PcdCName, TokenSpaceGuid] = Setting\r
        # Remove redundant PCD candidates, per the ARCH and SKU\r
        for PcdCName, TokenSpaceGuid, SkuName,Dummy4 in PcdList:\r
            Setting = PcdDict[self._Arch, SkuName, PcdCName, TokenSpaceGuid]\r
            if Setting == None:\r
                continue\r
            #\r
            # For the VOID* type, it can have optional data of MaxDatumSize and InitialValue\r
            # For the Integer & Boolean type, the optional data can only be InitialValue.\r
            # At this point, we put all the data into the PcdClssObject for we don't know the PCD's datumtype\r
            # until the DEC parser has been called.\r
            # \r
            VpdOffset, MaxDatumSize, InitialValue = self._ValidatePcd(PcdCName, TokenSpaceGuid, Setting, Type, Dummy4)\r
            SkuInfo = SkuInfoClass(SkuName, self.SkuIds[SkuName], '', '', '', '', VpdOffset, InitialValue)\r
            if (PcdCName,TokenSpaceGuid) in Pcds.keys():  \r
                pcdObject = Pcds[PcdCName,TokenSpaceGuid]\r
                pcdObject.SkuInfoList[SkuName] = SkuInfo\r
                if MaxDatumSize.strip():\r
                    CurrentMaxSize = int(MaxDatumSize.strip(),0)\r
                else:\r
                    CurrentMaxSize = 0\r
                if pcdObject.MaxDatumSize:\r
                    PcdMaxSize = int(pcdObject.MaxDatumSize,0)\r
                else:\r
                    PcdMaxSize = 0\r
                if CurrentMaxSize > PcdMaxSize:\r
                    pcdObject.MaxDatumSize = str(CurrentMaxSize)\r
            else:\r
                Pcds[PcdCName, TokenSpaceGuid] = PcdClassObject(\r
                                                PcdCName,\r
                                                TokenSpaceGuid,\r
                                                self._PCD_TYPE_STRING_[Type],\r
                                                '',\r
                                                InitialValue,\r
                                                '',\r
                                                MaxDatumSize,\r
                                                {SkuName : SkuInfo},\r
                                                False,\r
                                                None\r
                                                )\r
        for pcd in Pcds.values():\r
            SkuInfoObj = pcd.SkuInfoList.values()[0]\r
            pcdDecObject = self._DecPcds[pcd.TokenCName,pcd.TokenSpaceGuidCName]\r
            if 'DEFAULT' not in pcd.SkuInfoList.keys() and 'COMMON' not in pcd.SkuInfoList.keys():\r
                valuefromDec = pcdDecObject.DefaultValue\r
                SkuInfo = SkuInfoClass('DEFAULT', '0', '', '', '','',SkuInfoObj.VpdOffset, valuefromDec)\r
                pcd.SkuInfoList['DEFAULT'] = SkuInfo\r
            elif 'DEFAULT' not in pcd.SkuInfoList.keys() and 'COMMON' in pcd.SkuInfoList.keys():\r
                pcd.SkuInfoList['DEFAULT'] = pcd.SkuInfoList['COMMON']\r
                del(pcd.SkuInfoList['COMMON'])\r
            elif 'DEFAULT' in pcd.SkuInfoList.keys() and 'COMMON' in pcd.SkuInfoList.keys():\r
                del(pcd.SkuInfoList['COMMON'])\r
            if SkuObj.SkuUsageType == SkuObj.SINGLE:\r
                if 'DEFAULT' in pcd.SkuInfoList.keys() and SkuObj.SystemSkuId not in pcd.SkuInfoList.keys():\r
                    pcd.SkuInfoList[SkuObj.SystemSkuId] = pcd.SkuInfoList['DEFAULT']\r
                del(pcd.SkuInfoList['DEFAULT'])\r
            \r
        return Pcds\r
\r
    ## Add external modules\r
    #\r
    #   The external modules are mostly those listed in FDF file, which don't\r
    # need "build".\r
    #\r
    #   @param  FilePath    The path of module description file\r
    #\r
    def AddModule(self, FilePath):\r
        FilePath = NormPath(FilePath)\r
        if FilePath not in self.Modules:\r
            Module = ModuleBuildClassObject()\r
            Module.MetaFile = FilePath\r
            self.Modules.append(Module)\r
\r
    ## Add external PCDs\r
    #\r
    #   The external PCDs are mostly those listed in FDF file to specify address\r
    # or offset information.\r
    #\r
    #   @param  Name    Name of the PCD\r
    #   @param  Guid    Token space guid of the PCD\r
    #   @param  Value   Value of the PCD\r
    #\r
    def AddPcd(self, Name, Guid, Value):\r
        if (Name, Guid) not in self.Pcds:\r
            self.Pcds[Name, Guid] = PcdClassObject(Name, Guid, '', '', '', '', '', {}, False, None)\r
        self.Pcds[Name, Guid].DefaultValue = Value\r
\r
    _Macros             = property(_GetMacros)\r
    Arch                = property(_GetArch, _SetArch)\r
    Platform            = property(_GetPlatformName)\r
    PlatformName        = property(_GetPlatformName)\r
    Guid                = property(_GetFileGuid)\r
    Version             = property(_GetVersion)\r
    DscSpecification    = property(_GetDscSpec)\r
    OutputDirectory     = property(_GetOutpuDir)\r
    SupArchList         = property(_GetSupArch)\r
    BuildTargets        = property(_GetBuildTarget)\r
    SkuName             = property(_GetSkuName, _SetSkuName)\r
    SkuIdentifier       = property(_GetSkuIdentifier)\r
    AvilableSkuIds = property(_GetAviableSkuIds)\r
    PcdInfoFlag         = property(_GetPcdInfoFlag)\r
    VarCheckFlag = property(_GetVarCheckFlag)\r
    FlashDefinition     = property(_GetFdfFile)\r
    BuildNumber         = property(_GetBuildNumber)\r
    MakefileName        = property(_GetMakefileName)\r
    BsBaseAddress       = property(_GetBsBaseAddress)\r
    RtBaseAddress       = property(_GetRtBaseAddress)\r
    LoadFixAddress      = property(_GetLoadFixAddress)\r
    RFCLanguages        = property(_GetRFCLanguages)\r
    ISOLanguages        = property(_GetISOLanguages)\r
    VpdToolGuid         = property(_GetVpdToolGuid)   \r
    SkuIds              = property(_GetSkuIds)\r
    Modules             = property(_GetModules)\r
    LibraryInstances    = property(_GetLibraryInstances)\r
    LibraryClasses      = property(_GetLibraryClasses)\r
    Pcds                = property(_GetPcds)\r
    BuildOptions        = property(_GetBuildOptions)\r
\r
## Platform build information from DEC file\r
#\r
#  This class is used to retrieve information stored in database and convert them\r
# into PackageBuildClassObject form for easier use for AutoGen.\r
#\r
class DecBuildData(PackageBuildClassObject):\r
    # dict used to convert PCD type in database to string used by build tool\r
    _PCD_TYPE_STRING_ = {\r
        MODEL_PCD_FIXED_AT_BUILD        :   "FixedAtBuild",\r
        MODEL_PCD_PATCHABLE_IN_MODULE   :   "PatchableInModule",\r
        MODEL_PCD_FEATURE_FLAG          :   "FeatureFlag",\r
        MODEL_PCD_DYNAMIC               :   "Dynamic",\r
        MODEL_PCD_DYNAMIC_DEFAULT       :   "Dynamic",\r
        MODEL_PCD_DYNAMIC_HII           :   "DynamicHii",\r
        MODEL_PCD_DYNAMIC_VPD           :   "DynamicVpd",\r
        MODEL_PCD_DYNAMIC_EX            :   "DynamicEx",\r
        MODEL_PCD_DYNAMIC_EX_DEFAULT    :   "DynamicEx",\r
        MODEL_PCD_DYNAMIC_EX_HII        :   "DynamicExHii",\r
        MODEL_PCD_DYNAMIC_EX_VPD        :   "DynamicExVpd",\r
    }\r
\r
    # dict used to convert part of [Defines] to members of DecBuildData directly\r
    _PROPERTY_ = {\r
        #\r
        # Required Fields\r
        #\r
        TAB_DEC_DEFINES_PACKAGE_NAME                : "_PackageName",\r
        TAB_DEC_DEFINES_PACKAGE_GUID                : "_Guid",\r
        TAB_DEC_DEFINES_PACKAGE_VERSION             : "_Version",\r
        TAB_DEC_DEFINES_PKG_UNI_FILE                : "_PkgUniFile",\r
    }\r
\r
\r
    ## Constructor of DecBuildData\r
    #\r
    #  Initialize object of DecBuildData\r
    #\r
    #   @param      FilePath        The path of package description file\r
    #   @param      RawData         The raw data of DEC file\r
    #   @param      BuildDataBase   Database used to retrieve module information\r
    #   @param      Arch            The target architecture\r
    #   @param      Platform        (not used for DecBuildData)\r
    #   @param      Macros          Macros used for replacement in DSC file\r
    #\r
    def __init__(self, File, RawData, BuildDataBase, Arch='COMMON', Target=None, Toolchain=None):\r
        self.MetaFile = File\r
        self._PackageDir = File.Dir\r
        self._RawData = RawData\r
        self._Bdb = BuildDataBase\r
        self._Arch = Arch\r
        self._Target = Target\r
        self._Toolchain = Toolchain\r
        self._Clear()\r
\r
    ## XXX[key] = value\r
    def __setitem__(self, key, value):\r
        self.__dict__[self._PROPERTY_[key]] = value\r
\r
    ## value = XXX[key]\r
    def __getitem__(self, key):\r
        return self.__dict__[self._PROPERTY_[key]]\r
\r
    ## "in" test support\r
    def __contains__(self, key):\r
        return key in self._PROPERTY_\r
\r
    ## Set all internal used members of DecBuildData to None\r
    def _Clear(self):\r
        self._Header            = None\r
        self._PackageName       = None\r
        self._Guid              = None\r
        self._Version           = None\r
        self._PkgUniFile        = None\r
        self._Protocols         = None\r
        self._Ppis              = None\r
        self._Guids             = None\r
        self._Includes          = None\r
        self._LibraryClasses    = None\r
        self._Pcds              = None\r
        self.__Macros           = None\r
\r
    ## Get current effective macros\r
    def _GetMacros(self):\r
        if self.__Macros == None:\r
            self.__Macros = {}\r
            self.__Macros.update(GlobalData.gGlobalDefines)\r
        return self.__Macros\r
\r
    ## Get architecture\r
    def _GetArch(self):\r
        return self._Arch\r
\r
    ## Set architecture\r
    #\r
    #   Changing the default ARCH to another may affect all other information\r
    # because all information in a platform may be ARCH-related. That's\r
    # why we need to clear all internal used members, in order to cause all\r
    # information to be re-retrieved.\r
    #\r
    #   @param  Value   The value of ARCH\r
    #\r
    def _SetArch(self, Value):\r
        if self._Arch == Value:\r
            return\r
        self._Arch = Value\r
        self._Clear()\r
\r
    ## Retrieve all information in [Defines] section\r
    #\r
    #   (Retriving all [Defines] information in one-shot is just to save time.)\r
    #\r
    def _GetHeaderInfo(self):\r
        RecordList = self._RawData[MODEL_META_DATA_HEADER, self._Arch]\r
        for Record in RecordList:\r
            Name = Record[1]\r
            if Name in self:\r
                self[Name] = Record[2]\r
        self._Header = 'DUMMY'\r
\r
    ## Retrieve package name\r
    def _GetPackageName(self):\r
        if self._PackageName == None:\r
            if self._Header == None:\r
                self._GetHeaderInfo()\r
            if self._PackageName == None:\r
                EdkLogger.error("build", ATTRIBUTE_NOT_AVAILABLE, "No PACKAGE_NAME", File=self.MetaFile)\r
        return self._PackageName\r
\r
    ## Retrieve file guid\r
    def _GetFileGuid(self):\r
        if self._Guid == None:\r
            if self._Header == None:\r
                self._GetHeaderInfo()\r
            if self._Guid == None:\r
                EdkLogger.error("build", ATTRIBUTE_NOT_AVAILABLE, "No PACKAGE_GUID", File=self.MetaFile)\r
        return self._Guid\r
\r
    ## Retrieve package version\r
    def _GetVersion(self):\r
        if self._Version == None:\r
            if self._Header == None:\r
                self._GetHeaderInfo()\r
            if self._Version == None:\r
                self._Version = ''\r
        return self._Version\r
\r
    ## Retrieve protocol definitions (name/value pairs)\r
    def _GetProtocol(self):\r
        if self._Protocols == None:\r
            #\r
            # tdict is a special kind of dict, used for selecting correct\r
            # protocol defition for given ARCH\r
            #\r
            ProtocolDict = tdict(True)\r
            NameList = []\r
            # find out all protocol definitions for specific and 'common' arch\r
            RecordList = self._RawData[MODEL_EFI_PROTOCOL, self._Arch]\r
            for Name, Guid, Dummy, Arch, ID, LineNo in RecordList:\r
                if Name not in NameList:\r
                    NameList.append(Name)\r
                ProtocolDict[Arch, Name] = Guid\r
            # use sdict to keep the order\r
            self._Protocols = sdict()\r
            for Name in NameList:\r
                #\r
                # limit the ARCH to self._Arch, if no self._Arch found, tdict\r
                # will automatically turn to 'common' ARCH for trying\r
                #\r
                self._Protocols[Name] = ProtocolDict[self._Arch, Name]\r
        return self._Protocols\r
\r
    ## Retrieve PPI definitions (name/value pairs)\r
    def _GetPpi(self):\r
        if self._Ppis == None:\r
            #\r
            # tdict is a special kind of dict, used for selecting correct\r
            # PPI defition for given ARCH\r
            #\r
            PpiDict = tdict(True)\r
            NameList = []\r
            # find out all PPI definitions for specific arch and 'common' arch\r
            RecordList = self._RawData[MODEL_EFI_PPI, self._Arch]\r
            for Name, Guid, Dummy, Arch, ID, LineNo in RecordList:\r
                if Name not in NameList:\r
                    NameList.append(Name)\r
                PpiDict[Arch, Name] = Guid\r
            # use sdict to keep the order\r
            self._Ppis = sdict()\r
            for Name in NameList:\r
                #\r
                # limit the ARCH to self._Arch, if no self._Arch found, tdict\r
                # will automatically turn to 'common' ARCH for trying\r
                #\r
                self._Ppis[Name] = PpiDict[self._Arch, Name]\r
        return self._Ppis\r
\r
    ## Retrieve GUID definitions (name/value pairs)\r
    def _GetGuid(self):\r
        if self._Guids == None:\r
            #\r
            # tdict is a special kind of dict, used for selecting correct\r
            # GUID defition for given ARCH\r
            #\r
            GuidDict = tdict(True)\r
            NameList = []\r
            # find out all protocol definitions for specific and 'common' arch\r
            RecordList = self._RawData[MODEL_EFI_GUID, self._Arch]\r
            for Name, Guid, Dummy, Arch, ID, LineNo in RecordList:\r
                if Name not in NameList:\r
                    NameList.append(Name)\r
                GuidDict[Arch, Name] = Guid\r
            # use sdict to keep the order\r
            self._Guids = sdict()\r
            for Name in NameList:\r
                #\r
                # limit the ARCH to self._Arch, if no self._Arch found, tdict\r
                # will automatically turn to 'common' ARCH for trying\r
                #\r
                self._Guids[Name] = GuidDict[self._Arch, Name]\r
        return self._Guids\r
\r
    ## Retrieve public include paths declared in this package\r
    def _GetInclude(self):\r
        if self._Includes == None:\r
            self._Includes = []\r
            RecordList = self._RawData[MODEL_EFI_INCLUDE, self._Arch]\r
            Macros = self._Macros\r
            Macros["EDK_SOURCE"] = GlobalData.gEcpSource\r
            for Record in RecordList:\r
                File = PathClass(NormPath(Record[0], Macros), self._PackageDir, Arch=self._Arch)\r
                LineNo = Record[-1]\r
                # validate the path\r
                ErrorCode, ErrorInfo = File.Validate()\r
                if ErrorCode != 0:\r
                    EdkLogger.error('build', ErrorCode, ExtraData=ErrorInfo, File=self.MetaFile, Line=LineNo)\r
\r
                # avoid duplicate include path\r
                if File not in self._Includes:\r
                    self._Includes.append(File)\r
        return self._Includes\r
\r
    ## Retrieve library class declarations (not used in build at present)\r
    def _GetLibraryClass(self):\r
        if self._LibraryClasses == None:\r
            #\r
            # tdict is a special kind of dict, used for selecting correct\r
            # library class declaration for given ARCH\r
            #\r
            LibraryClassDict = tdict(True)\r
            LibraryClassSet = set()\r
            RecordList = self._RawData[MODEL_EFI_LIBRARY_CLASS, self._Arch]\r
            Macros = self._Macros\r
            for LibraryClass, File, Dummy, Arch, ID, LineNo in RecordList:\r
                File = PathClass(NormPath(File, Macros), self._PackageDir, Arch=self._Arch)\r
                # check the file validation\r
                ErrorCode, ErrorInfo = File.Validate()\r
                if ErrorCode != 0:\r
                    EdkLogger.error('build', ErrorCode, ExtraData=ErrorInfo, File=self.MetaFile, Line=LineNo)\r
                LibraryClassSet.add(LibraryClass)\r
                LibraryClassDict[Arch, LibraryClass] = File\r
            self._LibraryClasses = sdict()\r
            for LibraryClass in LibraryClassSet:\r
                self._LibraryClasses[LibraryClass] = LibraryClassDict[self._Arch, LibraryClass]\r
        return self._LibraryClasses\r
\r
    ## Retrieve PCD declarations\r
    def _GetPcds(self):\r
        if self._Pcds == None:\r
            self._Pcds = sdict()\r
            self._Pcds.update(self._GetPcd(MODEL_PCD_FIXED_AT_BUILD))\r
            self._Pcds.update(self._GetPcd(MODEL_PCD_PATCHABLE_IN_MODULE))\r
            self._Pcds.update(self._GetPcd(MODEL_PCD_FEATURE_FLAG))\r
            self._Pcds.update(self._GetPcd(MODEL_PCD_DYNAMIC))\r
            self._Pcds.update(self._GetPcd(MODEL_PCD_DYNAMIC_EX))\r
        return self._Pcds\r
\r
    ## Retrieve PCD declarations for given type\r
    def _GetPcd(self, Type):\r
        Pcds = sdict()\r
        #\r
        # tdict is a special kind of dict, used for selecting correct\r
        # PCD declaration for given ARCH\r
        #\r
        PcdDict = tdict(True, 3)\r
        # for summarizing PCD\r
        PcdSet = set()\r
        # find out all PCDs of the 'type'\r
        RecordList = self._RawData[Type, self._Arch]\r
        for TokenSpaceGuid, PcdCName, Setting, Arch, Dummy1, Dummy2 in RecordList:\r
            PcdDict[Arch, PcdCName, TokenSpaceGuid] = Setting\r
            PcdSet.add((PcdCName, TokenSpaceGuid))\r
\r
        for PcdCName, TokenSpaceGuid in PcdSet:\r
            #\r
            # limit the ARCH to self._Arch, if no self._Arch found, tdict\r
            # will automatically turn to 'common' ARCH and try again\r
            #\r
            Setting = PcdDict[self._Arch, PcdCName, TokenSpaceGuid]\r
            if Setting == None:\r
                continue\r
\r
            DefaultValue, DatumType, TokenNumber = AnalyzePcdData(Setting)\r
                                       \r
            validateranges, validlists, expressions = self._RawData.GetValidExpression(TokenSpaceGuid, PcdCName)                          \r
            Pcds[PcdCName, TokenSpaceGuid, self._PCD_TYPE_STRING_[Type]] = PcdClassObject(\r
                                                                            PcdCName,\r
                                                                            TokenSpaceGuid,\r
                                                                            self._PCD_TYPE_STRING_[Type],\r
                                                                            DatumType,\r
                                                                            DefaultValue,\r
                                                                            TokenNumber,\r
                                                                            '',\r
                                                                            {},\r
                                                                            False,\r
                                                                            None,\r
                                                                            list(validateranges),\r
                                                                            list(validlists),\r
                                                                            list(expressions)\r
                                                                            )\r
        return Pcds\r
\r
\r
    _Macros         = property(_GetMacros)\r
    Arch            = property(_GetArch, _SetArch)\r
    PackageName     = property(_GetPackageName)\r
    Guid            = property(_GetFileGuid)\r
    Version         = property(_GetVersion)\r
\r
    Protocols       = property(_GetProtocol)\r
    Ppis            = property(_GetPpi)\r
    Guids           = property(_GetGuid)\r
    Includes        = property(_GetInclude)\r
    LibraryClasses  = property(_GetLibraryClass)\r
    Pcds            = property(_GetPcds)\r
\r
## Module build information from INF file\r
#\r
#  This class is used to retrieve information stored in database and convert them\r
# into ModuleBuildClassObject form for easier use for AutoGen.\r
#\r
class InfBuildData(ModuleBuildClassObject):\r
    # dict used to convert PCD type in database to string used by build tool\r
    _PCD_TYPE_STRING_ = {\r
        MODEL_PCD_FIXED_AT_BUILD        :   "FixedAtBuild",\r
        MODEL_PCD_PATCHABLE_IN_MODULE   :   "PatchableInModule",\r
        MODEL_PCD_FEATURE_FLAG          :   "FeatureFlag",\r
        MODEL_PCD_DYNAMIC               :   "Dynamic",\r
        MODEL_PCD_DYNAMIC_DEFAULT       :   "Dynamic",\r
        MODEL_PCD_DYNAMIC_HII           :   "DynamicHii",\r
        MODEL_PCD_DYNAMIC_VPD           :   "DynamicVpd",\r
        MODEL_PCD_DYNAMIC_EX            :   "DynamicEx",\r
        MODEL_PCD_DYNAMIC_EX_DEFAULT    :   "DynamicEx",\r
        MODEL_PCD_DYNAMIC_EX_HII        :   "DynamicExHii",\r
        MODEL_PCD_DYNAMIC_EX_VPD        :   "DynamicExVpd",\r
    }\r
\r
    # dict used to convert part of [Defines] to members of InfBuildData directly\r
    _PROPERTY_ = {\r
        #\r
        # Required Fields\r
        #\r
        TAB_INF_DEFINES_BASE_NAME                   : "_BaseName",\r
        TAB_INF_DEFINES_FILE_GUID                   : "_Guid",\r
        TAB_INF_DEFINES_MODULE_TYPE                 : "_ModuleType",\r
        #\r
        # Optional Fields\r
        #\r
        #TAB_INF_DEFINES_INF_VERSION                 : "_AutoGenVersion",\r
        TAB_INF_DEFINES_COMPONENT_TYPE              : "_ComponentType",\r
        TAB_INF_DEFINES_MAKEFILE_NAME               : "_MakefileName",\r
        #TAB_INF_DEFINES_CUSTOM_MAKEFILE             : "_CustomMakefile",\r
        TAB_INF_DEFINES_DPX_SOURCE                  :"_DxsFile",\r
        TAB_INF_DEFINES_VERSION_NUMBER              : "_Version",\r
        TAB_INF_DEFINES_VERSION_STRING              : "_Version",\r
        TAB_INF_DEFINES_VERSION                     : "_Version",\r
        TAB_INF_DEFINES_PCD_IS_DRIVER               : "_PcdIsDriver",\r
        TAB_INF_DEFINES_SHADOW                      : "_Shadow",\r
\r
        TAB_COMPONENTS_SOURCE_OVERRIDE_PATH         : "_SourceOverridePath",\r
    }\r
\r
    # dict used to convert Component type to Module type\r
    _MODULE_TYPE_ = {\r
        "LIBRARY"               :   "BASE",\r
        "SECURITY_CORE"         :   "SEC",\r
        "PEI_CORE"              :   "PEI_CORE",\r
        "COMBINED_PEIM_DRIVER"  :   "PEIM",\r
        "PIC_PEIM"              :   "PEIM",\r
        "RELOCATABLE_PEIM"      :   "PEIM",\r
        "PE32_PEIM"             :   "PEIM",\r
        "BS_DRIVER"             :   "DXE_DRIVER",\r
        "RT_DRIVER"             :   "DXE_RUNTIME_DRIVER",\r
        "SAL_RT_DRIVER"         :   "DXE_SAL_DRIVER",\r
        "DXE_SMM_DRIVER"        :   "DXE_SMM_DRIVER",\r
    #    "SMM_DRIVER"            :   "DXE_SMM_DRIVER",\r
    #    "BS_DRIVER"             :   "DXE_SMM_DRIVER",\r
    #    "BS_DRIVER"             :   "UEFI_DRIVER",\r
        "APPLICATION"           :   "UEFI_APPLICATION",\r
        "LOGO"                  :   "BASE",\r
    }\r
\r
    # regular expression for converting XXX_FLAGS in [nmake] section to new type\r
    _NMAKE_FLAG_PATTERN_ = re.compile("(?:EBC_)?([A-Z]+)_(?:STD_|PROJ_|ARCH_)?FLAGS(?:_DLL|_ASL|_EXE)?", re.UNICODE)\r
    # dict used to convert old tool name used in [nmake] section to new ones\r
    _TOOL_CODE_ = {\r
        "C"         :   "CC",\r
        "LIB"       :   "SLINK",\r
        "LINK"      :   "DLINK",\r
    }\r
\r
\r
    ## Constructor of DscBuildData\r
    #\r
    #  Initialize object of DscBuildData\r
    #\r
    #   @param      FilePath        The path of platform description file\r
    #   @param      RawData         The raw data of DSC file\r
    #   @param      BuildDataBase   Database used to retrieve module/package information\r
    #   @param      Arch            The target architecture\r
    #   @param      Platform        The name of platform employing this module\r
    #   @param      Macros          Macros used for replacement in DSC file\r
    #\r
    def __init__(self, FilePath, RawData, BuildDatabase, Arch='COMMON', Target=None, Toolchain=None):\r
        self.MetaFile = FilePath\r
        self._ModuleDir = FilePath.Dir\r
        self._RawData = RawData\r
        self._Bdb = BuildDatabase\r
        self._Arch = Arch\r
        self._Target = Target\r
        self._Toolchain = Toolchain\r
        self._Platform = 'COMMON'\r
        self._SourceOverridePath = None\r
        if FilePath.Key in GlobalData.gOverrideDir:\r
            self._SourceOverridePath = GlobalData.gOverrideDir[FilePath.Key]\r
        self._Clear()\r
\r
    ## XXX[key] = value\r
    def __setitem__(self, key, value):\r
        self.__dict__[self._PROPERTY_[key]] = value\r
\r
    ## value = XXX[key]\r
    def __getitem__(self, key):\r
        return self.__dict__[self._PROPERTY_[key]]\r
\r
    ## "in" test support\r
    def __contains__(self, key):\r
        return key in self._PROPERTY_\r
\r
    ## Set all internal used members of InfBuildData to None\r
    def _Clear(self):\r
        self._HeaderComments = None\r
        self._TailComments = None\r
        self._Header_               = None\r
        self._AutoGenVersion        = None\r
        self._BaseName              = None\r
        self._DxsFile               = None\r
        self._ModuleType            = None\r
        self._ComponentType         = None\r
        self._BuildType             = None\r
        self._Guid                  = None\r
        self._Version               = None\r
        self._PcdIsDriver           = None\r
        self._BinaryModule          = None\r
        self._Shadow                = None\r
        self._MakefileName          = None\r
        self._CustomMakefile        = None\r
        self._Specification         = None\r
        self._LibraryClass          = None\r
        self._ModuleEntryPointList  = None\r
        self._ModuleUnloadImageList = None\r
        self._ConstructorList       = None\r
        self._DestructorList        = None\r
        self._Defs                  = None\r
        self._Binaries              = None\r
        self._Sources               = None\r
        self._LibraryClasses        = None\r
        self._Libraries             = None\r
        self._Protocols             = None\r
        self._ProtocolComments = None\r
        self._Ppis                  = None\r
        self._PpiComments = None\r
        self._Guids                 = None\r
        self._GuidsUsedByPcd = sdict()\r
        self._GuidComments = None\r
        self._Includes              = None\r
        self._Packages              = None\r
        self._Pcds                  = None\r
        self._PcdComments = None\r
        self._BuildOptions          = None\r
        self._Depex                 = None\r
        self._DepexExpression       = None\r
        self.__Macros               = None\r
\r
    ## Get current effective macros\r
    def _GetMacros(self):\r
        if self.__Macros == None:\r
            self.__Macros = {}\r
            # EDK_GLOBAL defined macros can be applied to EDK module\r
            if self.AutoGenVersion < 0x00010005:\r
                self.__Macros.update(GlobalData.gEdkGlobal)\r
                self.__Macros.update(GlobalData.gGlobalDefines)\r
        return self.__Macros\r
\r
    ## Get architecture\r
    def _GetArch(self):\r
        return self._Arch\r
\r
    ## Set architecture\r
    #\r
    #   Changing the default ARCH to another may affect all other information\r
    # because all information in a platform may be ARCH-related. That's\r
    # why we need to clear all internal used members, in order to cause all\r
    # information to be re-retrieved.\r
    #\r
    #   @param  Value   The value of ARCH\r
    #\r
    def _SetArch(self, Value):\r
        if self._Arch == Value:\r
            return\r
        self._Arch = Value\r
        self._Clear()\r
\r
    ## Return the name of platform employing this module\r
    def _GetPlatform(self):\r
        return self._Platform\r
\r
    ## Change the name of platform employing this module\r
    #\r
    #   Changing the default name of platform to another may affect some information\r
    # because they may be PLATFORM-related. That's why we need to clear all internal\r
    # used members, in order to cause all information to be re-retrieved.\r
    #\r
    def _SetPlatform(self, Value):\r
        if self._Platform == Value:\r
            return\r
        self._Platform = Value\r
        self._Clear()\r
    def _GetHeaderComments(self):\r
        if not self._HeaderComments:\r
            self._HeaderComments = []\r
            RecordList = self._RawData[MODEL_META_DATA_HEADER_COMMENT]\r
            for Record in RecordList:\r
                self._HeaderComments.append(Record[0])\r
        return self._HeaderComments\r
    def _GetTailComments(self):\r
        if not self._TailComments:\r
            self._TailComments = []\r
            RecordList = self._RawData[MODEL_META_DATA_TAIL_COMMENT]\r
            for Record in RecordList:\r
                self._TailComments.append(Record[0])\r
        return self._TailComments\r
    ## Retrieve all information in [Defines] section\r
    #\r
    #   (Retriving all [Defines] information in one-shot is just to save time.)\r
    #\r
    def _GetHeaderInfo(self):\r
        RecordList = self._RawData[MODEL_META_DATA_HEADER, self._Arch, self._Platform]\r
        for Record in RecordList:\r
            Name, Value = Record[1], ReplaceMacro(Record[2], self._Macros, False)\r
            # items defined _PROPERTY_ don't need additional processing\r
            if Name in self:\r
                self[Name] = Value\r
                if self._Defs == None:\r
                    self._Defs = sdict()\r
                self._Defs[Name] = Value\r
            # some special items in [Defines] section need special treatment\r
            elif Name in ('EFI_SPECIFICATION_VERSION', 'UEFI_SPECIFICATION_VERSION', 'EDK_RELEASE_VERSION', 'PI_SPECIFICATION_VERSION'):\r
                if Name in ('EFI_SPECIFICATION_VERSION', 'UEFI_SPECIFICATION_VERSION'):\r
                    Name = 'UEFI_SPECIFICATION_VERSION'\r
                if self._Specification == None:\r
                    self._Specification = sdict()\r
                self._Specification[Name] = GetHexVerValue(Value)\r
                if self._Specification[Name] == None:\r
                    EdkLogger.error("build", FORMAT_NOT_SUPPORTED,\r
                                    "'%s' format is not supported for %s" % (Value, Name),\r
                                    File=self.MetaFile, Line=Record[-1])\r
            elif Name == 'LIBRARY_CLASS':\r
                if self._LibraryClass == None:\r
                    self._LibraryClass = []\r
                ValueList = GetSplitValueList(Value)\r
                LibraryClass = ValueList[0]\r
                if len(ValueList) > 1:\r
                    SupModuleList = GetSplitValueList(ValueList[1], ' ')\r
                else:\r
                    SupModuleList = SUP_MODULE_LIST\r
                self._LibraryClass.append(LibraryClassObject(LibraryClass, SupModuleList))\r
            elif Name == 'ENTRY_POINT':\r
                if self._ModuleEntryPointList == None:\r
                    self._ModuleEntryPointList = []\r
                self._ModuleEntryPointList.append(Value)\r
            elif Name == 'UNLOAD_IMAGE':\r
                if self._ModuleUnloadImageList == None:\r
                    self._ModuleUnloadImageList = []\r
                if not Value:\r
                    continue\r
                self._ModuleUnloadImageList.append(Value)\r
            elif Name == 'CONSTRUCTOR':\r
                if self._ConstructorList == None:\r
                    self._ConstructorList = []\r
                if not Value:\r
                    continue\r
                self._ConstructorList.append(Value)\r
            elif Name == 'DESTRUCTOR':\r
                if self._DestructorList == None:\r
                    self._DestructorList = []\r
                if not Value:\r
                    continue\r
                self._DestructorList.append(Value)\r
            elif Name == TAB_INF_DEFINES_CUSTOM_MAKEFILE:\r
                TokenList = GetSplitValueList(Value)\r
                if self._CustomMakefile == None:\r
                    self._CustomMakefile = {}\r
                if len(TokenList) < 2:\r
                    self._CustomMakefile['MSFT'] = TokenList[0]\r
                    self._CustomMakefile['GCC'] = TokenList[0]\r
                else:\r
                    if TokenList[0] not in ['MSFT', 'GCC']:\r
                        EdkLogger.error("build", FORMAT_NOT_SUPPORTED,\r
                                        "No supported family [%s]" % TokenList[0],\r
                                        File=self.MetaFile, Line=Record[-1])\r
                    self._CustomMakefile[TokenList[0]] = TokenList[1]\r
            else:\r
                if self._Defs == None:\r
                    self._Defs = sdict()\r
                self._Defs[Name] = Value\r
\r
        #\r
        # Retrieve information in sections specific to Edk.x modules\r
        #\r
        if self.AutoGenVersion >= 0x00010005:\r
            if not self._ModuleType:\r
                EdkLogger.error("build", ATTRIBUTE_NOT_AVAILABLE,\r
                                "MODULE_TYPE is not given", File=self.MetaFile)\r
            if self._ModuleType not in SUP_MODULE_LIST:\r
                RecordList = self._RawData[MODEL_META_DATA_HEADER, self._Arch, self._Platform]\r
                for Record in RecordList:\r
                    Name = Record[1]\r
                    if Name == "MODULE_TYPE":\r
                        LineNo = Record[6]\r
                        break\r
                EdkLogger.error("build", FORMAT_NOT_SUPPORTED,\r
                                "MODULE_TYPE %s is not supported for EDK II, valid values are:\n %s" % (self._ModuleType,' '.join(l for l in SUP_MODULE_LIST)), \r
                                File=self.MetaFile, Line=LineNo)\r
            if (self._Specification == None) or (not 'PI_SPECIFICATION_VERSION' in self._Specification) or (int(self._Specification['PI_SPECIFICATION_VERSION'], 16) < 0x0001000A):\r
                if self._ModuleType == SUP_MODULE_SMM_CORE:\r
                    EdkLogger.error("build", FORMAT_NOT_SUPPORTED, "SMM_CORE module type can't be used in the module with PI_SPECIFICATION_VERSION less than 0x0001000A", File=self.MetaFile)                \r
            if self._Defs and 'PCI_DEVICE_ID' in self._Defs and 'PCI_VENDOR_ID' in self._Defs \\r
               and 'PCI_CLASS_CODE' in self._Defs:\r
                self._BuildType = 'UEFI_OPTIONROM'\r
            elif self._Defs and 'UEFI_HII_RESOURCE_SECTION' in self._Defs \\r
               and self._Defs['UEFI_HII_RESOURCE_SECTION'] == 'TRUE':\r
                self._BuildType = 'UEFI_HII'\r
            else:\r
                self._BuildType = self._ModuleType.upper()\r
            \r
            if self._DxsFile:\r
                File = PathClass(NormPath(self._DxsFile), self._ModuleDir, Arch=self._Arch)\r
                # check the file validation\r
                ErrorCode, ErrorInfo = File.Validate(".dxs", CaseSensitive=False)\r
                if ErrorCode != 0:\r
                    EdkLogger.error('build', ErrorCode, ExtraData=ErrorInfo,\r
                                    File=self.MetaFile, Line=LineNo)\r
                if self.Sources == None:\r
                    self._Sources = []\r
                self._Sources.append(File)\r
        else:  \r
            if not self._ComponentType:\r
                EdkLogger.error("build", ATTRIBUTE_NOT_AVAILABLE,\r
                                "COMPONENT_TYPE is not given", File=self.MetaFile)\r
            self._BuildType = self._ComponentType.upper()                \r
            if self._ComponentType in self._MODULE_TYPE_:\r
                self._ModuleType = self._MODULE_TYPE_[self._ComponentType]\r
            if self._ComponentType == 'LIBRARY':\r
                self._LibraryClass = [LibraryClassObject(self._BaseName, SUP_MODULE_LIST)]\r
            # make use some [nmake] section macros\r
            Macros = self._Macros\r
            Macros["EDK_SOURCE"] = GlobalData.gEcpSource\r
            Macros['PROCESSOR'] = self._Arch\r
            RecordList = self._RawData[MODEL_META_DATA_NMAKE, self._Arch, self._Platform]\r
            for Name,Value,Dummy,Arch,Platform,ID,LineNo in RecordList:\r
                Value = ReplaceMacro(Value, Macros, True)\r
                if Name == "IMAGE_ENTRY_POINT":\r
                    if self._ModuleEntryPointList == None:\r
                        self._ModuleEntryPointList = []\r
                    self._ModuleEntryPointList.append(Value)\r
                elif Name == "DPX_SOURCE":\r
                    File = PathClass(NormPath(Value), self._ModuleDir, Arch=self._Arch)\r
                    # check the file validation\r
                    ErrorCode, ErrorInfo = File.Validate(".dxs", CaseSensitive=False)\r
                    if ErrorCode != 0:\r
                        EdkLogger.error('build', ErrorCode, ExtraData=ErrorInfo,\r
                                        File=self.MetaFile, Line=LineNo)\r
                    if self.Sources == None:\r
                        self._Sources = []\r
                    self._Sources.append(File)\r
                else:\r
                    ToolList = self._NMAKE_FLAG_PATTERN_.findall(Name)\r
                    if len(ToolList) == 0 or len(ToolList) != 1:\r
                        pass\r
#                        EdkLogger.warn("build", "Don't know how to do with macro [%s]" % Name,\r
#                                       File=self.MetaFile, Line=LineNo)\r
                    else:\r
                        if self._BuildOptions == None:\r
                            self._BuildOptions = sdict()\r
\r
                        if ToolList[0] in self._TOOL_CODE_:\r
                            Tool = self._TOOL_CODE_[ToolList[0]]\r
                        else:\r
                            Tool = ToolList[0]\r
                        ToolChain = "*_*_*_%s_FLAGS" % Tool\r
                        ToolChainFamily = 'MSFT'    # Edk.x only support MSFT tool chain\r
                        #ignore not replaced macros in value\r
                        ValueList = GetSplitList(' ' + Value, '/D')\r
                        Dummy = ValueList[0]\r
                        for Index in range(1, len(ValueList)):\r
                            if ValueList[Index][-1] == '=' or ValueList[Index] == '':\r
                                continue\r
                            Dummy = Dummy + ' /D ' + ValueList[Index]\r
                        Value = Dummy.strip()\r
                        if (ToolChainFamily, ToolChain) not in self._BuildOptions:\r
                            self._BuildOptions[ToolChainFamily, ToolChain] = Value\r
                        else:\r
                            OptionString = self._BuildOptions[ToolChainFamily, ToolChain]\r
                            self._BuildOptions[ToolChainFamily, ToolChain] = OptionString + " " + Value\r
        # set _Header to non-None in order to avoid database re-querying\r
        self._Header_ = 'DUMMY'\r
\r
    ## Retrieve file version\r
    def _GetInfVersion(self):\r
        if self._AutoGenVersion == None:\r
            RecordList = self._RawData[MODEL_META_DATA_HEADER, self._Arch, self._Platform]\r
            for Record in RecordList:\r
                if Record[1] == TAB_INF_DEFINES_INF_VERSION:\r
                    self._AutoGenVersion = int(Record[2], 0)\r
                    break\r
            if self._AutoGenVersion == None:\r
                self._AutoGenVersion = 0x00010000\r
        return self._AutoGenVersion\r
\r
    ## Retrieve BASE_NAME\r
    def _GetBaseName(self):\r
        if self._BaseName == None:\r
            if self._Header_ == None:\r
                self._GetHeaderInfo()\r
            if self._BaseName == None:\r
                EdkLogger.error('build', ATTRIBUTE_NOT_AVAILABLE, "No BASE_NAME name", File=self.MetaFile)\r
        return self._BaseName\r
\r
    ## Retrieve DxsFile\r
    def _GetDxsFile(self):\r
        if self._DxsFile == None:\r
            if self._Header_ == None:\r
                self._GetHeaderInfo()\r
            if self._DxsFile == None:\r
                self._DxsFile = ''\r
        return self._DxsFile\r
\r
    ## Retrieve MODULE_TYPE\r
    def _GetModuleType(self):\r
        if self._ModuleType == None:\r
            if self._Header_ == None:\r
                self._GetHeaderInfo()\r
            if self._ModuleType == None:\r
                self._ModuleType = 'BASE'\r
            if self._ModuleType not in SUP_MODULE_LIST:\r
                self._ModuleType = "USER_DEFINED"\r
        return self._ModuleType\r
\r
    ## Retrieve COMPONENT_TYPE\r
    def _GetComponentType(self):\r
        if self._ComponentType == None:\r
            if self._Header_ == None:\r
                self._GetHeaderInfo()\r
            if self._ComponentType == None:\r
                self._ComponentType = 'USER_DEFINED'\r
        return self._ComponentType\r
\r
    ## Retrieve "BUILD_TYPE"\r
    def _GetBuildType(self):\r
        if self._BuildType == None:\r
            if self._Header_ == None:\r
                self._GetHeaderInfo()\r
            if not self._BuildType:\r
                self._BuildType = "BASE"\r
        return self._BuildType\r
\r
    ## Retrieve file guid\r
    def _GetFileGuid(self):\r
        if self._Guid == None:\r
            if self._Header_ == None:\r
                self._GetHeaderInfo()\r
            if self._Guid == None:\r
                self._Guid = '00000000-0000-0000-0000-000000000000'\r
        return self._Guid\r
\r
    ## Retrieve module version\r
    def _GetVersion(self):\r
        if self._Version == None:\r
            if self._Header_ == None:\r
                self._GetHeaderInfo()\r
            if self._Version == None:\r
                self._Version = '0.0'\r
        return self._Version\r
\r
    ## Retrieve PCD_IS_DRIVER\r
    def _GetPcdIsDriver(self):\r
        if self._PcdIsDriver == None:\r
            if self._Header_ == None:\r
                self._GetHeaderInfo()\r
            if self._PcdIsDriver == None:\r
                self._PcdIsDriver = ''\r
        return self._PcdIsDriver\r
\r
    ## Retrieve SHADOW\r
    def _GetShadow(self):\r
        if self._Shadow == None:\r
            if self._Header_ == None:\r
                self._GetHeaderInfo()\r
            if self._Shadow != None and self._Shadow.upper() == 'TRUE':\r
                self._Shadow = True\r
            else:\r
                self._Shadow = False\r
        return self._Shadow\r
\r
    ## Retrieve CUSTOM_MAKEFILE\r
    def _GetMakefile(self):\r
        if self._CustomMakefile == None:\r
            if self._Header_ == None:\r
                self._GetHeaderInfo()\r
            if self._CustomMakefile == None:\r
                self._CustomMakefile = {}\r
        return self._CustomMakefile\r
\r
    ## Retrieve EFI_SPECIFICATION_VERSION\r
    def _GetSpec(self):\r
        if self._Specification == None:\r
            if self._Header_ == None:\r
                self._GetHeaderInfo()\r
            if self._Specification == None:\r
                self._Specification = {}\r
        return self._Specification\r
\r
    ## Retrieve LIBRARY_CLASS\r
    def _GetLibraryClass(self):\r
        if self._LibraryClass == None:\r
            if self._Header_ == None:\r
                self._GetHeaderInfo()\r
            if self._LibraryClass == None:\r
                self._LibraryClass = []\r
        return self._LibraryClass\r
\r
    ## Retrieve ENTRY_POINT\r
    def _GetEntryPoint(self):\r
        if self._ModuleEntryPointList == None:\r
            if self._Header_ == None:\r
                self._GetHeaderInfo()\r
            if self._ModuleEntryPointList == None:\r
                self._ModuleEntryPointList = []\r
        return self._ModuleEntryPointList\r
\r
    ## Retrieve UNLOAD_IMAGE\r
    def _GetUnloadImage(self):\r
        if self._ModuleUnloadImageList == None:\r
            if self._Header_ == None:\r
                self._GetHeaderInfo()\r
            if self._ModuleUnloadImageList == None:\r
                self._ModuleUnloadImageList = []\r
        return self._ModuleUnloadImageList\r
\r
    ## Retrieve CONSTRUCTOR\r
    def _GetConstructor(self):\r
        if self._ConstructorList == None:\r
            if self._Header_ == None:\r
                self._GetHeaderInfo()\r
            if self._ConstructorList == None:\r
                self._ConstructorList = []\r
        return self._ConstructorList\r
\r
    ## Retrieve DESTRUCTOR\r
    def _GetDestructor(self):\r
        if self._DestructorList == None:\r
            if self._Header_ == None:\r
                self._GetHeaderInfo()\r
            if self._DestructorList == None:\r
                self._DestructorList = []\r
        return self._DestructorList\r
\r
    ## Retrieve definies other than above ones\r
    def _GetDefines(self):\r
        if self._Defs == None:\r
            if self._Header_ == None:\r
                self._GetHeaderInfo()\r
            if self._Defs == None:\r
                self._Defs = sdict()\r
        return self._Defs\r
\r
    ## Retrieve binary files\r
    def _GetBinaries(self):\r
        if self._Binaries == None:\r
            self._Binaries = []\r
            RecordList = self._RawData[MODEL_EFI_BINARY_FILE, self._Arch, self._Platform]\r
            Macros = self._Macros\r
            Macros["EDK_SOURCE"] = GlobalData.gEcpSource\r
            Macros['PROCESSOR'] = self._Arch\r
            for Record in RecordList:\r
                FileType = Record[0]\r
                LineNo = Record[-1]\r
                Target = 'COMMON'\r
                FeatureFlag = []\r
                if Record[2]:\r
                    TokenList = GetSplitValueList(Record[2], TAB_VALUE_SPLIT)\r
                    if TokenList:\r
                        Target = TokenList[0]\r
                    if len(TokenList) > 1:\r
                        FeatureFlag = Record[1:]\r
\r
                File = PathClass(NormPath(Record[1], Macros), self._ModuleDir, '', FileType, True, self._Arch, '', Target)\r
                # check the file validation\r
                ErrorCode, ErrorInfo = File.Validate()\r
                if ErrorCode != 0:\r
                    EdkLogger.error('build', ErrorCode, ExtraData=ErrorInfo, File=self.MetaFile, Line=LineNo)\r
                self._Binaries.append(File)\r
        return self._Binaries\r
\r
    ## Retrieve binary files with error check.\r
    def _GetBinaryFiles(self):\r
        Binaries = self._GetBinaries()\r
        if GlobalData.gIgnoreSource and Binaries == []:\r
            ErrorInfo = "The INF file does not contain any Binaries to use in creating the image\n"\r
            EdkLogger.error('build', RESOURCE_NOT_AVAILABLE, ExtraData=ErrorInfo, File=self.MetaFile)\r
\r
        return Binaries\r
    ## Check whether it exists the binaries with current ARCH in AsBuild INF\r
    def _IsSupportedArch(self):\r
        if self._GetBinaries() and not self._GetSourceFiles():\r
            return True\r
        else:\r
            return False\r
    ## Retrieve source files\r
    def _GetSourceFiles(self):\r
        #Ignore all source files in a binary build mode\r
        if GlobalData.gIgnoreSource:\r
            self._Sources = []\r
            return self._Sources\r
\r
        if self._Sources == None:\r
            self._Sources = []\r
            RecordList = self._RawData[MODEL_EFI_SOURCE_FILE, self._Arch, self._Platform]\r
            Macros = self._Macros\r
            for Record in RecordList:\r
                LineNo = Record[-1]\r
                ToolChainFamily = Record[1]\r
                TagName = Record[2]\r
                ToolCode = Record[3]\r
                FeatureFlag = Record[4]\r
                if self.AutoGenVersion < 0x00010005:\r
                    Macros["EDK_SOURCE"] = GlobalData.gEcpSource\r
                    Macros['PROCESSOR'] = self._Arch\r
                    # old module source files (Edk)\r
                    File = PathClass(NormPath(Record[0], Macros), self._ModuleDir, self._SourceOverridePath,\r
                                     '', False, self._Arch, ToolChainFamily, '', TagName, ToolCode)\r
                    # check the file validation\r
                    ErrorCode, ErrorInfo = File.Validate(CaseSensitive=False)\r
                    if ErrorCode != 0:\r
                        if File.Ext.lower() == '.h':\r
                            EdkLogger.warn('build', 'Include file not found', ExtraData=ErrorInfo,\r
                                           File=self.MetaFile, Line=LineNo)\r
                            continue\r
                        else:\r
                            EdkLogger.error('build', ErrorCode, ExtraData=File, File=self.MetaFile, Line=LineNo)\r
                else:\r
                    File = PathClass(NormPath(Record[0], Macros), self._ModuleDir, '',\r
                                     '', False, self._Arch, ToolChainFamily, '', TagName, ToolCode)\r
                    # check the file validation\r
                    ErrorCode, ErrorInfo = File.Validate()\r
                    if ErrorCode != 0:\r
                        EdkLogger.error('build', ErrorCode, ExtraData=ErrorInfo, File=self.MetaFile, Line=LineNo)\r
\r
                self._Sources.append(File)\r
        return self._Sources\r
\r
    ## Retrieve library classes employed by this module\r
    def _GetLibraryClassUses(self):\r
        if self._LibraryClasses == None:\r
            self._LibraryClasses = sdict()\r
            RecordList = self._RawData[MODEL_EFI_LIBRARY_CLASS, self._Arch, self._Platform]\r
            for Record in RecordList:\r
                Lib = Record[0]\r
                Instance = Record[1]\r
                if Instance:\r
                    Instance = NormPath(Instance, self._Macros)\r
                self._LibraryClasses[Lib] = Instance\r
        return self._LibraryClasses\r
\r
    ## Retrieve library names (for Edk.x style of modules)\r
    def _GetLibraryNames(self):\r
        if self._Libraries == None:\r
            self._Libraries = []\r
            RecordList = self._RawData[MODEL_EFI_LIBRARY_INSTANCE, self._Arch, self._Platform]\r
            for Record in RecordList:\r
                LibraryName = ReplaceMacro(Record[0], self._Macros, False)\r
                # in case of name with '.lib' extension, which is unusual in Edk.x inf\r
                LibraryName = os.path.splitext(LibraryName)[0]\r
                if LibraryName not in self._Libraries:\r
                    self._Libraries.append(LibraryName)\r
        return self._Libraries\r
\r
    def _GetProtocolComments(self):\r
        self._GetProtocols()\r
        return self._ProtocolComments\r
    ## Retrieve protocols consumed/produced by this module\r
    def _GetProtocols(self):\r
        if self._Protocols == None:\r
            self._Protocols = sdict()\r
            self._ProtocolComments = sdict()\r
            RecordList = self._RawData[MODEL_EFI_PROTOCOL, self._Arch, self._Platform]\r
            for Record in RecordList:\r
                CName = Record[0]\r
                Value = ProtocolValue(CName, self.Packages)\r
                if Value == None:\r
                    PackageList = "\n\t".join([str(P) for P in self.Packages])\r
                    EdkLogger.error('build', RESOURCE_NOT_AVAILABLE,\r
                                    "Value of Protocol [%s] is not found under [Protocols] section in" % CName,\r
                                    ExtraData=PackageList, File=self.MetaFile, Line=Record[-1])\r
                self._Protocols[CName] = Value\r
                CommentRecords = self._RawData[MODEL_META_DATA_COMMENT, self._Arch, self._Platform, Record[5]]\r
                Comments = []\r
                for CmtRec in CommentRecords:\r
                    Comments.append(CmtRec[0])\r
                self._ProtocolComments[CName] = Comments\r
        return self._Protocols\r
\r
    def _GetPpiComments(self):\r
        self._GetPpis()\r
        return self._PpiComments\r
    ## Retrieve PPIs consumed/produced by this module\r
    def _GetPpis(self):\r
        if self._Ppis == None:\r
            self._Ppis = sdict()\r
            self._PpiComments = sdict()\r
            RecordList = self._RawData[MODEL_EFI_PPI, self._Arch, self._Platform]\r
            for Record in RecordList:\r
                CName = Record[0]\r
                Value = PpiValue(CName, self.Packages)\r
                if Value == None:\r
                    PackageList = "\n\t".join([str(P) for P in self.Packages])\r
                    EdkLogger.error('build', RESOURCE_NOT_AVAILABLE,\r
                                    "Value of PPI [%s] is not found under [Ppis] section in " % CName,\r
                                    ExtraData=PackageList, File=self.MetaFile, Line=Record[-1])\r
                self._Ppis[CName] = Value\r
                CommentRecords = self._RawData[MODEL_META_DATA_COMMENT, self._Arch, self._Platform, Record[5]]\r
                Comments = []\r
                for CmtRec in CommentRecords:\r
                    Comments.append(CmtRec[0])\r
                self._PpiComments[CName] = Comments\r
        return self._Ppis\r
\r
    def _GetGuidComments(self):\r
        self._GetGuids()\r
        return self._GuidComments\r
    ## Retrieve GUIDs consumed/produced by this module\r
    def _GetGuids(self):\r
        if self._Guids == None:\r
            self._Guids = sdict()\r
            self._GuidComments = sdict()\r
            RecordList = self._RawData[MODEL_EFI_GUID, self._Arch, self._Platform]\r
            for Record in RecordList:\r
                CName = Record[0]\r
                Value = GuidValue(CName, self.Packages)\r
                if Value == None:\r
                    PackageList = "\n\t".join([str(P) for P in self.Packages])\r
                    EdkLogger.error('build', RESOURCE_NOT_AVAILABLE,\r
                                    "Value of Guid [%s] is not found under [Guids] section in" % CName,\r
                                    ExtraData=PackageList, File=self.MetaFile, Line=Record[-1])\r
                self._Guids[CName] = Value\r
                CommentRecords = self._RawData[MODEL_META_DATA_COMMENT, self._Arch, self._Platform, Record[5]]\r
                Comments = []\r
                for CmtRec in CommentRecords:\r
                    Comments.append(CmtRec[0])\r
                self._GuidComments[CName] = Comments\r
        return self._Guids\r
\r
    ## Retrieve include paths necessary for this module (for Edk.x style of modules)\r
    def _GetIncludes(self):\r
        if self._Includes == None:\r
            self._Includes = []\r
            if self._SourceOverridePath:\r
                self._Includes.append(self._SourceOverridePath)\r
\r
            Macros = self._Macros\r
            if 'PROCESSOR' in GlobalData.gEdkGlobal.keys():\r
                Macros['PROCESSOR'] = GlobalData.gEdkGlobal['PROCESSOR']\r
            else:\r
                Macros['PROCESSOR'] = self._Arch\r
            RecordList = self._RawData[MODEL_EFI_INCLUDE, self._Arch, self._Platform]\r
            for Record in RecordList:\r
                if Record[0].find('EDK_SOURCE') > -1:\r
                    Macros['EDK_SOURCE'] = GlobalData.gEcpSource\r
                    File = NormPath(Record[0], self._Macros)\r
                    if File[0] == '.':\r
                        File = os.path.join(self._ModuleDir, File)\r
                    else:\r
                        File = os.path.join(GlobalData.gWorkspace, File)\r
                    File = RealPath(os.path.normpath(File))\r
                    if File:\r
                        self._Includes.append(File)\r
\r
                    #TRICK: let compiler to choose correct header file\r
                    Macros['EDK_SOURCE'] = GlobalData.gEdkSource\r
                    File = NormPath(Record[0], self._Macros)\r
                    if File[0] == '.':\r
                        File = os.path.join(self._ModuleDir, File)\r
                    else:\r
                        File = os.path.join(GlobalData.gWorkspace, File)\r
                    File = RealPath(os.path.normpath(File))\r
                    if File:\r
                        self._Includes.append(File)\r
                else:\r
                    File = NormPath(Record[0], Macros)\r
                    if File[0] == '.':\r
                        File = os.path.join(self._ModuleDir, File)\r
                    else:\r
                        File = os.path.join(GlobalData.gWorkspace, File)\r
                    File = RealPath(os.path.normpath(File))\r
                    if File:\r
                        self._Includes.append(File)\r
        return self._Includes\r
\r
    ## Retrieve packages this module depends on\r
    def _GetPackages(self):\r
        if self._Packages == None:\r
            self._Packages = []\r
            RecordList = self._RawData[MODEL_META_DATA_PACKAGE, self._Arch, self._Platform]\r
            Macros = self._Macros\r
            Macros['EDK_SOURCE'] = GlobalData.gEcpSource\r
            for Record in RecordList:\r
                File = PathClass(NormPath(Record[0], Macros), GlobalData.gWorkspace, Arch=self._Arch)\r
                LineNo = Record[-1]\r
                # check the file validation\r
                ErrorCode, ErrorInfo = File.Validate('.dec')\r
                if ErrorCode != 0:\r
                    EdkLogger.error('build', ErrorCode, ExtraData=ErrorInfo, File=self.MetaFile, Line=LineNo)\r
                # parse this package now. we need it to get protocol/ppi/guid value\r
                Package = self._Bdb[File, self._Arch, self._Target, self._Toolchain]\r
                self._Packages.append(Package)\r
        return self._Packages\r
\r
    ## Retrieve PCD comments\r
    def _GetPcdComments(self):\r
        self._GetPcds()\r
        return self._PcdComments\r
    ## Retrieve PCDs used in this module\r
    def _GetPcds(self):\r
        if self._Pcds == None:\r
            self._Pcds = sdict()\r
            self._PcdComments = sdict()\r
            self._Pcds.update(self._GetPcd(MODEL_PCD_FIXED_AT_BUILD))\r
            self._Pcds.update(self._GetPcd(MODEL_PCD_PATCHABLE_IN_MODULE))\r
            self._Pcds.update(self._GetPcd(MODEL_PCD_FEATURE_FLAG))\r
            self._Pcds.update(self._GetPcd(MODEL_PCD_DYNAMIC))\r
            self._Pcds.update(self._GetPcd(MODEL_PCD_DYNAMIC_EX))\r
        return self._Pcds\r
\r
    ## Retrieve build options specific to this module\r
    def _GetBuildOptions(self):\r
        if self._BuildOptions == None:\r
            self._BuildOptions = sdict()\r
            RecordList = self._RawData[MODEL_META_DATA_BUILD_OPTION, self._Arch, self._Platform]\r
            for Record in RecordList:\r
                ToolChainFamily = Record[0]\r
                ToolChain = Record[1]\r
                Option = Record[2]\r
                if (ToolChainFamily, ToolChain) not in self._BuildOptions or Option.startswith('='):\r
                    self._BuildOptions[ToolChainFamily, ToolChain] = Option\r
                else:\r
                    # concatenate the option string if they're for the same tool\r
                    OptionString = self._BuildOptions[ToolChainFamily, ToolChain]\r
                    self._BuildOptions[ToolChainFamily, ToolChain] = OptionString + " " + Option\r
        return self._BuildOptions\r
\r
    ## Retrieve dependency expression\r
    def _GetDepex(self):\r
        if self._Depex == None:\r
            self._Depex = tdict(False, 2)\r
            RecordList = self._RawData[MODEL_EFI_DEPEX, self._Arch]\r
            \r
            # If the module has only Binaries and no Sources, then ignore [Depex] \r
            if self.Sources == None or self.Sources == []:\r
                if self.Binaries != None and self.Binaries != []:\r
                    return self._Depex\r
                \r
            # PEIM and DXE drivers must have a valid [Depex] section\r
            if len(self.LibraryClass) == 0 and len(RecordList) == 0:\r
                if self.ModuleType == 'DXE_DRIVER' or self.ModuleType == 'PEIM' or self.ModuleType == 'DXE_SMM_DRIVER' or \\r
                    self.ModuleType == 'DXE_SAL_DRIVER' or self.ModuleType == 'DXE_RUNTIME_DRIVER':\r
                    EdkLogger.error('build', RESOURCE_NOT_AVAILABLE, "No [Depex] section or no valid expression in [Depex] section for [%s] module" \\r
                                    % self.ModuleType, File=self.MetaFile)\r
\r
            if len(RecordList) != 0 and self.ModuleType == 'USER_DEFINED':\r
                for Record in RecordList:\r
                    if Record[4] not in ['PEIM', 'DXE_DRIVER', 'DXE_SMM_DRIVER']:\r
                        EdkLogger.error('build', FORMAT_INVALID,\r
                                        "'%s' module must specify the type of [Depex] section" % self.ModuleType,\r
                                        File=self.MetaFile)\r
\r
            Depex = sdict()\r
            for Record in RecordList:\r
                DepexStr = ReplaceMacro(Record[0], self._Macros, False)\r
                Arch = Record[3]\r
                ModuleType = Record[4]\r
                TokenList = DepexStr.split()\r
                if (Arch, ModuleType) not in Depex:\r
                    Depex[Arch, ModuleType] = []\r
                DepexList = Depex[Arch, ModuleType]\r
                for Token in TokenList:\r
                    if Token in DEPEX_SUPPORTED_OPCODE:\r
                        DepexList.append(Token)\r
                    elif Token.endswith(".inf"):    # module file name\r
                        ModuleFile = os.path.normpath(Token)\r
                        Module = self.BuildDatabase[ModuleFile]\r
                        if Module == None:\r
                            EdkLogger.error('build', RESOURCE_NOT_AVAILABLE, "Module is not found in active platform",\r
                                            ExtraData=Token, File=self.MetaFile, Line=Record[-1])\r
                        DepexList.append(Module.Guid)\r
                    else:\r
                        # get the GUID value now\r
                        Value = ProtocolValue(Token, self.Packages)\r
                        if Value == None:\r
                            Value = PpiValue(Token, self.Packages)\r
                            if Value == None:\r
                                Value = GuidValue(Token, self.Packages)\r
                        if Value == None:\r
                            PackageList = "\n\t".join([str(P) for P in self.Packages])\r
                            EdkLogger.error('build', RESOURCE_NOT_AVAILABLE,\r
                                            "Value of [%s] is not found in" % Token,\r
                                            ExtraData=PackageList, File=self.MetaFile, Line=Record[-1])\r
                        DepexList.append(Value)\r
            for Arch, ModuleType in Depex:\r
                self._Depex[Arch, ModuleType] = Depex[Arch, ModuleType]\r
        return self._Depex\r
\r
    ## Retrieve depedency expression\r
    def _GetDepexExpression(self):\r
        if self._DepexExpression == None:\r
            self._DepexExpression = tdict(False, 2)\r
            RecordList = self._RawData[MODEL_EFI_DEPEX, self._Arch]\r
            DepexExpression = sdict()\r
            for Record in RecordList:\r
                DepexStr = ReplaceMacro(Record[0], self._Macros, False)\r
                Arch = Record[3]\r
                ModuleType = Record[4]\r
                TokenList = DepexStr.split()\r
                if (Arch, ModuleType) not in DepexExpression:\r
                    DepexExpression[Arch, ModuleType] = ''\r
                for Token in TokenList:\r
                    DepexExpression[Arch, ModuleType] = DepexExpression[Arch, ModuleType] + Token.strip() + ' '\r
            for Arch, ModuleType in DepexExpression:\r
                self._DepexExpression[Arch, ModuleType] = DepexExpression[Arch, ModuleType]\r
        return self._DepexExpression\r
\r
    def GetGuidsUsedByPcd(self):\r
        return self._GuidsUsedByPcd\r
    ## Retrieve PCD for given type\r
    def _GetPcd(self, Type):\r
        Pcds = sdict()\r
        PcdDict = tdict(True, 4)\r
        PcdList = []\r
        RecordList = self._RawData[Type, self._Arch, self._Platform]\r
        for TokenSpaceGuid, PcdCName, Setting, Arch, Platform, Id, LineNo in RecordList:\r
            PcdDict[Arch, Platform, PcdCName, TokenSpaceGuid] = (Setting, LineNo)\r
            PcdList.append((PcdCName, TokenSpaceGuid))\r
            # get the guid value\r
            if TokenSpaceGuid not in self.Guids:\r
                Value = GuidValue(TokenSpaceGuid, self.Packages)\r
                if Value == None:\r
                    PackageList = "\n\t".join([str(P) for P in self.Packages])\r
                    EdkLogger.error('build', RESOURCE_NOT_AVAILABLE,\r
                                    "Value of Guid [%s] is not found under [Guids] section in" % TokenSpaceGuid,\r
                                    ExtraData=PackageList, File=self.MetaFile, Line=LineNo)\r
                self.Guids[TokenSpaceGuid] = Value\r
                self._GuidsUsedByPcd[TokenSpaceGuid] = Value\r
            CommentRecords = self._RawData[MODEL_META_DATA_COMMENT, self._Arch, self._Platform, Id]\r
            Comments = []\r
            for CmtRec in CommentRecords:\r
                Comments.append(CmtRec[0])\r
            self._PcdComments[TokenSpaceGuid, PcdCName] = Comments\r
\r
        # resolve PCD type, value, datum info, etc. by getting its definition from package\r
        for PcdCName, TokenSpaceGuid in PcdList:\r
            Setting, LineNo = PcdDict[self._Arch, self.Platform, PcdCName, TokenSpaceGuid]\r
            if Setting == None:\r
                continue\r
            ValueList = AnalyzePcdData(Setting)\r
            DefaultValue = ValueList[0]\r
            Pcd = PcdClassObject(\r
                    PcdCName,\r
                    TokenSpaceGuid,\r
                    '',\r
                    '',\r
                    DefaultValue,\r
                    '',\r
                    '',\r
                    {},\r
                    False,\r
                    self.Guids[TokenSpaceGuid]\r
                    )\r
            if Type == MODEL_PCD_PATCHABLE_IN_MODULE and ValueList[1]:\r
                # Patch PCD: TokenSpace.PcdCName|Value|Offset\r
                Pcd.Offset = ValueList[1]\r
\r
            # get necessary info from package declaring this PCD\r
            for Package in self.Packages:\r
                #\r
                # 'dynamic' in INF means its type is determined by platform;\r
                # if platform doesn't give its type, use 'lowest' one in the\r
                # following order, if any\r
                #\r
                #   "FixedAtBuild", "PatchableInModule", "FeatureFlag", "Dynamic", "DynamicEx"\r
                #\r
                PcdType = self._PCD_TYPE_STRING_[Type]\r
                if Type == MODEL_PCD_DYNAMIC:\r
                    Pcd.Pending = True\r
                    for T in ["FixedAtBuild", "PatchableInModule", "FeatureFlag", "Dynamic", "DynamicEx"]:\r
                        if (PcdCName, TokenSpaceGuid, T) in Package.Pcds:\r
                            PcdType = T\r
                            break\r
                else:\r
                    Pcd.Pending = False\r
\r
                if (PcdCName, TokenSpaceGuid, PcdType) in Package.Pcds:\r
                    PcdInPackage = Package.Pcds[PcdCName, TokenSpaceGuid, PcdType]\r
                    Pcd.Type = PcdType\r
                    Pcd.TokenValue = PcdInPackage.TokenValue\r
                    \r
                    #\r
                    # Check whether the token value exist or not.\r
                    #\r
                    if Pcd.TokenValue == None or Pcd.TokenValue == "":\r
                        EdkLogger.error(\r
                                'build',\r
                                FORMAT_INVALID,\r
                                "No TokenValue for PCD [%s.%s] in [%s]!" % (TokenSpaceGuid, PcdCName, str(Package)),\r
                                File =self.MetaFile, Line=LineNo,\r
                                ExtraData=None\r
                                )                        \r
                    #\r
                    # Check hexadecimal token value length and format.\r
                    #\r
                    ReIsValidPcdTokenValue = re.compile(r"^[0][x|X][0]*[0-9a-fA-F]{1,8}$", re.DOTALL)\r
                    if Pcd.TokenValue.startswith("0x") or Pcd.TokenValue.startswith("0X"):\r
                        if ReIsValidPcdTokenValue.match(Pcd.TokenValue) == None:\r
                            EdkLogger.error(\r
                                    'build',\r
                                    FORMAT_INVALID,\r
                                    "The format of TokenValue [%s] of PCD [%s.%s] in [%s] is invalid:" % (Pcd.TokenValue, TokenSpaceGuid, PcdCName, str(Package)),\r
                                    File =self.MetaFile, Line=LineNo,\r
                                    ExtraData=None\r
                                    )\r
                            \r
                    #\r
                    # Check decimal token value length and format.\r
                    #                            \r
                    else:\r
                        try:\r
                            TokenValueInt = int (Pcd.TokenValue, 10)\r
                            if (TokenValueInt < 0 or TokenValueInt > 4294967295):\r
                                EdkLogger.error(\r
                                            'build',\r
                                            FORMAT_INVALID,\r
                                            "The format of TokenValue [%s] of PCD [%s.%s] in [%s] is invalid, as a decimal it should between: 0 - 4294967295!"% (Pcd.TokenValue, TokenSpaceGuid, PcdCName, str(Package)),\r
                                            File =self.MetaFile, Line=LineNo,\r
                                            ExtraData=None\r
                                            )                                \r
                        except:\r
                            EdkLogger.error(\r
                                        'build',\r
                                        FORMAT_INVALID,\r
                                        "The format of TokenValue [%s] of PCD [%s.%s] in [%s] is invalid, it should be hexadecimal or decimal!"% (Pcd.TokenValue, TokenSpaceGuid, PcdCName, str(Package)),\r
                                        File =self.MetaFile, Line=LineNo,\r
                                        ExtraData=None\r
                                        )\r
                    \r
                    Pcd.DatumType = PcdInPackage.DatumType\r
                    Pcd.MaxDatumSize = PcdInPackage.MaxDatumSize\r
                    Pcd.InfDefaultValue = Pcd.DefaultValue\r
                    if Pcd.DefaultValue in [None, '']:\r
                        Pcd.DefaultValue = PcdInPackage.DefaultValue\r
                    break\r
            else:\r
                EdkLogger.error(\r
                            'build',\r
                            FORMAT_INVALID,\r
                            "PCD [%s.%s] in [%s] is not found in dependent packages:" % (TokenSpaceGuid, PcdCName, self.MetaFile),\r
                            File =self.MetaFile, Line=LineNo,\r
                            ExtraData="\t%s" % '\n\t'.join([str(P) for P in self.Packages])\r
                            )\r
            Pcds[PcdCName, TokenSpaceGuid] = Pcd\r
\r
        return Pcds\r
\r
    ## check whether current module is binary module\r
    def _IsBinaryModule(self):\r
        if self.Binaries and not self.Sources:\r
            return True\r
        elif GlobalData.gIgnoreSource:\r
            return True\r
        else:\r
            return False\r
\r
    _Macros = property(_GetMacros)\r
    Arch = property(_GetArch, _SetArch)\r
    Platform = property(_GetPlatform, _SetPlatform)\r
\r
    HeaderComments = property(_GetHeaderComments)\r
    TailComments = property(_GetTailComments)\r
    AutoGenVersion          = property(_GetInfVersion)\r
    BaseName                = property(_GetBaseName)\r
    ModuleType              = property(_GetModuleType)\r
    ComponentType           = property(_GetComponentType)\r
    BuildType               = property(_GetBuildType)\r
    Guid                    = property(_GetFileGuid)\r
    Version                 = property(_GetVersion)\r
    PcdIsDriver             = property(_GetPcdIsDriver)\r
    Shadow                  = property(_GetShadow)\r
    CustomMakefile          = property(_GetMakefile)\r
    Specification           = property(_GetSpec)\r
    LibraryClass            = property(_GetLibraryClass)\r
    ModuleEntryPointList    = property(_GetEntryPoint)\r
    ModuleUnloadImageList   = property(_GetUnloadImage)\r
    ConstructorList         = property(_GetConstructor)\r
    DestructorList          = property(_GetDestructor)\r
    Defines                 = property(_GetDefines)\r
    DxsFile                 = property(_GetDxsFile)\r
    \r
    Binaries                = property(_GetBinaryFiles)\r
    Sources                 = property(_GetSourceFiles)\r
    LibraryClasses          = property(_GetLibraryClassUses)\r
    Libraries               = property(_GetLibraryNames)\r
    Protocols               = property(_GetProtocols)\r
    ProtocolComments = property(_GetProtocolComments)\r
    Ppis                    = property(_GetPpis)\r
    PpiComments = property(_GetPpiComments)\r
    Guids                   = property(_GetGuids)\r
    GuidComments = property(_GetGuidComments)\r
    Includes                = property(_GetIncludes)\r
    Packages                = property(_GetPackages)\r
    Pcds                    = property(_GetPcds)\r
    PcdComments = property(_GetPcdComments)\r
    BuildOptions            = property(_GetBuildOptions)\r
    Depex                   = property(_GetDepex)\r
    DepexExpression         = property(_GetDepexExpression)\r
    IsBinaryModule = property(_IsBinaryModule)\r
    IsSupportedArch = property(_IsSupportedArch)\r
\r
## Database\r
#\r
#   This class defined the build database for all modules, packages and platform.\r
# It will call corresponding parser for the given file if it cannot find it in\r
# the database.\r
#\r
# @param DbPath             Path of database file\r
# @param GlobalMacros       Global macros used for replacement during file parsing\r
# @prarm RenewDb=False      Create new database file if it's already there\r
#\r
class WorkspaceDatabase(object):\r
\r
\r
    #\r
    # internal class used for call corresponding file parser and caching the result\r
    # to avoid unnecessary re-parsing\r
    #\r
    class BuildObjectFactory(object):\r
\r
        _FILE_TYPE_ = {\r
            ".inf"  : MODEL_FILE_INF,\r
            ".dec"  : MODEL_FILE_DEC,\r
            ".dsc"  : MODEL_FILE_DSC,\r
        }\r
\r
        # file parser\r
        _FILE_PARSER_ = {\r
            MODEL_FILE_INF  :   InfParser,\r
            MODEL_FILE_DEC  :   DecParser,\r
            MODEL_FILE_DSC  :   DscParser,\r
        }\r
\r
        # convert to xxxBuildData object\r
        _GENERATOR_ = {\r
            MODEL_FILE_INF  :   InfBuildData,\r
            MODEL_FILE_DEC  :   DecBuildData,\r
            MODEL_FILE_DSC  :   DscBuildData,\r
        }\r
\r
        _CACHE_ = {}    # (FilePath, Arch)  : <object>\r
\r
        # constructor\r
        def __init__(self, WorkspaceDb):\r
            self.WorkspaceDb = WorkspaceDb\r
\r
        # key = (FilePath, Arch=None)\r
        def __contains__(self, Key):\r
            FilePath = Key[0]\r
            if len(Key) > 1:\r
                Arch = Key[1]\r
            else:\r
                Arch = None\r
            return (FilePath, Arch) in self._CACHE_\r
\r
        # key = (FilePath, Arch=None, Target=None, Toochain=None)\r
        def __getitem__(self, Key):\r
            FilePath = Key[0]\r
            KeyLength = len(Key)\r
            if KeyLength > 1:\r
                Arch = Key[1]\r
            else:\r
                Arch = None\r
            if KeyLength > 2:\r
                Target = Key[2]\r
            else:\r
                Target = None\r
            if KeyLength > 3:\r
                Toolchain = Key[3]\r
            else:\r
                Toolchain = None\r
\r
            # if it's generated before, just return the cached one\r
            Key = (FilePath, Arch, Target, Toolchain)\r
            if Key in self._CACHE_:\r
                return self._CACHE_[Key]\r
\r
            # check file type\r
            Ext = FilePath.Type\r
            if Ext not in self._FILE_TYPE_:\r
                return None\r
            FileType = self._FILE_TYPE_[Ext]\r
            if FileType not in self._GENERATOR_:\r
                return None\r
\r
            # get the parser ready for this file\r
            MetaFile = self._FILE_PARSER_[FileType](\r
                                FilePath, \r
                                FileType, \r
                                MetaFileStorage(self.WorkspaceDb.Cur, FilePath, FileType)\r
                                )\r
            # alwasy do post-process, in case of macros change\r
            MetaFile.DoPostProcess()\r
            # object the build is based on\r
            BuildObject = self._GENERATOR_[FileType](\r
                                    FilePath,\r
                                    MetaFile,\r
                                    self,\r
                                    Arch,\r
                                    Target,\r
                                    Toolchain\r
                                    )\r
            self._CACHE_[Key] = BuildObject\r
            return BuildObject\r
\r
    # placeholder for file format conversion\r
    class TransformObjectFactory:\r
        def __init__(self, WorkspaceDb):\r
            self.WorkspaceDb = WorkspaceDb\r
\r
        # key = FilePath, Arch\r
        def __getitem__(self, Key):\r
            pass\r
\r
    ## Constructor of WorkspaceDatabase\r
    #\r
    # @param DbPath             Path of database file\r
    # @param GlobalMacros       Global macros used for replacement during file parsing\r
    # @prarm RenewDb=False      Create new database file if it's already there\r
    #\r
    def __init__(self, DbPath, RenewDb=False):\r
        self._DbClosedFlag = False\r
        if not DbPath:\r
            DbPath = os.path.normpath(os.path.join(GlobalData.gWorkspace, 'Conf', GlobalData.gDatabasePath))\r
\r
        # don't create necessary path for db in memory\r
        if DbPath != ':memory:':\r
            DbDir = os.path.split(DbPath)[0]\r
            if not os.path.exists(DbDir):\r
                os.makedirs(DbDir)\r
\r
            # remove db file in case inconsistency between db and file in file system\r
            if self._CheckWhetherDbNeedRenew(RenewDb, DbPath):\r
                os.remove(DbPath)\r
        \r
        # create db with optimized parameters\r
        self.Conn = sqlite3.connect(DbPath, isolation_level='DEFERRED')\r
        self.Conn.execute("PRAGMA synchronous=OFF")\r
        self.Conn.execute("PRAGMA temp_store=MEMORY")\r
        self.Conn.execute("PRAGMA count_changes=OFF")\r
        self.Conn.execute("PRAGMA cache_size=8192")\r
        #self.Conn.execute("PRAGMA page_size=8192")\r
\r
        # to avoid non-ascii character conversion issue\r
        self.Conn.text_factory = str\r
        self.Cur = self.Conn.cursor()\r
\r
        # create table for internal uses\r
        self.TblDataModel = TableDataModel(self.Cur)\r
        self.TblFile = TableFile(self.Cur)\r
        self.Platform = None\r
\r
        # conversion object for build or file format conversion purpose\r
        self.BuildObject = WorkspaceDatabase.BuildObjectFactory(self)\r
        self.TransformObject = WorkspaceDatabase.TransformObjectFactory(self)\r
\r
    ## Check whether workspace database need to be renew.\r
    #  The renew reason maybe:\r
    #  1) If user force to renew;\r
    #  2) If user do not force renew, and\r
    #     a) If the time of last modified python source is newer than database file;\r
    #     b) If the time of last modified frozen executable file is newer than database file;\r
    #\r
    #  @param force     User force renew database\r
    #  @param DbPath    The absolute path of workspace database file\r
    #\r
    #  @return Bool value for whether need renew workspace databse\r
    #\r
    def _CheckWhetherDbNeedRenew (self, force, DbPath):\r
        # if database does not exist, we need do nothing\r
        if not os.path.exists(DbPath): return False\r
            \r
        # if user force to renew database, then not check whether database is out of date\r
        if force: return True\r
        \r
        #    \r
        # Check the time of last modified source file or build.exe\r
        # if is newer than time of database, then database need to be re-created.\r
        #\r
        timeOfToolModified = 0\r
        if hasattr(sys, "frozen"):\r
            exePath             = os.path.abspath(sys.executable)\r
            timeOfToolModified  = os.stat(exePath).st_mtime\r
        else:\r
            curPath  = os.path.dirname(__file__) # curPath is the path of WorkspaceDatabase.py\r
            rootPath = os.path.split(curPath)[0] # rootPath is root path of python source, such as /BaseTools/Source/Python\r
            if rootPath == "" or rootPath == None:\r
                EdkLogger.verbose("\nFail to find the root path of build.exe or python sources, so can not \\r
determine whether database file is out of date!\n")\r
        \r
            # walk the root path of source or build's binary to get the time last modified.\r
        \r
            for root, dirs, files in os.walk (rootPath):\r
                for dir in dirs:\r
                    # bypass source control folder \r
                    if dir.lower() in [".svn", "_svn", "cvs"]:\r
                        dirs.remove(dir)\r
                        \r
                for file in files:\r
                    ext = os.path.splitext(file)[1]\r
                    if ext.lower() == ".py":            # only check .py files\r
                        fd = os.stat(os.path.join(root, file))\r
                        if timeOfToolModified < fd.st_mtime:\r
                            timeOfToolModified = fd.st_mtime\r
        if timeOfToolModified > os.stat(DbPath).st_mtime:\r
            EdkLogger.verbose("\nWorkspace database is out of data!")\r
            return True\r
            \r
        return False\r
            \r
    ## Initialize build database\r
    def InitDatabase(self):\r
        EdkLogger.verbose("\nInitialize build database started ...")\r
\r
        #\r
        # Create new tables\r
        #\r
        self.TblDataModel.Create(False)\r
        self.TblFile.Create(False)\r
\r
        #\r
        # Initialize table DataModel\r
        #\r
        self.TblDataModel.InitTable()\r
        EdkLogger.verbose("Initialize build database ... DONE!")\r
\r
    ## Query a table\r
    #\r
    # @param Table:  The instance of the table to be queried\r
    #\r
    def QueryTable(self, Table):\r
        Table.Query()\r
\r
    def __del__(self):\r
        self.Close()\r
\r
    ## Close entire database\r
    #\r
    # Commit all first\r
    # Close the connection and cursor\r
    #\r
    def Close(self):\r
        if not self._DbClosedFlag:\r
            self.Conn.commit()\r
            self.Cur.close()\r
            self.Conn.close()\r
            self._DbClosedFlag = True\r
\r
    ## Summarize all packages in the database\r
    def GetPackageList(self, Platform, Arch, TargetName, ToolChainTag):\r
        self.Platform = Platform\r
        PackageList =[]\r
        Pa = self.BuildObject[self.Platform, 'COMMON']\r
        #\r
        # Get Package related to Modules\r
        #\r
        for Module in Pa.Modules:\r
            ModuleObj = self.BuildObject[Module, Arch, TargetName, ToolChainTag]\r
            for Package in ModuleObj.Packages:\r
                if Package not in PackageList:\r
                    PackageList.append(Package)\r
        #\r
        # Get Packages related to Libraries\r
        #\r
        for Lib in Pa.LibraryInstances:\r
            LibObj = self.BuildObject[Lib, Arch, TargetName, ToolChainTag]\r
            for Package in LibObj.Packages:\r
                if Package not in PackageList:\r
                    PackageList.append(Package)            \r
        \r
        return PackageList\r
\r
    ## Summarize all platforms in the database\r
    def _GetPlatformList(self):\r
        PlatformList = []\r
        for PlatformFile in self.TblFile.GetFileList(MODEL_FILE_DSC):\r
            try:\r
                Platform = self.BuildObject[PathClass(PlatformFile), 'COMMON']\r
            except:\r
                Platform = None\r
            if Platform != None:\r
                PlatformList.append(Platform)\r
        return PlatformList\r
\r
    PlatformList = property(_GetPlatformList)\r
\r
##\r
#\r
# This acts like the main() function for the script, unless it is 'import'ed into another\r
# script.\r
#\r
if __name__ == '__main__':\r
    pass\r
\r