BaseTools/Source/Python/Workspace/InfBuildData.py

   1 ## @file
   2 # This file is used to create a database used by build tool
   3 #
   4 # Copyright (c) 2008 - 2018, Intel Corporation. All rights reserved.<BR>
   5 # (C) Copyright 2016 Hewlett Packard Enterprise Development LP<BR>
   6 # This program and the accompanying materials
   7 # are licensed and made available under the terms and conditions of the BSD License
   8 # which accompanies this distribution.  The full text of the license may be found at
   9 # http://opensource.org/licenses/bsd-license.php
  10 #
  11 # THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
  12 # WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
  13 #
  14
  15 from Common.StringUtils import *
  16 from Common.DataType import *
  17 from Common.Misc import *
  18 from types import *
  19 from MetaFileParser import *
  20 from collections import OrderedDict
  21
  22 from Workspace.BuildClassObject import ModuleBuildClassObject, LibraryClassObject, PcdClassObject
  23 ## Module build information from INF file
  24 #
  25 #  This class is used to retrieve information stored in database and convert them
  26 # into ModuleBuildClassObject form for easier use for AutoGen.
  27 #
  28 class InfBuildData(ModuleBuildClassObject):
  29     # dict used to convert PCD type in database to string used by build tool
  30     _PCD_TYPE_STRING_ = {
  31         MODEL_PCD_FIXED_AT_BUILD        :   TAB_PCDS_FIXED_AT_BUILD,
  32         MODEL_PCD_PATCHABLE_IN_MODULE   :   TAB_PCDS_PATCHABLE_IN_MODULE,
  33         MODEL_PCD_FEATURE_FLAG          :   TAB_PCDS_FEATURE_FLAG,
  34         MODEL_PCD_DYNAMIC               :   TAB_PCDS_DYNAMIC,
  35         MODEL_PCD_DYNAMIC_DEFAULT       :   TAB_PCDS_DYNAMIC,
  36         MODEL_PCD_DYNAMIC_HII           :   TAB_PCDS_DYNAMIC_HII,
  37         MODEL_PCD_DYNAMIC_VPD           :   TAB_PCDS_DYNAMIC_VPD,
  38         MODEL_PCD_DYNAMIC_EX            :   TAB_PCDS_DYNAMIC_EX,
  39         MODEL_PCD_DYNAMIC_EX_DEFAULT    :   TAB_PCDS_DYNAMIC_EX,
  40         MODEL_PCD_DYNAMIC_EX_HII        :   TAB_PCDS_DYNAMIC_EX_HII,
  41         MODEL_PCD_DYNAMIC_EX_VPD        :   TAB_PCDS_DYNAMIC_EX_VPD,
  42     }
  43
  44     # dict used to convert part of [Defines] to members of InfBuildData directly
  45     _PROPERTY_ = {
  46         #
  47         # Required Fields
  48         #
  49         TAB_INF_DEFINES_BASE_NAME                   : "_BaseName",
  50         TAB_INF_DEFINES_FILE_GUID                   : "_Guid",
  51         TAB_INF_DEFINES_MODULE_TYPE                 : "_ModuleType",
  52         #
  53         # Optional Fields
  54         #
  55         # TAB_INF_DEFINES_INF_VERSION                 : "_AutoGenVersion",
  56         TAB_INF_DEFINES_COMPONENT_TYPE              : "_ComponentType",
  57         TAB_INF_DEFINES_MAKEFILE_NAME               : "_MakefileName",
  58         # TAB_INF_DEFINES_CUSTOM_MAKEFILE             : "_CustomMakefile",
  59         TAB_INF_DEFINES_DPX_SOURCE                  :"_DxsFile",
  60         TAB_INF_DEFINES_VERSION_NUMBER              : "_Version",
  61         TAB_INF_DEFINES_VERSION_STRING              : "_Version",
  62         TAB_INF_DEFINES_VERSION                     : "_Version",
  63         TAB_INF_DEFINES_PCD_IS_DRIVER               : "_PcdIsDriver",
  64         TAB_INF_DEFINES_SHADOW                      : "_Shadow",
  65
  66         TAB_COMPONENTS_SOURCE_OVERRIDE_PATH         : "_SourceOverridePath",
  67     }
  68
  69     # regular expression for converting XXX_FLAGS in [nmake] section to new type
  70     _NMAKE_FLAG_PATTERN_ = re.compile("(?:EBC_)?([A-Z]+)_(?:STD_|PROJ_|ARCH_)?FLAGS(?:_DLL|_ASL|_EXE)?", re.UNICODE)
  71     # dict used to convert old tool name used in [nmake] section to new ones
  72     _TOOL_CODE_ = {
  73         "C"         :   "CC",
  74         BINARY_FILE_TYPE_LIB       :   "SLINK",
  75         "LINK"      :   "DLINK",
  76     }
  77
  78
  79     ## Constructor of DscBuildData
  80     #
  81     #  Initialize object of DscBuildData
  82     #
  83     #   @param      FilePath        The path of platform description file
  84     #   @param      RawData         The raw data of DSC file
  85     #   @param      BuildDataBase   Database used to retrieve module/package information
  86     #   @param      Arch            The target architecture
  87     #   @param      Platform        The name of platform employing this module
  88     #   @param      Macros          Macros used for replacement in DSC file
  89     #
  90     def __init__(self, FilePath, RawData, BuildDatabase, Arch=TAB_ARCH_COMMON, Target=None, Toolchain=None):
  91         self.MetaFile = FilePath
  92         self._ModuleDir = FilePath.Dir
  93         self._RawData = RawData
  94         self._Bdb = BuildDatabase
  95         self._Arch = Arch
  96         self._Target = Target
  97         self._Toolchain = Toolchain
  98         self._Platform = TAB_COMMON
  99         self._SourceOverridePath = None
 100         if FilePath.Key in GlobalData.gOverrideDir:
 101             self._SourceOverridePath = GlobalData.gOverrideDir[FilePath.Key]
 102         self._Clear()
 103
 104     ## XXX[key] = value
 105     def __setitem__(self, key, value):
 106         self.__dict__[self._PROPERTY_[key]] = value
 107
 108     ## value = XXX[key]
 109     def __getitem__(self, key):
 110         return self.__dict__[self._PROPERTY_[key]]
 111
 112     ## "in" test support
 113     def __contains__(self, key):
 114         return key in self._PROPERTY_
 115
 116     ## Set all internal used members of InfBuildData to None
 117     def _Clear(self):
 118         self._HeaderComments = None
 119         self._TailComments = None
 120         self._Header_               = None
 121         self._AutoGenVersion        = None
 122         self._BaseName              = None
 123         self._DxsFile               = None
 124         self._ModuleType            = None
 125         self._ComponentType         = None
 126         self._BuildType             = None
 127         self._Guid                  = None
 128         self._Version               = None
 129         self._PcdIsDriver           = None
 130         self._BinaryModule          = None
 131         self._Shadow                = None
 132         self._MakefileName          = None
 133         self._CustomMakefile        = None
 134         self._Specification         = None
 135         self._LibraryClass          = None
 136         self._ModuleEntryPointList  = None
 137         self._ModuleUnloadImageList = None
 138         self._ConstructorList       = None
 139         self._DestructorList        = None
 140         self._Defs                  = OrderedDict()
 141         self._Binaries              = None
 142         self._Sources               = None
 143         self._LibraryClasses        = None
 144         self._Libraries             = None
 145         self._Protocols             = None
 146         self._ProtocolComments      = None
 147         self._Ppis                  = None
 148         self._PpiComments           = None
 149         self._Guids                 = None
 150         self._GuidsUsedByPcd        = OrderedDict()
 151         self._GuidComments          = None
 152         self._Includes              = None
 153         self._Packages              = None
 154         self._Pcds                  = None
 155         self._PcdComments           = None
 156         self._BuildOptions          = None
 157         self._Depex                 = None
 158         self._DepexExpression       = None
 159         self.__Macros               = None
 160
 161     ## Get current effective macros
 162     def _GetMacros(self):
 163         if self.__Macros is None:
 164             self.__Macros = {}
 165             # EDK_GLOBAL defined macros can be applied to EDK module
 166             if self.AutoGenVersion < 0x00010005:
 167                 self.__Macros.update(GlobalData.gEdkGlobal)
 168                 self.__Macros.update(GlobalData.gGlobalDefines)
 169         return self.__Macros
 170
 171     ## Get architecture
 172     def _GetArch(self):
 173         return self._Arch
 174
 175     ## Set architecture
 176     #
 177     #   Changing the default ARCH to another may affect all other information
 178     # because all information in a platform may be ARCH-related. That's
 179     # why we need to clear all internal used members, in order to cause all
 180     # information to be re-retrieved.
 181     #
 182     #   @param  Value   The value of ARCH
 183     #
 184     def _SetArch(self, Value):
 185         if self._Arch == Value:
 186             return
 187         self._Arch = Value
 188         self._Clear()
 189
 190     ## Return the name of platform employing this module
 191     def _GetPlatform(self):
 192         return self._Platform
 193
 194     ## Change the name of platform employing this module
 195     #
 196     #   Changing the default name of platform to another may affect some information
 197     # because they may be PLATFORM-related. That's why we need to clear all internal
 198     # used members, in order to cause all information to be re-retrieved.
 199     #
 200     def _SetPlatform(self, Value):
 201         if self._Platform == Value:
 202             return
 203         self._Platform = Value
 204         self._Clear()
 205     def _GetHeaderComments(self):
 206         if not self._HeaderComments:
 207             self._HeaderComments = []
 208             RecordList = self._RawData[MODEL_META_DATA_HEADER_COMMENT]
 209             for Record in RecordList:
 210                 self._HeaderComments.append(Record[0])
 211         return self._HeaderComments
 212     def _GetTailComments(self):
 213         if not self._TailComments:
 214             self._TailComments = []
 215             RecordList = self._RawData[MODEL_META_DATA_TAIL_COMMENT]
 216             for Record in RecordList:
 217                 self._TailComments.append(Record[0])
 218         return self._TailComments
 219     ## Retrieve all information in [Defines] section
 220     #
 221     #   (Retriving all [Defines] information in one-shot is just to save time.)
 222     #
 223     def _GetHeaderInfo(self):
 224         RecordList = self._RawData[MODEL_META_DATA_HEADER, self._Arch, self._Platform]
 225         for Record in RecordList:
 226             Name, Value = Record[1], ReplaceMacro(Record[2], self._Macros, False)
 227             # items defined _PROPERTY_ don't need additional processing
 228             if Name in self:
 229                 self[Name] = Value
 230                 self._Defs[Name] = Value
 231                 self._Macros[Name] = Value
 232             # some special items in [Defines] section need special treatment
 233             elif Name in ('EFI_SPECIFICATION_VERSION', 'UEFI_SPECIFICATION_VERSION', 'EDK_RELEASE_VERSION', 'PI_SPECIFICATION_VERSION'):
 234                 if Name in ('EFI_SPECIFICATION_VERSION', 'UEFI_SPECIFICATION_VERSION'):
 235                     Name = 'UEFI_SPECIFICATION_VERSION'
 236                 if self._Specification is None:
 237                     self._Specification = OrderedDict()
 238                 self._Specification[Name] = GetHexVerValue(Value)
 239                 if self._Specification[Name] is None:
 240                     EdkLogger.error("build", FORMAT_NOT_SUPPORTED,
 241                                     "'%s' format is not supported for %s" % (Value, Name),
 242                                     File=self.MetaFile, Line=Record[-1])
 243             elif Name == 'LIBRARY_CLASS':
 244                 if self._LibraryClass is None:
 245                     self._LibraryClass = []
 246                 ValueList = GetSplitValueList(Value)
 247                 LibraryClass = ValueList[0]
 248                 if len(ValueList) > 1:
 249                     SupModuleList = GetSplitValueList(ValueList[1], ' ')
 250                 else:
 251                     SupModuleList = SUP_MODULE_LIST
 252                 self._LibraryClass.append(LibraryClassObject(LibraryClass, SupModuleList))
 253             elif Name == 'ENTRY_POINT':
 254                 if self._ModuleEntryPointList is None:
 255                     self._ModuleEntryPointList = []
 256                 self._ModuleEntryPointList.append(Value)
 257             elif Name == 'UNLOAD_IMAGE':
 258                 if self._ModuleUnloadImageList is None:
 259                     self._ModuleUnloadImageList = []
 260                 if not Value:
 261                     continue
 262                 self._ModuleUnloadImageList.append(Value)
 263             elif Name == 'CONSTRUCTOR':
 264                 if self._ConstructorList is None:
 265                     self._ConstructorList = []
 266                 if not Value:
 267                     continue
 268                 self._ConstructorList.append(Value)
 269             elif Name == 'DESTRUCTOR':
 270                 if self._DestructorList is None:
 271                     self._DestructorList = []
 272                 if not Value:
 273                     continue
 274                 self._DestructorList.append(Value)
 275             elif Name == TAB_INF_DEFINES_CUSTOM_MAKEFILE:
 276                 TokenList = GetSplitValueList(Value)
 277                 if self._CustomMakefile is None:
 278                     self._CustomMakefile = {}
 279                 if len(TokenList) < 2:
 280                     self._CustomMakefile['MSFT'] = TokenList[0]
 281                     self._CustomMakefile['GCC'] = TokenList[0]
 282                 else:
 283                     if TokenList[0] not in ['MSFT', 'GCC']:
 284                         EdkLogger.error("build", FORMAT_NOT_SUPPORTED,
 285                                         "No supported family [%s]" % TokenList[0],
 286                                         File=self.MetaFile, Line=Record[-1])
 287                     self._CustomMakefile[TokenList[0]] = TokenList[1]
 288             else:
 289                 self._Defs[Name] = Value
 290                 self._Macros[Name] = Value
 291
 292         #
 293         # Retrieve information in sections specific to Edk.x modules
 294         #
 295         if self.AutoGenVersion >= 0x00010005:
 296             if not self._ModuleType:
 297                 EdkLogger.error("build", ATTRIBUTE_NOT_AVAILABLE,
 298                                 "MODULE_TYPE is not given", File=self.MetaFile)
 299             if self._ModuleType not in SUP_MODULE_LIST:
 300                 RecordList = self._RawData[MODEL_META_DATA_HEADER, self._Arch, self._Platform]
 301                 for Record in RecordList:
 302                     Name = Record[1]
 303                     if Name == "MODULE_TYPE":
 304                         LineNo = Record[6]
 305                         break
 306                 EdkLogger.error("build", FORMAT_NOT_SUPPORTED,
 307                                 "MODULE_TYPE %s is not supported for EDK II, valid values are:\n %s" % (self._ModuleType, ' '.join(l for l in SUP_MODULE_LIST)),
 308                                 File=self.MetaFile, Line=LineNo)
 309             if (self._Specification is None) or (not 'PI_SPECIFICATION_VERSION' in self._Specification) or (int(self._Specification['PI_SPECIFICATION_VERSION'], 16) < 0x0001000A):
 310                 if self._ModuleType == SUP_MODULE_SMM_CORE:
 311                     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)
 312             if (self._Specification is None) or (not 'PI_SPECIFICATION_VERSION' in self._Specification) or (int(self._Specification['PI_SPECIFICATION_VERSION'], 16) < 0x00010032):
 313                 if self._ModuleType == SUP_MODULE_MM_CORE_STANDALONE:
 314                     EdkLogger.error("build", FORMAT_NOT_SUPPORTED, "MM_CORE_STANDALONE module type can't be used in the module with PI_SPECIFICATION_VERSION less than 0x00010032", File=self.MetaFile)
 315                 if self._ModuleType == SUP_MODULE_MM_STANDALONE:
 316                     EdkLogger.error("build", FORMAT_NOT_SUPPORTED, "MM_STANDALONE module type can't be used in the module with PI_SPECIFICATION_VERSION less than 0x00010032", File=self.MetaFile)
 317             if 'PCI_DEVICE_ID' in self._Defs and 'PCI_VENDOR_ID' in self._Defs \
 318                and 'PCI_CLASS_CODE' in self._Defs and 'PCI_REVISION' in self._Defs:
 319                 self._BuildType = 'UEFI_OPTIONROM'
 320                 if 'PCI_COMPRESS' in self._Defs:
 321                     if self._Defs['PCI_COMPRESS'] not in ('TRUE', 'FALSE'):
 322                         EdkLogger.error("build", FORMAT_INVALID, "Expected TRUE/FALSE for PCI_COMPRESS: %s" % self.MetaFile)
 323
 324             elif 'UEFI_HII_RESOURCE_SECTION' in self._Defs \
 325                and self._Defs['UEFI_HII_RESOURCE_SECTION'] == 'TRUE':
 326                 self._BuildType = 'UEFI_HII'
 327             else:
 328                 self._BuildType = self._ModuleType.upper()
 329
 330             if self._DxsFile:
 331                 File = PathClass(NormPath(self._DxsFile), self._ModuleDir, Arch=self._Arch)
 332                 # check the file validation
 333                 ErrorCode, ErrorInfo = File.Validate(".dxs", CaseSensitive=False)
 334                 if ErrorCode != 0:
 335                     EdkLogger.error('build', ErrorCode, ExtraData=ErrorInfo,
 336                                     File=self.MetaFile, Line=LineNo)
 337                 if self.Sources is None:
 338                     self._Sources = []
 339                 self._Sources.append(File)
 340         else:
 341             if not self._ComponentType:
 342                 EdkLogger.error("build", ATTRIBUTE_NOT_AVAILABLE,
 343                                 "COMPONENT_TYPE is not given", File=self.MetaFile)
 344             self._BuildType = self._ComponentType.upper()
 345             if self._ComponentType in COMPONENT_TO_MODULE_MAP_DICT:
 346                 self._ModuleType = COMPONENT_TO_MODULE_MAP_DICT[self._ComponentType]
 347             if self._ComponentType == EDK_COMPONENT_TYPE_LIBRARY:
 348                 self._LibraryClass = [LibraryClassObject(self._BaseName, SUP_MODULE_LIST)]
 349             # make use some [nmake] section macros
 350             Macros = self._Macros
 351             Macros["EDK_SOURCE"] = GlobalData.gEcpSource
 352             Macros['PROCESSOR'] = self._Arch
 353             RecordList = self._RawData[MODEL_META_DATA_NMAKE, self._Arch, self._Platform]
 354             for Name, Value, Dummy, Arch, Platform, ID, LineNo in RecordList:
 355                 Value = ReplaceMacro(Value, Macros, True)
 356                 if Name == "IMAGE_ENTRY_POINT":
 357                     if self._ModuleEntryPointList is None:
 358                         self._ModuleEntryPointList = []
 359                     self._ModuleEntryPointList.append(Value)
 360                 elif Name == "DPX_SOURCE":
 361                     File = PathClass(NormPath(Value), self._ModuleDir, Arch=self._Arch)
 362                     # check the file validation
 363                     ErrorCode, ErrorInfo = File.Validate(".dxs", CaseSensitive=False)
 364                     if ErrorCode != 0:
 365                         EdkLogger.error('build', ErrorCode, ExtraData=ErrorInfo,
 366                                         File=self.MetaFile, Line=LineNo)
 367                     if self.Sources is None:
 368                         self._Sources = []
 369                     self._Sources.append(File)
 370                 else:
 371                     ToolList = self._NMAKE_FLAG_PATTERN_.findall(Name)
 372                     if len(ToolList) == 0 or len(ToolList) != 1:
 373                         pass
 374 #                        EdkLogger.warn("build", "Don't know how to do with macro [%s]" % Name,
 375 #                                       File=self.MetaFile, Line=LineNo)
 376                     else:
 377                         if self._BuildOptions is None:
 378                             self._BuildOptions = OrderedDict()
 379
 380                         if ToolList[0] in self._TOOL_CODE_:
 381                             Tool = self._TOOL_CODE_[ToolList[0]]
 382                         else:
 383                             Tool = ToolList[0]
 384                         ToolChain = "*_*_*_%s_FLAGS" % Tool
 385                         ToolChainFamily = 'MSFT'  # Edk.x only support MSFT tool chain
 386                         # ignore not replaced macros in value
 387                         ValueList = GetSplitList(' ' + Value, '/D')
 388                         Dummy = ValueList[0]
 389                         for Index in range(1, len(ValueList)):
 390                             if ValueList[Index][-1] == '=' or ValueList[Index] == '':
 391                                 continue
 392                             Dummy = Dummy + ' /D ' + ValueList[Index]
 393                         Value = Dummy.strip()
 394                         if (ToolChainFamily, ToolChain) not in self._BuildOptions:
 395                             self._BuildOptions[ToolChainFamily, ToolChain] = Value
 396                         else:
 397                             OptionString = self._BuildOptions[ToolChainFamily, ToolChain]
 398                             self._BuildOptions[ToolChainFamily, ToolChain] = OptionString + " " + Value
 399         # set _Header to non-None in order to avoid database re-querying
 400         self._Header_ = 'DUMMY'
 401
 402     ## Retrieve file version
 403     def _GetInfVersion(self):
 404         if self._AutoGenVersion is None:
 405             RecordList = self._RawData[MODEL_META_DATA_HEADER, self._Arch, self._Platform]
 406             for Record in RecordList:
 407                 if Record[1] == TAB_INF_DEFINES_INF_VERSION:
 408                     if '.' in Record[2]:
 409                         ValueList = Record[2].split('.')
 410                         Major = '%04o' % int(ValueList[0], 0)
 411                         Minor = '%04o' % int(ValueList[1], 0)
 412                         self._AutoGenVersion = int('0x' + Major + Minor, 0)
 413                     else:
 414                         self._AutoGenVersion = int(Record[2], 0)
 415                     break
 416             if self._AutoGenVersion is None:
 417                 self._AutoGenVersion = 0x00010000
 418         return self._AutoGenVersion
 419
 420     ## Retrieve BASE_NAME
 421     def _GetBaseName(self):
 422         if self._BaseName is None:
 423             if self._Header_ is None:
 424                 self._GetHeaderInfo()
 425             if self._BaseName is None:
 426                 EdkLogger.error('build', ATTRIBUTE_NOT_AVAILABLE, "No BASE_NAME name", File=self.MetaFile)
 427         return self._BaseName
 428
 429     ## Retrieve DxsFile
 430     def _GetDxsFile(self):
 431         if self._DxsFile is None:
 432             if self._Header_ is None:
 433                 self._GetHeaderInfo()
 434             if self._DxsFile is None:
 435                 self._DxsFile = ''
 436         return self._DxsFile
 437
 438     ## Retrieve MODULE_TYPE
 439     def _GetModuleType(self):
 440         if self._ModuleType is None:
 441             if self._Header_ is None:
 442                 self._GetHeaderInfo()
 443             if self._ModuleType is None:
 444                 self._ModuleType = SUP_MODULE_BASE
 445             if self._ModuleType not in SUP_MODULE_LIST:
 446                 self._ModuleType = SUP_MODULE_USER_DEFINED
 447         return self._ModuleType
 448
 449     ## Retrieve COMPONENT_TYPE
 450     def _GetComponentType(self):
 451         if self._ComponentType is None:
 452             if self._Header_ is None:
 453                 self._GetHeaderInfo()
 454             if self._ComponentType is None:
 455                 self._ComponentType = SUP_MODULE_USER_DEFINED
 456         return self._ComponentType
 457
 458     ## Retrieve "BUILD_TYPE"
 459     def _GetBuildType(self):
 460         if self._BuildType is None:
 461             if self._Header_ is None:
 462                 self._GetHeaderInfo()
 463             if not self._BuildType:
 464                 self._BuildType = SUP_MODULE_BASE
 465         return self._BuildType
 466
 467     ## Retrieve file guid
 468     def _GetFileGuid(self):
 469         if self._Guid is None:
 470             if self._Header_ is None:
 471                 self._GetHeaderInfo()
 472             if self._Guid is None:
 473                 self._Guid = '00000000-0000-0000-0000-000000000000'
 474         return self._Guid
 475
 476     ## Retrieve module version
 477     def _GetVersion(self):
 478         if self._Version is None:
 479             if self._Header_ is None:
 480                 self._GetHeaderInfo()
 481             if self._Version is None:
 482                 self._Version = '0.0'
 483         return self._Version
 484
 485     ## Retrieve PCD_IS_DRIVER
 486     def _GetPcdIsDriver(self):
 487         if self._PcdIsDriver is None:
 488             if self._Header_ is None:
 489                 self._GetHeaderInfo()
 490             if self._PcdIsDriver is None:
 491                 self._PcdIsDriver = ''
 492         return self._PcdIsDriver
 493
 494     ## Retrieve SHADOW
 495     def _GetShadow(self):
 496         if self._Shadow is None:
 497             if self._Header_ is None:
 498                 self._GetHeaderInfo()
 499             if self._Shadow is not None and self._Shadow.upper() == 'TRUE':
 500                 self._Shadow = True
 501             else:
 502                 self._Shadow = False
 503         return self._Shadow
 504
 505     ## Retrieve CUSTOM_MAKEFILE
 506     def _GetMakefile(self):
 507         if self._CustomMakefile is None:
 508             if self._Header_ is None:
 509                 self._GetHeaderInfo()
 510             if self._CustomMakefile is None:
 511                 self._CustomMakefile = {}
 512         return self._CustomMakefile
 513
 514     ## Retrieve EFI_SPECIFICATION_VERSION
 515     def _GetSpec(self):
 516         if self._Specification is None:
 517             if self._Header_ is None:
 518                 self._GetHeaderInfo()
 519             if self._Specification is None:
 520                 self._Specification = {}
 521         return self._Specification
 522
 523     ## Retrieve LIBRARY_CLASS
 524     def _GetLibraryClass(self):
 525         if self._LibraryClass is None:
 526             if self._Header_ is None:
 527                 self._GetHeaderInfo()
 528             if self._LibraryClass is None:
 529                 self._LibraryClass = []
 530         return self._LibraryClass
 531
 532     ## Retrieve ENTRY_POINT
 533     def _GetEntryPoint(self):
 534         if self._ModuleEntryPointList is None:
 535             if self._Header_ is None:
 536                 self._GetHeaderInfo()
 537             if self._ModuleEntryPointList is None:
 538                 self._ModuleEntryPointList = []
 539         return self._ModuleEntryPointList
 540
 541     ## Retrieve UNLOAD_IMAGE
 542     def _GetUnloadImage(self):
 543         if self._ModuleUnloadImageList is None:
 544             if self._Header_ is None:
 545                 self._GetHeaderInfo()
 546             if self._ModuleUnloadImageList is None:
 547                 self._ModuleUnloadImageList = []
 548         return self._ModuleUnloadImageList
 549
 550     ## Retrieve CONSTRUCTOR
 551     def _GetConstructor(self):
 552         if self._ConstructorList is None:
 553             if self._Header_ is None:
 554                 self._GetHeaderInfo()
 555             if self._ConstructorList is None:
 556                 self._ConstructorList = []
 557         return self._ConstructorList
 558
 559     ## Retrieve DESTRUCTOR
 560     def _GetDestructor(self):
 561         if self._DestructorList is None:
 562             if self._Header_ is None:
 563                 self._GetHeaderInfo()
 564             if self._DestructorList is None:
 565                 self._DestructorList = []
 566         return self._DestructorList
 567
 568     ## Retrieve definies other than above ones
 569     def _GetDefines(self):
 570         if len(self._Defs) == 0 and self._Header_ is None:
 571             self._GetHeaderInfo()
 572         return self._Defs
 573
 574     ## Retrieve binary files
 575     def _GetBinaries(self):
 576         if self._Binaries is None:
 577             self._Binaries = []
 578             RecordList = self._RawData[MODEL_EFI_BINARY_FILE, self._Arch, self._Platform]
 579             Macros = self._Macros
 580             Macros["EDK_SOURCE"] = GlobalData.gEcpSource
 581             Macros['PROCESSOR'] = self._Arch
 582             for Record in RecordList:
 583                 FileType = Record[0]
 584                 LineNo = Record[-1]
 585                 Target = TAB_COMMON
 586                 FeatureFlag = []
 587                 if Record[2]:
 588                     TokenList = GetSplitValueList(Record[2], TAB_VALUE_SPLIT)
 589                     if TokenList:
 590                         Target = TokenList[0]
 591                     if len(TokenList) > 1:
 592                         FeatureFlag = Record[1:]
 593
 594                 File = PathClass(NormPath(Record[1], Macros), self._ModuleDir, '', FileType, True, self._Arch, '', Target)
 595                 # check the file validation
 596                 ErrorCode, ErrorInfo = File.Validate()
 597                 if ErrorCode != 0:
 598                     EdkLogger.error('build', ErrorCode, ExtraData=ErrorInfo, File=self.MetaFile, Line=LineNo)
 599                 self._Binaries.append(File)
 600         return self._Binaries
 601
 602     ## Retrieve binary files with error check.
 603     def _GetBinaryFiles(self):
 604         Binaries = self._GetBinaries()
 605         if GlobalData.gIgnoreSource and Binaries == []:
 606             ErrorInfo = "The INF file does not contain any Binaries to use in creating the image\n"
 607             EdkLogger.error('build', RESOURCE_NOT_AVAILABLE, ExtraData=ErrorInfo, File=self.MetaFile)
 608
 609         return Binaries
 610     ## Check whether it exists the binaries with current ARCH in AsBuild INF
 611     def _IsSupportedArch(self):
 612         if self._GetBinaries() and not self._GetSourceFiles():
 613             return True
 614         else:
 615             return False
 616     ## Retrieve source files
 617     def _GetSourceFiles(self):
 618         # Ignore all source files in a binary build mode
 619         if GlobalData.gIgnoreSource:
 620             self._Sources = []
 621             return self._Sources
 622
 623         if self._Sources is None:
 624             self._Sources = []
 625             RecordList = self._RawData[MODEL_EFI_SOURCE_FILE, self._Arch, self._Platform]
 626             Macros = self._Macros
 627             for Record in RecordList:
 628                 LineNo = Record[-1]
 629                 ToolChainFamily = Record[1]
 630                 TagName = Record[2]
 631                 ToolCode = Record[3]
 632                 FeatureFlag = Record[4]
 633                 if self.AutoGenVersion < 0x00010005:
 634                     Macros["EDK_SOURCE"] = GlobalData.gEcpSource
 635                     Macros['PROCESSOR'] = self._Arch
 636                     SourceFile = NormPath(Record[0], Macros)
 637                     if SourceFile[0] == os.path.sep:
 638                         SourceFile = mws.join(GlobalData.gWorkspace, SourceFile[1:])
 639                     # old module source files (Edk)
 640                     File = PathClass(SourceFile, self._ModuleDir, self._SourceOverridePath,
 641                                      '', False, self._Arch, ToolChainFamily, '', TagName, ToolCode)
 642                     # check the file validation
 643                     ErrorCode, ErrorInfo = File.Validate(CaseSensitive=False)
 644                     if ErrorCode != 0:
 645                         if File.Ext.lower() == '.h':
 646                             EdkLogger.warn('build', 'Include file not found', ExtraData=ErrorInfo,
 647                                            File=self.MetaFile, Line=LineNo)
 648                             continue
 649                         else:
 650                             EdkLogger.error('build', ErrorCode, ExtraData=File, File=self.MetaFile, Line=LineNo)
 651                 else:
 652                     File = PathClass(NormPath(Record[0], Macros), self._ModuleDir, '',
 653                                      '', False, self._Arch, ToolChainFamily, '', TagName, ToolCode)
 654                     # check the file validation
 655                     ErrorCode, ErrorInfo = File.Validate()
 656                     if ErrorCode != 0:
 657                         EdkLogger.error('build', ErrorCode, ExtraData=ErrorInfo, File=self.MetaFile, Line=LineNo)
 658
 659                 self._Sources.append(File)
 660         return self._Sources
 661
 662     ## Retrieve library classes employed by this module
 663     def _GetLibraryClassUses(self):
 664         if self._LibraryClasses is None:
 665             self._LibraryClasses = OrderedDict()
 666             RecordList = self._RawData[MODEL_EFI_LIBRARY_CLASS, self._Arch, self._Platform]
 667             for Record in RecordList:
 668                 Lib = Record[0]
 669                 Instance = Record[1]
 670                 if Instance:
 671                     Instance = NormPath(Instance, self._Macros)
 672                 self._LibraryClasses[Lib] = Instance
 673         return self._LibraryClasses
 674
 675     ## Retrieve library names (for Edk.x style of modules)
 676     def _GetLibraryNames(self):
 677         if self._Libraries is None:
 678             self._Libraries = []
 679             RecordList = self._RawData[MODEL_EFI_LIBRARY_INSTANCE, self._Arch, self._Platform]
 680             for Record in RecordList:
 681                 LibraryName = ReplaceMacro(Record[0], self._Macros, False)
 682                 # in case of name with '.lib' extension, which is unusual in Edk.x inf
 683                 LibraryName = os.path.splitext(LibraryName)[0]
 684                 if LibraryName not in self._Libraries:
 685                     self._Libraries.append(LibraryName)
 686         return self._Libraries
 687
 688     def _GetProtocolComments(self):
 689         self._GetProtocols()
 690         return self._ProtocolComments
 691     ## Retrieve protocols consumed/produced by this module
 692     def _GetProtocols(self):
 693         if self._Protocols is None:
 694             self._Protocols = OrderedDict()
 695             self._ProtocolComments = OrderedDict()
 696             RecordList = self._RawData[MODEL_EFI_PROTOCOL, self._Arch, self._Platform]
 697             for Record in RecordList:
 698                 CName = Record[0]
 699                 Value = ProtocolValue(CName, self.Packages, self.MetaFile.Path)
 700                 if Value is None:
 701                     PackageList = "\n\t".join(str(P) for P in self.Packages)
 702                     EdkLogger.error('build', RESOURCE_NOT_AVAILABLE,
 703                                     "Value of Protocol [%s] is not found under [Protocols] section in" % CName,
 704                                     ExtraData=PackageList, File=self.MetaFile, Line=Record[-1])
 705                 self._Protocols[CName] = Value
 706                 CommentRecords = self._RawData[MODEL_META_DATA_COMMENT, self._Arch, self._Platform, Record[5]]
 707                 Comments = []
 708                 for CmtRec in CommentRecords:
 709                     Comments.append(CmtRec[0])
 710                 self._ProtocolComments[CName] = Comments
 711         return self._Protocols
 712
 713     def _GetPpiComments(self):
 714         self._GetPpis()
 715         return self._PpiComments
 716     ## Retrieve PPIs consumed/produced by this module
 717     def _GetPpis(self):
 718         if self._Ppis is None:
 719             self._Ppis = OrderedDict()
 720             self._PpiComments = OrderedDict()
 721             RecordList = self._RawData[MODEL_EFI_PPI, self._Arch, self._Platform]
 722             for Record in RecordList:
 723                 CName = Record[0]
 724                 Value = PpiValue(CName, self.Packages, self.MetaFile.Path)
 725                 if Value is None:
 726                     PackageList = "\n\t".join(str(P) for P in self.Packages)
 727                     EdkLogger.error('build', RESOURCE_NOT_AVAILABLE,
 728                                     "Value of PPI [%s] is not found under [Ppis] section in " % CName,
 729                                     ExtraData=PackageList, File=self.MetaFile, Line=Record[-1])
 730                 self._Ppis[CName] = Value
 731                 CommentRecords = self._RawData[MODEL_META_DATA_COMMENT, self._Arch, self._Platform, Record[5]]
 732                 Comments = []
 733                 for CmtRec in CommentRecords:
 734                     Comments.append(CmtRec[0])
 735                 self._PpiComments[CName] = Comments
 736         return self._Ppis
 737
 738     def _GetGuidComments(self):
 739         self._GetGuids()
 740         return self._GuidComments
 741     ## Retrieve GUIDs consumed/produced by this module
 742     def _GetGuids(self):
 743         if self._Guids is None:
 744             self._Guids = OrderedDict()
 745             self._GuidComments = OrderedDict()
 746             RecordList = self._RawData[MODEL_EFI_GUID, self._Arch, self._Platform]
 747             for Record in RecordList:
 748                 CName = Record[0]
 749                 Value = GuidValue(CName, self.Packages, self.MetaFile.Path)
 750                 if Value is None:
 751                     PackageList = "\n\t".join(str(P) for P in self.Packages)
 752                     EdkLogger.error('build', RESOURCE_NOT_AVAILABLE,
 753                                     "Value of Guid [%s] is not found under [Guids] section in" % CName,
 754                                     ExtraData=PackageList, File=self.MetaFile, Line=Record[-1])
 755                 self._Guids[CName] = Value
 756                 CommentRecords = self._RawData[MODEL_META_DATA_COMMENT, self._Arch, self._Platform, Record[5]]
 757                 Comments = []
 758                 for CmtRec in CommentRecords:
 759                     Comments.append(CmtRec[0])
 760                 self._GuidComments[CName] = Comments
 761         return self._Guids
 762
 763     ## Retrieve include paths necessary for this module (for Edk.x style of modules)
 764     def _GetIncludes(self):
 765         if self._Includes is None:
 766             self._Includes = []
 767             if self._SourceOverridePath:
 768                 self._Includes.append(self._SourceOverridePath)
 769
 770             Macros = self._Macros
 771             Macros['PROCESSOR'] = GlobalData.gEdkGlobal.get('PROCESSOR', self._Arch)
 772             RecordList = self._RawData[MODEL_EFI_INCLUDE, self._Arch, self._Platform]
 773             for Record in RecordList:
 774                 if Record[0].find('EDK_SOURCE') > -1:
 775                     Macros['EDK_SOURCE'] = GlobalData.gEcpSource
 776                     File = NormPath(Record[0], self._Macros)
 777                     if File[0] == '.':
 778                         File = os.path.join(self._ModuleDir, File)
 779                     else:
 780                         File = os.path.join(GlobalData.gWorkspace, File)
 781                     File = RealPath(os.path.normpath(File))
 782                     if File:
 783                         self._Includes.append(File)
 784
 785                     # TRICK: let compiler to choose correct header file
 786                     Macros['EDK_SOURCE'] = GlobalData.gEdkSource
 787                     File = NormPath(Record[0], self._Macros)
 788                     if File[0] == '.':
 789                         File = os.path.join(self._ModuleDir, File)
 790                     else:
 791                         File = os.path.join(GlobalData.gWorkspace, File)
 792                     File = RealPath(os.path.normpath(File))
 793                     if File:
 794                         self._Includes.append(File)
 795                 else:
 796                     File = NormPath(Record[0], Macros)
 797                     if File[0] == '.':
 798                         File = os.path.join(self._ModuleDir, File)
 799                     else:
 800                         File = mws.join(GlobalData.gWorkspace, File)
 801                     File = RealPath(os.path.normpath(File))
 802                     if File:
 803                         self._Includes.append(File)
 804                     if not File and Record[0].find('EFI_SOURCE') > -1:
 805                         # tricky to regard WorkSpace as EFI_SOURCE
 806                         Macros['EFI_SOURCE'] = GlobalData.gWorkspace
 807                         File = NormPath(Record[0], Macros)
 808                         if File[0] == '.':
 809                             File = os.path.join(self._ModuleDir, File)
 810                         else:
 811                             File = os.path.join(GlobalData.gWorkspace, File)
 812                         File = RealPath(os.path.normpath(File))
 813                         if File:
 814                             self._Includes.append(File)
 815         return self._Includes
 816
 817     ## Retrieve packages this module depends on
 818     def _GetPackages(self):
 819         if self._Packages is None:
 820             self._Packages = []
 821             RecordList = self._RawData[MODEL_META_DATA_PACKAGE, self._Arch, self._Platform]
 822             Macros = self._Macros
 823             Macros['EDK_SOURCE'] = GlobalData.gEcpSource
 824             for Record in RecordList:
 825                 File = PathClass(NormPath(Record[0], Macros), GlobalData.gWorkspace, Arch=self._Arch)
 826                 LineNo = Record[-1]
 827                 # check the file validation
 828                 ErrorCode, ErrorInfo = File.Validate('.dec')
 829                 if ErrorCode != 0:
 830                     EdkLogger.error('build', ErrorCode, ExtraData=ErrorInfo, File=self.MetaFile, Line=LineNo)
 831                 # parse this package now. we need it to get protocol/ppi/guid value
 832                 Package = self._Bdb[File, self._Arch, self._Target, self._Toolchain]
 833                 self._Packages.append(Package)
 834         return self._Packages
 835
 836     ## Retrieve PCD comments
 837     def _GetPcdComments(self):
 838         self._GetPcds()
 839         return self._PcdComments
 840     ## Retrieve PCDs used in this module
 841     def _GetPcds(self):
 842         if self._Pcds is None:
 843             self._Pcds = OrderedDict()
 844             self._PcdComments = OrderedDict()
 845             self._Pcds.update(self._GetPcd(MODEL_PCD_FIXED_AT_BUILD))
 846             self._Pcds.update(self._GetPcd(MODEL_PCD_PATCHABLE_IN_MODULE))
 847             self._Pcds.update(self._GetPcd(MODEL_PCD_FEATURE_FLAG))
 848             self._Pcds.update(self._GetPcd(MODEL_PCD_DYNAMIC))
 849             self._Pcds.update(self._GetPcd(MODEL_PCD_DYNAMIC_EX))
 850         return self._Pcds
 851
 852     ## Retrieve build options specific to this module
 853     def _GetBuildOptions(self):
 854         if self._BuildOptions is None:
 855             self._BuildOptions = OrderedDict()
 856             RecordList = self._RawData[MODEL_META_DATA_BUILD_OPTION, self._Arch, self._Platform]
 857             for Record in RecordList:
 858                 ToolChainFamily = Record[0]
 859                 ToolChain = Record[1]
 860                 Option = Record[2]
 861                 if (ToolChainFamily, ToolChain) not in self._BuildOptions or Option.startswith('='):
 862                     self._BuildOptions[ToolChainFamily, ToolChain] = Option
 863                 else:
 864                     # concatenate the option string if they're for the same tool
 865                     OptionString = self._BuildOptions[ToolChainFamily, ToolChain]
 866                     self._BuildOptions[ToolChainFamily, ToolChain] = OptionString + " " + Option
 867         return self._BuildOptions
 868
 869     ## Retrieve dependency expression
 870     def _GetDepex(self):
 871         if self._Depex is None:
 872             self._Depex = tdict(False, 2)
 873             RecordList = self._RawData[MODEL_EFI_DEPEX, self._Arch]
 874
 875             # If the module has only Binaries and no Sources, then ignore [Depex]
 876             if self.Sources is None or self.Sources == []:
 877                 if self.Binaries is not None and self.Binaries != []:
 878                     return self._Depex
 879
 880             # PEIM and DXE drivers must have a valid [Depex] section
 881             if len(self.LibraryClass) == 0 and len(RecordList) == 0:
 882                 if self.ModuleType == SUP_MODULE_DXE_DRIVER or self.ModuleType == SUP_MODULE_PEIM or self.ModuleType == SUP_MODULE_DXE_SMM_DRIVER or \
 883                     self.ModuleType == SUP_MODULE_DXE_SAL_DRIVER or self.ModuleType == SUP_MODULE_DXE_RUNTIME_DRIVER:
 884                     EdkLogger.error('build', RESOURCE_NOT_AVAILABLE, "No [Depex] section or no valid expression in [Depex] section for [%s] module" \
 885                                     % self.ModuleType, File=self.MetaFile)
 886
 887             if len(RecordList) != 0 and self.ModuleType == SUP_MODULE_USER_DEFINED:
 888                 for Record in RecordList:
 889                     if Record[4] not in [SUP_MODULE_PEIM, SUP_MODULE_DXE_DRIVER, SUP_MODULE_DXE_SMM_DRIVER]:
 890                         EdkLogger.error('build', FORMAT_INVALID,
 891                                         "'%s' module must specify the type of [Depex] section" % self.ModuleType,
 892                                         File=self.MetaFile)
 893
 894             Depex = OrderedDict()
 895             for Record in RecordList:
 896                 DepexStr = ReplaceMacro(Record[0], self._Macros, False)
 897                 Arch = Record[3]
 898                 ModuleType = Record[4]
 899                 TokenList = DepexStr.split()
 900                 if (Arch, ModuleType) not in Depex:
 901                     Depex[Arch, ModuleType] = []
 902                 DepexList = Depex[Arch, ModuleType]
 903                 for Token in TokenList:
 904                     if Token in DEPEX_SUPPORTED_OPCODE_SET:
 905                         DepexList.append(Token)
 906                     elif Token.endswith(".inf"):  # module file name
 907                         ModuleFile = os.path.normpath(Token)
 908                         Module = self.BuildDatabase[ModuleFile]
 909                         if Module is None:
 910                             EdkLogger.error('build', RESOURCE_NOT_AVAILABLE, "Module is not found in active platform",
 911                                             ExtraData=Token, File=self.MetaFile, Line=Record[-1])
 912                         DepexList.append(Module.Guid)
 913                     else:
 914                         # get the GUID value now
 915                         Value = ProtocolValue(Token, self.Packages, self.MetaFile.Path)
 916                         if Value is None:
 917                             Value = PpiValue(Token, self.Packages, self.MetaFile.Path)
 918                             if Value is None:
 919                                 Value = GuidValue(Token, self.Packages, self.MetaFile.Path)
 920                         if Value is None:
 921                             PackageList = "\n\t".join(str(P) for P in self.Packages)
 922                             EdkLogger.error('build', RESOURCE_NOT_AVAILABLE,
 923                                             "Value of [%s] is not found in" % Token,
 924                                             ExtraData=PackageList, File=self.MetaFile, Line=Record[-1])
 925                         DepexList.append(Value)
 926             for Arch, ModuleType in Depex:
 927                 self._Depex[Arch, ModuleType] = Depex[Arch, ModuleType]
 928         return self._Depex
 929
 930     ## Retrieve depedency expression
 931     def _GetDepexExpression(self):
 932         if self._DepexExpression is None:
 933             self._DepexExpression = tdict(False, 2)
 934             RecordList = self._RawData[MODEL_EFI_DEPEX, self._Arch]
 935             DepexExpression = OrderedDict()
 936             for Record in RecordList:
 937                 DepexStr = ReplaceMacro(Record[0], self._Macros, False)
 938                 Arch = Record[3]
 939                 ModuleType = Record[4]
 940                 TokenList = DepexStr.split()
 941                 if (Arch, ModuleType) not in DepexExpression:
 942                     DepexExpression[Arch, ModuleType] = ''
 943                 for Token in TokenList:
 944                     DepexExpression[Arch, ModuleType] = DepexExpression[Arch, ModuleType] + Token.strip() + ' '
 945             for Arch, ModuleType in DepexExpression:
 946                 self._DepexExpression[Arch, ModuleType] = DepexExpression[Arch, ModuleType]
 947         return self._DepexExpression
 948
 949     def GetGuidsUsedByPcd(self):
 950         return self._GuidsUsedByPcd
 951     ## Retrieve PCD for given type
 952     def _GetPcd(self, Type):
 953         Pcds = OrderedDict()
 954         PcdDict = tdict(True, 4)
 955         PcdList = []
 956         RecordList = self._RawData[Type, self._Arch, self._Platform]
 957         for TokenSpaceGuid, PcdCName, Setting, Arch, Platform, Id, LineNo in RecordList:
 958             PcdDict[Arch, Platform, PcdCName, TokenSpaceGuid] = (Setting, LineNo)
 959             PcdList.append((PcdCName, TokenSpaceGuid))
 960             # get the guid value
 961             if TokenSpaceGuid not in self.Guids:
 962                 Value = GuidValue(TokenSpaceGuid, self.Packages, self.MetaFile.Path)
 963                 if Value is None:
 964                     PackageList = "\n\t".join(str(P) for P in self.Packages)
 965                     EdkLogger.error('build', RESOURCE_NOT_AVAILABLE,
 966                                     "Value of Guid [%s] is not found under [Guids] section in" % TokenSpaceGuid,
 967                                     ExtraData=PackageList, File=self.MetaFile, Line=LineNo)
 968                 self.Guids[TokenSpaceGuid] = Value
 969                 self._GuidsUsedByPcd[TokenSpaceGuid] = Value
 970             CommentRecords = self._RawData[MODEL_META_DATA_COMMENT, self._Arch, self._Platform, Id]
 971             Comments = []
 972             for CmtRec in CommentRecords:
 973                 Comments.append(CmtRec[0])
 974             self._PcdComments[TokenSpaceGuid, PcdCName] = Comments
 975
 976         # resolve PCD type, value, datum info, etc. by getting its definition from package
 977         _GuidDict = self.Guids.copy()
 978         for PcdCName, TokenSpaceGuid in PcdList:
 979             PcdRealName = PcdCName
 980             Setting, LineNo = PcdDict[self._Arch, self.Platform, PcdCName, TokenSpaceGuid]
 981             if Setting is None:
 982                 continue
 983             ValueList = AnalyzePcdData(Setting)
 984             DefaultValue = ValueList[0]
 985             Pcd = PcdClassObject(
 986                     PcdCName,
 987                     TokenSpaceGuid,
 988                     '',
 989                     '',
 990                     DefaultValue,
 991                     '',
 992                     '',
 993                     {},
 994                     False,
 995                     self.Guids[TokenSpaceGuid]
 996                     )
 997             if Type == MODEL_PCD_PATCHABLE_IN_MODULE and ValueList[1]:
 998                 # Patch PCD: TokenSpace.PcdCName|Value|Offset
 999                 Pcd.Offset = ValueList[1]
