## @file\r
# This file is used to create a database used by build tool\r
#\r
-# Copyright (c) 2008 - 2010, Intel Corporation. All rights reserved.<BR>\r
+# Copyright (c) 2008 - 2018, Intel Corporation. All rights reserved.<BR>\r
+# (C) Copyright 2016 Hewlett Packard Enterprise Development LP<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
##\r
# Import Modules\r
#\r
+from __future__ import absolute_import\r
import sqlite3\r
-import os\r
-import os.path\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.StringUtils 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
-\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
- }\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', Platform='DUMMY', Macros={}):\r
- self.MetaFile = FilePath\r
- self._RawData = RawData\r
- self._Bdb = BuildDataBase\r
- self._Arch = Arch\r
- self._Macros = Macros\r
- self._Clear()\r
- RecordList = self._RawData[MODEL_META_DATA_DEFINE, self._Arch]\r
- for Record in RecordList:\r
- GlobalData.gEdkGlobal[Record[0]] = Record[1]\r
- \r
- RecordList = self._RawData[MODEL_META_DATA_GLOBAL_DEFINE, self._Arch]\r
- for Record in RecordList:\r
- GlobalData.gGlobalDefines[Record[0]] = Record[1]\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._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._BuildOptions = None\r
- self._LoadFixAddress = None\r
- self._VpdToolGuid = None\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[0]\r
- # items defined _PROPERTY_ don't need additional processing\r
- if Name in self:\r
- self[Name] = Record[1]\r
- # some special items in [Defines] section need special treatment\r
- elif Name == TAB_DSC_DEFINES_OUTPUT_DIRECTORY:\r
- self._OutputDirectory = NormPath(Record[1], 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[1], 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[1], TAB_VALUE_SPLIT)\r
- elif Name == TAB_DSC_DEFINES_BUILD_TARGETS:\r
- self._BuildTargets = GetSplitValueList(Record[1])\r
- elif Name == TAB_DSC_DEFINES_SKUID_IDENTIFIER:\r
- if self._SkuName == None:\r
- self._SkuName = Record[1]\r
- elif Name == TAB_FIX_LOAD_TOP_MEMORY_ADDRESS:\r
- self._LoadFixAddress = Record[1]\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[1])\r
- except:\r
- EdkLogger.error("build", FORMAT_INVALID, "Invalid GUID format for VPD_TOOL_GUID", File=self.MetaFile)\r
- self._VpdToolGuid = Record[1] \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 FILE_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
- self._Version = ''\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
- self._DscSpecification = ''\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
- self._SupArchList = ARCH_LIST\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
- self._BuildTargets = ['DEBUG', 'RELEASE']\r
- return self._BuildTargets\r
-\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
- if Value in self.SkuIds:\r
- self._SkuName = Value\r
- # Needs to re-retrieve the PCD information\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
- if self._LoadFixAddress == None:\r
- self._LoadFixAddress = ''\r
- return self._LoadFixAddress\r
-\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 = {}\r
- RecordList = self._RawData[MODEL_EFI_SKU_ID]\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
- 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 = {"EDK_SOURCE":GlobalData.gEcpSource, "EFI_SOURCE":GlobalData.gEfiSource}\r
- Macros.update(self._Macros)\r
- for Record in RecordList:\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 ModuleFile in self._Modules:\r
- EdkLogger.error('build', FILE_DUPLICATED, File=self.MetaFile, ExtraData=str(ModuleFile), Line=LineNo)\r
-\r
- Module = ModuleBuildClassObject()\r
- Module.MetaFile = ModuleFile\r
-\r
- # get module override path\r
- RecordList = self._RawData[MODEL_META_DATA_COMPONENT_SOURCE_OVERRIDE_PATH, self._Arch, None, ModuleId]\r
- if RecordList != []:\r
- Module.SourceOverridePath = os.path.join(GlobalData.gWorkspace, NormPath(RecordList[0][0], Macros))\r
-\r
- # Check if the source override path exists\r
- if not os.path.isdir(Module.SourceOverridePath):\r
- EdkLogger.error('build', FILE_NOT_FOUND, Message = 'Source override path does not exist:', File=self.MetaFile, ExtraData=Module.SourceOverridePath, Line=LineNo)\r
- \r
- #Add to GlobalData Variables\r
- GlobalData.gOverrideDir[ModuleFile.Key] = Module.SourceOverridePath\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
- 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]\r
- Macros = {"EDK_SOURCE":GlobalData.gEcpSource, "EFI_SOURCE":GlobalData.gEfiSource}\r
- Macros.update(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 R8 style library instances, which are listed in different section\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]\r
- self._LibraryClasses[Library.BaseName, ':dummy:'] = Library\r
- return self._LibraryClasses\r
-\r
- ## Retrieve all PCD settings in platform\r
- def _GetPcds(self):\r
- if self._Pcds == None:\r
- self._Pcds = {}\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 = {}\r
- #\r
- # Retrieve build option for EDKII style module\r
- #\r
- RecordList = self._RawData[MODEL_META_DATA_BUILD_OPTION, 'COMMON', EDKII_NAME]\r
- for ToolChainFamily, ToolChain, Option, Dummy1, Dummy2, Dummy3, Dummy4 in RecordList:\r
- self._BuildOptions[ToolChainFamily, ToolChain, EDKII_NAME] = Option\r
- #\r
- # Retrieve build option for EDK style module\r
- #\r
- RecordList = self._RawData[MODEL_META_DATA_BUILD_OPTION, 'COMMON', EDK_NAME] \r
- for ToolChainFamily, ToolChain, Option, Dummy1, Dummy2, Dummy3, Dummy4 in RecordList:\r
- self._BuildOptions[ToolChainFamily, ToolChain, EDK_NAME] = Option\r
- return self._BuildOptions\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 = {}\r
- #\r
- # tdict is a special dict kind of type, used for selecting correct\r
- # PCD settings for certain ARCH\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
- for TokenSpaceGuid, PcdCName, Setting, Arch, SkuName, Dummy3, Dummy4 in RecordList:\r
- PcdSet.add((PcdCName, TokenSpaceGuid))\r
- PcdDict[Arch, PcdCName, TokenSpaceGuid] = Setting\r
- # Remove redundant PCD candidates\r
- for PcdCName, TokenSpaceGuid in PcdSet:\r
- ValueList = ['', '', '']\r
- Setting = PcdDict[self._Arch, PcdCName, TokenSpaceGuid]\r
- if Setting == None:\r
- continue\r
- TokenList = Setting.split(TAB_VALUE_SPLIT)\r
- ValueList[0:len(TokenList)] = TokenList\r
- PcdValue, DatumType, MaxDatumSize = ValueList\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
- Pcds = {}\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
- # Find out all possible PCD candidates for self._Arch\r
- RecordList = self._RawData[Type, self._Arch]\r
- for TokenSpaceGuid, PcdCName, Setting, Arch, SkuName, Dummy3, Dummy4 in RecordList:\r
- PcdSet.add((PcdCName, TokenSpaceGuid))\r
- PcdDict[Arch, SkuName, PcdCName, TokenSpaceGuid] = Setting\r
- # Remove redundant PCD candidates, per the ARCH and SKU\r
- for PcdCName, TokenSpaceGuid in PcdSet:\r
- ValueList = ['', '', '']\r
- Setting = PcdDict[self._Arch, self.SkuName, PcdCName, TokenSpaceGuid]\r
- if Setting == None:\r
- continue\r
- TokenList = Setting.split(TAB_VALUE_SPLIT)\r
- ValueList[0:len(TokenList)] = TokenList\r
- PcdValue, DatumType, MaxDatumSize = ValueList\r
-\r
- SkuInfo = SkuInfoClass(self.SkuName, self.SkuIds[self.SkuName], '', '', '', '', '', PcdValue)\r
- Pcds[PcdCName, TokenSpaceGuid] = PcdClassObject(\r
- PcdCName,\r
- TokenSpaceGuid,\r
- self._PCD_TYPE_STRING_[Type],\r
- DatumType,\r
- PcdValue,\r
- '',\r
- MaxDatumSize,\r
- {self.SkuName : SkuInfo},\r
- False,\r
- None\r
- )\r
- return Pcds\r
-\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
- Pcds = {}\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
- for TokenSpaceGuid, PcdCName, Setting, Arch, SkuName, Dummy3, Dummy4 in RecordList:\r
- PcdSet.add((PcdCName, TokenSpaceGuid))\r
- PcdDict[Arch, SkuName, PcdCName, TokenSpaceGuid] = Setting\r
- # Remove redundant PCD candidates, per the ARCH and SKU\r
- for PcdCName, TokenSpaceGuid in PcdSet:\r
- ValueList = ['', '', '', '']\r
- Setting = PcdDict[self._Arch, self.SkuName, PcdCName, TokenSpaceGuid]\r
- if Setting == None:\r
- continue\r
- TokenList = Setting.split(TAB_VALUE_SPLIT)\r
- ValueList[0:len(TokenList)] = TokenList\r
- VariableName, VariableGuid, VariableOffset, DefaultValue = ValueList\r
- SkuInfo = SkuInfoClass(self.SkuName, self.SkuIds[self.SkuName], VariableName, VariableGuid, VariableOffset, DefaultValue)\r
- Pcds[PcdCName, TokenSpaceGuid] = PcdClassObject(\r
- PcdCName,\r
- TokenSpaceGuid,\r
- self._PCD_TYPE_STRING_[Type],\r
- '',\r
- DefaultValue,\r
- '',\r
- '',\r
- {self.SkuName : SkuInfo},\r
- False,\r
- None\r
- )\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
- Pcds = {}\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
- # Find out all possible PCD candidates for self._Arch\r
- RecordList = self._RawData[Type, self._Arch]\r
- for TokenSpaceGuid, PcdCName, Setting, Arch, SkuName, Dummy3, Dummy4 in RecordList:\r
- PcdSet.add((PcdCName, TokenSpaceGuid))\r
- PcdDict[Arch, SkuName, PcdCName, TokenSpaceGuid] = Setting\r
- # Remove redundant PCD candidates, per the ARCH and SKU\r
- for PcdCName, TokenSpaceGuid in PcdSet:\r
- ValueList = ['', '', '']\r
- Setting = PcdDict[self._Arch, self.SkuName, PcdCName, TokenSpaceGuid]\r
- if Setting == None:\r
- continue\r
- TokenList = Setting.split(TAB_VALUE_SPLIT)\r
- ValueList[0:len(TokenList)] = TokenList\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 = ValueList\r
-\r
- SkuInfo = SkuInfoClass(self.SkuName, self.SkuIds[self.SkuName], '', '', '', '', VpdOffset, InitialValue)\r
- Pcds[PcdCName, TokenSpaceGuid] = PcdClassObject(\r
- PcdCName,\r
- TokenSpaceGuid,\r
- self._PCD_TYPE_STRING_[Type],\r
- '',\r
- '',\r
- '',\r
- MaxDatumSize,\r
- {self.SkuName : SkuInfo},\r
- False,\r
- None\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
- 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
- FlashDefinition = property(_GetFdfFile)\r
- BuildNumber = property(_GetBuildNumber)\r
- MakefileName = property(_GetMakefileName)\r
- BsBaseAddress = property(_GetBsBaseAddress)\r
- RtBaseAddress = property(_GetRtBaseAddress)\r
- LoadFixAddress = property(_GetLoadFixAddress)\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', Platform='DUMMY', Macros={}):\r
- self.MetaFile = File\r
- self._PackageDir = File.Dir\r
- self._RawData = RawData\r
- self._Bdb = BuildDataBase\r
- self._Arch = Arch\r
- self._Macros = Macros\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
-\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]\r
- for Record in RecordList:\r
- Name = Record[0]\r
- if Name in self:\r
- self[Name] = Record[1]\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 = {"EDK_SOURCE":GlobalData.gEcpSource, "EFI_SOURCE":GlobalData.gEfiSource}\r
- Macros.update(self._Macros)\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 = {"EDK_SOURCE":GlobalData.gEcpSource, "EFI_SOURCE":GlobalData.gEfiSource}\r
- Macros.update(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 = {}\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 = {}\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
- ValueList = ['', '', '']\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
- TokenList = Setting.split(TAB_VALUE_SPLIT)\r
- ValueList[0:len(TokenList)] = TokenList\r
- DefaultValue, DatumType, TokenNumber = ValueList\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
- )\r
- return Pcds\r
-\r
-\r
- Arch = property(_GetArch, _SetArch)\r
- PackageName = property(_GetPackageName)\r
- Guid = property(_GetFileGuid)\r
- Version = property(_GetVersion)\r
+from .MetaDataTable import *\r
+from .MetaFileTable import *\r
+from .MetaFileParser import *\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_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', Platform='COMMON', Macros={}):\r
- self.MetaFile = FilePath\r
- self._ModuleDir = FilePath.Dir\r
- self._RawData = RawData\r
- self._Bdb = BuildDatabase\r
- self._Arch = Arch\r
- self._Platform = 'COMMON'\r
- self._Macros = Macros\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._Header_ = None\r
- self._AutoGenVersion = None\r
- self._BaseName = 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._Ppis = None\r
- self._Guids = None\r
- self._Includes = None\r
- self._Packages = None\r
- self._Pcds = None\r
- self._BuildOptions = None\r
- self._Depex = None\r
- self._DepexExpression = None\r
- #self._SourceOverridePath = None\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
-\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
- Record = ReplaceMacros(Record, GlobalData.gEdkGlobal, False)\r
- Name = Record[0]\r
- # items defined _PROPERTY_ don't need additional processing\r
- if Name in self:\r
- self[Name] = Record[1]\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(Record[1])\r
- if self._Specification[Name] == None:\r
- EdkLogger.error("build", FORMAT_NOT_SUPPORTED,\r
- "'%s' format is not supported for %s" % (Record[1], Name),\r
- File=self.MetaFile, Line=Record[-1])\r
- elif Name == 'LIBRARY_CLASS':\r
- if self._LibraryClass == None:\r
- self._LibraryClass = []\r
- ValueList = GetSplitValueList(Record[1])\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(Record[1])\r
- elif Name == 'UNLOAD_IMAGE':\r
- if self._ModuleUnloadImageList == None:\r
- self._ModuleUnloadImageList = []\r
- if Record[1] == '':\r
- continue\r
- self._ModuleUnloadImageList.append(Record[1])\r
- elif Name == 'CONSTRUCTOR':\r
- if self._ConstructorList == None:\r
- self._ConstructorList = []\r
- if Record[1] == '':\r
- continue\r
- self._ConstructorList.append(Record[1])\r
- elif Name == 'DESTRUCTOR':\r
- if self._DestructorList == None:\r
- self._DestructorList = []\r
- if Record[1] == '':\r
- continue\r
- self._DestructorList.append(Record[1])\r
- elif Name == TAB_INF_DEFINES_CUSTOM_MAKEFILE:\r
- TokenList = GetSplitValueList(Record[1])\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] = Record[1]\r
-\r
- #\r
- # Retrieve information in sections specific to R8.x modules\r
- #\r
- if self._AutoGenVersion >= 0x00010005: # _AutoGenVersion may be None, which is less than anything\r
- if not self._ModuleType:\r
- EdkLogger.error("build", ATTRIBUTE_NOT_AVAILABLE,\r
- "MODULE_TYPE is not given", File=self.MetaFile)\r
- if (self._Specification == None) or (not 'PI_SPECIFICATION_VERSION' in self._Specification) or (self._Specification['PI_SPECIFICATION_VERSION'] < 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
- else:\r
- self._BuildType = self._ComponentType.upper()\r
- if not self._ComponentType:\r
- EdkLogger.error("build", ATTRIBUTE_NOT_AVAILABLE,\r
- "COMPONENT_TYPE is not given", File=self.MetaFile)\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
- RecordList = self._RawData[MODEL_META_DATA_NMAKE, self._Arch, self._Platform]\r
- for Name,Value,Dummy,Arch,Platform,ID,LineNo in RecordList:\r
- Value = Value.replace('$(PROCESSOR)', self._Arch)\r
- Name = Name.replace('$(PROCESSOR)', self._Arch)\r
- Name, Value = ReplaceMacros((Name, Value), GlobalData.gEdkGlobal, 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
- Macros = {"EDK_SOURCE":GlobalData.gEcpSource, "EFI_SOURCE":GlobalData.gEfiSource}\r
- Macros.update(self._Macros)\r
- File = PathClass(NormPath(Value, Macros), 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' # R8.x only support MSFT tool chain\r
- #ignore not replaced macros in value\r
- ValueList = GetSplitValueList(' ' + 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
- if self._Header_ == None:\r
- self._GetHeaderInfo()\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 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-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 _GetBinaryFiles(self):\r
- if self._Binaries == None:\r
- self._Binaries = []\r
- RecordList = self._RawData[MODEL_EFI_BINARY_FILE, self._Arch, self._Platform]\r
- Macros = {"EDK_SOURCE":GlobalData.gEcpSource, "EFI_SOURCE":GlobalData.gEfiSource, 'PROCESSOR':self._Arch}\r
- Macros.update(self._Macros)\r
- for Record in RecordList:\r
- Record = ReplaceMacros(Record, GlobalData.gEdkGlobal, False)\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 source files\r
- def _GetSourceFiles(self):\r
- if self._Sources == None:\r
- self._Sources = []\r
- RecordList = self._RawData[MODEL_EFI_SOURCE_FILE, self._Arch, self._Platform]\r
- Macros = {"EDK_SOURCE":GlobalData.gEcpSource, "EFI_SOURCE":GlobalData.gEfiSource, 'PROCESSOR':self._Arch}\r
- Macros.update(self._Macros)\r
- for Record in RecordList:\r
- Record = ReplaceMacros(Record, GlobalData.gEdkGlobal, False)\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
- # old module source files (R8)\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
- Record = ReplaceMacros(Record, GlobalData.gEdkGlobal, False)\r
- Lib = Record[0]\r
- Instance = Record[1]\r
- if Instance != None and Instance != '':\r
- Instance = NormPath(Instance, self._Macros)\r
- self._LibraryClasses[Lib] = Instance\r
- return self._LibraryClasses\r
-\r
- ## Retrieve library names (for R8.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
- # in case of name with '.lib' extension, which is unusual in R8.x inf\r
- Record = ReplaceMacros(Record, GlobalData.gEdkGlobal, False)\r
- LibraryName = os.path.splitext(Record[0])[0]\r
- if LibraryName not in self._Libraries:\r
- self._Libraries.append(LibraryName)\r
- return self._Libraries\r
-\r
- ## Retrieve protocols consumed/produced by this module\r
- def _GetProtocols(self):\r
- if self._Protocols == None:\r
- self._Protocols = 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
- return self._Protocols\r
-\r
- ## Retrieve PPIs consumed/produced by this module\r
- def _GetPpis(self):\r
- if self._Ppis == None:\r
- self._Ppis = 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
- return self._Ppis\r
-\r
- ## Retrieve GUIDs consumed/produced by this module\r
- def _GetGuids(self):\r
- if self._Guids == None:\r
- self._Guids = 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
- return self._Guids\r
-\r
- ## Retrieve include paths necessary for this module (for R8.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
- RecordList = self._RawData[MODEL_EFI_INCLUDE, self._Arch, self._Platform]\r
- # [includes] section must be used only in old (R8.x) inf file\r
- if self.AutoGenVersion >= 0x00010005 and len(RecordList) > 0:\r
- EdkLogger.error('build', FORMAT_NOT_SUPPORTED, "No [include] section allowed",\r
- File=self.MetaFile, Line=RecordList[0][-1]-1)\r
- for Record in RecordList:\r
- Record = ReplaceMacros(Record, GlobalData.gEdkGlobal, False)\r
- Record[0] = Record[0].replace('$(PROCESSOR)', self._Arch)\r
- Record[0] = ReplaceMacro(Record[0], {'EFI_SOURCE' : GlobalData.gEfiSource}, False)\r
- if Record[0].find('EDK_SOURCE') > -1:\r
- File = NormPath(ReplaceMacro(Record[0], {'EDK_SOURCE' : GlobalData.gEcpSource}, False), 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
- File = NormPath(ReplaceMacro(Record[0], {'EDK_SOURCE' : GlobalData.gEdkSource}, False), 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], 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
- 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 = {"EDK_SOURCE":GlobalData.gEcpSource, "EFI_SOURCE":GlobalData.gEfiSource}\r
- Macros.update(self._Macros)\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]\r
- self._Packages.append(Package)\r
- return self._Packages\r
-\r
- ## Retrieve PCDs used in this module\r
- def _GetPcds(self):\r
- if self._Pcds == None:\r
- self._Pcds = {}\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:\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 depedency 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
- # 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
- Depex = {}\r
- for Record in RecordList:\r
- Record = ReplaceMacros(Record, GlobalData.gEdkGlobal, False)\r
- Arch = Record[3]\r
- ModuleType = Record[4]\r
- TokenList = Record[0].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 = {}\r
- for Record in RecordList:\r
- Record = ReplaceMacros(Record, GlobalData.gEdkGlobal, False)\r
- Arch = Record[3]\r
- ModuleType = Record[4]\r
- TokenList = Record[0].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
- ## Retrieve PCD for given type\r
- def _GetPcd(self, Type):\r
- Pcds = {}\r
- PcdDict = tdict(True, 4)\r
- PcdSet = set()\r
- RecordList = self._RawData[Type, self._Arch, self._Platform]\r
- for TokenSpaceGuid, PcdCName, Setting, Arch, Platform, Dummy1, LineNo in RecordList:\r
- PcdDict[Arch, Platform, PcdCName, TokenSpaceGuid] = (Setting, LineNo)\r
- PcdSet.add((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
-\r
- # resolve PCD type, value, datum info, etc. by getting its definition from package\r
- for PcdCName, TokenSpaceGuid in PcdSet:\r
- ValueList = ['', '']\r
- Setting, LineNo = PcdDict[self._Arch, self.Platform, PcdCName, TokenSpaceGuid]\r
- if Setting == None:\r
- continue\r
- TokenList = Setting.split(TAB_VALUE_SPLIT)\r
- ValueList[0:len(TokenList)] = TokenList\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
-\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
- 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
- PARSER_ERROR,\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
- return Pcds\r
-\r
- Arch = property(_GetArch, _SetArch)\r
- Platform = property(_GetPlatform, _SetPlatform)\r
-\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
-\r
- Binaries = property(_GetBinaryFiles)\r
- Sources = property(_GetSourceFiles)\r
- LibraryClasses = property(_GetLibraryClassUses)\r
- Libraries = property(_GetLibraryNames)\r
- Protocols = property(_GetProtocols)\r
- Ppis = property(_GetPpis)\r
- Guids = property(_GetGuids)\r
- Includes = property(_GetIncludes)\r
- Packages = property(_GetPackages)\r
- Pcds = property(_GetPcds)\r
- BuildOptions = property(_GetBuildOptions)\r
- Depex = property(_GetDepex)\r
- DepexExpression = property(_GetDepexExpression)\r
+from Workspace.DecBuildData import DecBuildData\r
+from Workspace.DscBuildData import DscBuildData\r
+from Workspace.InfBuildData import InfBuildData\r
\r
## Database\r
#\r
# @prarm RenewDb=False Create new database file if it's already there\r
#\r
class WorkspaceDatabase(object):\r
- # file parser\r
- _FILE_PARSER_ = {\r
- MODEL_FILE_INF : InfParser,\r
- MODEL_FILE_DEC : DecParser,\r
- MODEL_FILE_DSC : DscParser,\r
- MODEL_FILE_FDF : None, #FdfParser,\r
- MODEL_FILE_CIF : None\r
- }\r
-\r
- # file table\r
- _FILE_TABLE_ = {\r
- MODEL_FILE_INF : ModuleTable,\r
- MODEL_FILE_DEC : PackageTable,\r
- MODEL_FILE_DSC : PlatformTable,\r
- }\r
-\r
- # default database file path\r
- _DB_PATH_ = "Conf/.cache/build.db"\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
- ".fdf" : MODEL_FILE_FDF,\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
MODEL_FILE_INF : InfBuildData,\r
MODEL_FILE_DEC : DecBuildData,\r
MODEL_FILE_DSC : DscBuildData,\r
- MODEL_FILE_FDF : None #FlashDefTable,\r
}\r
\r
_CACHE_ = {} # (FilePath, Arch) : <object>\r
def __init__(self, WorkspaceDb):\r
self.WorkspaceDb = WorkspaceDb\r
\r
- # key = (FilePath, Arch='COMMON')\r
+ # key = (FilePath, Arch=None)\r
def __contains__(self, Key):\r
FilePath = Key[0]\r
- Arch = 'COMMON'\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='COMMON')\r
+ # key = (FilePath, Arch=None, Target=None, Toochain=None)\r
def __getitem__(self, Key):\r
FilePath = Key[0]\r
- Arch = 'COMMON'\r
- Platform = 'COMMON'\r
- if len(Key) > 1:\r
+ KeyLength = len(Key)\r
+ if KeyLength > 1:\r
Arch = Key[1]\r
- if len(Key) > 2:\r
- Platform = Key[2]\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)\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.Ext.lower()\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 table for current file\r
- MetaFile = self.WorkspaceDb[FilePath, FileType, self.WorkspaceDb._GlobalMacros]\r
+ # get the parser ready for this file\r
+ MetaFile = self._FILE_PARSER_[FileType](\r
+ FilePath,\r
+ FileType,\r
+ Arch,\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
- Platform,\r
- self.WorkspaceDb._GlobalMacros,\r
+ Target,\r
+ Toolchain\r
)\r
self._CACHE_[Key] = BuildObject\r
return BuildObject\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, GlobalMacros={}, RenewDb=False):\r
- self._GlobalMacros = GlobalMacros\r
-\r
- if DbPath == None or DbPath == '':\r
- DbPath = os.path.normpath(os.path.join(GlobalData.gWorkspace, self._DB_PATH_))\r
+ def __init__(self, DbPath, RenewDb=False):\r
+ self._DbClosedFlag = False\r
+ if not DbPath:\r
+ DbPath = os.path.normpath(mws.join(GlobalData.gWorkspace, 'Conf', GlobalData.gDatabasePath))\r
\r
# don't create necessary path for db in memory\r
if DbPath != ':memory:':\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
+\r
# create db with optimized parameters\r
self.Conn = sqlite3.connect(DbPath, isolation_level='DEFERRED')\r
self.Conn.execute("PRAGMA synchronous=OFF")\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
# @return Bool value for whether need renew workspace databse\r
#\r
def _CheckWhetherDbNeedRenew (self, force, DbPath):\r
- DbDir = os.path.split(DbPath)[0]\r
- MacroFilePath = os.path.normpath(os.path.join(DbDir, "build.mac"))\r
- MacroMatch = False\r
- if os.path.exists(MacroFilePath) and os.path.isfile(MacroFilePath):\r
- LastMacros = None\r
- try:\r
- f = open(MacroFilePath,'r')\r
- LastMacros = pickle.load(f)\r
- f.close()\r
- except IOError:\r
- pass\r
- except:\r
- f.close()\r
-\r
- if LastMacros != None and type(LastMacros) is DictType:\r
- if LastMacros == self._GlobalMacros:\r
- MacroMatch = True\r
- for Macro in LastMacros.keys():\r
- if not (Macro in self._GlobalMacros and LastMacros[Macro] == self._GlobalMacros[Macro]):\r
- MacroMatch = False;\r
- break;\r
-\r
- if not MacroMatch:\r
- # save command line macros to file\r
- try:\r
- f = open(MacroFilePath,'w')\r
- pickle.dump(self._GlobalMacros, f, 2)\r
- f.close()\r
- except IOError:\r
- pass\r
- except:\r
- f.close()\r
-\r
- force = True\r
-\r
# if database does not exist, we need do nothing\r
if not os.path.exists(DbPath): return False\r
- \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
+\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
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
+ if rootPath == "" or rootPath is 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
+\r
# walk the root path of source or build's binary to get the time last modified.\r
- \r
+\r
for root, dirs, files in os.walk (rootPath):\r
for dir in dirs:\r
- # bypass source control folder \r
+ # bypass source control folder\r
if dir.lower() in [".svn", "_svn", "cvs"]:\r
dirs.remove(dir)\r
- \r
+\r
for file in files:\r
ext = os.path.splitext(file)[1]\r
if ext.lower() == ".py": # only check .py files\r
if timeOfToolModified > os.stat(DbPath).st_mtime:\r
EdkLogger.verbose("\nWorkspace database is out of data!")\r
return True\r
- \r
+\r
return False\r
- \r
+\r
## Initialize build database\r
def InitDatabase(self):\r
EdkLogger.verbose("\nInitialize build database started ...")\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
- self.Conn.commit()\r
- self.Cur.close()\r
- self.Conn.close()\r
-\r
- ## Get unique file ID for the gvien file\r
- def GetFileId(self, FilePath):\r
- return self.TblFile.GetFileId(FilePath)\r
-\r
- ## Get file type value for the gvien file ID\r
- def GetFileType(self, FileId):\r
- return self.TblFile.GetFileType(FileId)\r
-\r
- ## Get time stamp stored in file table\r
- def GetTimeStamp(self, FileId):\r
- return self.TblFile.GetFileTimeStamp(FileId)\r
-\r
- ## Update time stamp in file table\r
- def SetTimeStamp(self, FileId, TimeStamp):\r
- return self.TblFile.SetFileTimeStamp(FileId, TimeStamp)\r
-\r
- ## Check if a table integrity flag exists or not\r
- def CheckIntegrity(self, TableName):\r
- try:\r
- Result = self.Cur.execute("select min(ID) from %s" % (TableName)).fetchall()\r
- if Result[0][0] != -1:\r
- return False\r
- #\r
- # Check whether the meta data file has external dependency by comparing the time stamp\r
- #\r
- Sql = "select Value1, Value2 from %s where Model=%d" % (TableName, MODEL_EXTERNAL_DEPENDENCY)\r
- for Dependency in self.Cur.execute(Sql).fetchall():\r
- if str(os.stat(Dependency[0])[8]) != Dependency[1]:\r
- return False\r
- except:\r
- return False\r
- return True\r
-\r
- ## Compose table name for given file type and file ID\r
- def GetTableName(self, FileType, FileId):\r
- return "_%s_%s" % (FileType, FileId)\r
-\r
- ## Return a temp table containing all content of the given file\r
- #\r
- # @param FileInfo The tuple containing path and type of a file\r
- #\r
- def __getitem__(self, FileInfo):\r
- FilePath, FileType, Macros = FileInfo\r
- if FileType not in self._FILE_TABLE_:\r
- return None\r
-\r
- # flag used to indicate if it's parsed or not\r
- FilePath = str(FilePath)\r
- Parsed = False\r
- FileId = self.GetFileId(FilePath)\r
- if FileId != None:\r
- TimeStamp = os.stat(FilePath)[8]\r
- TableName = self.GetTableName(FileType, FileId)\r
- if TimeStamp != self.GetTimeStamp(FileId):\r
- # update the timestamp in database\r
- self.SetTimeStamp(FileId, TimeStamp)\r
- else:\r
- # if the table exists and is integrity, don't parse it\r
- Parsed = self.CheckIntegrity(TableName)\r
- else:\r
- FileId = self.TblFile.InsertFile(FilePath, FileType)\r
- TableName = self.GetTableName(FileType, FileId)\r
-\r
- FileTable = self._FILE_TABLE_[FileType](self.Cur, TableName, FileId)\r
- FileTable.Create(not Parsed)\r
- Parser = self._FILE_PARSER_[FileType](FilePath, FileType, FileTable, Macros)\r
- # set the "Finished" flag in parser in order to avoid re-parsing (if parsed)\r
- Parser.Finished = Parsed\r
- return Parser\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):\r
+ def GetPackageList(self, Platform, Arch, TargetName, ToolChainTag):\r
+ self.Platform = Platform\r
PackageList = []\r
- for Module in self.ModuleList:\r
- for Package in Module.Packages:\r
+ Pa = self.BuildObject[self.Platform, Arch, TargetName, ToolChainTag]\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
PlatformList = []\r
for PlatformFile in self.TblFile.GetFileList(MODEL_FILE_DSC):\r
try:\r
- Platform = self.BuildObject[PathClass(PlatformFile), 'COMMON']\r
+ Platform = self.BuildObject[PathClass(PlatformFile), TAB_COMMON]\r
except:\r
Platform = None\r
- if Platform != None:\r
+ if Platform is not None:\r
PlatformList.append(Platform)\r
return PlatformList\r
\r
- ## Summarize all modules in the database\r
- def _GetModuleList(self):\r
- ModuleList = []\r
- for ModuleFile in self.TblFile.GetFileList(MODEL_FILE_INF):\r
- try:\r
- Module = self.BuildObject[PathClass(ModuleFile), 'COMMON']\r
- except:\r
- Module = None\r
- if Module != None:\r
- ModuleList.append(Module)\r
- return ModuleList\r
+ def _MapPlatform(self, Dscfile):\r
+ Platform = self.BuildObject[PathClass(Dscfile), TAB_COMMON]\r
+ if Platform is None:\r
+ EdkLogger.error('build', PARSER_ERROR, "Failed to parser DSC file: %s" % Dscfile)\r
+ return Platform\r
\r
PlatformList = property(_GetPlatformList)\r
- PackageList = property(_GetPackageList)\r
- ModuleList = property(_GetModuleList)\r
\r
##\r
#\r
projects / mirror_edk2.git / blobdiff