| | 1 | ## @file\r |
| | 2 | # This file is used to create a database used by build tool\r |
| | 3 | #\r |
| | 4 | # Copyright (c) 2008 - 2015, Intel Corporation. All rights reserved.<BR>\r |
| | 5 | # This program and the accompanying materials\r |
| | 6 | # are licensed and made available under the terms and conditions of the BSD License\r |
| | 7 | # which accompanies this distribution. The full text of the license may be found at\r |
| | 8 | # http://opensource.org/licenses/bsd-license.php\r |
| | 9 | #\r |
| | 10 | # THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,\r |
| | 11 | # WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.\r |
| | 12 | #\r |
| | 13 | \r |
| | 14 | ##\r |
| | 15 | # Import Modules\r |
| | 16 | #\r |
| | 17 | import sqlite3\r |
| | 18 | import Common.LongFilePathOs as os\r |
| | 19 | import pickle\r |
| | 20 | import uuid\r |
| | 21 | \r |
| | 22 | import Common.EdkLogger as EdkLogger\r |
| | 23 | import Common.GlobalData as GlobalData\r |
| | 24 | \r |
| | 25 | from Common.String import *\r |
| | 26 | from Common.DataType import *\r |
| | 27 | from Common.Misc import *\r |
| | 28 | from types import *\r |
| | 29 | \r |
| | 30 | from CommonDataClass.CommonClass import SkuInfoClass\r |
| | 31 | \r |
| | 32 | from MetaDataTable import *\r |
| | 33 | from MetaFileTable import *\r |
| | 34 | from MetaFileParser import *\r |
| | 35 | from BuildClassObject import *\r |
| | 36 | from WorkspaceCommon import GetDeclaredPcd\r |
| | 37 | from Common.Misc import AnalyzeDscPcd\r |
| | 38 | from Common.Misc import ProcessDuplicatedInf\r |
| | 39 | import re\r |
| | 40 | from Common.Parsing import IsValidWord\r |
| | 41 | from Common.VariableAttributes import VariableAttributes\r |
| | 42 | import Common.GlobalData as GlobalData\r |
| | 43 | \r |
| | 44 | ## Platform build information from DSC file\r |
| | 45 | #\r |
| | 46 | # This class is used to retrieve information stored in database and convert them\r |
| | 47 | # into PlatformBuildClassObject form for easier use for AutoGen.\r |
| | 48 | #\r |
| | 49 | class DscBuildData(PlatformBuildClassObject):\r |
| | 50 | # dict used to convert PCD type in database to string used by build tool\r |
| | 51 | _PCD_TYPE_STRING_ = {\r |
| | 52 | MODEL_PCD_FIXED_AT_BUILD : "FixedAtBuild",\r |
| | 53 | MODEL_PCD_PATCHABLE_IN_MODULE : "PatchableInModule",\r |
| | 54 | MODEL_PCD_FEATURE_FLAG : "FeatureFlag",\r |
| | 55 | MODEL_PCD_DYNAMIC : "Dynamic",\r |
| | 56 | MODEL_PCD_DYNAMIC_DEFAULT : "Dynamic",\r |
| | 57 | MODEL_PCD_DYNAMIC_HII : "DynamicHii",\r |
| | 58 | MODEL_PCD_DYNAMIC_VPD : "DynamicVpd",\r |
| | 59 | MODEL_PCD_DYNAMIC_EX : "DynamicEx",\r |
| | 60 | MODEL_PCD_DYNAMIC_EX_DEFAULT : "DynamicEx",\r |
| | 61 | MODEL_PCD_DYNAMIC_EX_HII : "DynamicExHii",\r |
| | 62 | MODEL_PCD_DYNAMIC_EX_VPD : "DynamicExVpd",\r |
| | 63 | }\r |
| | 64 | \r |
| | 65 | # dict used to convert part of [Defines] to members of DscBuildData directly\r |
| | 66 | _PROPERTY_ = {\r |
| | 67 | #\r |
| | 68 | # Required Fields\r |
| | 69 | #\r |
| | 70 | TAB_DSC_DEFINES_PLATFORM_NAME : "_PlatformName",\r |
| | 71 | TAB_DSC_DEFINES_PLATFORM_GUID : "_Guid",\r |
| | 72 | TAB_DSC_DEFINES_PLATFORM_VERSION : "_Version",\r |
| | 73 | TAB_DSC_DEFINES_DSC_SPECIFICATION : "_DscSpecification",\r |
| | 74 | #TAB_DSC_DEFINES_OUTPUT_DIRECTORY : "_OutputDirectory",\r |
| | 75 | #TAB_DSC_DEFINES_SUPPORTED_ARCHITECTURES : "_SupArchList",\r |
| | 76 | #TAB_DSC_DEFINES_BUILD_TARGETS : "_BuildTargets",\r |
| | 77 | TAB_DSC_DEFINES_SKUID_IDENTIFIER : "_SkuName",\r |
| | 78 | #TAB_DSC_DEFINES_FLASH_DEFINITION : "_FlashDefinition",\r |
| | 79 | TAB_DSC_DEFINES_BUILD_NUMBER : "_BuildNumber",\r |
| | 80 | TAB_DSC_DEFINES_MAKEFILE_NAME : "_MakefileName",\r |
| | 81 | TAB_DSC_DEFINES_BS_BASE_ADDRESS : "_BsBaseAddress",\r |
| | 82 | TAB_DSC_DEFINES_RT_BASE_ADDRESS : "_RtBaseAddress",\r |
| | 83 | #TAB_DSC_DEFINES_RFC_LANGUAGES : "_RFCLanguages",\r |
| | 84 | #TAB_DSC_DEFINES_ISO_LANGUAGES : "_ISOLanguages",\r |
| | 85 | }\r |
| | 86 | \r |
| | 87 | # used to compose dummy library class name for those forced library instances\r |
| | 88 | _NullLibraryNumber = 0\r |
| | 89 | \r |
| | 90 | ## Constructor of DscBuildData\r |
| | 91 | #\r |
| | 92 | # Initialize object of DscBuildData\r |
| | 93 | #\r |
| | 94 | # @param FilePath The path of platform description file\r |
| | 95 | # @param RawData The raw data of DSC file\r |
| | 96 | # @param BuildDataBase Database used to retrieve module/package information\r |
| | 97 | # @param Arch The target architecture\r |
| | 98 | # @param Platform (not used for DscBuildData)\r |
| | 99 | # @param Macros Macros used for replacement in DSC file\r |
| | 100 | #\r |
| | 101 | def __init__(self, FilePath, RawData, BuildDataBase, Arch='COMMON', Target=None, Toolchain=None):\r |
| | 102 | self.MetaFile = FilePath\r |
| | 103 | self._RawData = RawData\r |
| | 104 | self._Bdb = BuildDataBase\r |
| | 105 | self._Arch = Arch\r |
| | 106 | self._Target = Target\r |
| | 107 | self._Toolchain = Toolchain\r |
| | 108 | self._Clear()\r |
| | 109 | self._HandleOverridePath()\r |
| | 110 | \r |
| | 111 | ## XXX[key] = value\r |
| | 112 | def __setitem__(self, key, value):\r |
| | 113 | self.__dict__[self._PROPERTY_[key]] = value\r |
| | 114 | \r |
| | 115 | ## value = XXX[key]\r |
| | 116 | def __getitem__(self, key):\r |
| | 117 | return self.__dict__[self._PROPERTY_[key]]\r |
| | 118 | \r |
| | 119 | ## "in" test support\r |
| | 120 | def __contains__(self, key):\r |
| | 121 | return key in self._PROPERTY_\r |
| | 122 | \r |
| | 123 | ## Set all internal used members of DscBuildData to None\r |
| | 124 | def _Clear(self):\r |
| | 125 | self._Header = None\r |
| | 126 | self._PlatformName = None\r |
| | 127 | self._Guid = None\r |
| | 128 | self._Version = None\r |
| | 129 | self._DscSpecification = None\r |
| | 130 | self._OutputDirectory = None\r |
| | 131 | self._SupArchList = None\r |
| | 132 | self._BuildTargets = None\r |
| | 133 | self._SkuName = None\r |
| | 134 | self._SkuIdentifier = None\r |
| | 135 | self._AvilableSkuIds = None\r |
| | 136 | self._PcdInfoFlag = None\r |
| | 137 | self._VarCheckFlag = None\r |
| | 138 | self._FlashDefinition = None\r |
| | 139 | self._BuildNumber = None\r |
| | 140 | self._MakefileName = None\r |
| | 141 | self._BsBaseAddress = None\r |
| | 142 | self._RtBaseAddress = None\r |
| | 143 | self._SkuIds = None\r |
| | 144 | self._Modules = None\r |
| | 145 | self._LibraryInstances = None\r |
| | 146 | self._LibraryClasses = None\r |
| | 147 | self._Pcds = None\r |
| | 148 | self._DecPcds = None\r |
| | 149 | self._BuildOptions = None\r |
| | 150 | self._LoadFixAddress = None\r |
| | 151 | self._RFCLanguages = None\r |
| | 152 | self._ISOLanguages = None\r |
| | 153 | self._VpdToolGuid = None\r |
| | 154 | self.__Macros = None\r |
| | 155 | \r |
| | 156 | \r |
| | 157 | ## handle Override Path of Module\r |
| | 158 | def _HandleOverridePath(self):\r |
| | 159 | RecordList = self._RawData[MODEL_META_DATA_COMPONENT, self._Arch]\r |
| | 160 | Macros = self._Macros\r |
| | 161 | Macros["EDK_SOURCE"] = GlobalData.gEcpSource\r |
| | 162 | for Record in RecordList:\r |
| | 163 | ModuleId = Record[5]\r |
| | 164 | LineNo = Record[6]\r |
| | 165 | ModuleFile = PathClass(NormPath(Record[0]), GlobalData.gWorkspace, Arch=self._Arch)\r |
| | 166 | RecordList = self._RawData[MODEL_META_DATA_COMPONENT_SOURCE_OVERRIDE_PATH, self._Arch, None, ModuleId]\r |
| | 167 | if RecordList != []:\r |
| | 168 | SourceOverridePath = os.path.join(GlobalData.gWorkspace, NormPath(RecordList[0][0]))\r |
| | 169 | \r |
| | 170 | # Check if the source override path exists\r |
| | 171 | if not os.path.isdir(SourceOverridePath):\r |
| | 172 | EdkLogger.error('build', FILE_NOT_FOUND, Message='Source override path does not exist:', File=self.MetaFile, ExtraData=SourceOverridePath, Line=LineNo)\r |
| | 173 | \r |
| | 174 | #Add to GlobalData Variables\r |
| | 175 | GlobalData.gOverrideDir[ModuleFile.Key] = SourceOverridePath\r |
| | 176 | \r |
| | 177 | ## Get current effective macros\r |
| | 178 | def _GetMacros(self):\r |
| | 179 | if self.__Macros == None:\r |
| | 180 | self.__Macros = {}\r |
| | 181 | self.__Macros.update(GlobalData.gPlatformDefines)\r |
| | 182 | self.__Macros.update(GlobalData.gGlobalDefines)\r |
| | 183 | self.__Macros.update(GlobalData.gCommandLineDefines)\r |
| | 184 | return self.__Macros\r |
| | 185 | \r |
| | 186 | ## Get architecture\r |
| | 187 | def _GetArch(self):\r |
| | 188 | return self._Arch\r |
| | 189 | \r |
| | 190 | ## Set architecture\r |
| | 191 | #\r |
| | 192 | # Changing the default ARCH to another may affect all other information\r |
| | 193 | # because all information in a platform may be ARCH-related. That's\r |
| | 194 | # why we need to clear all internal used members, in order to cause all\r |
| | 195 | # information to be re-retrieved.\r |
| | 196 | #\r |
| | 197 | # @param Value The value of ARCH\r |
| | 198 | #\r |
| | 199 | def _SetArch(self, Value):\r |
| | 200 | if self._Arch == Value:\r |
| | 201 | return\r |
| | 202 | self._Arch = Value\r |
| | 203 | self._Clear()\r |
| | 204 | \r |
| | 205 | ## Retrieve all information in [Defines] section\r |
| | 206 | #\r |
| | 207 | # (Retriving all [Defines] information in one-shot is just to save time.)\r |
| | 208 | #\r |
| | 209 | def _GetHeaderInfo(self):\r |
| | 210 | RecordList = self._RawData[MODEL_META_DATA_HEADER, self._Arch]\r |
| | 211 | for Record in RecordList:\r |
| | 212 | Name = Record[1]\r |
| | 213 | # items defined _PROPERTY_ don't need additional processing\r |
| | 214 | \r |
| | 215 | # some special items in [Defines] section need special treatment\r |
| | 216 | if Name == TAB_DSC_DEFINES_OUTPUT_DIRECTORY:\r |
| | 217 | self._OutputDirectory = NormPath(Record[2], self._Macros)\r |
| | 218 | if ' ' in self._OutputDirectory:\r |
| | 219 | EdkLogger.error("build", FORMAT_NOT_SUPPORTED, "No space is allowed in OUTPUT_DIRECTORY",\r |
| | 220 | File=self.MetaFile, Line=Record[-1],\r |
| | 221 | ExtraData=self._OutputDirectory)\r |
| | 222 | elif Name == TAB_DSC_DEFINES_FLASH_DEFINITION:\r |
| | 223 | self._FlashDefinition = PathClass(NormPath(Record[2], self._Macros), GlobalData.gWorkspace)\r |
| | 224 | ErrorCode, ErrorInfo = self._FlashDefinition.Validate('.fdf')\r |
| | 225 | if ErrorCode != 0:\r |
| | 226 | EdkLogger.error('build', ErrorCode, File=self.MetaFile, Line=Record[-1],\r |
| | 227 | ExtraData=ErrorInfo)\r |
| | 228 | elif Name == TAB_DSC_DEFINES_SUPPORTED_ARCHITECTURES:\r |
| | 229 | self._SupArchList = GetSplitValueList(Record[2], TAB_VALUE_SPLIT)\r |
| | 230 | elif Name == TAB_DSC_DEFINES_BUILD_TARGETS:\r |
| | 231 | self._BuildTargets = GetSplitValueList(Record[2])\r |
| | 232 | elif Name == TAB_DSC_DEFINES_SKUID_IDENTIFIER:\r |
| | 233 | if self._SkuName == None:\r |
| | 234 | self._SkuName = Record[2]\r |
| | 235 | self._SkuIdentifier = Record[2]\r |
| | 236 | self._AvilableSkuIds = Record[2]\r |
| | 237 | elif Name == TAB_DSC_DEFINES_PCD_INFO_GENERATION:\r |
| | 238 | self._PcdInfoFlag = Record[2]\r |
| | 239 | elif Name == TAB_DSC_DEFINES_PCD_VAR_CHECK_GENERATION:\r |
| | 240 | self._VarCheckFlag = Record[2]\r |
| | 241 | elif Name == TAB_FIX_LOAD_TOP_MEMORY_ADDRESS:\r |
| | 242 | try:\r |
| | 243 | self._LoadFixAddress = int (Record[2], 0)\r |
| | 244 | except:\r |
| | 245 | EdkLogger.error("build", PARAMETER_INVALID, "FIX_LOAD_TOP_MEMORY_ADDRESS %s is not valid dec or hex string" % (Record[2]))\r |
| | 246 | elif Name == TAB_DSC_DEFINES_RFC_LANGUAGES:\r |
| | 247 | if not Record[2] or Record[2][0] != '"' or Record[2][-1] != '"' or len(Record[2]) == 1:\r |
| | 248 | 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 |
| | 249 | File=self.MetaFile, Line=Record[-1])\r |
| | 250 | LanguageCodes = Record[2][1:-1]\r |
| | 251 | if not LanguageCodes:\r |
| | 252 | EdkLogger.error('build', FORMAT_NOT_SUPPORTED, 'one or more RFC4646 format language code must be provided for RFC_LANGUAGES statement',\r |
| | 253 | File=self.MetaFile, Line=Record[-1]) \r |
| | 254 | LanguageList = GetSplitValueList(LanguageCodes, TAB_SEMI_COLON_SPLIT)\r |
| | 255 | # check whether there is empty entries in the list\r |
| | 256 | if None in LanguageList:\r |
| | 257 | EdkLogger.error('build', FORMAT_NOT_SUPPORTED, 'one or more empty language code is in RFC_LANGUAGES statement',\r |
| | 258 | File=self.MetaFile, Line=Record[-1]) \r |
| | 259 | self._RFCLanguages = LanguageList\r |
| | 260 | elif Name == TAB_DSC_DEFINES_ISO_LANGUAGES:\r |
| | 261 | if not Record[2] or Record[2][0] != '"' or Record[2][-1] != '"' or len(Record[2]) == 1:\r |
| | 262 | EdkLogger.error('build', FORMAT_NOT_SUPPORTED, 'language code for ISO_LANGUAGES must have double quotes around it, for example: ISO_LANGUAGES = "engchn"',\r |
| | 263 | File=self.MetaFile, Line=Record[-1])\r |
| | 264 | LanguageCodes = Record[2][1:-1]\r |
| | 265 | if not LanguageCodes:\r |
| | 266 | EdkLogger.error('build', FORMAT_NOT_SUPPORTED, 'one or more ISO639-2 format language code must be provided for ISO_LANGUAGES statement',\r |
| | 267 | File=self.MetaFile, Line=Record[-1]) \r |
| | 268 | if len(LanguageCodes)%3:\r |
| | 269 | EdkLogger.error('build', FORMAT_NOT_SUPPORTED, 'bad ISO639-2 format for ISO_LANGUAGES',\r |
| | 270 | File=self.MetaFile, Line=Record[-1])\r |
| | 271 | LanguageList = []\r |
| | 272 | for i in range(0, len(LanguageCodes), 3):\r |
| | 273 | LanguageList.append(LanguageCodes[i:i+3])\r |
| | 274 | self._ISOLanguages = LanguageList \r |
| | 275 | elif Name == TAB_DSC_DEFINES_VPD_TOOL_GUID:\r |
| | 276 | #\r |
| | 277 | # try to convert GUID to a real UUID value to see whether the GUID is format \r |
| | 278 | # for VPD_TOOL_GUID is correct.\r |
| | 279 | #\r |
| | 280 | try:\r |
| | 281 | uuid.UUID(Record[2])\r |
| | 282 | except:\r |
| | 283 | EdkLogger.error("build", FORMAT_INVALID, "Invalid GUID format for VPD_TOOL_GUID", File=self.MetaFile)\r |
| | 284 | self._VpdToolGuid = Record[2] \r |
| | 285 | elif Name in self:\r |
| | 286 | self[Name] = Record[2] \r |
| | 287 | # set _Header to non-None in order to avoid database re-querying\r |
| | 288 | self._Header = 'DUMMY'\r |
| | 289 | \r |
| | 290 | ## Retrieve platform name\r |
| | 291 | def _GetPlatformName(self):\r |
| | 292 | if self._PlatformName == None:\r |
| | 293 | if self._Header == None:\r |
| | 294 | self._GetHeaderInfo()\r |
| | 295 | if self._PlatformName == None:\r |
| | 296 | EdkLogger.error('build', ATTRIBUTE_NOT_AVAILABLE, "No PLATFORM_NAME", File=self.MetaFile)\r |
| | 297 | return self._PlatformName\r |
| | 298 | \r |
| | 299 | ## Retrieve file guid\r |
| | 300 | def _GetFileGuid(self):\r |
| | 301 | if self._Guid == None:\r |
| | 302 | if self._Header == None:\r |
| | 303 | self._GetHeaderInfo()\r |
| | 304 | if self._Guid == None:\r |
| | 305 | EdkLogger.error('build', ATTRIBUTE_NOT_AVAILABLE, "No PLATFORM_GUID", File=self.MetaFile)\r |
| | 306 | return self._Guid\r |
| | 307 | \r |
| | 308 | ## Retrieve platform version\r |
| | 309 | def _GetVersion(self):\r |
| | 310 | if self._Version == None:\r |
| | 311 | if self._Header == None:\r |
| | 312 | self._GetHeaderInfo()\r |
| | 313 | if self._Version == None:\r |
| | 314 | EdkLogger.error('build', ATTRIBUTE_NOT_AVAILABLE, "No PLATFORM_VERSION", File=self.MetaFile)\r |
| | 315 | return self._Version\r |
| | 316 | \r |
| | 317 | ## Retrieve platform description file version\r |
| | 318 | def _GetDscSpec(self):\r |
| | 319 | if self._DscSpecification == None:\r |
| | 320 | if self._Header == None:\r |
| | 321 | self._GetHeaderInfo()\r |
| | 322 | if self._DscSpecification == None:\r |
| | 323 | EdkLogger.error('build', ATTRIBUTE_NOT_AVAILABLE, "No DSC_SPECIFICATION", File=self.MetaFile) \r |
| | 324 | return self._DscSpecification\r |
| | 325 | \r |
| | 326 | ## Retrieve OUTPUT_DIRECTORY\r |
| | 327 | def _GetOutpuDir(self):\r |
| | 328 | if self._OutputDirectory == None:\r |
| | 329 | if self._Header == None:\r |
| | 330 | self._GetHeaderInfo()\r |
| | 331 | if self._OutputDirectory == None:\r |
| | 332 | self._OutputDirectory = os.path.join("Build", self._PlatformName)\r |
| | 333 | return self._OutputDirectory\r |
| | 334 | \r |
| | 335 | ## Retrieve SUPPORTED_ARCHITECTURES\r |
| | 336 | def _GetSupArch(self):\r |
| | 337 | if self._SupArchList == None:\r |
| | 338 | if self._Header == None:\r |
| | 339 | self._GetHeaderInfo()\r |
| | 340 | if self._SupArchList == None:\r |
| | 341 | EdkLogger.error('build', ATTRIBUTE_NOT_AVAILABLE, "No SUPPORTED_ARCHITECTURES", File=self.MetaFile)\r |
| | 342 | return self._SupArchList\r |
| | 343 | \r |
| | 344 | ## Retrieve BUILD_TARGETS\r |
| | 345 | def _GetBuildTarget(self):\r |
| | 346 | if self._BuildTargets == None:\r |
| | 347 | if self._Header == None:\r |
| | 348 | self._GetHeaderInfo()\r |
| | 349 | if self._BuildTargets == None:\r |
| | 350 | EdkLogger.error('build', ATTRIBUTE_NOT_AVAILABLE, "No BUILD_TARGETS", File=self.MetaFile)\r |
| | 351 | return self._BuildTargets\r |
| | 352 | \r |
| | 353 | def _GetPcdInfoFlag(self):\r |
| | 354 | if self._PcdInfoFlag == None or self._PcdInfoFlag.upper() == 'FALSE':\r |
| | 355 | return False\r |
| | 356 | elif self._PcdInfoFlag.upper() == 'TRUE':\r |
| | 357 | return True\r |
| | 358 | else:\r |
| | 359 | return False\r |
| | 360 | def _GetVarCheckFlag(self): \r |
| | 361 | if self._VarCheckFlag == None or self._VarCheckFlag.upper() == 'FALSE':\r |
| | 362 | return False\r |
| | 363 | elif self._VarCheckFlag.upper() == 'TRUE':\r |
| | 364 | return True\r |
| | 365 | else:\r |
| | 366 | return False\r |
| | 367 | def _GetAviableSkuIds(self):\r |
| | 368 | if self._AvilableSkuIds:\r |
| | 369 | return self._AvilableSkuIds\r |
| | 370 | return self.SkuIdentifier\r |
| | 371 | def _GetSkuIdentifier(self):\r |
| | 372 | if self._SkuName:\r |
| | 373 | return self._SkuName\r |
| | 374 | if self._SkuIdentifier == None:\r |
| | 375 | if self._Header == None:\r |
| | 376 | self._GetHeaderInfo()\r |
| | 377 | return self._SkuIdentifier\r |
| | 378 | ## Retrieve SKUID_IDENTIFIER\r |
| | 379 | def _GetSkuName(self):\r |
| | 380 | if self._SkuName == None:\r |
| | 381 | if self._Header == None:\r |
| | 382 | self._GetHeaderInfo()\r |
| | 383 | if (self._SkuName == None or self._SkuName not in self.SkuIds):\r |
| | 384 | self._SkuName = 'DEFAULT'\r |
| | 385 | return self._SkuName\r |
| | 386 | \r |
| | 387 | ## Override SKUID_IDENTIFIER\r |
| | 388 | def _SetSkuName(self, Value):\r |
| | 389 | self._SkuName = Value\r |
| | 390 | self._Pcds = None\r |
| | 391 | \r |
| | 392 | def _GetFdfFile(self):\r |
| | 393 | if self._FlashDefinition == None:\r |
| | 394 | if self._Header == None:\r |
| | 395 | self._GetHeaderInfo()\r |
| | 396 | if self._FlashDefinition == None:\r |
| | 397 | self._FlashDefinition = ''\r |
| | 398 | return self._FlashDefinition\r |
| | 399 | \r |
| | 400 | ## Retrieve FLASH_DEFINITION\r |
| | 401 | def _GetBuildNumber(self):\r |
| | 402 | if self._BuildNumber == None:\r |
| | 403 | if self._Header == None:\r |
| | 404 | self._GetHeaderInfo()\r |
| | 405 | if self._BuildNumber == None:\r |
| | 406 | self._BuildNumber = ''\r |
| | 407 | return self._BuildNumber\r |
| | 408 | \r |
| | 409 | ## Retrieve MAKEFILE_NAME\r |
| | 410 | def _GetMakefileName(self):\r |
| | 411 | if self._MakefileName == None:\r |
| | 412 | if self._Header == None:\r |
| | 413 | self._GetHeaderInfo()\r |
| | 414 | if self._MakefileName == None:\r |
| | 415 | self._MakefileName = ''\r |
| | 416 | return self._MakefileName\r |
| | 417 | \r |
| | 418 | ## Retrieve BsBaseAddress\r |
| | 419 | def _GetBsBaseAddress(self):\r |
| | 420 | if self._BsBaseAddress == None:\r |
| | 421 | if self._Header == None:\r |
| | 422 | self._GetHeaderInfo()\r |
| | 423 | if self._BsBaseAddress == None:\r |
| | 424 | self._BsBaseAddress = ''\r |
| | 425 | return self._BsBaseAddress\r |
| | 426 | \r |
| | 427 | ## Retrieve RtBaseAddress\r |
| | 428 | def _GetRtBaseAddress(self):\r |
| | 429 | if self._RtBaseAddress == None:\r |
| | 430 | if self._Header == None:\r |
| | 431 | self._GetHeaderInfo()\r |
| | 432 | if self._RtBaseAddress == None:\r |
| | 433 | self._RtBaseAddress = ''\r |
| | 434 | return self._RtBaseAddress\r |
| | 435 | \r |
| | 436 | ## Retrieve the top address for the load fix address\r |
| | 437 | def _GetLoadFixAddress(self):\r |
| | 438 | if self._LoadFixAddress == None:\r |
| | 439 | if self._Header == None:\r |
| | 440 | self._GetHeaderInfo()\r |
| | 441 | \r |
| | 442 | if self._LoadFixAddress == None:\r |
| | 443 | self._LoadFixAddress = self._Macros.get(TAB_FIX_LOAD_TOP_MEMORY_ADDRESS, '0')\r |
| | 444 | \r |
| | 445 | try:\r |
| | 446 | self._LoadFixAddress = int (self._LoadFixAddress, 0)\r |
| | 447 | except:\r |
| | 448 | EdkLogger.error("build", PARAMETER_INVALID, "FIX_LOAD_TOP_MEMORY_ADDRESS %s is not valid dec or hex string" % (self._LoadFixAddress))\r |
| | 449 | \r |
| | 450 | #\r |
| | 451 | # If command line defined, should override the value in DSC file.\r |
| | 452 | #\r |
| | 453 | if 'FIX_LOAD_TOP_MEMORY_ADDRESS' in GlobalData.gCommandLineDefines.keys():\r |
| | 454 | try:\r |
| | 455 | self._LoadFixAddress = int(GlobalData.gCommandLineDefines['FIX_LOAD_TOP_MEMORY_ADDRESS'], 0)\r |
| | 456 | except:\r |
| | 457 | 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 |
| | 458 | \r |
| | 459 | if self._LoadFixAddress < 0:\r |
| | 460 | EdkLogger.error("build", PARAMETER_INVALID, "FIX_LOAD_TOP_MEMORY_ADDRESS is set to the invalid negative value 0x%x" % (self._LoadFixAddress))\r |
| | 461 | if self._LoadFixAddress != 0xFFFFFFFFFFFFFFFF and self._LoadFixAddress % 0x1000 != 0:\r |
| | 462 | EdkLogger.error("build", PARAMETER_INVALID, "FIX_LOAD_TOP_MEMORY_ADDRESS is set to the invalid unaligned 4K value 0x%x" % (self._LoadFixAddress))\r |
| | 463 | \r |
| | 464 | return self._LoadFixAddress\r |
| | 465 | \r |
| | 466 | ## Retrieve RFCLanguage filter\r |
| | 467 | def _GetRFCLanguages(self):\r |
| | 468 | if self._RFCLanguages == None:\r |
| | 469 | if self._Header == None:\r |
| | 470 | self._GetHeaderInfo()\r |
| | 471 | if self._RFCLanguages == None:\r |
| | 472 | self._RFCLanguages = []\r |
| | 473 | return self._RFCLanguages\r |
| | 474 | \r |
| | 475 | ## Retrieve ISOLanguage filter\r |
| | 476 | def _GetISOLanguages(self):\r |
| | 477 | if self._ISOLanguages == None:\r |
| | 478 | if self._Header == None:\r |
| | 479 | self._GetHeaderInfo()\r |
| | 480 | if self._ISOLanguages == None:\r |
| | 481 | self._ISOLanguages = []\r |
| | 482 | return self._ISOLanguages\r |
| | 483 | ## Retrieve the GUID string for VPD tool\r |
| | 484 | def _GetVpdToolGuid(self):\r |
| | 485 | if self._VpdToolGuid == None:\r |
| | 486 | if self._Header == None:\r |
| | 487 | self._GetHeaderInfo()\r |
| | 488 | if self._VpdToolGuid == None:\r |
| | 489 | self._VpdToolGuid = ''\r |
| | 490 | return self._VpdToolGuid\r |
| | 491 | \r |
| | 492 | ## Retrieve [SkuIds] section information\r |
| | 493 | def _GetSkuIds(self):\r |
| | 494 | if self._SkuIds == None:\r |
| | 495 | self._SkuIds = sdict()\r |
| | 496 | RecordList = self._RawData[MODEL_EFI_SKU_ID, self._Arch]\r |
| | 497 | for Record in RecordList:\r |
| | 498 | if Record[0] in [None, '']:\r |
| | 499 | EdkLogger.error('build', FORMAT_INVALID, 'No Sku ID number',\r |
| | 500 | File=self.MetaFile, Line=Record[-1])\r |
| | 501 | if Record[1] in [None, '']:\r |
| | 502 | EdkLogger.error('build', FORMAT_INVALID, 'No Sku ID name',\r |
| | 503 | File=self.MetaFile, Line=Record[-1])\r |
| | 504 | self._SkuIds[Record[1]] = Record[0]\r |
| | 505 | if 'DEFAULT' not in self._SkuIds:\r |
| | 506 | self._SkuIds['DEFAULT'] = '0'\r |
| | 507 | if 'COMMON' not in self._SkuIds:\r |
| | 508 | self._SkuIds['COMMON'] = '0'\r |
| | 509 | return self._SkuIds\r |
| | 510 | \r |
| | 511 | ## Retrieve [Components] section information\r |
| | 512 | def _GetModules(self):\r |
| | 513 | if self._Modules != None:\r |
| | 514 | return self._Modules\r |
| | 515 | \r |
| | 516 | self._Modules = sdict()\r |
| | 517 | RecordList = self._RawData[MODEL_META_DATA_COMPONENT, self._Arch]\r |
| | 518 | Macros = self._Macros\r |
| | 519 | Macros["EDK_SOURCE"] = GlobalData.gEcpSource\r |
| | 520 | for Record in RecordList:\r |
| | 521 | DuplicatedFile = False\r |
| | 522 | ModuleFile = PathClass(NormPath(Record[0], Macros), GlobalData.gWorkspace, Arch=self._Arch)\r |
| | 523 | ModuleId = Record[5]\r |
| | 524 | LineNo = Record[6]\r |
| | 525 | \r |
| | 526 | # check the file validation\r |
| | 527 | ErrorCode, ErrorInfo = ModuleFile.Validate('.inf')\r |
| | 528 | if ErrorCode != 0:\r |
| | 529 | EdkLogger.error('build', ErrorCode, File=self.MetaFile, Line=LineNo,\r |
| | 530 | ExtraData=ErrorInfo)\r |
| | 531 | # Check duplication\r |
| | 532 | # If arch is COMMON, no duplicate module is checked since all modules in all component sections are selected\r |
| | 533 | if self._Arch != 'COMMON' and ModuleFile in self._Modules:\r |
| | 534 | DuplicatedFile = True\r |
| | 535 | \r |
| | 536 | Module = ModuleBuildClassObject()\r |
| | 537 | Module.MetaFile = ModuleFile\r |
| | 538 | \r |
| | 539 | # get module private library instance\r |
| | 540 | RecordList = self._RawData[MODEL_EFI_LIBRARY_CLASS, self._Arch, None, ModuleId]\r |
| | 541 | for Record in RecordList:\r |
| | 542 | LibraryClass = Record[0]\r |
| | 543 | LibraryPath = PathClass(NormPath(Record[1], Macros), GlobalData.gWorkspace, Arch=self._Arch)\r |
| | 544 | LineNo = Record[-1]\r |
| | 545 | \r |
| | 546 | # check the file validation\r |
| | 547 | ErrorCode, ErrorInfo = LibraryPath.Validate('.inf')\r |
| | 548 | if ErrorCode != 0:\r |
| | 549 | EdkLogger.error('build', ErrorCode, File=self.MetaFile, Line=LineNo,\r |
| | 550 | ExtraData=ErrorInfo)\r |
| | 551 | \r |
| | 552 | if LibraryClass == '' or LibraryClass == 'NULL':\r |
| | 553 | self._NullLibraryNumber += 1\r |
| | 554 | LibraryClass = 'NULL%d' % self._NullLibraryNumber\r |
| | 555 | EdkLogger.verbose("Found forced library for %s\n\t%s [%s]" % (ModuleFile, LibraryPath, LibraryClass))\r |
| | 556 | Module.LibraryClasses[LibraryClass] = LibraryPath\r |
| | 557 | if LibraryPath not in self.LibraryInstances:\r |
| | 558 | self.LibraryInstances.append(LibraryPath)\r |
| | 559 | \r |
| | 560 | # get module private PCD setting\r |
| | 561 | for Type in [MODEL_PCD_FIXED_AT_BUILD, MODEL_PCD_PATCHABLE_IN_MODULE, \\r |
| | 562 | MODEL_PCD_FEATURE_FLAG, MODEL_PCD_DYNAMIC, MODEL_PCD_DYNAMIC_EX]:\r |
| | 563 | RecordList = self._RawData[Type, self._Arch, None, ModuleId]\r |
| | 564 | for TokenSpaceGuid, PcdCName, Setting, Dummy1, Dummy2, Dummy3, Dummy4 in RecordList:\r |
| | 565 | TokenList = GetSplitValueList(Setting)\r |
| | 566 | DefaultValue = TokenList[0]\r |
| | 567 | if len(TokenList) > 1:\r |
| | 568 | MaxDatumSize = TokenList[1]\r |
| | 569 | else:\r |
| | 570 | MaxDatumSize = ''\r |
| | 571 | TypeString = self._PCD_TYPE_STRING_[Type]\r |
| | 572 | Pcd = PcdClassObject(\r |
| | 573 | PcdCName,\r |
| | 574 | TokenSpaceGuid,\r |
| | 575 | TypeString,\r |
| | 576 | '',\r |
| | 577 | DefaultValue,\r |
| | 578 | '',\r |
| | 579 | MaxDatumSize,\r |
| | 580 | {},\r |
| | 581 | False,\r |
| | 582 | None\r |
| | 583 | )\r |
| | 584 | Module.Pcds[PcdCName, TokenSpaceGuid] = Pcd\r |
| | 585 | \r |
| | 586 | # get module private build options\r |
| | 587 | RecordList = self._RawData[MODEL_META_DATA_BUILD_OPTION, self._Arch, None, ModuleId]\r |
| | 588 | for ToolChainFamily, ToolChain, Option, Dummy1, Dummy2, Dummy3, Dummy4 in RecordList:\r |
| | 589 | if (ToolChainFamily, ToolChain) not in Module.BuildOptions:\r |
| | 590 | Module.BuildOptions[ToolChainFamily, ToolChain] = Option\r |
| | 591 | else:\r |
| | 592 | OptionString = Module.BuildOptions[ToolChainFamily, ToolChain]\r |
| | 593 | Module.BuildOptions[ToolChainFamily, ToolChain] = OptionString + " " + Option\r |
| | 594 | \r |
| | 595 | RecordList = self._RawData[MODEL_META_DATA_HEADER, self._Arch, None, ModuleId]\r |
| | 596 | if DuplicatedFile and not RecordList:\r |
| | 597 | EdkLogger.error('build', FILE_DUPLICATED, File=self.MetaFile, ExtraData=str(ModuleFile), Line=LineNo)\r |
| | 598 | if RecordList:\r |
| | 599 | if len(RecordList) != 1:\r |
| | 600 | EdkLogger.error('build', OPTION_UNKNOWN, 'Only FILE_GUID can be listed in <Defines> section.',\r |
| | 601 | File=self.MetaFile, ExtraData=str(ModuleFile), Line=LineNo)\r |
| | 602 | ModuleFile = ProcessDuplicatedInf(ModuleFile, RecordList[0][2], GlobalData.gWorkspace)\r |
| | 603 | ModuleFile.Arch = self._Arch\r |
| | 604 | \r |
| | 605 | self._Modules[ModuleFile] = Module\r |
| | 606 | return self._Modules\r |
| | 607 | \r |
| | 608 | ## Retrieve all possible library instances used in this platform\r |
| | 609 | def _GetLibraryInstances(self):\r |
| | 610 | if self._LibraryInstances == None:\r |
| | 611 | self._GetLibraryClasses()\r |
| | 612 | return self._LibraryInstances\r |
| | 613 | \r |
| | 614 | ## Retrieve [LibraryClasses] information\r |
| | 615 | def _GetLibraryClasses(self):\r |
| | 616 | if self._LibraryClasses == None:\r |
| | 617 | self._LibraryInstances = []\r |
| | 618 | #\r |
| | 619 | # tdict is a special dict kind of type, used for selecting correct\r |
| | 620 | # library instance for given library class and module type\r |
| | 621 | #\r |
| | 622 | LibraryClassDict = tdict(True, 3)\r |
| | 623 | # track all library class names\r |
| | 624 | LibraryClassSet = set()\r |
| | 625 | RecordList = self._RawData[MODEL_EFI_LIBRARY_CLASS, self._Arch, None, -1]\r |
| | 626 | Macros = self._Macros\r |
| | 627 | for Record in RecordList:\r |
| | 628 | LibraryClass, LibraryInstance, Dummy, Arch, ModuleType, Dummy, LineNo = Record\r |
| | 629 | if LibraryClass == '' or LibraryClass == 'NULL':\r |
| | 630 | self._NullLibraryNumber += 1\r |
| | 631 | LibraryClass = 'NULL%d' % self._NullLibraryNumber\r |
| | 632 | EdkLogger.verbose("Found forced library for arch=%s\n\t%s [%s]" % (Arch, LibraryInstance, LibraryClass))\r |
| | 633 | LibraryClassSet.add(LibraryClass)\r |
| | 634 | LibraryInstance = PathClass(NormPath(LibraryInstance, Macros), GlobalData.gWorkspace, Arch=self._Arch)\r |
| | 635 | # check the file validation\r |
| | 636 | ErrorCode, ErrorInfo = LibraryInstance.Validate('.inf')\r |
| | 637 | if ErrorCode != 0:\r |
| | 638 | EdkLogger.error('build', ErrorCode, File=self.MetaFile, Line=LineNo,\r |
| | 639 | ExtraData=ErrorInfo)\r |
| | 640 | \r |
| | 641 | if ModuleType != 'COMMON' and ModuleType not in SUP_MODULE_LIST:\r |
| | 642 | EdkLogger.error('build', OPTION_UNKNOWN, "Unknown module type [%s]" % ModuleType,\r |
| | 643 | File=self.MetaFile, ExtraData=LibraryInstance, Line=LineNo)\r |
| | 644 | LibraryClassDict[Arch, ModuleType, LibraryClass] = LibraryInstance\r |
| | 645 | if LibraryInstance not in self._LibraryInstances:\r |
| | 646 | self._LibraryInstances.append(LibraryInstance)\r |
| | 647 | \r |
| | 648 | # resolve the specific library instance for each class and each module type\r |
| | 649 | self._LibraryClasses = tdict(True)\r |
| | 650 | for LibraryClass in LibraryClassSet:\r |
| | 651 | # try all possible module types\r |
| | 652 | for ModuleType in SUP_MODULE_LIST:\r |
| | 653 | LibraryInstance = LibraryClassDict[self._Arch, ModuleType, LibraryClass]\r |
| | 654 | if LibraryInstance == None:\r |
| | 655 | continue\r |
| | 656 | self._LibraryClasses[LibraryClass, ModuleType] = LibraryInstance\r |
| | 657 | \r |
| | 658 | # for Edk style library instances, which are listed in different section\r |
| | 659 | Macros["EDK_SOURCE"] = GlobalData.gEcpSource\r |
| | 660 | RecordList = self._RawData[MODEL_EFI_LIBRARY_INSTANCE, self._Arch]\r |
| | 661 | for Record in RecordList:\r |
| | 662 | File = PathClass(NormPath(Record[0], Macros), GlobalData.gWorkspace, Arch=self._Arch)\r |
| | 663 | LineNo = Record[-1]\r |
| | 664 | # check the file validation\r |
| | 665 | ErrorCode, ErrorInfo = File.Validate('.inf')\r |
| | 666 | if ErrorCode != 0:\r |
| | 667 | EdkLogger.error('build', ErrorCode, File=self.MetaFile, Line=LineNo,\r |
| | 668 | ExtraData=ErrorInfo)\r |
| | 669 | if File not in self._LibraryInstances:\r |
| | 670 | self._LibraryInstances.append(File)\r |
| | 671 | #\r |
| | 672 | # we need the module name as the library class name, so we have\r |
| | 673 | # to parse it here. (self._Bdb[] will trigger a file parse if it\r |
| | 674 | # hasn't been parsed)\r |
| | 675 | #\r |
| | 676 | Library = self._Bdb[File, self._Arch, self._Target, self._Toolchain]\r |
| | 677 | self._LibraryClasses[Library.BaseName, ':dummy:'] = Library\r |
| | 678 | return self._LibraryClasses\r |
| | 679 | \r |
| | 680 | def _ValidatePcd(self, PcdCName, TokenSpaceGuid, Setting, PcdType, LineNo):\r |
| | 681 | if self._DecPcds == None:\r |
| | 682 | self._DecPcds = GetDeclaredPcd(self, self._Bdb, self._Arch, self._Target, self._Toolchain)\r |
| | 683 | FdfInfList = []\r |
| | 684 | if GlobalData.gFdfParser:\r |
| | 685 | FdfInfList = GlobalData.gFdfParser.Profile.InfList\r |
| | 686 | \r |
| | 687 | PkgSet = set()\r |
| | 688 | for Inf in FdfInfList:\r |
| | 689 | ModuleFile = PathClass(NormPath(Inf), GlobalData.gWorkspace, Arch=self._Arch)\r |
| | 690 | if ModuleFile in self._Modules:\r |
| | 691 | continue\r |
| | 692 | ModuleData = self._Bdb[ModuleFile, self._Arch, self._Target, self._Toolchain]\r |
| | 693 | PkgSet.update(ModuleData.Packages)\r |
| | 694 | DecPcds = {}\r |
| | 695 | for Pkg in PkgSet:\r |
| | 696 | for Pcd in Pkg.Pcds:\r |
| | 697 | DecPcds[Pcd[0], Pcd[1]] = Pkg.Pcds[Pcd]\r |
| | 698 | self._DecPcds.update(DecPcds)\r |
| | 699 | \r |
| | 700 | if (PcdCName, TokenSpaceGuid) not in self._DecPcds:\r |
| | 701 | EdkLogger.error('build', PARSER_ERROR,\r |
| | 702 | "Pcd (%s.%s) defined in DSC is not declared in DEC files. Arch: ['%s']" % (TokenSpaceGuid, PcdCName, self._Arch),\r |
| | 703 | File=self.MetaFile, Line=LineNo)\r |
| | 704 | ValueList, IsValid, Index = AnalyzeDscPcd(Setting, PcdType, self._DecPcds[PcdCName, TokenSpaceGuid].DatumType)\r |
| | 705 | if not IsValid and PcdType not in [MODEL_PCD_FEATURE_FLAG, MODEL_PCD_FIXED_AT_BUILD]:\r |
| | 706 | EdkLogger.error('build', FORMAT_INVALID, "Pcd format incorrect.", File=self.MetaFile, Line=LineNo,\r |
| | 707 | ExtraData="%s.%s|%s" % (TokenSpaceGuid, PcdCName, Setting))\r |
| | 708 | if ValueList[Index] and PcdType not in [MODEL_PCD_FEATURE_FLAG, MODEL_PCD_FIXED_AT_BUILD]:\r |
| | 709 | try:\r |
| | 710 | ValueList[Index] = ValueExpression(ValueList[Index], GlobalData.gPlatformPcds)(True)\r |
| | 711 | except WrnExpression, Value:\r |
| | 712 | ValueList[Index] = Value.result\r |
| | 713 | except EvaluationException, Excpt:\r |
| | 714 | if hasattr(Excpt, 'Pcd'):\r |
| | 715 | if Excpt.Pcd in GlobalData.gPlatformOtherPcds:\r |
| | 716 | EdkLogger.error('Parser', FORMAT_INVALID, "Cannot use this PCD (%s) in an expression as"\r |
| | 717 | " it must be defined in a [PcdsFixedAtBuild] or [PcdsFeatureFlag] section"\r |
| | 718 | " of the DSC file" % Excpt.Pcd,\r |
| | 719 | File=self.MetaFile, Line=LineNo)\r |
| | 720 | else:\r |
| | 721 | EdkLogger.error('Parser', FORMAT_INVALID, "PCD (%s) is not defined in DSC file" % Excpt.Pcd,\r |
| | 722 | File=self.MetaFile, Line=LineNo)\r |
| | 723 | else:\r |
| | 724 | EdkLogger.error('Parser', FORMAT_INVALID, "Invalid expression: %s" % str(Excpt),\r |
| | 725 | File=self.MetaFile, Line=LineNo)\r |
| | 726 | if ValueList[Index] == 'True':\r |
| | 727 | ValueList[Index] = '1'\r |
| | 728 | elif ValueList[Index] == 'False':\r |
| | 729 | ValueList[Index] = '0'\r |
| | 730 | if ValueList[Index]:\r |
| | 731 | Valid, ErrStr = CheckPcdDatum(self._DecPcds[PcdCName, TokenSpaceGuid].DatumType, ValueList[Index])\r |
| | 732 | if not Valid:\r |
| | 733 | EdkLogger.error('build', FORMAT_INVALID, ErrStr, File=self.MetaFile, Line=LineNo,\r |
| | 734 | ExtraData="%s.%s" % (TokenSpaceGuid, PcdCName))\r |
| | 735 | return ValueList\r |
| | 736 | \r |
| | 737 | ## Retrieve all PCD settings in platform\r |
| | 738 | def _GetPcds(self):\r |
| | 739 | if self._Pcds == None:\r |
| | 740 | self._Pcds = sdict()\r |
| | 741 | self._Pcds.update(self._GetPcd(MODEL_PCD_FIXED_AT_BUILD))\r |
| | 742 | self._Pcds.update(self._GetPcd(MODEL_PCD_PATCHABLE_IN_MODULE))\r |
| | 743 | self._Pcds.update(self._GetPcd(MODEL_PCD_FEATURE_FLAG))\r |
| | 744 | self._Pcds.update(self._GetDynamicPcd(MODEL_PCD_DYNAMIC_DEFAULT))\r |
| | 745 | self._Pcds.update(self._GetDynamicHiiPcd(MODEL_PCD_DYNAMIC_HII))\r |
| | 746 | self._Pcds.update(self._GetDynamicVpdPcd(MODEL_PCD_DYNAMIC_VPD))\r |
| | 747 | self._Pcds.update(self._GetDynamicPcd(MODEL_PCD_DYNAMIC_EX_DEFAULT))\r |
| | 748 | self._Pcds.update(self._GetDynamicHiiPcd(MODEL_PCD_DYNAMIC_EX_HII))\r |
| | 749 | self._Pcds.update(self._GetDynamicVpdPcd(MODEL_PCD_DYNAMIC_EX_VPD))\r |
| | 750 | return self._Pcds\r |
| | 751 | \r |
| | 752 | ## Retrieve [BuildOptions]\r |
| | 753 | def _GetBuildOptions(self):\r |
| | 754 | if self._BuildOptions == None:\r |
| | 755 | self._BuildOptions = sdict()\r |
| | 756 | #\r |
| | 757 | # Retrieve build option for EDKII style module\r |
| | 758 | #\r |
| | 759 | RecordList = self._RawData[MODEL_META_DATA_BUILD_OPTION, self._Arch, EDKII_NAME]\r |
| | 760 | for ToolChainFamily, ToolChain, Option, Dummy1, Dummy2, Dummy3, Dummy4 in RecordList:\r |
| | 761 | self._BuildOptions[ToolChainFamily, ToolChain, EDKII_NAME] = Option\r |
| | 762 | #\r |
| | 763 | # Retrieve build option for EDK style module\r |
| | 764 | #\r |
| | 765 | RecordList = self._RawData[MODEL_META_DATA_BUILD_OPTION, self._Arch, EDK_NAME] \r |
| | 766 | for ToolChainFamily, ToolChain, Option, Dummy1, Dummy2, Dummy3, Dummy4 in RecordList:\r |
| | 767 | self._BuildOptions[ToolChainFamily, ToolChain, EDK_NAME] = Option\r |
| | 768 | return self._BuildOptions\r |
| | 769 | \r |
| | 770 | ## Retrieve non-dynamic PCD settings\r |
| | 771 | #\r |
| | 772 | # @param Type PCD type\r |
| | 773 | #\r |
| | 774 | # @retval a dict object contains settings of given PCD type\r |
| | 775 | #\r |
| | 776 | def _GetPcd(self, Type):\r |
| | 777 | Pcds = sdict()\r |
| | 778 | #\r |
| | 779 | # tdict is a special dict kind of type, used for selecting correct\r |
| | 780 | # PCD settings for certain ARCH\r |
| | 781 | #\r |
| | 782 | \r |
| | 783 | SkuObj = SkuClass(self.SkuIdentifier,self.SkuIds)\r |
| | 784 | \r |
| | 785 | PcdDict = tdict(True, 3)\r |
| | 786 | PcdSet = set()\r |
| | 787 | # Find out all possible PCD candidates for self._Arch\r |
| | 788 | RecordList = self._RawData[Type, self._Arch]\r |
| | 789 | PcdValueDict = sdict()\r |
| | 790 | for TokenSpaceGuid, PcdCName, Setting, Arch, SkuName, Dummy3, Dummy4 in RecordList:\r |
| | 791 | if SkuName in (SkuObj.SystemSkuId,'DEFAULT','COMMON'):\r |
| | 792 | PcdSet.add((PcdCName, TokenSpaceGuid, SkuName,Dummy4))\r |
| | 793 | PcdDict[Arch, PcdCName, TokenSpaceGuid,SkuName] = Setting\r |
| | 794 | \r |
| | 795 | #handle pcd value override \r |
| | 796 | for PcdCName, TokenSpaceGuid, SkuName,Dummy4 in PcdSet:\r |
| | 797 | Setting = PcdDict[self._Arch, PcdCName, TokenSpaceGuid,SkuName]\r |
| | 798 | if Setting == None:\r |
| | 799 | continue\r |
| | 800 | PcdValue, DatumType, MaxDatumSize = self._ValidatePcd(PcdCName, TokenSpaceGuid, Setting, Type, Dummy4)\r |
| | 801 | if (PcdCName, TokenSpaceGuid) in PcdValueDict:\r |
| | 802 | PcdValueDict[PcdCName, TokenSpaceGuid][SkuName] = (PcdValue,DatumType,MaxDatumSize) \r |
| | 803 | else:\r |
| | 804 | PcdValueDict[PcdCName, TokenSpaceGuid] = {SkuName:(PcdValue,DatumType,MaxDatumSize)} \r |
| | 805 | \r |
| | 806 | PcdsKeys = PcdValueDict.keys()\r |
| | 807 | for PcdCName,TokenSpaceGuid in PcdsKeys:\r |
| | 808 | \r |
| | 809 | PcdSetting = PcdValueDict[PcdCName, TokenSpaceGuid]\r |
| | 810 | PcdValue = None\r |
| | 811 | DatumType = None\r |
| | 812 | MaxDatumSize = None\r |
| | 813 | if 'COMMON' in PcdSetting:\r |
| | 814 | PcdValue,DatumType,MaxDatumSize = PcdSetting['COMMON']\r |
| | 815 | if 'DEFAULT' in PcdSetting:\r |
| | 816 | PcdValue,DatumType,MaxDatumSize = PcdSetting['DEFAULT']\r |
| | 817 | if SkuObj.SystemSkuId in PcdSetting:\r |
| | 818 | PcdValue,DatumType,MaxDatumSize = PcdSetting[SkuObj.SystemSkuId]\r |
| | 819 | \r |
| | 820 | Pcds[PcdCName, TokenSpaceGuid] = PcdClassObject(\r |
| | 821 | PcdCName,\r |
| | 822 | TokenSpaceGuid,\r |
| | 823 | self._PCD_TYPE_STRING_[Type],\r |
| | 824 | DatumType,\r |
| | 825 | PcdValue,\r |
| | 826 | '',\r |
| | 827 | MaxDatumSize,\r |
| | 828 | {},\r |
| | 829 | False,\r |
| | 830 | None\r |
| | 831 | )\r |
| | 832 | return Pcds\r |
| | 833 | \r |
| | 834 | ## Retrieve dynamic PCD settings\r |
| | 835 | #\r |
| | 836 | # @param Type PCD type\r |
| | 837 | #\r |
| | 838 | # @retval a dict object contains settings of given PCD type\r |
| | 839 | #\r |
| | 840 | def _GetDynamicPcd(self, Type):\r |
| | 841 | \r |
| | 842 | SkuObj = SkuClass(self.SkuIdentifier,self.SkuIds)\r |
| | 843 | \r |
| | 844 | Pcds = sdict()\r |
| | 845 | #\r |
| | 846 | # tdict is a special dict kind of type, used for selecting correct\r |
| | 847 | # PCD settings for certain ARCH and SKU\r |
| | 848 | #\r |
| | 849 | PcdDict = tdict(True, 4)\r |
| | 850 | PcdList = []\r |
| | 851 | # Find out all possible PCD candidates for self._Arch\r |
| | 852 | RecordList = self._RawData[Type, self._Arch]\r |
| | 853 | AvailableSkuIdSet = SkuObj.AvailableSkuIdSet.copy()\r |
| | 854 | \r |
| | 855 | AvailableSkuIdSet.update({'DEFAULT':0,'COMMON':0})\r |
| | 856 | for TokenSpaceGuid, PcdCName, Setting, Arch, SkuName, Dummy3, Dummy4 in RecordList:\r |
| | 857 | if SkuName not in AvailableSkuIdSet:\r |
| | 858 | continue\r |
| | 859 | \r |
| | 860 | PcdList.append((PcdCName, TokenSpaceGuid, SkuName,Dummy4))\r |
| | 861 | PcdDict[Arch, SkuName, PcdCName, TokenSpaceGuid] = Setting\r |
| | 862 | # Remove redundant PCD candidates, per the ARCH and SKU\r |
| | 863 | for PcdCName, TokenSpaceGuid, SkuName, Dummy4 in PcdList:\r |
| | 864 | \r |
| | 865 | Setting = PcdDict[self._Arch, SkuName, PcdCName, TokenSpaceGuid]\r |
| | 866 | if Setting == None:\r |
| | 867 | continue\r |
| | 868 | \r |
| | 869 | PcdValue, DatumType, MaxDatumSize = self._ValidatePcd(PcdCName, TokenSpaceGuid, Setting, Type, Dummy4)\r |
| | 870 | SkuInfo = SkuInfoClass(SkuName, self.SkuIds[SkuName], '', '', '', '', '', PcdValue)\r |
| | 871 | if (PcdCName,TokenSpaceGuid) in Pcds.keys(): \r |
| | 872 | pcdObject = Pcds[PcdCName,TokenSpaceGuid]\r |
| | 873 | pcdObject.SkuInfoList[SkuName] = SkuInfo\r |
| | 874 | if MaxDatumSize.strip():\r |
| | 875 | CurrentMaxSize = int(MaxDatumSize.strip(),0)\r |
| | 876 | else:\r |
| | 877 | CurrentMaxSize = 0\r |
| | 878 | if pcdObject.MaxDatumSize:\r |
| | 879 | PcdMaxSize = int(pcdObject.MaxDatumSize,0)\r |
| | 880 | else:\r |
| | 881 | PcdMaxSize = 0\r |
| | 882 | if CurrentMaxSize > PcdMaxSize:\r |
| | 883 | pcdObject.MaxDatumSize = str(CurrentMaxSize)\r |
| | 884 | else: \r |
| | 885 | Pcds[PcdCName, TokenSpaceGuid] = PcdClassObject(\r |
| | 886 | PcdCName,\r |
| | 887 | TokenSpaceGuid,\r |
| | 888 | self._PCD_TYPE_STRING_[Type],\r |
| | 889 | DatumType,\r |
| | 890 | PcdValue,\r |
| | 891 | '',\r |
| | 892 | MaxDatumSize,\r |
| | 893 | {SkuName : SkuInfo},\r |
| | 894 | False,\r |
| | 895 | None\r |
| | 896 | )\r |
| | 897 | \r |
| | 898 | for pcd in Pcds.values():\r |
| | 899 | pcdDecObject = self._DecPcds[pcd.TokenCName,pcd.TokenSpaceGuidCName]\r |
| | 900 | if 'DEFAULT' not in pcd.SkuInfoList.keys() and 'COMMON' not in pcd.SkuInfoList.keys(): \r |
| | 901 | valuefromDec = pcdDecObject.DefaultValue\r |
| | 902 | SkuInfo = SkuInfoClass('DEFAULT', '0', '', '', '', '', '', valuefromDec)\r |
| | 903 | pcd.SkuInfoList['DEFAULT'] = SkuInfo\r |
| | 904 | elif 'DEFAULT' not in pcd.SkuInfoList.keys() and 'COMMON' in pcd.SkuInfoList.keys():\r |
| | 905 | pcd.SkuInfoList['DEFAULT'] = pcd.SkuInfoList['COMMON']\r |
| | 906 | del(pcd.SkuInfoList['COMMON'])\r |
| | 907 | elif 'DEFAULT' in pcd.SkuInfoList.keys() and 'COMMON' in pcd.SkuInfoList.keys():\r |
| | 908 | del(pcd.SkuInfoList['COMMON'])\r |
| | 909 | if SkuObj.SkuUsageType == SkuObj.SINGLE:\r |
| | 910 | if 'DEFAULT' in pcd.SkuInfoList.keys() and SkuObj.SystemSkuId not in pcd.SkuInfoList.keys():\r |
| | 911 | pcd.SkuInfoList[SkuObj.SystemSkuId] = pcd.SkuInfoList['DEFAULT']\r |
| | 912 | del(pcd.SkuInfoList['DEFAULT'])\r |
| | 913 | \r |
| | 914 | return Pcds\r |
| | 915 | \r |
| | 916 | def CompareVarAttr(self, Attr1, Attr2):\r |
| | 917 | if not Attr1 or not Attr2: # for empty string\r |
| | 918 | return True\r |
| | 919 | Attr1s = [attr.strip() for attr in Attr1.split(",")]\r |
| | 920 | Attr1Set = set(Attr1s)\r |
| | 921 | Attr2s = [attr.strip() for attr in Attr2.split(",")]\r |
| | 922 | Attr2Set = set(Attr2s)\r |
| | 923 | if Attr2Set == Attr1Set:\r |
| | 924 | return True\r |
| | 925 | else:\r |
| | 926 | return False\r |
| | 927 | ## Retrieve dynamic HII PCD settings\r |
| | 928 | #\r |
| | 929 | # @param Type PCD type\r |
| | 930 | #\r |
| | 931 | # @retval a dict object contains settings of given PCD type\r |
| | 932 | #\r |
| | 933 | def _GetDynamicHiiPcd(self, Type):\r |
| | 934 | \r |
| | 935 | SkuObj = SkuClass(self.SkuIdentifier,self.SkuIds)\r |
| | 936 | VariableAttrs = {}\r |
| | 937 | \r |
| | 938 | Pcds = sdict()\r |
| | 939 | #\r |
| | 940 | # tdict is a special dict kind of type, used for selecting correct\r |
| | 941 | # PCD settings for certain ARCH and SKU\r |
| | 942 | #\r |
| | 943 | PcdDict = tdict(True, 4)\r |
| | 944 | PcdSet = set()\r |
| | 945 | RecordList = self._RawData[Type, self._Arch]\r |
| | 946 | # Find out all possible PCD candidates for self._Arch\r |
| | 947 | AvailableSkuIdSet = SkuObj.AvailableSkuIdSet.copy()\r |
| | 948 | \r |
| | 949 | AvailableSkuIdSet.update({'DEFAULT':0,'COMMON':0})\r |
| | 950 | for TokenSpaceGuid, PcdCName, Setting, Arch, SkuName, Dummy3, Dummy4 in RecordList:\r |
| | 951 | if SkuName not in AvailableSkuIdSet:\r |
| | 952 | continue\r |
| | 953 | PcdSet.add((PcdCName, TokenSpaceGuid, SkuName,Dummy4))\r |
| | 954 | PcdDict[Arch, SkuName, PcdCName, TokenSpaceGuid] = Setting\r |
| | 955 | # Remove redundant PCD candidates, per the ARCH and SKU\r |
| | 956 | for PcdCName, TokenSpaceGuid,SkuName, Dummy4 in PcdSet:\r |
| | 957 | \r |
| | 958 | Setting = PcdDict[self._Arch, SkuName, PcdCName, TokenSpaceGuid]\r |
| | 959 | if Setting == None:\r |
| | 960 | continue\r |
| | 961 | VariableName, VariableGuid, VariableOffset, DefaultValue, VarAttribute = self._ValidatePcd(PcdCName, TokenSpaceGuid, Setting, Type, Dummy4)\r |
| | 962 | \r |
| | 963 | rt, Msg = VariableAttributes.ValidateVarAttributes(VarAttribute)\r |
| | 964 | if not rt:\r |
| | 965 | EdkLogger.error("build", PCD_VARIABLE_ATTRIBUTES_ERROR, "Variable attributes settings for %s is incorrect.\n %s" % (".".join((TokenSpaceGuid, PcdCName)), Msg),\r |
| | 966 | ExtraData = "[%s]" % VarAttribute)\r |
| | 967 | ExceedMax = False\r |
| | 968 | FormatCorrect = True\r |
| | 969 | if VariableOffset.isdigit():\r |
| | 970 | if int(VariableOffset,10) > 0xFFFF:\r |
| | 971 | ExceedMax = True\r |
| | 972 | elif re.match(r'[\t\s]*0[xX][a-fA-F0-9]+$',VariableOffset):\r |
| | 973 | if int(VariableOffset,16) > 0xFFFF:\r |
| | 974 | ExceedMax = True\r |
| | 975 | # For Offset written in "A.B"\r |
| | 976 | elif VariableOffset.find('.') > -1:\r |
| | 977 | VariableOffsetList = VariableOffset.split(".")\r |
| | 978 | if not (len(VariableOffsetList) == 2\r |
| | 979 | and IsValidWord(VariableOffsetList[0])\r |
| | 980 | and IsValidWord(VariableOffsetList[1])):\r |
| | 981 | FormatCorrect = False\r |
| | 982 | else:\r |
| | 983 | FormatCorrect = False\r |
| | 984 | if not FormatCorrect:\r |
| | 985 | EdkLogger.error('Build', FORMAT_INVALID, "Invalid syntax or format of the variable offset value is incorrect for %s." % ".".join((TokenSpaceGuid,PcdCName)))\r |
| | 986 | \r |
| | 987 | if ExceedMax:\r |
| | 988 | 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 |
| | 989 | if (VariableName, VariableGuid) not in VariableAttrs:\r |
| | 990 | VariableAttrs[(VariableName, VariableGuid)] = VarAttribute\r |
| | 991 | else:\r |
| | 992 | if not self.CompareVarAttr(VariableAttrs[(VariableName, VariableGuid)], VarAttribute):\r |
| | 993 | 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 |
| | 994 | \r |
| | 995 | SkuInfo = SkuInfoClass(SkuName, self.SkuIds[SkuName], VariableName, VariableGuid, VariableOffset, DefaultValue, VariableAttribute = VarAttribute)\r |
| | 996 | pcdDecObject = self._DecPcds[PcdCName, TokenSpaceGuid]\r |
| | 997 | if (PcdCName,TokenSpaceGuid) in Pcds.keys(): \r |
| | 998 | pcdObject = Pcds[PcdCName,TokenSpaceGuid]\r |
| | 999 | pcdObject.SkuInfoList[SkuName] = SkuInfo\r |
| | 1000 | else:\r |
| | 1001 | Pcds[PcdCName, TokenSpaceGuid] = PcdClassObject(\r |
| | 1002 | PcdCName,\r |
| | 1003 | TokenSpaceGuid,\r |
| | 1004 | self._PCD_TYPE_STRING_[Type],\r |
| | 1005 | '',\r |
| | 1006 | DefaultValue,\r |
| | 1007 | '',\r |
| | 1008 | '',\r |
| | 1009 | {SkuName : SkuInfo},\r |
| | 1010 | False,\r |
| | 1011 | None,\r |
| | 1012 | pcdDecObject.validateranges,\r |
| | 1013 | pcdDecObject.validlists,\r |
| | 1014 | pcdDecObject.expressions\r |
| | 1015 | )\r |
| | 1016 | \r |
| | 1017 | \r |
| | 1018 | for pcd in Pcds.values():\r |
| | 1019 | SkuInfoObj = pcd.SkuInfoList.values()[0]\r |
| | 1020 | pcdDecObject = self._DecPcds[pcd.TokenCName,pcd.TokenSpaceGuidCName]\r |
| | 1021 | # Only fix the value while no value provided in DSC file.\r |
| | 1022 | for sku in pcd.SkuInfoList.values():\r |
| | 1023 | if (sku.HiiDefaultValue == "" or sku.HiiDefaultValue==None):\r |
| | 1024 | sku.HiiDefaultValue = pcdDecObject.DefaultValue\r |
| | 1025 | if 'DEFAULT' not in pcd.SkuInfoList.keys() and 'COMMON' not in pcd.SkuInfoList.keys(): \r |
| | 1026 | valuefromDec = pcdDecObject.DefaultValue\r |
| | 1027 | SkuInfo = SkuInfoClass('DEFAULT', '0', SkuInfoObj.VariableName, SkuInfoObj.VariableGuid, SkuInfoObj.VariableOffset, valuefromDec)\r |
| | 1028 | pcd.SkuInfoList['DEFAULT'] = SkuInfo\r |
| | 1029 | elif 'DEFAULT' not in pcd.SkuInfoList.keys() and 'COMMON' in pcd.SkuInfoList.keys():\r |
| | 1030 | pcd.SkuInfoList['DEFAULT'] = pcd.SkuInfoList['COMMON']\r |
| | 1031 | del(pcd.SkuInfoList['COMMON'])\r |
| | 1032 | elif 'DEFAULT' in pcd.SkuInfoList.keys() and 'COMMON' in pcd.SkuInfoList.keys():\r |
| | 1033 | del(pcd.SkuInfoList['COMMON'])\r |
| | 1034 | \r |
| | 1035 | if SkuObj.SkuUsageType == SkuObj.SINGLE:\r |
| | 1036 | if 'DEFAULT' in pcd.SkuInfoList.keys() and SkuObj.SystemSkuId not in pcd.SkuInfoList.keys():\r |
| | 1037 | pcd.SkuInfoList[SkuObj.SystemSkuId] = pcd.SkuInfoList['DEFAULT']\r |
| | 1038 | del(pcd.SkuInfoList['DEFAULT'])\r |
| | 1039 | \r |
| | 1040 | \r |
| | 1041 | if pcd.MaxDatumSize.strip(): \r |
| | 1042 | MaxSize = int(pcd.MaxDatumSize,0)\r |
| | 1043 | else:\r |
| | 1044 | MaxSize = 0\r |
| | 1045 | if pcdDecObject.DatumType == 'VOID*':\r |
| | 1046 | for (skuname,skuobj) in pcd.SkuInfoList.items():\r |
| | 1047 | datalen = 0\r |
| | 1048 | if skuobj.HiiDefaultValue.startswith("L"):\r |
| | 1049 | datalen = (len(skuobj.HiiDefaultValue)- 3 + 1) * 2\r |
| | 1050 | elif skuobj.HiiDefaultValue.startswith("{"):\r |
| | 1051 | datalen = len(skuobj.HiiDefaultValue.split(","))\r |
| | 1052 | else:\r |
| | 1053 | datalen = len(skuobj.HiiDefaultValue) -2 + 1 \r |
| | 1054 | if datalen>MaxSize:\r |
| | 1055 | MaxSize = datalen\r |
| | 1056 | pcd.MaxDatumSize = str(MaxSize)\r |
| | 1057 | return Pcds\r |
| | 1058 | \r |
| | 1059 | ## Retrieve dynamic VPD PCD settings\r |
| | 1060 | #\r |
| | 1061 | # @param Type PCD type\r |
| | 1062 | #\r |
| | 1063 | # @retval a dict object contains settings of given PCD type\r |
| | 1064 | #\r |
| | 1065 | def _GetDynamicVpdPcd(self, Type):\r |
| | 1066 | \r |
| | 1067 | SkuObj = SkuClass(self.SkuIdentifier,self.SkuIds)\r |
| | 1068 | \r |
| | 1069 | Pcds = sdict()\r |
| | 1070 | #\r |
| | 1071 | # tdict is a special dict kind of type, used for selecting correct\r |
| | 1072 | # PCD settings for certain ARCH and SKU\r |
| | 1073 | #\r |
| | 1074 | PcdDict = tdict(True, 4)\r |
| | 1075 | PcdList = []\r |
| | 1076 | # Find out all possible PCD candidates for self._Arch\r |
| | 1077 | RecordList = self._RawData[Type, self._Arch]\r |
| | 1078 | AvailableSkuIdSet = SkuObj.AvailableSkuIdSet.copy()\r |
| | 1079 | \r |
| | 1080 | AvailableSkuIdSet.update({'DEFAULT':0,'COMMON':0})\r |
| | 1081 | for TokenSpaceGuid, PcdCName, Setting, Arch, SkuName, Dummy3, Dummy4 in RecordList:\r |
| | 1082 | if SkuName not in AvailableSkuIdSet:\r |
| | 1083 | continue\r |
| | 1084 | \r |
| | 1085 | PcdList.append((PcdCName, TokenSpaceGuid,SkuName, Dummy4))\r |
| | 1086 | PcdDict[Arch, SkuName, PcdCName, TokenSpaceGuid] = Setting\r |
| | 1087 | # Remove redundant PCD candidates, per the ARCH and SKU\r |
| | 1088 | for PcdCName, TokenSpaceGuid, SkuName,Dummy4 in PcdList:\r |
| | 1089 | Setting = PcdDict[self._Arch, SkuName, PcdCName, TokenSpaceGuid]\r |
| | 1090 | if Setting == None:\r |
| | 1091 | continue\r |
| | 1092 | #\r |
| | 1093 | # For the VOID* type, it can have optional data of MaxDatumSize and InitialValue\r |
| | 1094 | # For the Integer & Boolean type, the optional data can only be InitialValue.\r |
| | 1095 | # At this point, we put all the data into the PcdClssObject for we don't know the PCD's datumtype\r |
| | 1096 | # until the DEC parser has been called.\r |
| | 1097 | # \r |
| | 1098 | VpdOffset, MaxDatumSize, InitialValue = self._ValidatePcd(PcdCName, TokenSpaceGuid, Setting, Type, Dummy4)\r |
| | 1099 | SkuInfo = SkuInfoClass(SkuName, self.SkuIds[SkuName], '', '', '', '', VpdOffset, InitialValue)\r |
| | 1100 | if (PcdCName,TokenSpaceGuid) in Pcds.keys(): \r |
| | 1101 | pcdObject = Pcds[PcdCName,TokenSpaceGuid]\r |
| | 1102 | pcdObject.SkuInfoList[SkuName] = SkuInfo\r |
| | 1103 | if MaxDatumSize.strip():\r |
| | 1104 | CurrentMaxSize = int(MaxDatumSize.strip(),0)\r |
| | 1105 | else:\r |
| | 1106 | CurrentMaxSize = 0\r |
| | 1107 | if pcdObject.MaxDatumSize:\r |
| | 1108 | PcdMaxSize = int(pcdObject.MaxDatumSize,0)\r |
| | 1109 | else:\r |
| | 1110 | PcdMaxSize = 0\r |
| | 1111 | if CurrentMaxSize > PcdMaxSize:\r |
| | 1112 | pcdObject.MaxDatumSize = str(CurrentMaxSize)\r |
| | 1113 | else:\r |
| | 1114 | Pcds[PcdCName, TokenSpaceGuid] = PcdClassObject(\r |
| | 1115 | PcdCName,\r |
| | 1116 | TokenSpaceGuid,\r |
| | 1117 | self._PCD_TYPE_STRING_[Type],\r |
| | 1118 | '',\r |
| | 1119 | '',\r |
| | 1120 | '',\r |
| | 1121 | MaxDatumSize,\r |
| | 1122 | {SkuName : SkuInfo},\r |
| | 1123 | False,\r |
| | 1124 | None\r |
| | 1125 | )\r |
| | 1126 | for pcd in Pcds.values():\r |
| | 1127 | SkuInfoObj = pcd.SkuInfoList.values()[0]\r |
| | 1128 | pcdDecObject = self._DecPcds[pcd.TokenCName,pcd.TokenSpaceGuidCName]\r |
| | 1129 | if 'DEFAULT' not in pcd.SkuInfoList.keys() and 'COMMON' not in pcd.SkuInfoList.keys():\r |
| | 1130 | valuefromDec = pcdDecObject.DefaultValue\r |
| | 1131 | SkuInfo = SkuInfoClass('DEFAULT', '0', '', '', '','',SkuInfoObj.VpdOffset, valuefromDec)\r |
| | 1132 | pcd.SkuInfoList['DEFAULT'] = SkuInfo\r |
| | 1133 | elif 'DEFAULT' not in pcd.SkuInfoList.keys() and 'COMMON' in pcd.SkuInfoList.keys():\r |
| | 1134 | pcd.SkuInfoList['DEFAULT'] = pcd.SkuInfoList['COMMON']\r |
| | 1135 | del(pcd.SkuInfoList['COMMON'])\r |
| | 1136 | elif 'DEFAULT' in pcd.SkuInfoList.keys() and 'COMMON' in pcd.SkuInfoList.keys():\r |
| | 1137 | del(pcd.SkuInfoList['COMMON'])\r |
| | 1138 | if SkuObj.SkuUsageType == SkuObj.SINGLE:\r |
| | 1139 | if 'DEFAULT' in pcd.SkuInfoList.keys() and SkuObj.SystemSkuId not in pcd.SkuInfoList.keys():\r |
| | 1140 | pcd.SkuInfoList[SkuObj.SystemSkuId] = pcd.SkuInfoList['DEFAULT']\r |
| | 1141 | del(pcd.SkuInfoList['DEFAULT'])\r |
| | 1142 | \r |
| | 1143 | return Pcds\r |
| | 1144 | \r |
| | 1145 | ## Add external modules\r |
| | 1146 | #\r |
| | 1147 | # The external modules are mostly those listed in FDF file, which don't\r |
| | 1148 | # need "build".\r |
| | 1149 | #\r |
| | 1150 | # @param FilePath The path of module description file\r |
| | 1151 | #\r |
| | 1152 | def AddModule(self, FilePath):\r |
| | 1153 | FilePath = NormPath(FilePath)\r |
| | 1154 | if FilePath not in self.Modules:\r |
| | 1155 | Module = ModuleBuildClassObject()\r |
| | 1156 | Module.MetaFile = FilePath\r |
| | 1157 | self.Modules.append(Module)\r |
| | 1158 | \r |
| | 1159 | ## Add external PCDs\r |
| | 1160 | #\r |
| | 1161 | # The external PCDs are mostly those listed in FDF file to specify address\r |
| | 1162 | # or offset information.\r |
| | 1163 | #\r |
| | 1164 | # @param Name Name of the PCD\r |
| | 1165 | # @param Guid Token space guid of the PCD\r |
| | 1166 | # @param Value Value of the PCD\r |
| | 1167 | #\r |
| | 1168 | def AddPcd(self, Name, Guid, Value):\r |
| | 1169 | if (Name, Guid) not in self.Pcds:\r |
| | 1170 | self.Pcds[Name, Guid] = PcdClassObject(Name, Guid, '', '', '', '', '', {}, False, None)\r |
| | 1171 | self.Pcds[Name, Guid].DefaultValue = Value\r |
| | 1172 | \r |
| | 1173 | _Macros = property(_GetMacros)\r |
| | 1174 | Arch = property(_GetArch, _SetArch)\r |
| | 1175 | Platform = property(_GetPlatformName)\r |
| | 1176 | PlatformName = property(_GetPlatformName)\r |
| | 1177 | Guid = property(_GetFileGuid)\r |
| | 1178 | Version = property(_GetVersion)\r |
| | 1179 | DscSpecification = property(_GetDscSpec)\r |
| | 1180 | OutputDirectory = property(_GetOutpuDir)\r |
| | 1181 | SupArchList = property(_GetSupArch)\r |
| | 1182 | BuildTargets = property(_GetBuildTarget)\r |
| | 1183 | SkuName = property(_GetSkuName, _SetSkuName)\r |
| | 1184 | SkuIdentifier = property(_GetSkuIdentifier)\r |
| | 1185 | AvilableSkuIds = property(_GetAviableSkuIds)\r |
| | 1186 | PcdInfoFlag = property(_GetPcdInfoFlag)\r |
| | 1187 | VarCheckFlag = property(_GetVarCheckFlag)\r |
| | 1188 | FlashDefinition = property(_GetFdfFile)\r |
| | 1189 | BuildNumber = property(_GetBuildNumber)\r |
| | 1190 | MakefileName = property(_GetMakefileName)\r |
| | 1191 | BsBaseAddress = property(_GetBsBaseAddress)\r |
| | 1192 | RtBaseAddress = property(_GetRtBaseAddress)\r |
| | 1193 | LoadFixAddress = property(_GetLoadFixAddress)\r |
| | 1194 | RFCLanguages = property(_GetRFCLanguages)\r |
| | 1195 | ISOLanguages = property(_GetISOLanguages)\r |
| | 1196 | VpdToolGuid = property(_GetVpdToolGuid) \r |
| | 1197 | SkuIds = property(_GetSkuIds)\r |
| | 1198 | Modules = property(_GetModules)\r |
| | 1199 | LibraryInstances = property(_GetLibraryInstances)\r |
| | 1200 | LibraryClasses = property(_GetLibraryClasses)\r |
| | 1201 | Pcds = property(_GetPcds)\r |
| | 1202 | BuildOptions = property(_GetBuildOptions)\r |
| | 1203 | \r |
| | 1204 | ## Platform build information from DEC file\r |
| | 1205 | #\r |
| | 1206 | # This class is used to retrieve information stored in database and convert them\r |
| | 1207 | # into PackageBuildClassObject form for easier use for AutoGen.\r |
| | 1208 | #\r |
| | 1209 | class DecBuildData(PackageBuildClassObject):\r |
| | 1210 | # dict used to convert PCD type in database to string used by build tool\r |
| | 1211 | _PCD_TYPE_STRING_ = {\r |
| | 1212 | MODEL_PCD_FIXED_AT_BUILD : "FixedAtBuild",\r |
| | 1213 | MODEL_PCD_PATCHABLE_IN_MODULE : "PatchableInModule",\r |
| | 1214 | MODEL_PCD_FEATURE_FLAG : "FeatureFlag",\r |
| | 1215 | MODEL_PCD_DYNAMIC : "Dynamic",\r |
| | 1216 | MODEL_PCD_DYNAMIC_DEFAULT : "Dynamic",\r |
| | 1217 | MODEL_PCD_DYNAMIC_HII : "DynamicHii",\r |
| | 1218 | MODEL_PCD_DYNAMIC_VPD : "DynamicVpd",\r |
| | 1219 | MODEL_PCD_DYNAMIC_EX : "DynamicEx",\r |
| | 1220 | MODEL_PCD_DYNAMIC_EX_DEFAULT : "DynamicEx",\r |
| | 1221 | MODEL_PCD_DYNAMIC_EX_HII : "DynamicExHii",\r |
| | 1222 | MODEL_PCD_DYNAMIC_EX_VPD : "DynamicExVpd",\r |
| | 1223 | }\r |
| | 1224 | \r |
| | 1225 | # dict used to convert part of [Defines] to members of DecBuildData directly\r |
| | 1226 | _PROPERTY_ = {\r |
| | 1227 | #\r |
| | 1228 | # Required Fields\r |
| | 1229 | #\r |
| | 1230 | TAB_DEC_DEFINES_PACKAGE_NAME : "_PackageName",\r |
| | 1231 | TAB_DEC_DEFINES_PACKAGE_GUID : "_Guid",\r |
| | 1232 | TAB_DEC_DEFINES_PACKAGE_VERSION : "_Version",\r |
| | 1233 | TAB_DEC_DEFINES_PKG_UNI_FILE : "_PkgUniFile",\r |
| | 1234 | }\r |
| | 1235 | \r |
| | 1236 | \r |
| | 1237 | ## Constructor of DecBuildData\r |
| | 1238 | #\r |
| | 1239 | # Initialize object of DecBuildData\r |
| | 1240 | #\r |
| | 1241 | # @param FilePath The path of package description file\r |
| | 1242 | # @param RawData The raw data of DEC file\r |
| | 1243 | # @param BuildDataBase Database used to retrieve module information\r |
| | 1244 | # @param Arch The target architecture\r |
| | 1245 | # @param Platform (not used for DecBuildData)\r |
| | 1246 | # @param Macros Macros used for replacement in DSC file\r |
| | 1247 | #\r |
| | 1248 | def __init__(self, File, RawData, BuildDataBase, Arch='COMMON', Target=None, Toolchain=None):\r |
| | 1249 | self.MetaFile = File\r |
| | 1250 | self._PackageDir = File.Dir\r |
| | 1251 | self._RawData = RawData\r |
| | 1252 | self._Bdb = BuildDataBase\r |
| | 1253 | self._Arch = Arch\r |
| | 1254 | self._Target = Target\r |
| | 1255 | self._Toolchain = Toolchain\r |
| | 1256 | self._Clear()\r |
| | 1257 | \r |
| | 1258 | ## XXX[key] = value\r |
| | 1259 | def __setitem__(self, key, value):\r |
| | 1260 | self.__dict__[self._PROPERTY_[key]] = value\r |
| | 1261 | \r |
| | 1262 | ## value = XXX[key]\r |
| | 1263 | def __getitem__(self, key):\r |
| | 1264 | return self.__dict__[self._PROPERTY_[key]]\r |
| | 1265 | \r |
| | 1266 | ## "in" test support\r |
| | 1267 | def __contains__(self, key):\r |
| | 1268 | return key in self._PROPERTY_\r |
| | 1269 | \r |
| | 1270 | ## Set all internal used members of DecBuildData to None\r |
| | 1271 | def _Clear(self):\r |
| | 1272 | self._Header = None\r |
| | 1273 | self._PackageName = None\r |
| | 1274 | self._Guid = None\r |
| | 1275 | self._Version = None\r |
| | 1276 | self._PkgUniFile = None\r |
| | 1277 | self._Protocols = None\r |
| | 1278 | self._Ppis = None\r |
| | 1279 | self._Guids = None\r |
| | 1280 | self._Includes = None\r |
| | 1281 | self._LibraryClasses = None\r |
| | 1282 | self._Pcds = None\r |
| | 1283 | self.__Macros = None\r |
| | 1284 | \r |
| | 1285 | ## Get current effective macros\r |
| | 1286 | def _GetMacros(self):\r |
| | 1287 | if self.__Macros == None:\r |
| | 1288 | self.__Macros = {}\r |
| | 1289 | self.__Macros.update(GlobalData.gGlobalDefines)\r |
| | 1290 | return self.__Macros\r |
| | 1291 | \r |
| | 1292 | ## Get architecture\r |
| | 1293 | def _GetArch(self):\r |
| | 1294 | return self._Arch\r |
| | 1295 | \r |
| | 1296 | ## Set architecture\r |
| | 1297 | #\r |
| | 1298 | # Changing the default ARCH to another may affect all other information\r |
| | 1299 | # because all information in a platform may be ARCH-related. That's\r |
| | 1300 | # why we need to clear all internal used members, in order to cause all\r |
| | 1301 | # information to be re-retrieved.\r |
| | 1302 | #\r |
| | 1303 | # @param Value The value of ARCH\r |
| | 1304 | #\r |
| | 1305 | def _SetArch(self, Value):\r |
| | 1306 | if self._Arch == Value:\r |
| | 1307 | return\r |
| | 1308 | self._Arch = Value\r |
| | 1309 | self._Clear()\r |
| | 1310 | \r |
| | 1311 | ## Retrieve all information in [Defines] section\r |
| | 1312 | #\r |
| | 1313 | # (Retriving all [Defines] information in one-shot is just to save time.)\r |
| | 1314 | #\r |
| | 1315 | def _GetHeaderInfo(self):\r |
| | 1316 | RecordList = self._RawData[MODEL_META_DATA_HEADER, self._Arch]\r |
| | 1317 | for Record in RecordList:\r |
| | 1318 | Name = Record[1]\r |
| | 1319 | if Name in self:\r |
| | 1320 | self[Name] = Record[2]\r |
| | 1321 | self._Header = 'DUMMY'\r |
| | 1322 | \r |
| | 1323 | ## Retrieve package name\r |
| | 1324 | def _GetPackageName(self):\r |
| | 1325 | if self._PackageName == None:\r |
| | 1326 | if self._Header == None:\r |
| | 1327 | self._GetHeaderInfo()\r |
| | 1328 | if self._PackageName == None:\r |
| | 1329 | EdkLogger.error("build", ATTRIBUTE_NOT_AVAILABLE, "No PACKAGE_NAME", File=self.MetaFile)\r |
| | 1330 | return self._PackageName\r |
| | 1331 | \r |
| | 1332 | ## Retrieve file guid\r |
| | 1333 | def _GetFileGuid(self):\r |
| | 1334 | if self._Guid == None:\r |
| | 1335 | if self._Header == None:\r |
| | 1336 | self._GetHeaderInfo()\r |
| | 1337 | if self._Guid == None:\r |
| | 1338 | EdkLogger.error("build", ATTRIBUTE_NOT_AVAILABLE, "No PACKAGE_GUID", File=self.MetaFile)\r |
| | 1339 | return self._Guid\r |
| | 1340 | \r |
| | 1341 | ## Retrieve package version\r |
| | 1342 | def _GetVersion(self):\r |
| | 1343 | if self._Version == None:\r |
| | 1344 | if self._Header == None:\r |
| | 1345 | self._GetHeaderInfo()\r |
| | 1346 | if self._Version == None:\r |
| | 1347 | self._Version = ''\r |
| | 1348 | return self._Version\r |
| | 1349 | \r |
| | 1350 | ## Retrieve protocol definitions (name/value pairs)\r |
| | 1351 | def _GetProtocol(self):\r |
| | 1352 | if self._Protocols == None:\r |
| | 1353 | #\r |
| | 1354 | # tdict is a special kind of dict, used for selecting correct\r |
| | 1355 | # protocol defition for given ARCH\r |
| | 1356 | #\r |
| | 1357 | ProtocolDict = tdict(True)\r |
| | 1358 | NameList = []\r |
| | 1359 | # find out all protocol definitions for specific and 'common' arch\r |
| | 1360 | RecordList = self._RawData[MODEL_EFI_PROTOCOL, self._Arch]\r |
| | 1361 | for Name, Guid, Dummy, Arch, ID, LineNo in RecordList:\r |
| | 1362 | if Name not in NameList:\r |
| | 1363 | NameList.append(Name)\r |
| | 1364 | ProtocolDict[Arch, Name] = Guid\r |
| | 1365 | # use sdict to keep the order\r |
| | 1366 | self._Protocols = sdict()\r |
| | 1367 | for Name in NameList:\r |
| | 1368 | #\r |
| | 1369 | # limit the ARCH to self._Arch, if no self._Arch found, tdict\r |
| | 1370 | # will automatically turn to 'common' ARCH for trying\r |
| | 1371 | #\r |
| | 1372 | self._Protocols[Name] = ProtocolDict[self._Arch, Name]\r |
| | 1373 | return self._Protocols\r |
| | 1374 | \r |
| | 1375 | ## Retrieve PPI definitions (name/value pairs)\r |
| | 1376 | def _GetPpi(self):\r |
| | 1377 | if self._Ppis == None:\r |
| | 1378 | #\r |
| | 1379 | # tdict is a special kind of dict, used for selecting correct\r |
| | 1380 | # PPI defition for given ARCH\r |
| | 1381 | #\r |
| | 1382 | PpiDict = tdict(True)\r |
| | 1383 | NameList = []\r |
| | 1384 | # find out all PPI definitions for specific arch and 'common' arch\r |
| | 1385 | RecordList = self._RawData[MODEL_EFI_PPI, self._Arch]\r |
| | 1386 | for Name, Guid, Dummy, Arch, ID, LineNo in RecordList:\r |
| | 1387 | if Name not in NameList:\r |
| | 1388 | NameList.append(Name)\r |
| | 1389 | PpiDict[Arch, Name] = Guid\r |
| | 1390 | # use sdict to keep the order\r |
| | 1391 | self._Ppis = sdict()\r |
| | 1392 | for Name in NameList:\r |
| | 1393 | #\r |
| | 1394 | # limit the ARCH to self._Arch, if no self._Arch found, tdict\r |
| | 1395 | # will automatically turn to 'common' ARCH for trying\r |
| | 1396 | #\r |
| | 1397 | self._Ppis[Name] = PpiDict[self._Arch, Name]\r |
| | 1398 | return self._Ppis\r |
| | 1399 | \r |
| | 1400 | ## Retrieve GUID definitions (name/value pairs)\r |
| | 1401 | def _GetGuid(self):\r |
| | 1402 | if self._Guids == None:\r |
| | 1403 | #\r |
| | 1404 | # tdict is a special kind of dict, used for selecting correct\r |
| | 1405 | # GUID defition for given ARCH\r |
| | 1406 | #\r |
| | 1407 | GuidDict = tdict(True)\r |
| | 1408 | NameList = []\r |
| | 1409 | # find out all protocol definitions for specific and 'common' arch\r |
| | 1410 | RecordList = self._RawData[MODEL_EFI_GUID, self._Arch]\r |
| | 1411 | for Name, Guid, Dummy, Arch, ID, LineNo in RecordList:\r |
| | 1412 | if Name not in NameList:\r |
| | 1413 | NameList.append(Name)\r |
| | 1414 | GuidDict[Arch, Name] = Guid\r |
| | 1415 | # use sdict to keep the order\r |
| | 1416 | self._Guids = sdict()\r |
| | 1417 | for Name in NameList:\r |
| | 1418 | #\r |
| | 1419 | # limit the ARCH to self._Arch, if no self._Arch found, tdict\r |
| | 1420 | # will automatically turn to 'common' ARCH for trying\r |
| | 1421 | #\r |
| | 1422 | self._Guids[Name] = GuidDict[self._Arch, Name]\r |
| | 1423 | return self._Guids\r |
| | 1424 | \r |
| | 1425 | ## Retrieve public include paths declared in this package\r |
| | 1426 | def _GetInclude(self):\r |
| | 1427 | if self._Includes == None:\r |
| | 1428 | self._Includes = []\r |
| | 1429 | RecordList = self._RawData[MODEL_EFI_INCLUDE, self._Arch]\r |
| | 1430 | Macros = self._Macros\r |
| | 1431 | Macros["EDK_SOURCE"] = GlobalData.gEcpSource\r |
| | 1432 | for Record in RecordList:\r |
| | 1433 | File = PathClass(NormPath(Record[0], Macros), self._PackageDir, Arch=self._Arch)\r |
| | 1434 | LineNo = Record[-1]\r |
| | 1435 | # validate the path\r |
| | 1436 | ErrorCode, ErrorInfo = File.Validate()\r |
| | 1437 | if ErrorCode != 0:\r |
| | 1438 | EdkLogger.error('build', ErrorCode, ExtraData=ErrorInfo, File=self.MetaFile, Line=LineNo)\r |
| | 1439 | \r |
| | 1440 | # avoid duplicate include path\r |
| | 1441 | if File not in self._Includes:\r |
| | 1442 | self._Includes.append(File)\r |
| | 1443 | return self._Includes\r |
| | 1444 | \r |
| | 1445 | ## Retrieve library class declarations (not used in build at present)\r |
| | 1446 | def _GetLibraryClass(self):\r |
| | 1447 | if self._LibraryClasses == None:\r |
| | 1448 | #\r |
| | 1449 | # tdict is a special kind of dict, used for selecting correct\r |
| | 1450 | # library class declaration for given ARCH\r |
| | 1451 | #\r |
| | 1452 | LibraryClassDict = tdict(True)\r |
| | 1453 | LibraryClassSet = set()\r |
| | 1454 | RecordList = self._RawData[MODEL_EFI_LIBRARY_CLASS, self._Arch]\r |
| | 1455 | Macros = self._Macros\r |
| | 1456 | for LibraryClass, File, Dummy, Arch, ID, LineNo in RecordList:\r |
| | 1457 | File = PathClass(NormPath(File, Macros), self._PackageDir, Arch=self._Arch)\r |
| | 1458 | # check the file validation\r |
| | 1459 | ErrorCode, ErrorInfo = File.Validate()\r |
| | 1460 | if ErrorCode != 0:\r |
| | 1461 | EdkLogger.error('build', ErrorCode, ExtraData=ErrorInfo, File=self.MetaFile, Line=LineNo)\r |
| | 1462 | LibraryClassSet.add(LibraryClass)\r |
| | 1463 | LibraryClassDict[Arch, LibraryClass] = File\r |
| | 1464 | self._LibraryClasses = sdict()\r |
| | 1465 | for LibraryClass in LibraryClassSet:\r |
| | 1466 | self._LibraryClasses[LibraryClass] = LibraryClassDict[self._Arch, LibraryClass]\r |
| | 1467 | return self._LibraryClasses\r |
| | 1468 | \r |
| | 1469 | ## Retrieve PCD declarations\r |
| | 1470 | def _GetPcds(self):\r |
| | 1471 | if self._Pcds == None:\r |
| | 1472 | self._Pcds = sdict()\r |
| | 1473 | self._Pcds.update(self._GetPcd(MODEL_PCD_FIXED_AT_BUILD))\r |
| | 1474 | self._Pcds.update(self._GetPcd(MODEL_PCD_PATCHABLE_IN_MODULE))\r |
| | 1475 | self._Pcds.update(self._GetPcd(MODEL_PCD_FEATURE_FLAG))\r |
| | 1476 | self._Pcds.update(self._GetPcd(MODEL_PCD_DYNAMIC))\r |
| | 1477 | self._Pcds.update(self._GetPcd(MODEL_PCD_DYNAMIC_EX))\r |
| | 1478 | return self._Pcds\r |
| | 1479 | \r |
| | 1480 | ## Retrieve PCD declarations for given type\r |
| | 1481 | def _GetPcd(self, Type):\r |
| | 1482 | Pcds = sdict()\r |
| | 1483 | #\r |
| | 1484 | # tdict is a special kind of dict, used for selecting correct\r |
| | 1485 | # PCD declaration for given ARCH\r |
| | 1486 | #\r |
| | 1487 | PcdDict = tdict(True, 3)\r |
| | 1488 | # for summarizing PCD\r |
| | 1489 | PcdSet = set()\r |
| | 1490 | # find out all PCDs of the 'type'\r |
| | 1491 | RecordList = self._RawData[Type, self._Arch]\r |
| | 1492 | for TokenSpaceGuid, PcdCName, Setting, Arch, Dummy1, Dummy2 in RecordList:\r |
| | 1493 | PcdDict[Arch, PcdCName, TokenSpaceGuid] = Setting\r |
| | 1494 | PcdSet.add((PcdCName, TokenSpaceGuid))\r |
| | 1495 | \r |
| | 1496 | for PcdCName, TokenSpaceGuid in PcdSet:\r |
| | 1497 | #\r |
| | 1498 | # limit the ARCH to self._Arch, if no self._Arch found, tdict\r |
| | 1499 | # will automatically turn to 'common' ARCH and try again\r |
| | 1500 | #\r |
| | 1501 | Setting = PcdDict[self._Arch, PcdCName, TokenSpaceGuid]\r |
| | 1502 | if Setting == None:\r |
| | 1503 | continue\r |
| | 1504 | \r |
| | 1505 | DefaultValue, DatumType, TokenNumber = AnalyzePcdData(Setting)\r |
| | 1506 | \r |
| | 1507 | validateranges, validlists, expressions = self._RawData.GetValidExpression(TokenSpaceGuid, PcdCName) \r |
| | 1508 | Pcds[PcdCName, TokenSpaceGuid, self._PCD_TYPE_STRING_[Type]] = PcdClassObject(\r |
| | 1509 | PcdCName,\r |
| | 1510 | TokenSpaceGuid,\r |
| | 1511 | self._PCD_TYPE_STRING_[Type],\r |
| | 1512 | DatumType,\r |
| | 1513 | DefaultValue,\r |
| | 1514 | TokenNumber,\r |
| | 1515 | '',\r |
| | 1516 | {},\r |
| | 1517 | False,\r |
| | 1518 | None,\r |
| | 1519 | list(validateranges),\r |
| | 1520 | list(validlists),\r |
| | 1521 | list(expressions)\r |
| | 1522 | )\r |
| | 1523 | return Pcds\r |
| | 1524 | \r |
| | 1525 | \r |
| | 1526 | _Macros = property(_GetMacros)\r |
| | 1527 | Arch = property(_GetArch, _SetArch)\r |
| | 1528 | PackageName = property(_GetPackageName)\r |
| | 1529 | Guid = property(_GetFileGuid)\r |
| | 1530 | Version = property(_GetVersion)\r |
| | 1531 | \r |
| | 1532 | Protocols = property(_GetProtocol)\r |
| | 1533 | Ppis = property(_GetPpi)\r |
| | 1534 | Guids = property(_GetGuid)\r |
| | 1535 | Includes = property(_GetInclude)\r |
| | 1536 | LibraryClasses = property(_GetLibraryClass)\r |
| | 1537 | Pcds = property(_GetPcds)\r |
| | 1538 | \r |
| | 1539 | ## Module build information from INF file\r |
| | 1540 | #\r |
| | 1541 | # This class is used to retrieve information stored in database and convert them\r |
| | 1542 | # into ModuleBuildClassObject form for easier use for AutoGen.\r |
| | 1543 | #\r |
| | 1544 | class InfBuildData(ModuleBuildClassObject):\r |
| | 1545 | # dict used to convert PCD type in database to string used by build tool\r |
| | 1546 | _PCD_TYPE_STRING_ = {\r |
| | 1547 | MODEL_PCD_FIXED_AT_BUILD : "FixedAtBuild",\r |
| | 1548 | MODEL_PCD_PATCHABLE_IN_MODULE : "PatchableInModule",\r |
| | 1549 | MODEL_PCD_FEATURE_FLAG : "FeatureFlag",\r |
| | 1550 | MODEL_PCD_DYNAMIC : "Dynamic",\r |
| | 1551 | MODEL_PCD_DYNAMIC_DEFAULT : "Dynamic",\r |
| | 1552 | MODEL_PCD_DYNAMIC_HII : "DynamicHii",\r |
| | 1553 | MODEL_PCD_DYNAMIC_VPD : "DynamicVpd",\r |
| | 1554 | MODEL_PCD_DYNAMIC_EX : "DynamicEx",\r |
| | 1555 | MODEL_PCD_DYNAMIC_EX_DEFAULT : "DynamicEx",\r |
| | 1556 | MODEL_PCD_DYNAMIC_EX_HII : "DynamicExHii",\r |
| | 1557 | MODEL_PCD_DYNAMIC_EX_VPD : "DynamicExVpd",\r |
| | 1558 | }\r |
| | 1559 | \r |
| | 1560 | # dict used to convert part of [Defines] to members of InfBuildData directly\r |
| | 1561 | _PROPERTY_ = {\r |
| | 1562 | #\r |
| | 1563 | # Required Fields\r |
| | 1564 | #\r |
| | 1565 | TAB_INF_DEFINES_BASE_NAME : "_BaseName",\r |
| | 1566 | TAB_INF_DEFINES_FILE_GUID : "_Guid",\r |
| | 1567 | TAB_INF_DEFINES_MODULE_TYPE : "_ModuleType",\r |
| | 1568 | #\r |
| | 1569 | # Optional Fields\r |
| | 1570 | #\r |
| | 1571 | #TAB_INF_DEFINES_INF_VERSION : "_AutoGenVersion",\r |
| | 1572 | TAB_INF_DEFINES_COMPONENT_TYPE : "_ComponentType",\r |
| | 1573 | TAB_INF_DEFINES_MAKEFILE_NAME : "_MakefileName",\r |
| | 1574 | #TAB_INF_DEFINES_CUSTOM_MAKEFILE : "_CustomMakefile",\r |
| | 1575 | TAB_INF_DEFINES_DPX_SOURCE :"_DxsFile",\r |
| | 1576 | TAB_INF_DEFINES_VERSION_NUMBER : "_Version",\r |
| | 1577 | TAB_INF_DEFINES_VERSION_STRING : "_Version",\r |
| | 1578 | TAB_INF_DEFINES_VERSION : "_Version",\r |
| | 1579 | TAB_INF_DEFINES_PCD_IS_DRIVER : "_PcdIsDriver",\r |
| | 1580 | TAB_INF_DEFINES_SHADOW : "_Shadow",\r |
| | 1581 | \r |
| | 1582 | TAB_COMPONENTS_SOURCE_OVERRIDE_PATH : "_SourceOverridePath",\r |
| | 1583 | }\r |
| | 1584 | \r |
| | 1585 | # dict used to convert Component type to Module type\r |
| | 1586 | _MODULE_TYPE_ = {\r |
| | 1587 | "LIBRARY" : "BASE",\r |
| | 1588 | "SECURITY_CORE" : "SEC",\r |
| | 1589 | "PEI_CORE" : "PEI_CORE",\r |
| | 1590 | "COMBINED_PEIM_DRIVER" : "PEIM",\r |
| | 1591 | "PIC_PEIM" : "PEIM",\r |
| | 1592 | "RELOCATABLE_PEIM" : "PEIM",\r |
| | 1593 | "PE32_PEIM" : "PEIM",\r |
| | 1594 | "BS_DRIVER" : "DXE_DRIVER",\r |
| | 1595 | "RT_DRIVER" : "DXE_RUNTIME_DRIVER",\r |
| | 1596 | "SAL_RT_DRIVER" : "DXE_SAL_DRIVER",\r |
| | 1597 | "DXE_SMM_DRIVER" : "DXE_SMM_DRIVER",\r |
| | 1598 | # "SMM_DRIVER" : "DXE_SMM_DRIVER",\r |
| | 1599 | # "BS_DRIVER" : "DXE_SMM_DRIVER",\r |
| | 1600 | # "BS_DRIVER" : "UEFI_DRIVER",\r |
| | 1601 | "APPLICATION" : "UEFI_APPLICATION",\r |
| | 1602 | "LOGO" : "BASE",\r |
| | 1603 | }\r |
| | 1604 | \r |
| | 1605 | # regular expression for converting XXX_FLAGS in [nmake] section to new type\r |
| | 1606 | _NMAKE_FLAG_PATTERN_ = re.compile("(?:EBC_)?([A-Z]+)_(?:STD_|PROJ_|ARCH_)?FLAGS(?:_DLL|_ASL|_EXE)?", re.UNICODE)\r |
| | 1607 | # dict used to convert old tool name used in [nmake] section to new ones\r |
| | 1608 | _TOOL_CODE_ = {\r |
| | 1609 | "C" : "CC",\r |
| | 1610 | "LIB" : "SLINK",\r |
| | 1611 | "LINK" : "DLINK",\r |
| | 1612 | }\r |
| | 1613 | \r |
| | 1614 | \r |
| | 1615 | ## Constructor of DscBuildData\r |
| | 1616 | #\r |
| | 1617 | # Initialize object of DscBuildData\r |
| | 1618 | #\r |
| | 1619 | # @param FilePath The path of platform description file\r |
| | 1620 | # @param RawData The raw data of DSC file\r |
| | 1621 | # @param BuildDataBase Database used to retrieve module/package information\r |
| | 1622 | # @param Arch The target architecture\r |
| | 1623 | # @param Platform The name of platform employing this module\r |
| | 1624 | # @param Macros Macros used for replacement in DSC file\r |
| | 1625 | #\r |
| | 1626 | def __init__(self, FilePath, RawData, BuildDatabase, Arch='COMMON', Target=None, Toolchain=None):\r |
| | 1627 | self.MetaFile = FilePath\r |
| | 1628 | self._ModuleDir = FilePath.Dir\r |
| | 1629 | self._RawData = RawData\r |
| | 1630 | self._Bdb = BuildDatabase\r |
| | 1631 | self._Arch = Arch\r |
| | 1632 | self._Target = Target\r |
| | 1633 | self._Toolchain = Toolchain\r |
| | 1634 | self._Platform = 'COMMON'\r |
| | 1635 | self._SourceOverridePath = None\r |
| | 1636 | if FilePath.Key in GlobalData.gOverrideDir:\r |
| | 1637 | self._SourceOverridePath = GlobalData.gOverrideDir[FilePath.Key]\r |
| | 1638 | self._Clear()\r |
| | 1639 | \r |
| | 1640 | ## XXX[key] = value\r |
| | 1641 | def __setitem__(self, key, value):\r |
| | 1642 | self.__dict__[self._PROPERTY_[key]] = value\r |
| | 1643 | \r |
| | 1644 | ## value = XXX[key]\r |
| | 1645 | def __getitem__(self, key):\r |
| | 1646 | return self.__dict__[self._PROPERTY_[key]]\r |
| | 1647 | \r |
| | 1648 | ## "in" test support\r |
| | 1649 | def __contains__(self, key):\r |
| | 1650 | return key in self._PROPERTY_\r |
| | 1651 | \r |
| | 1652 | ## Set all internal used members of InfBuildData to None\r |
| | 1653 | def _Clear(self):\r |
| | 1654 | self._HeaderComments = None\r |
| | 1655 | self._TailComments = None\r |
| | 1656 | self._Header_ = None\r |
| | 1657 | self._AutoGenVersion = None\r |
| | 1658 | self._BaseName = None\r |
| | 1659 | self._DxsFile = None\r |
| | 1660 | self._ModuleType = None\r |
| | 1661 | self._ComponentType = None\r |
| | 1662 | self._BuildType = None\r |
| | 1663 | self._Guid = None\r |
| | 1664 | self._Version = None\r |
| | 1665 | self._PcdIsDriver = None\r |
| | 1666 | self._BinaryModule = None\r |
| | 1667 | self._Shadow = None\r |
| | 1668 | self._MakefileName = None\r |
| | 1669 | self._CustomMakefile = None\r |
| | 1670 | self._Specification = None\r |
| | 1671 | self._LibraryClass = None\r |
| | 1672 | self._ModuleEntryPointList = None\r |
| | 1673 | self._ModuleUnloadImageList = None\r |
| | 1674 | self._ConstructorList = None\r |
| | 1675 | self._DestructorList = None\r |
| | 1676 | self._Defs = None\r |
| | 1677 | self._Binaries = None\r |
| | 1678 | self._Sources = None\r |
| | 1679 | self._LibraryClasses = None\r |
| | 1680 | self._Libraries = None\r |
| | 1681 | self._Protocols = None\r |
| | 1682 | self._ProtocolComments = None\r |
| | 1683 | self._Ppis = None\r |
| | 1684 | self._PpiComments = None\r |
| | 1685 | self._Guids = None\r |
| | 1686 | self._GuidsUsedByPcd = sdict()\r |
| | 1687 | self._GuidComments = None\r |
| | 1688 | self._Includes = None\r |
| | 1689 | self._Packages = None\r |
| | 1690 | self._Pcds = None\r |
| | 1691 | self._PcdComments = None\r |
| | 1692 | self._BuildOptions = None\r |
| | 1693 | self._Depex = None\r |
| | 1694 | self._DepexExpression = None\r |
| | 1695 | self.__Macros = None\r |
| | 1696 | \r |
| | 1697 | ## Get current effective macros\r |
| | 1698 | def _GetMacros(self):\r |
| | 1699 | if self.__Macros == None:\r |
| | 1700 | self.__Macros = {}\r |
| | 1701 | # EDK_GLOBAL defined macros can be applied to EDK module\r |
| | 1702 | if self.AutoGenVersion < 0x00010005:\r |
| | 1703 | self.__Macros.update(GlobalData.gEdkGlobal)\r |
| | 1704 | self.__Macros.update(GlobalData.gGlobalDefines)\r |
| | 1705 | return self.__Macros\r |
| | 1706 | \r |
| | 1707 | ## Get architecture\r |
| | 1708 | def _GetArch(self):\r |
| | 1709 | return self._Arch\r |
| | 1710 | \r |
| | 1711 | ## Set architecture\r |
| | 1712 | #\r |
| | 1713 | # Changing the default ARCH to another may affect all other information\r |
| | 1714 | # because all information in a platform may be ARCH-related. That's\r |
| | 1715 | # why we need to clear all internal used members, in order to cause all\r |
| | 1716 | # information to be re-retrieved.\r |
| | 1717 | #\r |
| | 1718 | # @param Value The value of ARCH\r |
| | 1719 | #\r |
| | 1720 | def _SetArch(self, Value):\r |
| | 1721 | if self._Arch == Value:\r |
| | 1722 | return\r |
| | 1723 | self._Arch = Value\r |
| | 1724 | self._Clear()\r |
| | 1725 | \r |
| | 1726 | ## Return the name of platform employing this module\r |
| | 1727 | def _GetPlatform(self):\r |
| | 1728 | return self._Platform\r |
| | 1729 | \r |
| | 1730 | ## Change the name of platform employing this module\r |
| | 1731 | #\r |
| | 1732 | # Changing the default name of platform to another may affect some information\r |
| | 1733 | # because they may be PLATFORM-related. That's why we need to clear all internal\r |
| | 1734 | # used members, in order to cause all information to be re-retrieved.\r |
| | 1735 | #\r |
| | 1736 | def _SetPlatform(self, Value):\r |
| | 1737 | if self._Platform == Value:\r |
| | 1738 | return\r |
| | 1739 | self._Platform = Value\r |
| | 1740 | self._Clear()\r |
| | 1741 | def _GetHeaderComments(self):\r |
| | 1742 | if not self._HeaderComments:\r |
| | 1743 | self._HeaderComments = []\r |
| | 1744 | RecordList = self._RawData[MODEL_META_DATA_HEADER_COMMENT]\r |
| | 1745 | for Record in RecordList:\r |
| | 1746 | self._HeaderComments.append(Record[0])\r |
| | 1747 | return self._HeaderComments\r |
| | 1748 | def _GetTailComments(self):\r |
| | 1749 | if not self._TailComments:\r |
| | 1750 | self._TailComments = []\r |
| | 1751 | RecordList = self._RawData[MODEL_META_DATA_TAIL_COMMENT]\r |
| | 1752 | for Record in RecordList:\r |
| | 1753 | self._TailComments.append(Record[0])\r |
| | 1754 | return self._TailComments\r |
| | 1755 | ## Retrieve all information in [Defines] section\r |
| | 1756 | #\r |
| | 1757 | # (Retriving all [Defines] information in one-shot is just to save time.)\r |
| | 1758 | #\r |
| | 1759 | def _GetHeaderInfo(self):\r |
| | 1760 | RecordList = self._RawData[MODEL_META_DATA_HEADER, self._Arch, self._Platform]\r |
| | 1761 | for Record in RecordList:\r |
| | 1762 | Name, Value = Record[1], ReplaceMacro(Record[2], self._Macros, False)\r |
| | 1763 | # items defined _PROPERTY_ don't need additional processing\r |
| | 1764 | if Name in self:\r |
| | 1765 | self[Name] = Value\r |
| | 1766 | if self._Defs == None:\r |
| | 1767 | self._Defs = sdict()\r |
| | 1768 | self._Defs[Name] = Value\r |
| | 1769 | # some special items in [Defines] section need special treatment\r |
| | 1770 | elif Name in ('EFI_SPECIFICATION_VERSION', 'UEFI_SPECIFICATION_VERSION', 'EDK_RELEASE_VERSION', 'PI_SPECIFICATION_VERSION'):\r |
| | 1771 | if Name in ('EFI_SPECIFICATION_VERSION', 'UEFI_SPECIFICATION_VERSION'):\r |
| | 1772 | Name = 'UEFI_SPECIFICATION_VERSION'\r |
| | 1773 | if self._Specification == None:\r |
| | 1774 | self._Specification = sdict()\r |
| | 1775 | self._Specification[Name] = GetHexVerValue(Value)\r |
| | 1776 | if self._Specification[Name] == None:\r |
| | 1777 | EdkLogger.error("build", FORMAT_NOT_SUPPORTED,\r |
| | 1778 | "'%s' format is not supported for %s" % (Value, Name),\r |
| | 1779 | File=self.MetaFile, Line=Record[-1])\r |
| | 1780 | elif Name == 'LIBRARY_CLASS':\r |
| | 1781 | if self._LibraryClass == None:\r |
| | 1782 | self._LibraryClass = []\r |
| | 1783 | ValueList = GetSplitValueList(Value)\r |
| | 1784 | LibraryClass = ValueList[0]\r |
| | 1785 | if len(ValueList) > 1:\r |
| | 1786 | SupModuleList = GetSplitValueList(ValueList[1], ' ')\r |
| | 1787 | else:\r |
| | 1788 | SupModuleList = SUP_MODULE_LIST\r |
| | 1789 | self._LibraryClass.append(LibraryClassObject(LibraryClass, SupModuleList))\r |
| | 1790 | elif Name == 'ENTRY_POINT':\r |
| | 1791 | if self._ModuleEntryPointList == None:\r |
| | 1792 | self._ModuleEntryPointList = []\r |
| | 1793 | self._ModuleEntryPointList.append(Value)\r |
| | 1794 | elif Name == 'UNLOAD_IMAGE':\r |
| | 1795 | if self._ModuleUnloadImageList == None:\r |
| | 1796 | self._ModuleUnloadImageList = []\r |
| | 1797 | if not Value:\r |
| | 1798 | continue\r |
| | 1799 | self._ModuleUnloadImageList.append(Value)\r |
| | 1800 | elif Name == 'CONSTRUCTOR':\r |
| | 1801 | if self._ConstructorList == None:\r |
| | 1802 | self._ConstructorList = []\r |
| | 1803 | if not Value:\r |
| | 1804 | continue\r |
| | 1805 | self._ConstructorList.append(Value)\r |
| | 1806 | elif Name == 'DESTRUCTOR':\r |
| | 1807 | if self._DestructorList == None:\r |
| | 1808 | self._DestructorList = []\r |
| | 1809 | if not Value:\r |
| | 1810 | continue\r |
| | 1811 | self._DestructorList.append(Value)\r |
| | 1812 | elif Name == TAB_INF_DEFINES_CUSTOM_MAKEFILE:\r |
| | 1813 | TokenList = GetSplitValueList(Value)\r |
| | 1814 | if self._CustomMakefile == None:\r |
| | 1815 | self._CustomMakefile = {}\r |
| | 1816 | if len(TokenList) < 2:\r |
| | 1817 | self._CustomMakefile['MSFT'] = TokenList[0]\r |
| | 1818 | self._CustomMakefile['GCC'] = TokenList[0]\r |
| | 1819 | else:\r |
| | 1820 | if TokenList[0] not in ['MSFT', 'GCC']:\r |
| | 1821 | EdkLogger.error("build", FORMAT_NOT_SUPPORTED,\r |
| | 1822 | "No supported family [%s]" % TokenList[0],\r |
| | 1823 | File=self.MetaFile, Line=Record[-1])\r |
| | 1824 | self._CustomMakefile[TokenList[0]] = TokenList[1]\r |
| | 1825 | else:\r |
| | 1826 | if self._Defs == None:\r |
| | 1827 | self._Defs = sdict()\r |
| | 1828 | self._Defs[Name] = Value\r |
| | 1829 | \r |
| | 1830 | #\r |
| | 1831 | # Retrieve information in sections specific to Edk.x modules\r |
| | 1832 | #\r |
| | 1833 | if self.AutoGenVersion >= 0x00010005:\r |
| | 1834 | if not self._ModuleType:\r |
| | 1835 | EdkLogger.error("build", ATTRIBUTE_NOT_AVAILABLE,\r |
| | 1836 | "MODULE_TYPE is not given", File=self.MetaFile)\r |
| | 1837 | if self._ModuleType not in SUP_MODULE_LIST:\r |
| | 1838 | RecordList = self._RawData[MODEL_META_DATA_HEADER, self._Arch, self._Platform]\r |
| | 1839 | for Record in RecordList:\r |
| | 1840 | Name = Record[1]\r |
| | 1841 | if Name == "MODULE_TYPE":\r |
| | 1842 | LineNo = Record[6]\r |
| | 1843 | break\r |
| | 1844 | EdkLogger.error("build", FORMAT_NOT_SUPPORTED,\r |
| | 1845 | "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 |
| | 1846 | File=self.MetaFile, Line=LineNo)\r |
| | 1847 | if (self._Specification == None) or (not 'PI_SPECIFICATION_VERSION' in self._Specification) or (int(self._Specification['PI_SPECIFICATION_VERSION'], 16) < 0x0001000A):\r |
| | 1848 | if self._ModuleType == SUP_MODULE_SMM_CORE:\r |
| | 1849 | 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 |
| | 1850 | if self._Defs and 'PCI_DEVICE_ID' in self._Defs and 'PCI_VENDOR_ID' in self._Defs \\r |
| | 1851 | and 'PCI_CLASS_CODE' in self._Defs:\r |
| | 1852 | self._BuildType = 'UEFI_OPTIONROM'\r |
| | 1853 | elif self._Defs and 'UEFI_HII_RESOURCE_SECTION' in self._Defs \\r |
| | 1854 | and self._Defs['UEFI_HII_RESOURCE_SECTION'] == 'TRUE':\r |
| | 1855 | self._BuildType = 'UEFI_HII'\r |
| | 1856 | else:\r |
| | 1857 | self._BuildType = self._ModuleType.upper()\r |
| | 1858 | \r |
| | 1859 | if self._DxsFile:\r |
| | 1860 | File = PathClass(NormPath(self._DxsFile), self._ModuleDir, Arch=self._Arch)\r |
| | 1861 | # check the file validation\r |
| | 1862 | ErrorCode, ErrorInfo = File.Validate(".dxs", CaseSensitive=False)\r |
| | 1863 | if ErrorCode != 0:\r |
| | 1864 | EdkLogger.error('build', ErrorCode, ExtraData=ErrorInfo,\r |
| | 1865 | File=self.MetaFile, Line=LineNo)\r |
| | 1866 | if self.Sources == None:\r |
| | 1867 | self._Sources = []\r |
| | 1868 | self._Sources.append(File)\r |
| | 1869 | else: \r |
| | 1870 | if not self._ComponentType:\r |
| | 1871 | EdkLogger.error("build", ATTRIBUTE_NOT_AVAILABLE,\r |
| | 1872 | "COMPONENT_TYPE is not given", File=self.MetaFile)\r |
| | 1873 | self._BuildType = self._ComponentType.upper() \r |
| | 1874 | if self._ComponentType in self._MODULE_TYPE_:\r |
| | 1875 | self._ModuleType = self._MODULE_TYPE_[self._ComponentType]\r |
| | 1876 | if self._ComponentType == 'LIBRARY':\r |
| | 1877 | self._LibraryClass = [LibraryClassObject(self._BaseName, SUP_MODULE_LIST)]\r |
| | 1878 | # make use some [nmake] section macros\r |
| | 1879 | Macros = self._Macros\r |
| | 1880 | Macros["EDK_SOURCE"] = GlobalData.gEcpSource\r |
| | 1881 | Macros['PROCESSOR'] = self._Arch\r |
| | 1882 | RecordList = self._RawData[MODEL_META_DATA_NMAKE, self._Arch, self._Platform]\r |
| | 1883 | for Name,Value,Dummy,Arch,Platform,ID,LineNo in RecordList:\r |
| | 1884 | Value = ReplaceMacro(Value, Macros, True)\r |
| | 1885 | if Name == "IMAGE_ENTRY_POINT":\r |
| | 1886 | if self._ModuleEntryPointList == None:\r |
| | 1887 | self._ModuleEntryPointList = []\r |
| | 1888 | self._ModuleEntryPointList.append(Value)\r |
| | 1889 | elif Name == "DPX_SOURCE":\r |
| | 1890 | File = PathClass(NormPath(Value), self._ModuleDir, Arch=self._Arch)\r |
| | 1891 | # check the file validation\r |
| | 1892 | ErrorCode, ErrorInfo = File.Validate(".dxs", CaseSensitive=False)\r |
| | 1893 | if ErrorCode != 0:\r |
| | 1894 | EdkLogger.error('build', ErrorCode, ExtraData=ErrorInfo,\r |
| | 1895 | File=self.MetaFile, Line=LineNo)\r |
| | 1896 | if self.Sources == None:\r |
| | 1897 | self._Sources = []\r |
| | 1898 | self._Sources.append(File)\r |
| | 1899 | else:\r |
| | 1900 | ToolList = self._NMAKE_FLAG_PATTERN_.findall(Name)\r |
| | 1901 | if len(ToolList) == 0 or len(ToolList) != 1:\r |
| | 1902 | pass\r |
| | 1903 | # EdkLogger.warn("build", "Don't know how to do with macro [%s]" % Name,\r |
| | 1904 | # File=self.MetaFile, Line=LineNo)\r |
| | 1905 | else:\r |
| | 1906 | if self._BuildOptions == None:\r |
| | 1907 | self._BuildOptions = sdict()\r |
| | 1908 | \r |
| | 1909 | if ToolList[0] in self._TOOL_CODE_:\r |
| | 1910 | Tool = self._TOOL_CODE_[ToolList[0]]\r |
| | 1911 | else:\r |
| | 1912 | Tool = ToolList[0]\r |
| | 1913 | ToolChain = "*_*_*_%s_FLAGS" % Tool\r |
| | 1914 | ToolChainFamily = 'MSFT' # Edk.x only support MSFT tool chain\r |
| | 1915 | #ignore not replaced macros in value\r |
| | 1916 | ValueList = GetSplitList(' ' + Value, '/D')\r |
| | 1917 | Dummy = ValueList[0]\r |
| | 1918 | for Index in range(1, len(ValueList)):\r |
| | 1919 | if ValueList[Index][-1] == '=' or ValueList[Index] == '':\r |
| | 1920 | continue\r |
| | 1921 | Dummy = Dummy + ' /D ' + ValueList[Index]\r |
| | 1922 | Value = Dummy.strip()\r |
| | 1923 | if (ToolChainFamily, ToolChain) not in self._BuildOptions:\r |
| | 1924 | self._BuildOptions[ToolChainFamily, ToolChain] = Value\r |
| | 1925 | else:\r |
| | 1926 | OptionString = self._BuildOptions[ToolChainFamily, ToolChain]\r |
| | 1927 | self._BuildOptions[ToolChainFamily, ToolChain] = OptionString + " " + Value\r |
| | 1928 | # set _Header to non-None in order to avoid database re-querying\r |
| | 1929 | self._Header_ = 'DUMMY'\r |
| | 1930 | \r |
| | 1931 | ## Retrieve file version\r |
| | 1932 | def _GetInfVersion(self):\r |
| | 1933 | if self._AutoGenVersion == None:\r |
| | 1934 | RecordList = self._RawData[MODEL_META_DATA_HEADER, self._Arch, self._Platform]\r |
| | 1935 | for Record in RecordList:\r |
| | 1936 | if Record[1] == TAB_INF_DEFINES_INF_VERSION:\r |
| | 1937 | self._AutoGenVersion = int(Record[2], 0)\r |
| | 1938 | break\r |
| | 1939 | if self._AutoGenVersion == None:\r |
| | 1940 | self._AutoGenVersion = 0x00010000\r |
| | 1941 | return self._AutoGenVersion\r |
| | 1942 | \r |
| | 1943 | ## Retrieve BASE_NAME\r |
| | 1944 | def _GetBaseName(self):\r |
| | 1945 | if self._BaseName == None:\r |
| | 1946 | if self._Header_ == None:\r |
| | 1947 | self._GetHeaderInfo()\r |
| | 1948 | if self._BaseName == None:\r |
| | 1949 | EdkLogger.error('build', ATTRIBUTE_NOT_AVAILABLE, "No BASE_NAME name", File=self.MetaFile)\r |
| | 1950 | return self._BaseName\r |
| | 1951 | \r |
| | 1952 | ## Retrieve DxsFile\r |
| | 1953 | def _GetDxsFile(self):\r |
| | 1954 | if self._DxsFile == None:\r |
| | 1955 | if self._Header_ == None:\r |
| | 1956 | self._GetHeaderInfo()\r |
| | 1957 | if self._DxsFile == None:\r |
| | 1958 | self._DxsFile = ''\r |
| | 1959 | return self._DxsFile\r |
| | 1960 | \r |
| | 1961 | ## Retrieve MODULE_TYPE\r |
| | 1962 | def _GetModuleType(self):\r |
| | 1963 | if self._ModuleType == None:\r |
| | 1964 | if self._Header_ == None:\r |
| | 1965 | self._GetHeaderInfo()\r |
| | 1966 | if self._ModuleType == None:\r |
| | 1967 | self._ModuleType = 'BASE'\r |
| | 1968 | if self._ModuleType not in SUP_MODULE_LIST:\r |
| | 1969 | self._ModuleType = "USER_DEFINED"\r |
| | 1970 | return self._ModuleType\r |
| | 1971 | \r |
| | 1972 | ## Retrieve COMPONENT_TYPE\r |
| | 1973 | def _GetComponentType(self):\r |
| | 1974 | if self._ComponentType == None:\r |
| | 1975 | if self._Header_ == None:\r |
| | 1976 | self._GetHeaderInfo()\r |
| | 1977 | if self._ComponentType == None:\r |
| | 1978 | self._ComponentType = 'USER_DEFINED'\r |
| | 1979 | return self._ComponentType\r |
| | 1980 | \r |
| | 1981 | ## Retrieve "BUILD_TYPE"\r |
| | 1982 | def _GetBuildType(self):\r |
| | 1983 | if self._BuildType == None:\r |
| | 1984 | if self._Header_ == None:\r |
| | 1985 | self._GetHeaderInfo()\r |
| | 1986 | if not self._BuildType:\r |
| | 1987 | self._BuildType = "BASE"\r |
| | 1988 | return self._BuildType\r |
| | 1989 | \r |
| | 1990 | ## Retrieve file guid\r |
| | 1991 | def _GetFileGuid(self):\r |
| | 1992 | if self._Guid == None:\r |
| | 1993 | if self._Header_ == None:\r |
| | 1994 | self._GetHeaderInfo()\r |
| | 1995 | if self._Guid == None:\r |
| | 1996 | self._Guid = '00000000-0000-0000-000000000000'\r |
| | 1997 | return self._Guid\r |
| | 1998 | \r |
| | 1999 | ## Retrieve module version\r |
| | 2000 | def _GetVersion(self):\r |
| | 2001 | if self._Version == None:\r |
| | 2002 | if self._Header_ == None:\r |
| | 2003 | self._GetHeaderInfo()\r |
| | 2004 | if self._Version == None:\r |
| | 2005 | self._Version = '0.0'\r |
| | 2006 | return self._Version\r |
| | 2007 | \r |
| | 2008 | ## Retrieve PCD_IS_DRIVER\r |
| | 2009 | def _GetPcdIsDriver(self):\r |
| | 2010 | if self._PcdIsDriver == None:\r |
| | 2011 | if self._Header_ == None:\r |
| | 2012 | self._GetHeaderInfo()\r |
| | 2013 | if self._PcdIsDriver == None:\r |
| | 2014 | self._PcdIsDriver = ''\r |
| | 2015 | return self._PcdIsDriver\r |
| | 2016 | \r |
| | 2017 | ## Retrieve SHADOW\r |
| | 2018 | def _GetShadow(self):\r |
| | 2019 | if self._Shadow == None:\r |
| | 2020 | if self._Header_ == None:\r |
| | 2021 | self._GetHeaderInfo()\r |
| | 2022 | if self._Shadow != None and self._Shadow.upper() == 'TRUE':\r |
| | 2023 | self._Shadow = True\r |
| | 2024 | else:\r |
| | 2025 | self._Shadow = False\r |
| | 2026 | return self._Shadow\r |
| | 2027 | \r |
| | 2028 | ## Retrieve CUSTOM_MAKEFILE\r |
| | 2029 | def _GetMakefile(self):\r |
| | 2030 | if self._CustomMakefile == None:\r |
| | 2031 | if self._Header_ == None:\r |
| | 2032 | self._GetHeaderInfo()\r |
| | 2033 | if self._CustomMakefile == None:\r |
| | 2034 | self._CustomMakefile = {}\r |
| | 2035 | return self._CustomMakefile\r |
| | 2036 | \r |
| | 2037 | ## Retrieve EFI_SPECIFICATION_VERSION\r |
| | 2038 | def _GetSpec(self):\r |
| | 2039 | if self._Specification == None:\r |
| | 2040 | if self._Header_ == None:\r |
| | 2041 | self._GetHeaderInfo()\r |
| | 2042 | if self._Specification == None:\r |
| | 2043 | self._Specification = {}\r |
| | 2044 | return self._Specification\r |
| | 2045 | \r |
| | 2046 | ## Retrieve LIBRARY_CLASS\r |
| | 2047 | def _GetLibraryClass(self):\r |
| | 2048 | if self._LibraryClass == None:\r |
| | 2049 | if self._Header_ == None:\r |
| | 2050 | self._GetHeaderInfo()\r |
| | 2051 | if self._LibraryClass == None:\r |
| | 2052 | self._LibraryClass = []\r |
| | 2053 | return self._LibraryClass\r |
| | 2054 | \r |
| | 2055 | ## Retrieve ENTRY_POINT\r |
| | 2056 | def _GetEntryPoint(self):\r |
| | 2057 | if self._ModuleEntryPointList == None:\r |
| | 2058 | if self._Header_ == None:\r |
| | 2059 | self._GetHeaderInfo()\r |
| | 2060 | if self._ModuleEntryPointList == None:\r |
| | 2061 | self._ModuleEntryPointList = []\r |
| | 2062 | return self._ModuleEntryPointList\r |
| | 2063 | \r |
| | 2064 | ## Retrieve UNLOAD_IMAGE\r |
| | 2065 | def _GetUnloadImage(self):\r |
| | 2066 | if self._ModuleUnloadImageList == None:\r |
| | 2067 | if self._Header_ == None:\r |
| | 2068 | self._GetHeaderInfo()\r |
| | 2069 | if self._ModuleUnloadImageList == None:\r |
| | 2070 | self._ModuleUnloadImageList = []\r |
| | 2071 | return self._ModuleUnloadImageList\r |
| | 2072 | \r |
| | 2073 | ## Retrieve CONSTRUCTOR\r |
| | 2074 | def _GetConstructor(self):\r |
| | 2075 | if self._ConstructorList == None:\r |
| | 2076 | if self._Header_ == None:\r |
| | 2077 | self._GetHeaderInfo()\r |
| | 2078 | if self._ConstructorList == None:\r |
| | 2079 | self._ConstructorList = []\r |
| | 2080 | return self._ConstructorList\r |
| | 2081 | \r |
| | 2082 | ## Retrieve DESTRUCTOR\r |
| | 2083 | def _GetDestructor(self):\r |
| | 2084 | if self._DestructorList == None:\r |
| | 2085 | if self._Header_ == None:\r |
| | 2086 | self._GetHeaderInfo()\r |
| | 2087 | if self._DestructorList == None:\r |
| | 2088 | self._DestructorList = []\r |
| | 2089 | return self._DestructorList\r |
| | 2090 | \r |
| | 2091 | ## Retrieve definies other than above ones\r |
| | 2092 | def _GetDefines(self):\r |
| | 2093 | if self._Defs == None:\r |
| | 2094 | if self._Header_ == None:\r |
| | 2095 | self._GetHeaderInfo()\r |
| | 2096 | if self._Defs == None:\r |
| | 2097 | self._Defs = sdict()\r |
| | 2098 | return self._Defs\r |
| | 2099 | \r |
| | 2100 | ## Retrieve binary files\r |
| | 2101 | def _GetBinaries(self):\r |
| | 2102 | if self._Binaries == None:\r |
| | 2103 | self._Binaries = []\r |
| | 2104 | RecordList = self._RawData[MODEL_EFI_BINARY_FILE, self._Arch, self._Platform]\r |
| | 2105 | Macros = self._Macros\r |
| | 2106 | Macros["EDK_SOURCE"] = GlobalData.gEcpSource\r |
| | 2107 | Macros['PROCESSOR'] = self._Arch\r |
| | 2108 | for Record in RecordList:\r |
| | 2109 | FileType = Record[0]\r |
| | 2110 | LineNo = Record[-1]\r |
| | 2111 | Target = 'COMMON'\r |
| | 2112 | FeatureFlag = []\r |
| | 2113 | if Record[2]:\r |
| | 2114 | TokenList = GetSplitValueList(Record[2], TAB_VALUE_SPLIT)\r |
| | 2115 | if TokenList:\r |
| | 2116 | Target = TokenList[0]\r |
| | 2117 | if len(TokenList) > 1:\r |
| | 2118 | FeatureFlag = Record[1:]\r |
| | 2119 | \r |
| | 2120 | File = PathClass(NormPath(Record[1], Macros), self._ModuleDir, '', FileType, True, self._Arch, '', Target)\r |
| | 2121 | # check the file validation\r |
| | 2122 | ErrorCode, ErrorInfo = File.Validate()\r |
| | 2123 | if ErrorCode != 0:\r |
| | 2124 | EdkLogger.error('build', ErrorCode, ExtraData=ErrorInfo, File=self.MetaFile, Line=LineNo)\r |
| | 2125 | self._Binaries.append(File)\r |
| | 2126 | return self._Binaries\r |
| | 2127 | \r |
| | 2128 | ## Retrieve binary files with error check.\r |
| | 2129 | def _GetBinaryFiles(self):\r |
| | 2130 | Binaries = self._GetBinaries()\r |
| | 2131 | if GlobalData.gIgnoreSource and Binaries == []:\r |
| | 2132 | ErrorInfo = "The INF file does not contain any Binaries to use in creating the image\n"\r |
| | 2133 | EdkLogger.error('build', RESOURCE_NOT_AVAILABLE, ExtraData=ErrorInfo, File=self.MetaFile)\r |
| | 2134 | \r |
| | 2135 | return Binaries\r |
| | 2136 | ## Check whether it exists the binaries with current ARCH in AsBuild INF\r |
| | 2137 | def _IsSupportedArch(self):\r |
| | 2138 | if self._GetBinaries() and not self._GetSourceFiles():\r |
| | 2139 | return True\r |
| | 2140 | else:\r |
| | 2141 | return False\r |
| | 2142 | ## Retrieve source files\r |
| | 2143 | def _GetSourceFiles(self):\r |
| | 2144 | #Ignore all source files in a binary build mode\r |
| | 2145 | if GlobalData.gIgnoreSource:\r |
| | 2146 | self._Sources = []\r |
| | 2147 | return self._Sources\r |
| | 2148 | \r |
| | 2149 | if self._Sources == None:\r |
| | 2150 | self._Sources = []\r |
| | 2151 | RecordList = self._RawData[MODEL_EFI_SOURCE_FILE, self._Arch, self._Platform]\r |
| | 2152 | Macros = self._Macros\r |
| | 2153 | for Record in RecordList:\r |
| | 2154 | LineNo = Record[-1]\r |
| | 2155 | ToolChainFamily = Record[1]\r |
| | 2156 | TagName = Record[2]\r |
| | 2157 | ToolCode = Record[3]\r |
| | 2158 | FeatureFlag = Record[4]\r |
| | 2159 | if self.AutoGenVersion < 0x00010005:\r |
| | 2160 | Macros["EDK_SOURCE"] = GlobalData.gEcpSource\r |
| | 2161 | Macros['PROCESSOR'] = self._Arch\r |
| | 2162 | # old module source files (Edk)\r |
| | 2163 | File = PathClass(NormPath(Record[0], Macros), self._ModuleDir, self._SourceOverridePath,\r |
| | 2164 | '', False, self._Arch, ToolChainFamily, '', TagName, ToolCode)\r |
| | 2165 | # check the file validation\r |
| | 2166 | ErrorCode, ErrorInfo = File.Validate(CaseSensitive=False)\r |
| | 2167 | if ErrorCode != 0:\r |
| | 2168 | if File.Ext.lower() == '.h':\r |
| | 2169 | EdkLogger.warn('build', 'Include file not found', ExtraData=ErrorInfo,\r |
| | 2170 | File=self.MetaFile, Line=LineNo)\r |
| | 2171 | continue\r |
| | 2172 | else:\r |
| | 2173 | EdkLogger.error('build', ErrorCode, ExtraData=File, File=self.MetaFile, Line=LineNo)\r |
| | 2174 | else:\r |
| | 2175 | File = PathClass(NormPath(Record[0], Macros), self._ModuleDir, '',\r |
| | 2176 | '', False, self._Arch, ToolChainFamily, '', TagName, ToolCode)\r |
| | 2177 | # check the file validation\r |
| | 2178 | ErrorCode, ErrorInfo = File.Validate()\r |
| | 2179 | if ErrorCode != 0:\r |
| | 2180 | EdkLogger.error('build', ErrorCode, ExtraData=ErrorInfo, File=self.MetaFile, Line=LineNo)\r |
| | 2181 | \r |
| | 2182 | self._Sources.append(File)\r |
| | 2183 | return self._Sources\r |
| | 2184 | \r |
| | 2185 | ## Retrieve library classes employed by this module\r |
| | 2186 | def _GetLibraryClassUses(self):\r |
| | 2187 | if self._LibraryClasses == None:\r |
| | 2188 | self._LibraryClasses = sdict()\r |
| | 2189 | RecordList = self._RawData[MODEL_EFI_LIBRARY_CLASS, self._Arch, self._Platform]\r |
| | 2190 | for Record in RecordList:\r |
| | 2191 | Lib = Record[0]\r |
| | 2192 | Instance = Record[1]\r |
| | 2193 | if Instance:\r |
| | 2194 | Instance = NormPath(Instance, self._Macros)\r |
| | 2195 | self._LibraryClasses[Lib] = Instance\r |
| | 2196 | return self._LibraryClasses\r |
| | 2197 | \r |
| | 2198 | ## Retrieve library names (for Edk.x style of modules)\r |
| | 2199 | def _GetLibraryNames(self):\r |
| | 2200 | if self._Libraries == None:\r |
| | 2201 | self._Libraries = []\r |
| | 2202 | RecordList = self._RawData[MODEL_EFI_LIBRARY_INSTANCE, self._Arch, self._Platform]\r |
| | 2203 | for Record in RecordList:\r |
| | 2204 | LibraryName = ReplaceMacro(Record[0], self._Macros, False)\r |
| | 2205 | # in case of name with '.lib' extension, which is unusual in Edk.x inf\r |
| | 2206 | LibraryName = os.path.splitext(LibraryName)[0]\r |
| | 2207 | if LibraryName not in self._Libraries:\r |
| | 2208 | self._Libraries.append(LibraryName)\r |
| | 2209 | return self._Libraries\r |
| | 2210 | \r |
| | 2211 | def _GetProtocolComments(self):\r |
| | 2212 | self._GetProtocols()\r |
| | 2213 | return self._ProtocolComments\r |
| | 2214 | ## Retrieve protocols consumed/produced by this module\r |
| | 2215 | def _GetProtocols(self):\r |
| | 2216 | if self._Protocols == None:\r |
| | 2217 | self._Protocols = sdict()\r |
| | 2218 | self._ProtocolComments = sdict()\r |
| | 2219 | RecordList = self._RawData[MODEL_EFI_PROTOCOL, self._Arch, self._Platform]\r |
| | 2220 | for Record in RecordList:\r |
| | 2221 | CName = Record[0]\r |
| | 2222 | Value = ProtocolValue(CName, self.Packages)\r |
| | 2223 | if Value == None:\r |
| | 2224 | PackageList = "\n\t".join([str(P) for P in self.Packages])\r |
| | 2225 | EdkLogger.error('build', RESOURCE_NOT_AVAILABLE,\r |
| | 2226 | "Value of Protocol [%s] is not found under [Protocols] section in" % CName,\r |
| | 2227 | ExtraData=PackageList, File=self.MetaFile, Line=Record[-1])\r |
| | 2228 | self._Protocols[CName] = Value\r |
| | 2229 | CommentRecords = self._RawData[MODEL_META_DATA_COMMENT, self._Arch, self._Platform, Record[5]]\r |
| | 2230 | Comments = []\r |
| | 2231 | for CmtRec in CommentRecords:\r |
| | 2232 | Comments.append(CmtRec[0])\r |
| | 2233 | self._ProtocolComments[CName] = Comments\r |
| | 2234 | return self._Protocols\r |
| | 2235 | \r |
| | 2236 | def _GetPpiComments(self):\r |
| | 2237 | self._GetPpis()\r |
| | 2238 | return self._PpiComments\r |
| | 2239 | ## Retrieve PPIs consumed/produced by this module\r |
| | 2240 | def _GetPpis(self):\r |
| | 2241 | if self._Ppis == None:\r |
| | 2242 | self._Ppis = sdict()\r |
| | 2243 | self._PpiComments = sdict()\r |
| | 2244 | RecordList = self._RawData[MODEL_EFI_PPI, self._Arch, self._Platform]\r |
| | 2245 | for Record in RecordList:\r |
| | 2246 | CName = Record[0]\r |
| | 2247 | Value = PpiValue(CName, self.Packages)\r |
| | 2248 | if Value == None:\r |
| | 2249 | PackageList = "\n\t".join([str(P) for P in self.Packages])\r |
| | 2250 | EdkLogger.error('build', RESOURCE_NOT_AVAILABLE,\r |
| | 2251 | "Value of PPI [%s] is not found under [Ppis] section in " % CName,\r |
| | 2252 | ExtraData=PackageList, File=self.MetaFile, Line=Record[-1])\r |
| | 2253 | self._Ppis[CName] = Value\r |
| | 2254 | CommentRecords = self._RawData[MODEL_META_DATA_COMMENT, self._Arch, self._Platform, Record[5]]\r |
| | 2255 | Comments = []\r |
| | 2256 | for CmtRec in CommentRecords:\r |
| | 2257 | Comments.append(CmtRec[0])\r |
| | 2258 | self._PpiComments[CName] = Comments\r |
| | 2259 | return self._Ppis\r |
| | 2260 | \r |
| | 2261 | def _GetGuidComments(self):\r |
| | 2262 | self._GetGuids()\r |
| | 2263 | return self._GuidComments\r |
| | 2264 | ## Retrieve GUIDs consumed/produced by this module\r |
| | 2265 | def _GetGuids(self):\r |
| | 2266 | if self._Guids == None:\r |
| | 2267 | self._Guids = sdict()\r |
| | 2268 | self._GuidComments = sdict()\r |
| | 2269 | RecordList = self._RawData[MODEL_EFI_GUID, self._Arch, self._Platform]\r |
| | 2270 | for Record in RecordList:\r |
| | 2271 | CName = Record[0]\r |
| | 2272 | Value = GuidValue(CName, self.Packages)\r |
| | 2273 | if Value == None:\r |
| | 2274 | PackageList = "\n\t".join([str(P) for P in self.Packages])\r |
| | 2275 | EdkLogger.error('build', RESOURCE_NOT_AVAILABLE,\r |
| | 2276 | "Value of Guid [%s] is not found under [Guids] section in" % CName,\r |
| | 2277 | ExtraData=PackageList, File=self.MetaFile, Line=Record[-1])\r |
| | 2278 | self._Guids[CName] = Value\r |
| | 2279 | CommentRecords = self._RawData[MODEL_META_DATA_COMMENT, self._Arch, self._Platform, Record[5]]\r |
| | 2280 | Comments = []\r |
| | 2281 | for CmtRec in CommentRecords:\r |
| | 2282 | Comments.append(CmtRec[0])\r |
| | 2283 | self._GuidComments[CName] = Comments\r |
| | 2284 | return self._Guids\r |
| | 2285 | \r |
| | 2286 | ## Retrieve include paths necessary for this module (for Edk.x style of modules)\r |
| | 2287 | def _GetIncludes(self):\r |
| | 2288 | if self._Includes == None:\r |
| | 2289 | self._Includes = []\r |
| | 2290 | if self._SourceOverridePath:\r |
| | 2291 | self._Includes.append(self._SourceOverridePath)\r |
| | 2292 | \r |
| | 2293 | Macros = self._Macros\r |
| | 2294 | if 'PROCESSOR' in GlobalData.gEdkGlobal.keys():\r |
| | 2295 | Macros['PROCESSOR'] = GlobalData.gEdkGlobal['PROCESSOR']\r |
| | 2296 | else:\r |
| | 2297 | Macros['PROCESSOR'] = self._Arch\r |
| | 2298 | RecordList = self._RawData[MODEL_EFI_INCLUDE, self._Arch, self._Platform]\r |
| | 2299 | for Record in RecordList:\r |
| | 2300 | if Record[0].find('EDK_SOURCE') > -1:\r |
| | 2301 | Macros['EDK_SOURCE'] = GlobalData.gEcpSource\r |
| | 2302 | File = NormPath(Record[0], self._Macros)\r |
| | 2303 | if File[0] == '.':\r |
| | 2304 | File = os.path.join(self._ModuleDir, File)\r |
| | 2305 | else:\r |
| | 2306 | File = os.path.join(GlobalData.gWorkspace, File)\r |
| | 2307 | File = RealPath(os.path.normpath(File))\r |
| | 2308 | if File:\r |
| | 2309 | self._Includes.append(File)\r |
| | 2310 | \r |
| | 2311 | #TRICK: let compiler to choose correct header file\r |
| | 2312 | Macros['EDK_SOURCE'] = GlobalData.gEdkSource\r |
| | 2313 | File = NormPath(Record[0], self._Macros)\r |
| | 2314 | if File[0] == '.':\r |
| | 2315 | File = os.path.join(self._ModuleDir, File)\r |
| | 2316 | else:\r |
| | 2317 | File = os.path.join(GlobalData.gWorkspace, File)\r |
| | 2318 | File = RealPath(os.path.normpath(File))\r |
| | 2319 | if File:\r |
| | 2320 | self._Includes.append(File)\r |
| | 2321 | else:\r |
| | 2322 | File = NormPath(Record[0], Macros)\r |
| | 2323 | if File[0] == '.':\r |
| | 2324 | File = os.path.join(self._ModuleDir, File)\r |
| | 2325 | else:\r |
| | 2326 | File = os.path.join(GlobalData.gWorkspace, File)\r |
| | 2327 | File = RealPath(os.path.normpath(File))\r |
| | 2328 | if File:\r |
| | 2329 | self._Includes.append(File)\r |
| | 2330 | return self._Includes\r |
| | 2331 | \r |
| | 2332 | ## Retrieve packages this module depends on\r |
| | 2333 | def _GetPackages(self):\r |
| | 2334 | if self._Packages == None:\r |
| | 2335 | self._Packages = []\r |
| | 2336 | RecordList = self._RawData[MODEL_META_DATA_PACKAGE, self._Arch, self._Platform]\r |
| | 2337 | Macros = self._Macros\r |
| | 2338 | Macros['EDK_SOURCE'] = GlobalData.gEcpSource\r |
| | 2339 | for Record in RecordList:\r |
| | 2340 | File = PathClass(NormPath(Record[0], Macros), GlobalData.gWorkspace, Arch=self._Arch)\r |
| | 2341 | LineNo = Record[-1]\r |
| | 2342 | # check the file validation\r |
| | 2343 | ErrorCode, ErrorInfo = File.Validate('.dec')\r |
| | 2344 | if ErrorCode != 0:\r |
| | 2345 | EdkLogger.error('build', ErrorCode, ExtraData=ErrorInfo, File=self.MetaFile, Line=LineNo)\r |
| | 2346 | # parse this package now. we need it to get protocol/ppi/guid value\r |
| | 2347 | Package = self._Bdb[File, self._Arch, self._Target, self._Toolchain]\r |
| | 2348 | self._Packages.append(Package)\r |
| | 2349 | return self._Packages\r |
| | 2350 | \r |
| | 2351 | ## Retrieve PCD comments\r |
| | 2352 | def _GetPcdComments(self):\r |
| | 2353 | self._GetPcds()\r |
| | 2354 | return self._PcdComments\r |
| | 2355 | ## Retrieve PCDs used in this module\r |
| | 2356 | def _GetPcds(self):\r |
| | 2357 | if self._Pcds == None:\r |
| | 2358 | self._Pcds = sdict()\r |
| | 2359 | self._PcdComments = sdict()\r |
| | 2360 | self._Pcds.update(self._GetPcd(MODEL_PCD_FIXED_AT_BUILD))\r |
| | 2361 | self._Pcds.update(self._GetPcd(MODEL_PCD_PATCHABLE_IN_MODULE))\r |
| | 2362 | self._Pcds.update(self._GetPcd(MODEL_PCD_FEATURE_FLAG))\r |
| | 2363 | self._Pcds.update(self._GetPcd(MODEL_PCD_DYNAMIC))\r |
| | 2364 | self._Pcds.update(self._GetPcd(MODEL_PCD_DYNAMIC_EX))\r |
| | 2365 | return self._Pcds\r |
| | 2366 | \r |
| | 2367 | ## Retrieve build options specific to this module\r |
| | 2368 | def _GetBuildOptions(self):\r |
| | 2369 | if self._BuildOptions == None:\r |
| | 2370 | self._BuildOptions = sdict()\r |
| | 2371 | RecordList = self._RawData[MODEL_META_DATA_BUILD_OPTION, self._Arch, self._Platform]\r |
| | 2372 | for Record in RecordList:\r |
| | 2373 | ToolChainFamily = Record[0]\r |
| | 2374 | ToolChain = Record[1]\r |
| | 2375 | Option = Record[2]\r |
| | 2376 | if (ToolChainFamily, ToolChain) not in self._BuildOptions:\r |
| | 2377 | self._BuildOptions[ToolChainFamily, ToolChain] = Option\r |
| | 2378 | else:\r |
| | 2379 | # concatenate the option string if they're for the same tool\r |
| | 2380 | OptionString = self._BuildOptions[ToolChainFamily, ToolChain]\r |
| | 2381 | self._BuildOptions[ToolChainFamily, ToolChain] = OptionString + " " + Option\r |
| | 2382 | return self._BuildOptions\r |
| | 2383 | \r |
| | 2384 | ## Retrieve dependency expression\r |
| | 2385 | def _GetDepex(self):\r |
| | 2386 | if self._Depex == None:\r |
| | 2387 | self._Depex = tdict(False, 2)\r |
| | 2388 | RecordList = self._RawData[MODEL_EFI_DEPEX, self._Arch]\r |
| | 2389 | \r |
| | 2390 | # If the module has only Binaries and no Sources, then ignore [Depex] \r |
| | 2391 | if self.Sources == None or self.Sources == []:\r |
| | 2392 | if self.Binaries != None and self.Binaries != []:\r |
| | 2393 | return self._Depex\r |
| | 2394 | \r |
| | 2395 | # PEIM and DXE drivers must have a valid [Depex] section\r |
| | 2396 | if len(self.LibraryClass) == 0 and len(RecordList) == 0:\r |
| | 2397 | if self.ModuleType == 'DXE_DRIVER' or self.ModuleType == 'PEIM' or self.ModuleType == 'DXE_SMM_DRIVER' or \\r |
| | 2398 | self.ModuleType == 'DXE_SAL_DRIVER' or self.ModuleType == 'DXE_RUNTIME_DRIVER':\r |
| | 2399 | EdkLogger.error('build', RESOURCE_NOT_AVAILABLE, "No [Depex] section or no valid expression in [Depex] section for [%s] module" \\r |
| | 2400 | % self.ModuleType, File=self.MetaFile)\r |
| | 2401 | \r |
| | 2402 | if len(RecordList) != 0 and self.ModuleType == 'USER_DEFINED':\r |
| | 2403 | for Record in RecordList:\r |
| | 2404 | if Record[4] not in ['PEIM', 'DXE_DRIVER', 'DXE_SMM_DRIVER']:\r |
| | 2405 | EdkLogger.error('build', FORMAT_INVALID,\r |
| | 2406 | "'%s' module must specify the type of [Depex] section" % self.ModuleType,\r |
| | 2407 | File=self.MetaFile)\r |
| | 2408 | \r |
| | 2409 | Depex = sdict()\r |
| | 2410 | for Record in RecordList:\r |
| | 2411 | DepexStr = ReplaceMacro(Record[0], self._Macros, False)\r |
| | 2412 | Arch = Record[3]\r |
| | 2413 | ModuleType = Record[4]\r |
| | 2414 | TokenList = DepexStr.split()\r |
| | 2415 | if (Arch, ModuleType) not in Depex:\r |
| | 2416 | Depex[Arch, ModuleType] = []\r |
| | 2417 | DepexList = Depex[Arch, ModuleType]\r |
| | 2418 | for Token in TokenList:\r |
| | 2419 | if Token in DEPEX_SUPPORTED_OPCODE:\r |
| | 2420 | DepexList.append(Token)\r |
| | 2421 | elif Token.endswith(".inf"): # module file name\r |
| | 2422 | ModuleFile = os.path.normpath(Token)\r |
| | 2423 | Module = self.BuildDatabase[ModuleFile]\r |
| | 2424 | if Module == None:\r |
| | 2425 | EdkLogger.error('build', RESOURCE_NOT_AVAILABLE, "Module is not found in active platform",\r |
| | 2426 | ExtraData=Token, File=self.MetaFile, Line=Record[-1])\r |
| | 2427 | DepexList.append(Module.Guid)\r |
| | 2428 | else:\r |
| | 2429 | # get the GUID value now\r |
| | 2430 | Value = ProtocolValue(Token, self.Packages)\r |
| | 2431 | if Value == None:\r |
| | 2432 | Value = PpiValue(Token, self.Packages)\r |
| | 2433 | if Value == None:\r |
| | 2434 | Value = GuidValue(Token, self.Packages)\r |
| | 2435 | if Value == None:\r |
| | 2436 | PackageList = "\n\t".join([str(P) for P in self.Packages])\r |
| | 2437 | EdkLogger.error('build', RESOURCE_NOT_AVAILABLE,\r |
| | 2438 | "Value of [%s] is not found in" % Token,\r |
| | 2439 | ExtraData=PackageList, File=self.MetaFile, Line=Record[-1])\r |
| | 2440 | DepexList.append(Value)\r |
| | 2441 | for Arch, ModuleType in Depex:\r |
| | 2442 | self._Depex[Arch, ModuleType] = Depex[Arch, ModuleType]\r |
| | 2443 | return self._Depex\r |
| | 2444 | \r |
| | 2445 | ## Retrieve depedency expression\r |
| | 2446 | def _GetDepexExpression(self):\r |
| | 2447 | if self._DepexExpression == None:\r |
| | 2448 | self._DepexExpression = tdict(False, 2)\r |
| | 2449 | RecordList = self._RawData[MODEL_EFI_DEPEX, self._Arch]\r |
| | 2450 | DepexExpression = sdict()\r |
| | 2451 | for Record in RecordList:\r |
| | 2452 | DepexStr = ReplaceMacro(Record[0], self._Macros, False)\r |
| | 2453 | Arch = Record[3]\r |
| | 2454 | ModuleType = Record[4]\r |
| | 2455 | TokenList = DepexStr.split()\r |
| | 2456 | if (Arch, ModuleType) not in DepexExpression:\r |
| | 2457 | DepexExpression[Arch, ModuleType] = ''\r |
| | 2458 | for Token in TokenList:\r |
| | 2459 | DepexExpression[Arch, ModuleType] = DepexExpression[Arch, ModuleType] + Token.strip() + ' '\r |
| | 2460 | for Arch, ModuleType in DepexExpression:\r |
| | 2461 | self._DepexExpression[Arch, ModuleType] = DepexExpression[Arch, ModuleType]\r |
| | 2462 | return self._DepexExpression\r |
| | 2463 | \r |
| | 2464 | def GetGuidsUsedByPcd(self):\r |
| | 2465 | return self._GuidsUsedByPcd\r |
| | 2466 | ## Retrieve PCD for given type\r |
| | 2467 | def _GetPcd(self, Type):\r |
| | 2468 | Pcds = sdict()\r |
| | 2469 | PcdDict = tdict(True, 4)\r |
| | 2470 | PcdList = []\r |
| | 2471 | RecordList = self._RawData[Type, self._Arch, self._Platform]\r |
| | 2472 | for TokenSpaceGuid, PcdCName, Setting, Arch, Platform, Id, LineNo in RecordList:\r |
| | 2473 | PcdDict[Arch, Platform, PcdCName, TokenSpaceGuid] = (Setting, LineNo)\r |
| | 2474 | PcdList.append((PcdCName, TokenSpaceGuid))\r |
| | 2475 | # get the guid value\r |
| | 2476 | if TokenSpaceGuid not in self.Guids:\r |
| | 2477 | Value = GuidValue(TokenSpaceGuid, self.Packages)\r |
| | 2478 | if Value == None:\r |
| | 2479 | PackageList = "\n\t".join([str(P) for P in self.Packages])\r |
| | 2480 | EdkLogger.error('build', RESOURCE_NOT_AVAILABLE,\r |
| | 2481 | "Value of Guid [%s] is not found under [Guids] section in" % TokenSpaceGuid,\r |
| | 2482 | ExtraData=PackageList, File=self.MetaFile, Line=LineNo)\r |
| | 2483 | self.Guids[TokenSpaceGuid] = Value\r |
| | 2484 | self._GuidsUsedByPcd[TokenSpaceGuid] = Value\r |
| | 2485 | CommentRecords = self._RawData[MODEL_META_DATA_COMMENT, self._Arch, self._Platform, Id]\r |
| | 2486 | Comments = []\r |
| | 2487 | for CmtRec in CommentRecords:\r |
| | 2488 | Comments.append(CmtRec[0])\r |
| | 2489 | self._PcdComments[TokenSpaceGuid, PcdCName] = Comments\r |
| | 2490 | \r |
| | 2491 | # resolve PCD type, value, datum info, etc. by getting its definition from package\r |
| | 2492 | for PcdCName, TokenSpaceGuid in PcdList:\r |
| | 2493 | Setting, LineNo = PcdDict[self._Arch, self.Platform, PcdCName, TokenSpaceGuid]\r |
| | 2494 | if Setting == None:\r |
| | 2495 | continue\r |
| | 2496 | ValueList = AnalyzePcdData(Setting)\r |
| | 2497 | DefaultValue = ValueList[0]\r |
| | 2498 | Pcd = PcdClassObject(\r |
| | 2499 | PcdCName,\r |
| | 2500 | TokenSpaceGuid,\r |
| | 2501 | '',\r |
| | 2502 | '',\r |
| | 2503 | DefaultValue,\r |
| | 2504 | '',\r |
| | 2505 | '',\r |
| | 2506 | {},\r |
| | 2507 | False,\r |
| | 2508 | self.Guids[TokenSpaceGuid]\r |
| | 2509 | )\r |
| | 2510 | if Type == MODEL_PCD_PATCHABLE_IN_MODULE and ValueList[1]:\r |
| | 2511 | # Patch PCD: TokenSpace.PcdCName|Value|Offset\r |
| | 2512 | Pcd.Offset = ValueList[1]\r |
| | 2513 | \r |
| | 2514 | # get necessary info from package declaring this PCD\r |
| | 2515 | for Package in self.Packages:\r |
| | 2516 | #\r |
| | 2517 | # 'dynamic' in INF means its type is determined by platform;\r |
| | 2518 | # if platform doesn't give its type, use 'lowest' one in the\r |
| | 2519 | # following order, if any\r |
| | 2520 | #\r |
| | 2521 | # "FixedAtBuild", "PatchableInModule", "FeatureFlag", "Dynamic", "DynamicEx"\r |
| | 2522 | #\r |
| | 2523 | PcdType = self._PCD_TYPE_STRING_[Type]\r |
| | 2524 | if Type == MODEL_PCD_DYNAMIC:\r |
| | 2525 | Pcd.Pending = True\r |
| | 2526 | for T in ["FixedAtBuild", "PatchableInModule", "FeatureFlag", "Dynamic", "DynamicEx"]:\r |
| | 2527 | if (PcdCName, TokenSpaceGuid, T) in Package.Pcds:\r |
| | 2528 | PcdType = T\r |
| | 2529 | break\r |
| | 2530 | else:\r |
| | 2531 | Pcd.Pending = False\r |
| | 2532 | \r |
| | 2533 | if (PcdCName, TokenSpaceGuid, PcdType) in Package.Pcds:\r |
| | 2534 | PcdInPackage = Package.Pcds[PcdCName, TokenSpaceGuid, PcdType]\r |
| | 2535 | Pcd.Type = PcdType\r |
| | 2536 | Pcd.TokenValue = PcdInPackage.TokenValue\r |
| | 2537 | \r |
| | 2538 | #\r |
| | 2539 | # Check whether the token value exist or not.\r |
| | 2540 | #\r |
| | 2541 | if Pcd.TokenValue == None or Pcd.TokenValue == "":\r |
| | 2542 | EdkLogger.error(\r |
| | 2543 | 'build',\r |
| | 2544 | FORMAT_INVALID,\r |
| | 2545 | "No TokenValue for PCD [%s.%s] in [%s]!" % (TokenSpaceGuid, PcdCName, str(Package)),\r |
| | 2546 | File =self.MetaFile, Line=LineNo,\r |
| | 2547 | ExtraData=None\r |
| | 2548 | ) \r |
| | 2549 | #\r |
| | 2550 | # Check hexadecimal token value length and format.\r |
| | 2551 | #\r |
| | 2552 | ReIsValidPcdTokenValue = re.compile(r"^[0][x|X][0]*[0-9a-fA-F]{1,8}$", re.DOTALL)\r |
| | 2553 | if Pcd.TokenValue.startswith("0x") or Pcd.TokenValue.startswith("0X"):\r |
| | 2554 | if ReIsValidPcdTokenValue.match(Pcd.TokenValue) == None:\r |
| | 2555 | EdkLogger.error(\r |
| | 2556 | 'build',\r |
| | 2557 | FORMAT_INVALID,\r |
| | 2558 | "The format of TokenValue [%s] of PCD [%s.%s] in [%s] is invalid:" % (Pcd.TokenValue, TokenSpaceGuid, PcdCName, str(Package)),\r |
| | 2559 | File =self.MetaFile, Line=LineNo,\r |
| | 2560 | ExtraData=None\r |
| | 2561 | )\r |
| | 2562 | \r |
| | 2563 | #\r |
| | 2564 | # Check decimal token value length and format.\r |
| | 2565 | # \r |
| | 2566 | else:\r |
| | 2567 | try:\r |
| | 2568 | TokenValueInt = int (Pcd.TokenValue, 10)\r |
| | 2569 | if (TokenValueInt < 0 or TokenValueInt > 4294967295):\r |
| | 2570 | EdkLogger.error(\r |
| | 2571 | 'build',\r |
| | 2572 | FORMAT_INVALID,\r |
| | 2573 | "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 |
| | 2574 | File =self.MetaFile, Line=LineNo,\r |
| | 2575 | ExtraData=None\r |
| | 2576 | ) \r |
| | 2577 | except:\r |
| | 2578 | EdkLogger.error(\r |
| | 2579 | 'build',\r |
| | 2580 | FORMAT_INVALID,\r |
| | 2581 | "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 |
| | 2582 | File =self.MetaFile, Line=LineNo,\r |
| | 2583 | ExtraData=None\r |
| | 2584 | )\r |
| | 2585 | \r |
| | 2586 | Pcd.DatumType = PcdInPackage.DatumType\r |
| | 2587 | Pcd.MaxDatumSize = PcdInPackage.MaxDatumSize\r |
| | 2588 | Pcd.InfDefaultValue = Pcd.DefaultValue\r |
| | 2589 | if Pcd.DefaultValue in [None, '']:\r |
| | 2590 | Pcd.DefaultValue = PcdInPackage.DefaultValue\r |
| | 2591 | break\r |
| | 2592 | else:\r |
| | 2593 | EdkLogger.error(\r |
| | 2594 | 'build',\r |
| | 2595 | FORMAT_INVALID,\r |
| | 2596 | "PCD [%s.%s] in [%s] is not found in dependent packages:" % (TokenSpaceGuid, PcdCName, self.MetaFile),\r |
| | 2597 | File =self.MetaFile, Line=LineNo,\r |
| | 2598 | ExtraData="\t%s" % '\n\t'.join([str(P) for P in self.Packages])\r |
| | 2599 | )\r |
| | 2600 | Pcds[PcdCName, TokenSpaceGuid] = Pcd\r |
| | 2601 | \r |
| | 2602 | return Pcds\r |
| | 2603 | \r |
| | 2604 | ## check whether current module is binary module\r |
| | 2605 | def _IsBinaryModule(self):\r |
| | 2606 | if self.Binaries and not self.Sources:\r |
| | 2607 | return True\r |
| | 2608 | elif GlobalData.gIgnoreSource:\r |
| | 2609 | return True\r |
| | 2610 | else:\r |
| | 2611 | return False\r |
| | 2612 | \r |
| | 2613 | _Macros = property(_GetMacros)\r |
| | 2614 | Arch = property(_GetArch, _SetArch)\r |
| | 2615 | Platform = property(_GetPlatform, _SetPlatform)\r |
| | 2616 | \r |
| | 2617 | HeaderComments = property(_GetHeaderComments)\r |
| | 2618 | TailComments = property(_GetTailComments)\r |
| | 2619 | AutoGenVersion = property(_GetInfVersion)\r |
| | 2620 | BaseName = property(_GetBaseName)\r |
| | 2621 | ModuleType = property(_GetModuleType)\r |
| | 2622 | ComponentType = property(_GetComponentType)\r |
| | 2623 | BuildType = property(_GetBuildType)\r |
| | 2624 | Guid = property(_GetFileGuid)\r |
| | 2625 | Version = property(_GetVersion)\r |
| | 2626 | PcdIsDriver = property(_GetPcdIsDriver)\r |
| | 2627 | Shadow = property(_GetShadow)\r |
| | 2628 | CustomMakefile = property(_GetMakefile)\r |
| | 2629 | Specification = property(_GetSpec)\r |
| | 2630 | LibraryClass = property(_GetLibraryClass)\r |
| | 2631 | ModuleEntryPointList = property(_GetEntryPoint)\r |
| | 2632 | ModuleUnloadImageList = property(_GetUnloadImage)\r |
| | 2633 | ConstructorList = property(_GetConstructor)\r |
| | 2634 | DestructorList = property(_GetDestructor)\r |
| | 2635 | Defines = property(_GetDefines)\r |
| | 2636 | DxsFile = property(_GetDxsFile)\r |
| | 2637 | \r |
| | 2638 | Binaries = property(_GetBinaryFiles)\r |
| | 2639 | Sources = property(_GetSourceFiles)\r |
| | 2640 | LibraryClasses = property(_GetLibraryClassUses)\r |
| | 2641 | Libraries = property(_GetLibraryNames)\r |
| | 2642 | Protocols = property(_GetProtocols)\r |
| | 2643 | ProtocolComments = property(_GetProtocolComments)\r |
| | 2644 | Ppis = property(_GetPpis)\r |
| | 2645 | PpiComments = property(_GetPpiComments)\r |
| | 2646 | Guids = property(_GetGuids)\r |
| | 2647 | GuidComments = property(_GetGuidComments)\r |
| | 2648 | Includes = property(_GetIncludes)\r |
| | 2649 | Packages = property(_GetPackages)\r |
| | 2650 | Pcds = property(_GetPcds)\r |
| | 2651 | PcdComments = property(_GetPcdComments)\r |
| | 2652 | BuildOptions = property(_GetBuildOptions)\r |
| | 2653 | Depex = property(_GetDepex)\r |
| | 2654 | DepexExpression = property(_GetDepexExpression)\r |
| | 2655 | IsBinaryModule = property(_IsBinaryModule)\r |
| | 2656 | IsSupportedArch = property(_IsSupportedArch)\r |
| | 2657 | \r |
| | 2658 | ## Database\r |
| | 2659 | #\r |
| | 2660 | # This class defined the build database for all modules, packages and platform.\r |
| | 2661 | # It will call corresponding parser for the given file if it cannot find it in\r |
| | 2662 | # the database.\r |
| | 2663 | #\r |
| | 2664 | # @param DbPath Path of database file\r |
| | 2665 | # @param GlobalMacros Global macros used for replacement during file parsing\r |
| | 2666 | # @prarm RenewDb=False Create new database file if it's already there\r |
| | 2667 | #\r |
| | 2668 | class WorkspaceDatabase(object):\r |
| | 2669 | \r |
| | 2670 | \r |
| | 2671 | #\r |
| | 2672 | # internal class used for call corresponding file parser and caching the result\r |
| | 2673 | # to avoid unnecessary re-parsing\r |
| | 2674 | #\r |
| | 2675 | class BuildObjectFactory(object):\r |
| | 2676 | \r |
| | 2677 | _FILE_TYPE_ = {\r |
| | 2678 | ".inf" : MODEL_FILE_INF,\r |
| | 2679 | ".dec" : MODEL_FILE_DEC,\r |
| | 2680 | ".dsc" : MODEL_FILE_DSC,\r |
| | 2681 | }\r |
| | 2682 | \r |
| | 2683 | # file parser\r |
| | 2684 | _FILE_PARSER_ = {\r |
| | 2685 | MODEL_FILE_INF : InfParser,\r |
| | 2686 | MODEL_FILE_DEC : DecParser,\r |
| | 2687 | MODEL_FILE_DSC : DscParser,\r |
| | 2688 | }\r |
| | 2689 | \r |
| | 2690 | # convert to xxxBuildData object\r |
| | 2691 | _GENERATOR_ = {\r |
| | 2692 | MODEL_FILE_INF : InfBuildData,\r |
| | 2693 | MODEL_FILE_DEC : DecBuildData,\r |
| | 2694 | MODEL_FILE_DSC : DscBuildData,\r |
| | 2695 | }\r |
| | 2696 | \r |
| | 2697 | _CACHE_ = {} # (FilePath, Arch) : <object>\r |
| | 2698 | \r |
| | 2699 | # constructor\r |
| | 2700 | def __init__(self, WorkspaceDb):\r |
| | 2701 | self.WorkspaceDb = WorkspaceDb\r |
| | 2702 | \r |
| | 2703 | # key = (FilePath, Arch=None)\r |
| | 2704 | def __contains__(self, Key):\r |
| | 2705 | FilePath = Key[0]\r |
| | 2706 | if len(Key) > 1:\r |
| | 2707 | Arch = Key[1]\r |
| | 2708 | else:\r |
| | 2709 | Arch = None\r |
| | 2710 | return (FilePath, Arch) in self._CACHE_\r |
| | 2711 | \r |
| | 2712 | # key = (FilePath, Arch=None, Target=None, Toochain=None)\r |
| | 2713 | def __getitem__(self, Key):\r |
| | 2714 | FilePath = Key[0]\r |
| | 2715 | KeyLength = len(Key)\r |
| | 2716 | if KeyLength > 1:\r |
| | 2717 | Arch = Key[1]\r |
| | 2718 | else:\r |
| | 2719 | Arch = None\r |
| | 2720 | if KeyLength > 2:\r |
| | 2721 | Target = Key[2]\r |
| | 2722 | else:\r |
| | 2723 | Target = None\r |
| | 2724 | if KeyLength > 3:\r |
| | 2725 | Toolchain = Key[3]\r |
| | 2726 | else:\r |
| | 2727 | Toolchain = None\r |
| | 2728 | \r |
| | 2729 | # if it's generated before, just return the cached one\r |
| | 2730 | Key = (FilePath, Arch, Target, Toolchain)\r |
| | 2731 | if Key in self._CACHE_:\r |
| | 2732 | return self._CACHE_[Key]\r |
| | 2733 | \r |
| | 2734 | # check file type\r |
| | 2735 | Ext = FilePath.Type\r |
| | 2736 | if Ext not in self._FILE_TYPE_:\r |
| | 2737 | return None\r |
| | 2738 | FileType = self._FILE_TYPE_[Ext]\r |
| | 2739 | if FileType not in self._GENERATOR_:\r |
| | 2740 | return None\r |
| | 2741 | \r |
| | 2742 | # get the parser ready for this file\r |
| | 2743 | MetaFile = self._FILE_PARSER_[FileType](\r |
| | 2744 | FilePath, \r |
| | 2745 | FileType, \r |
| | 2746 | MetaFileStorage(self.WorkspaceDb.Cur, FilePath, FileType)\r |
| | 2747 | )\r |
| | 2748 | # alwasy do post-process, in case of macros change\r |
| | 2749 | MetaFile.DoPostProcess()\r |
| | 2750 | # object the build is based on\r |
| | 2751 | BuildObject = self._GENERATOR_[FileType](\r |
| | 2752 | FilePath,\r |
| | 2753 | MetaFile,\r |
| | 2754 | self,\r |
| | 2755 | Arch,\r |
| | 2756 | Target,\r |
| | 2757 | Toolchain\r |
| | 2758 | )\r |
| | 2759 | self._CACHE_[Key] = BuildObject\r |
| | 2760 | return BuildObject\r |
| | 2761 | \r |
| | 2762 | # placeholder for file format conversion\r |
| | 2763 | class TransformObjectFactory:\r |
| | 2764 | def __init__(self, WorkspaceDb):\r |
| | 2765 | self.WorkspaceDb = WorkspaceDb\r |
| | 2766 | \r |
| | 2767 | # key = FilePath, Arch\r |
| | 2768 | def __getitem__(self, Key):\r |
| | 2769 | pass\r |
| | 2770 | \r |
| | 2771 | ## Constructor of WorkspaceDatabase\r |
| | 2772 | #\r |
| | 2773 | # @param DbPath Path of database file\r |
| | 2774 | # @param GlobalMacros Global macros used for replacement during file parsing\r |
| | 2775 | # @prarm RenewDb=False Create new database file if it's already there\r |
| | 2776 | #\r |
| | 2777 | def __init__(self, DbPath, RenewDb=False):\r |
| | 2778 | self._DbClosedFlag = False\r |
| | 2779 | if not DbPath:\r |
| | 2780 | DbPath = os.path.normpath(os.path.join(GlobalData.gWorkspace, 'Conf', GlobalData.gDatabasePath))\r |
| | 2781 | \r |
| | 2782 | # don't create necessary path for db in memory\r |
| | 2783 | if DbPath != ':memory:':\r |
| | 2784 | DbDir = os.path.split(DbPath)[0]\r |
| | 2785 | if not os.path.exists(DbDir):\r |
| | 2786 | os.makedirs(DbDir)\r |
| | 2787 | \r |
| | 2788 | # remove db file in case inconsistency between db and file in file system\r |
| | 2789 | if self._CheckWhetherDbNeedRenew(RenewDb, DbPath):\r |
| | 2790 | os.remove(DbPath)\r |
| | 2791 | \r |
| | 2792 | # create db with optimized parameters\r |
| | 2793 | self.Conn = sqlite3.connect(DbPath, isolation_level='DEFERRED')\r |
| | 2794 | self.Conn.execute("PRAGMA synchronous=OFF")\r |
| | 2795 | self.Conn.execute("PRAGMA temp_store=MEMORY")\r |
| | 2796 | self.Conn.execute("PRAGMA count_changes=OFF")\r |
| | 2797 | self.Conn.execute("PRAGMA cache_size=8192")\r |
| | 2798 | #self.Conn.execute("PRAGMA page_size=8192")\r |
| | 2799 | \r |
| | 2800 | # to avoid non-ascii character conversion issue\r |
| | 2801 | self.Conn.text_factory = str\r |
| | 2802 | self.Cur = self.Conn.cursor()\r |
| | 2803 | \r |
| | 2804 | # create table for internal uses\r |
| | 2805 | self.TblDataModel = TableDataModel(self.Cur)\r |
| | 2806 | self.TblFile = TableFile(self.Cur)\r |
| | 2807 | self.Platform = None\r |
| | 2808 | \r |
| | 2809 | # conversion object for build or file format conversion purpose\r |
| | 2810 | self.BuildObject = WorkspaceDatabase.BuildObjectFactory(self)\r |
| | 2811 | self.TransformObject = WorkspaceDatabase.TransformObjectFactory(self)\r |
| | 2812 | \r |
| | 2813 | ## Check whether workspace database need to be renew.\r |
| | 2814 | # The renew reason maybe:\r |
| | 2815 | # 1) If user force to renew;\r |
| | 2816 | # 2) If user do not force renew, and\r |
| | 2817 | # a) If the time of last modified python source is newer than database file;\r |
| | 2818 | # b) If the time of last modified frozen executable file is newer than database file;\r |
| | 2819 | #\r |
| | 2820 | # @param force User force renew database\r |
| | 2821 | # @param DbPath The absolute path of workspace database file\r |
| | 2822 | #\r |
| | 2823 | # @return Bool value for whether need renew workspace databse\r |
| | 2824 | #\r |
| | 2825 | def _CheckWhetherDbNeedRenew (self, force, DbPath):\r |
| | 2826 | # if database does not exist, we need do nothing\r |
| | 2827 | if not os.path.exists(DbPath): return False\r |
| | 2828 | \r |
| | 2829 | # if user force to renew database, then not check whether database is out of date\r |
| | 2830 | if force: return True\r |
| | 2831 | \r |
| | 2832 | # \r |
| | 2833 | # Check the time of last modified source file or build.exe\r |
| | 2834 | # if is newer than time of database, then database need to be re-created.\r |
| | 2835 | #\r |
| | 2836 | timeOfToolModified = 0\r |
| | 2837 | if hasattr(sys, "frozen"):\r |
| | 2838 | exePath = os.path.abspath(sys.executable)\r |
| | 2839 | timeOfToolModified = os.stat(exePath).st_mtime\r |
| | 2840 | else:\r |
| | 2841 | curPath = os.path.dirname(__file__) # curPath is the path of WorkspaceDatabase.py\r |
| | 2842 | rootPath = os.path.split(curPath)[0] # rootPath is root path of python source, such as /BaseTools/Source/Python\r |
| | 2843 | if rootPath == "" or rootPath == None:\r |
| | 2844 | EdkLogger.verbose("\nFail to find the root path of build.exe or python sources, so can not \\r |
| | 2845 | determine whether database file is out of date!\n")\r |
| | 2846 | \r |
| | 2847 | # walk the root path of source or build's binary to get the time last modified.\r |
| | 2848 | \r |
| | 2849 | for root, dirs, files in os.walk (rootPath):\r |
| | 2850 | for dir in dirs:\r |
| | 2851 | # bypass source control folder \r |
| | 2852 | if dir.lower() in [".svn", "_svn", "cvs"]:\r |
| | 2853 | dirs.remove(dir)\r |
| | 2854 | \r |
| | 2855 | for file in files:\r |
| | 2856 | ext = os.path.splitext(file)[1]\r |
| | 2857 | if ext.lower() == ".py": # only check .py files\r |
| | 2858 | fd = os.stat(os.path.join(root, file))\r |
| | 2859 | if timeOfToolModified < fd.st_mtime:\r |
| | 2860 | timeOfToolModified = fd.st_mtime\r |
| | 2861 | if timeOfToolModified > os.stat(DbPath).st_mtime:\r |
| | 2862 | EdkLogger.verbose("\nWorkspace database is out of data!")\r |
| | 2863 | return True\r |
| | 2864 | \r |
| | 2865 | return False\r |
| | 2866 | \r |
| | 2867 | ## Initialize build database\r |
| | 2868 | def InitDatabase(self):\r |
| | 2869 | EdkLogger.verbose("\nInitialize build database started ...")\r |
| | 2870 | \r |
| | 2871 | #\r |
| | 2872 | # Create new tables\r |
| | 2873 | #\r |
| | 2874 | self.TblDataModel.Create(False)\r |
| | 2875 | self.TblFile.Create(False)\r |
| | 2876 | \r |
| | 2877 | #\r |
| | 2878 | # Initialize table DataModel\r |
| | 2879 | #\r |
| | 2880 | self.TblDataModel.InitTable()\r |
| | 2881 | EdkLogger.verbose("Initialize build database ... DONE!")\r |
| | 2882 | \r |
| | 2883 | ## Query a table\r |
| | 2884 | #\r |
| | 2885 | # @param Table: The instance of the table to be queried\r |
| | 2886 | #\r |
| | 2887 | def QueryTable(self, Table):\r |
| | 2888 | Table.Query()\r |
| | 2889 | \r |
| | 2890 | def __del__(self):\r |
| | 2891 | self.Close()\r |
| | 2892 | \r |
| | 2893 | ## Close entire database\r |
| | 2894 | #\r |
| | 2895 | # Commit all first\r |
| | 2896 | # Close the connection and cursor\r |
| | 2897 | #\r |
| | 2898 | def Close(self):\r |
| | 2899 | if not self._DbClosedFlag:\r |
| | 2900 | self.Conn.commit()\r |
| | 2901 | self.Cur.close()\r |
| | 2902 | self.Conn.close()\r |
| | 2903 | self._DbClosedFlag = True\r |
| | 2904 | \r |
| | 2905 | ## Summarize all packages in the database\r |
| | 2906 | def GetPackageList(self, Platform, Arch, TargetName, ToolChainTag):\r |
| | 2907 | self.Platform = Platform\r |
| | 2908 | PackageList =[]\r |
| | 2909 | Pa = self.BuildObject[self.Platform, 'COMMON']\r |
| | 2910 | #\r |
| | 2911 | # Get Package related to Modules\r |
| | 2912 | #\r |
| | 2913 | for Module in Pa.Modules:\r |
| | 2914 | ModuleObj = self.BuildObject[Module, Arch, TargetName, ToolChainTag]\r |
| | 2915 | for Package in ModuleObj.Packages:\r |
| | 2916 | if Package not in PackageList:\r |
| | 2917 | PackageList.append(Package)\r |
| | 2918 | #\r |
| | 2919 | # Get Packages related to Libraries\r |
| | 2920 | #\r |
| | 2921 | for Lib in Pa.LibraryInstances:\r |
| | 2922 | LibObj = self.BuildObject[Lib, Arch, TargetName, ToolChainTag]\r |
| | 2923 | for Package in LibObj.Packages:\r |
| | 2924 | if Package not in PackageList:\r |
| | 2925 | PackageList.append(Package) \r |
| | 2926 | \r |
| | 2927 | return PackageList\r |
| | 2928 | \r |
| | 2929 | ## Summarize all platforms in the database\r |
| | 2930 | def _GetPlatformList(self):\r |
| | 2931 | PlatformList = []\r |
| | 2932 | for PlatformFile in self.TblFile.GetFileList(MODEL_FILE_DSC):\r |
| | 2933 | try:\r |
| | 2934 | Platform = self.BuildObject[PathClass(PlatformFile), 'COMMON']\r |
| | 2935 | except:\r |
| | 2936 | Platform = None\r |
| | 2937 | if Platform != None:\r |
| | 2938 | PlatformList.append(Platform)\r |
| | 2939 | return PlatformList\r |
| | 2940 | \r |
| | 2941 | PlatformList = property(_GetPlatformList)\r |
| | 2942 | \r |
| | 2943 | ##\r |
| | 2944 | #\r |
| | 2945 | # This acts like the main() function for the script, unless it is 'import'ed into another\r |
| | 2946 | # script.\r |
| | 2947 | #\r |
| | 2948 | if __name__ == '__main__':\r |
| | 2949 | pass\r |
| | 2950 | \r |
projects / mirror_edk2.git / blame_incremental