1000
1001             if (PcdRealName, TokenSpaceGuid) in GlobalData.MixedPcd:
1002                 for Package in self.Packages:
1003                     for key in Package.Pcds:
1004                         if (Package.Pcds[key].TokenCName, Package.Pcds[key].TokenSpaceGuidCName) == (PcdRealName, TokenSpaceGuid):
1005                             for item in GlobalData.MixedPcd[(PcdRealName, TokenSpaceGuid)]:
1006                                 Pcd_Type = item[0].split('_')[-1]
1007                                 if Pcd_Type == Package.Pcds[key].Type:
1008                                     Value = Package.Pcds[key]
1009                                     Value.TokenCName = Package.Pcds[key].TokenCName + '_' + Pcd_Type
1010                                     if len(key) == 2:
1011                                         newkey = (Value.TokenCName, key[1])
1012                                     elif len(key) == 3:
1013                                         newkey = (Value.TokenCName, key[1], key[2])
1014                                     del Package.Pcds[key]
1015                                     Package.Pcds[newkey] = Value
1016                                     break
1017                                 else:
1018                                     pass
1019                         else:
1020                             pass
1021
1022             # get necessary info from package declaring this PCD
1023             for Package in self.Packages:
1024                 #
1025                 # 'dynamic' in INF means its type is determined by platform;
1026                 # if platform doesn't give its type, use 'lowest' one in the
1027                 # following order, if any
1028                 #
1029                 #   TAB_PCDS_FIXED_AT_BUILD, TAB_PCDS_PATCHABLE_IN_MODULE, TAB_PCDS_FEATURE_FLAG, TAB_PCDS_DYNAMIC, TAB_PCDS_DYNAMIC_EX
1030                 #
1031                 _GuidDict.update(Package.Guids)
1032                 PcdType = self._PCD_TYPE_STRING_[Type]
1033                 if Type == MODEL_PCD_DYNAMIC:
1034                     Pcd.Pending = True
1035                     for T in PCD_TYPE_LIST:
1036                         if (PcdRealName, TokenSpaceGuid) in GlobalData.MixedPcd:
1037                             for item in GlobalData.MixedPcd[(PcdRealName, TokenSpaceGuid)]:
1038                                 if str(item[0]).endswith(T) and (item[0], item[1], T) in Package.Pcds:
1039                                     PcdType = T
1040                                     PcdCName = item[0]
1041                                     break
1042                                 else:
1043                                     pass
1044                             break
1045                         else:
1046                             if (PcdRealName, TokenSpaceGuid, T) in Package.Pcds:
1047                                 PcdType = T
1048                                 break
1049
1050                 else:
1051                     Pcd.Pending = False
1052                     if (PcdRealName, TokenSpaceGuid) in GlobalData.MixedPcd:
1053                         for item in GlobalData.MixedPcd[(PcdRealName, TokenSpaceGuid)]:
1054                             Pcd_Type = item[0].split('_')[-1]
1055                             if Pcd_Type == PcdType:
1056                                 PcdCName = item[0]
1057                                 break
1058                             else:
1059                                 pass
1060                     else:
1061                         pass
1062
1063                 if (PcdCName, TokenSpaceGuid, PcdType) in Package.Pcds:
1064                     PcdInPackage = Package.Pcds[PcdCName, TokenSpaceGuid, PcdType]
1065                     Pcd.Type = PcdType
1066                     Pcd.TokenValue = PcdInPackage.TokenValue
1067
1068                     #
1069                     # Check whether the token value exist or not.
1070                     #
1071                     if Pcd.TokenValue is None or Pcd.TokenValue == "":
1072                         EdkLogger.error(
1073                                 'build',
1074                                 FORMAT_INVALID,
1075                                 "No TokenValue for PCD [%s.%s] in [%s]!" % (TokenSpaceGuid, PcdRealName, str(Package)),
1076                                 File=self.MetaFile, Line=LineNo,
1077                                 ExtraData=None
1078                                 )
1079                     #
1080                     # Check hexadecimal token value length and format.
1081                     #
1082                     ReIsValidPcdTokenValue = re.compile(r"^[0][x|X][0]*[0-9a-fA-F]{1,8}$", re.DOTALL)
1083                     if Pcd.TokenValue.startswith("0x") or Pcd.TokenValue.startswith("0X"):
1084                         if ReIsValidPcdTokenValue.match(Pcd.TokenValue) is None:
1085                             EdkLogger.error(
1086                                     'build',
1087                                     FORMAT_INVALID,
1088                                     "The format of TokenValue [%s] of PCD [%s.%s] in [%s] is invalid:" % (Pcd.TokenValue, TokenSpaceGuid, PcdRealName, str(Package)),
1089                                     File=self.MetaFile, Line=LineNo,
1090                                     ExtraData=None
1091                                     )
1092
1093                     #
1094                     # Check decimal token value length and format.
1095                     #
1096                     else:
1097                         try:
1098                             TokenValueInt = int (Pcd.TokenValue, 10)
1099                             if (TokenValueInt < 0 or TokenValueInt > 4294967295):
1100                                 EdkLogger.error(
1101                                             'build',
1102                                             FORMAT_INVALID,
1103                                             "The format of TokenValue [%s] of PCD [%s.%s] in [%s] is invalid, as a decimal it should between: 0 - 4294967295!" % (Pcd.TokenValue, TokenSpaceGuid, PcdRealName, str(Package)),
1104                                             File=self.MetaFile, Line=LineNo,
1105                                             ExtraData=None
1106                                             )
1107                         except:
1108                             EdkLogger.error(
1109                                         'build',
1110                                         FORMAT_INVALID,
1111                                         "The format of TokenValue [%s] of PCD [%s.%s] in [%s] is invalid, it should be hexadecimal or decimal!" % (Pcd.TokenValue, TokenSpaceGuid, PcdRealName, str(Package)),
1112                                         File=self.MetaFile, Line=LineNo,
1113                                         ExtraData=None
1114                                         )
1115
1116                     Pcd.DatumType = PcdInPackage.DatumType
1117                     Pcd.MaxDatumSize = PcdInPackage.MaxDatumSize
1118                     Pcd.InfDefaultValue = Pcd.DefaultValue
1119                     if not Pcd.DefaultValue:
1120                         Pcd.DefaultValue = PcdInPackage.DefaultValue
1121                     else:
1122                         try:
1123                             Pcd.DefaultValue = ValueExpressionEx(Pcd.DefaultValue, Pcd.DatumType, _GuidDict)(True)
1124                         except BadExpression, Value:
1125                             EdkLogger.error('Parser', FORMAT_INVALID, 'PCD [%s.%s] Value "%s", %s' %(TokenSpaceGuid, PcdRealName, Pcd.DefaultValue, Value),
1126                                             File=self.MetaFile, Line=LineNo)
1127                     break
1128             else:
1129                 EdkLogger.error(
1130                             'build',
1131                             FORMAT_INVALID,
1132                             "PCD [%s.%s] in [%s] is not found in dependent packages:" % (TokenSpaceGuid, PcdRealName, self.MetaFile),
1133                             File=self.MetaFile, Line=LineNo,
1134                             ExtraData="\t%s" % '\n\t'.join(str(P) for P in self.Packages)
1135                             )
1136             Pcds[PcdCName, TokenSpaceGuid] = Pcd
1137
1138         return Pcds
1139
1140     ## check whether current module is binary module
1141     def _IsBinaryModule(self):
1142         if self.Binaries and not self.Sources:
1143             return True
1144         elif GlobalData.gIgnoreSource:
1145             return True
1146         else:
1147             return False
1148
1149     _Macros = property(_GetMacros)
1150     Arch = property(_GetArch, _SetArch)
1151     Platform = property(_GetPlatform, _SetPlatform)
1152
1153     HeaderComments = property(_GetHeaderComments)
1154     TailComments = property(_GetTailComments)
1155     AutoGenVersion          = property(_GetInfVersion)
1156     BaseName                = property(_GetBaseName)
1157     ModuleType              = property(_GetModuleType)
1158     ComponentType           = property(_GetComponentType)
1159     BuildType               = property(_GetBuildType)
1160     Guid                    = property(_GetFileGuid)
1161     Version                 = property(_GetVersion)
1162     PcdIsDriver             = property(_GetPcdIsDriver)
1163     Shadow                  = property(_GetShadow)
1164     CustomMakefile          = property(_GetMakefile)
1165     Specification           = property(_GetSpec)
1166     LibraryClass            = property(_GetLibraryClass)
1167     ModuleEntryPointList    = property(_GetEntryPoint)
1168     ModuleUnloadImageList   = property(_GetUnloadImage)
1169     ConstructorList         = property(_GetConstructor)
1170     DestructorList          = property(_GetDestructor)
1171     Defines                 = property(_GetDefines)
1172     DxsFile                 = property(_GetDxsFile)
1173
1174     Binaries                = property(_GetBinaryFiles)
1175     Sources                 = property(_GetSourceFiles)
1176     LibraryClasses          = property(_GetLibraryClassUses)
1177     Libraries               = property(_GetLibraryNames)
1178     Protocols               = property(_GetProtocols)
1179     ProtocolComments        = property(_GetProtocolComments)
1180     Ppis                    = property(_GetPpis)
1181     PpiComments             = property(_GetPpiComments)
1182     Guids                   = property(_GetGuids)
1183     GuidComments            = property(_GetGuidComments)
1184     Includes                = property(_GetIncludes)
1185     Packages                = property(_GetPackages)
1186     Pcds                    = property(_GetPcds)
1187     PcdComments             = property(_GetPcdComments)
1188     BuildOptions            = property(_GetBuildOptions)
1189     Depex                   = property(_GetDepex)
1190     DepexExpression         = property(_GetDepexExpression)
1191     IsBinaryModule          = property(_IsBinaryModule)
1192     IsSupportedArch         = property(_IsSupportedArch)