BaseTools/Source/Python/Workspace/DscBuildData.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 ## Platform build information from DSC file
  16 #
  17 #  This class is used to retrieve information stored in database and convert them
  18 # into PlatformBuildClassObject form for easier use for AutoGen.
  19 #
  20 from Common.String import *
  21 from Common.DataType import *
  22 from Common.Misc import *
  23 from types import *
  24
  25 from CommonDataClass.CommonClass import SkuInfoClass
  26 from Common.TargetTxtClassObject import *
  27 from Common.ToolDefClassObject import *
  28 from MetaDataTable import *
  29 from MetaFileTable import *
  30 from MetaFileParser import *
  31
  32 from WorkspaceCommon import GetDeclaredPcd
  33 from Common.Misc import AnalyzeDscPcd
  34 from Common.Misc import ProcessDuplicatedInf
  35 import re
  36 from Common.Parsing import IsValidWord
  37 from Common.VariableAttributes import VariableAttributes
  38 import Common.GlobalData as GlobalData
  39 import subprocess
  40 from Workspace.BuildClassObject import PlatformBuildClassObject, StructurePcd, PcdClassObject, ModuleBuildClassObject
  41
  42 #
  43 # Treat CHAR16 as a synonym for UINT16.  CHAR16 support is required for VFR C structs
  44 #
  45 PcdValueInitName = 'PcdValueInit'
  46 PcdSupportedBaseTypes = ['BOOLEAN', 'UINT8', 'UINT16', 'UINT32', 'UINT64', 'CHAR16']
  47 PcdSupportedBaseTypeWidth = {'BOOLEAN':8, 'UINT8':8, 'UINT16':16, 'UINT32':32, 'UINT64':64}
  48 PcdUnsupportedBaseTypes = ['INT8', 'INT16', 'INT32', 'INT64', 'CHAR8', 'UINTN', 'INTN', 'VOID']
  49
  50 PcdMainCHeader = '''
  51 /**
  52   DO NOT EDIT
  53   FILE auto-generated
  54 **/
  55
  56 #include <stdio.h>
  57 #include <stdlib.h>
  58 #include <string.h>
  59 #include <PcdValueCommon.h>
  60 '''
  61
  62 PcdMainCEntry = '''
  63 int
  64 main (
  65   int   argc,
  66   char  *argv[]
  67   )
  68 {
  69   return PcdValueMain (argc, argv);
  70 }
  71 '''
  72
  73 PcdMakefileHeader = '''
  74 #
  75 # DO NOT EDIT
  76 # This file is auto-generated by build utility
  77 #
  78
  79 '''
  80
  81 WindowsCFLAGS = 'CFLAGS = $(CFLAGS) /wd4200 /wd4034 /wd4101 '
  82 LinuxCFLAGS = 'BUILD_CFLAGS += -Wno-pointer-to-int-cast -Wno-unused-variable '
  83 PcdMakefileEnd = '''
  84 !INCLUDE $(BASE_TOOLS_PATH)\Source\C\Makefiles\ms.common
  85
  86 LIBS = $(LIB_PATH)\Common.lib
  87
  88 !INCLUDE $(BASE_TOOLS_PATH)\Source\C\Makefiles\ms.app
  89 '''
  90
  91 PcdGccMakefile = '''
  92 ARCH ?= IA32
  93 MAKEROOT ?= $(EDK_TOOLS_PATH)/Source/C
  94 LIBS = -lCommon
  95 '''
  96
  97 class DscBuildData(PlatformBuildClassObject):
  98     # dict used to convert PCD type in database to string used by build tool
  99     _PCD_TYPE_STRING_ = {
 100         MODEL_PCD_FIXED_AT_BUILD        :   "FixedAtBuild",
 101         MODEL_PCD_PATCHABLE_IN_MODULE   :   "PatchableInModule",
 102         MODEL_PCD_FEATURE_FLAG          :   "FeatureFlag",
 103         MODEL_PCD_DYNAMIC               :   "Dynamic",
 104         MODEL_PCD_DYNAMIC_DEFAULT       :   "Dynamic",
 105         MODEL_PCD_DYNAMIC_HII           :   "DynamicHii",
 106         MODEL_PCD_DYNAMIC_VPD           :   "DynamicVpd",
 107         MODEL_PCD_DYNAMIC_EX            :   "DynamicEx",
 108         MODEL_PCD_DYNAMIC_EX_DEFAULT    :   "DynamicEx",
 109         MODEL_PCD_DYNAMIC_EX_HII        :   "DynamicExHii",
 110         MODEL_PCD_DYNAMIC_EX_VPD        :   "DynamicExVpd",
 111     }
 112
 113     # dict used to convert part of [Defines] to members of DscBuildData directly
 114     _PROPERTY_ = {
 115         #
 116         # Required Fields
 117         #
 118         TAB_DSC_DEFINES_PLATFORM_NAME           :   "_PlatformName",
 119         TAB_DSC_DEFINES_PLATFORM_GUID           :   "_Guid",
 120         TAB_DSC_DEFINES_PLATFORM_VERSION        :   "_Version",
 121         TAB_DSC_DEFINES_DSC_SPECIFICATION       :   "_DscSpecification",
 122         # TAB_DSC_DEFINES_OUTPUT_DIRECTORY        :   "_OutputDirectory",
 123         # TAB_DSC_DEFINES_SUPPORTED_ARCHITECTURES :   "_SupArchList",
 124         # TAB_DSC_DEFINES_BUILD_TARGETS           :   "_BuildTargets",
 125         TAB_DSC_DEFINES_SKUID_IDENTIFIER        :   "_SkuName",
 126         # TAB_DSC_DEFINES_FLASH_DEFINITION        :   "_FlashDefinition",
 127         TAB_DSC_DEFINES_BUILD_NUMBER            :   "_BuildNumber",
 128         TAB_DSC_DEFINES_MAKEFILE_NAME           :   "_MakefileName",
 129         TAB_DSC_DEFINES_BS_BASE_ADDRESS         :   "_BsBaseAddress",
 130         TAB_DSC_DEFINES_RT_BASE_ADDRESS         :   "_RtBaseAddress",
 131         # TAB_DSC_DEFINES_RFC_LANGUAGES           :   "_RFCLanguages",
 132         # TAB_DSC_DEFINES_ISO_LANGUAGES           :   "_ISOLanguages",
 133     }
 134
 135     # used to compose dummy library class name for those forced library instances
 136     _NullLibraryNumber = 0
 137
 138     ## Constructor of DscBuildData
 139     #
 140     #  Initialize object of DscBuildData
 141     #
 142     #   @param      FilePath        The path of platform description file
 143     #   @param      RawData         The raw data of DSC file
 144     #   @param      BuildDataBase   Database used to retrieve module/package information
 145     #   @param      Arch            The target architecture
 146     #   @param      Platform        (not used for DscBuildData)
 147     #   @param      Macros          Macros used for replacement in DSC file
 148     #
 149     def __init__(self, FilePath, RawData, BuildDataBase, Arch='COMMON', Target=None, Toolchain=None):
 150         self.MetaFile = FilePath
 151         self._RawData = RawData
 152         self._Bdb = BuildDataBase
 153         self._Arch = Arch
 154         self._Target = Target
 155         self._Toolchain = Toolchain
 156         self._ToolChainFamily = None
 157         self._Clear()
 158         self._HandleOverridePath()
 159         if os.getenv("WORKSPACE"):
 160             self.OutputPath = os.path.join(os.getenv("WORKSPACE"), 'Build', PcdValueInitName)
 161         else:
 162             self.OutputPath = os.path.dirname(self.DscFile)
 163         self.DefaultStores = None
 164         self.SkuIdMgr = SkuClass(self.SkuName, self.SkuIds)
 165         arraystr = self.SkuIdMgr.DumpSkuIdArrary()
 166
 167     ## XXX[key] = value
 168     def __setitem__(self, key, value):
 169         self.__dict__[self._PROPERTY_[key]] = value
 170
 171     ## value = XXX[key]
 172     def __getitem__(self, key):
 173         return self.__dict__[self._PROPERTY_[key]]
 174
 175     ## "in" test support
 176     def __contains__(self, key):
 177         return key in self._PROPERTY_
 178
 179     ## Set all internal used members of DscBuildData to None
 180     def _Clear(self):
 181         self._Header            = None
 182         self._PlatformName      = None
 183         self._Guid              = None
 184         self._Version           = None
 185         self._DscSpecification  = None
 186         self._OutputDirectory   = None
 187         self._SupArchList       = None
 188         self._BuildTargets      = None
 189         self._SkuName           = None
 190         self._PcdInfoFlag       = None
 191         self._VarCheckFlag      = None
 192         self._FlashDefinition   = None
 193         self._Prebuild          = None
 194         self._Postbuild         = None
 195         self._BuildNumber       = None
 196         self._MakefileName      = None
 197         self._BsBaseAddress     = None
 198         self._RtBaseAddress     = None
 199         self._SkuIds            = None
 200         self._Modules           = None
 201         self._LibraryInstances  = None
 202         self._LibraryClasses    = None
 203         self._Pcds              = None
 204         self._DecPcds           = None
 205         self._BuildOptions      = None
 206         self._ModuleTypeOptions = None
 207         self._LoadFixAddress    = None
 208         self._RFCLanguages      = None
 209         self._ISOLanguages      = None
 210         self._VpdToolGuid       = None
 211         self.__Macros           = None
 212         self.DefaultStores      = None
 213
 214
 215     ## handle Override Path of Module
 216     def _HandleOverridePath(self):
 217         RecordList = self._RawData[MODEL_META_DATA_COMPONENT, self._Arch]
 218         Macros = self._Macros
 219         Macros["EDK_SOURCE"] = GlobalData.gEcpSource
 220         for Record in RecordList:
 221             ModuleId = Record[6]
 222             LineNo = Record[7]
 223             ModuleFile = PathClass(NormPath(Record[0]), GlobalData.gWorkspace, Arch=self._Arch)
 224             RecordList = self._RawData[MODEL_META_DATA_COMPONENT_SOURCE_OVERRIDE_PATH, self._Arch, None, ModuleId]
 225             if RecordList != []:
 226                 SourceOverridePath = mws.join(GlobalData.gWorkspace, NormPath(RecordList[0][0]))
 227
 228                 # Check if the source override path exists
 229                 if not os.path.isdir(SourceOverridePath):
 230                     EdkLogger.error('build', FILE_NOT_FOUND, Message='Source override path does not exist:', File=self.MetaFile, ExtraData=SourceOverridePath, Line=LineNo)
 231
 232                 # Add to GlobalData Variables
 233                 GlobalData.gOverrideDir[ModuleFile.Key] = SourceOverridePath
 234
 235     ## Get current effective macros
 236     def _GetMacros(self):
 237         if self.__Macros == None:
 238             self.__Macros = {}
 239             self.__Macros.update(GlobalData.gPlatformDefines)
 240             self.__Macros.update(GlobalData.gGlobalDefines)
 241             self.__Macros.update(GlobalData.gCommandLineDefines)
 242         return self.__Macros
 243
 244     ## Get architecture
 245     def _GetArch(self):
 246         return self._Arch
 247
 248     ## Set architecture
 249     #
 250     #   Changing the default ARCH to another may affect all other information
 251     # because all information in a platform may be ARCH-related. That's
 252     # why we need to clear all internal used members, in order to cause all
 253     # information to be re-retrieved.
 254     #
 255     #   @param  Value   The value of ARCH
 256     #
 257     def _SetArch(self, Value):
 258         if self._Arch == Value:
 259             return
 260         self._Arch = Value
 261         self._Clear()
 262
 263     ## Retrieve all information in [Defines] section
 264     #
 265     #   (Retriving all [Defines] information in one-shot is just to save time.)
 266     #
 267     def _GetHeaderInfo(self):
 268         RecordList = self._RawData[MODEL_META_DATA_HEADER, self._Arch]
 269         for Record in RecordList:
 270             Name = Record[1]
 271             # items defined _PROPERTY_ don't need additional processing
 272
 273             # some special items in [Defines] section need special treatment
 274             if Name == TAB_DSC_DEFINES_OUTPUT_DIRECTORY:
 275                 self._OutputDirectory = NormPath(Record[2], self._Macros)
 276                 if ' ' in self._OutputDirectory:
 277                     EdkLogger.error("build", FORMAT_NOT_SUPPORTED, "No space is allowed in OUTPUT_DIRECTORY",
 278                                     File=self.MetaFile, Line=Record[-1],
 279                                     ExtraData=self._OutputDirectory)
 280             elif Name == TAB_DSC_DEFINES_FLASH_DEFINITION:
 281                 self._FlashDefinition = PathClass(NormPath(Record[2], self._Macros), GlobalData.gWorkspace)
 282                 ErrorCode, ErrorInfo = self._FlashDefinition.Validate('.fdf')
 283                 if ErrorCode != 0:
 284                     EdkLogger.error('build', ErrorCode, File=self.MetaFile, Line=Record[-1],
 285                                     ExtraData=ErrorInfo)
 286             elif Name == TAB_DSC_PREBUILD:
 287                 PrebuildValue = Record[2]
 288                 if Record[2][0] == '"':
 289                     if Record[2][-1] != '"':
 290                         EdkLogger.error('build', FORMAT_INVALID, 'Missing double quotes in the end of %s statement.' % TAB_DSC_PREBUILD,
 291                                     File=self.MetaFile, Line=Record[-1])
 292                     PrebuildValue = Record[2][1:-1]
 293                 self._Prebuild = PrebuildValue
 294             elif Name == TAB_DSC_POSTBUILD:
 295                 PostbuildValue = Record[2]
 296                 if Record[2][0] == '"':
 297                     if Record[2][-1] != '"':
 298                         EdkLogger.error('build', FORMAT_INVALID, 'Missing double quotes in the end of %s statement.' % TAB_DSC_POSTBUILD,
 299                                     File=self.MetaFile, Line=Record[-1])
 300                     PostbuildValue = Record[2][1:-1]
 301                 self._Postbuild = PostbuildValue
 302             elif Name == TAB_DSC_DEFINES_SUPPORTED_ARCHITECTURES:
 303                 self._SupArchList = GetSplitValueList(Record[2], TAB_VALUE_SPLIT)
 304             elif Name == TAB_DSC_DEFINES_BUILD_TARGETS:
 305                 self._BuildTargets = GetSplitValueList(Record[2])
 306             elif Name == TAB_DSC_DEFINES_SKUID_IDENTIFIER:
 307                 if self._SkuName == None:
 308                     self._SkuName = Record[2]
 309                 if GlobalData.gSKUID_CMD:
 310                     self._SkuName = GlobalData.gSKUID_CMD
 311             elif Name == TAB_DSC_DEFINES_PCD_INFO_GENERATION:
 312                 self._PcdInfoFlag = Record[2]
 313             elif Name == TAB_DSC_DEFINES_PCD_VAR_CHECK_GENERATION:
 314                 self._VarCheckFlag = Record[2]
 315             elif Name == TAB_FIX_LOAD_TOP_MEMORY_ADDRESS:
 316                 try:
 317                     self._LoadFixAddress = int (Record[2], 0)
 318                 except:
 319                     EdkLogger.error("build", PARAMETER_INVALID, "FIX_LOAD_TOP_MEMORY_ADDRESS %s is not valid dec or hex string" % (Record[2]))
 320             elif Name == TAB_DSC_DEFINES_RFC_LANGUAGES:
 321                 if not Record[2] or Record[2][0] != '"' or Record[2][-1] != '"' or len(Record[2]) == 1:
 322                     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"',
 323                                     File=self.MetaFile, Line=Record[-1])
 324                 LanguageCodes = Record[2][1:-1]
 325                 if not LanguageCodes:
 326                     EdkLogger.error('build', FORMAT_NOT_SUPPORTED, 'one or more RFC4646 format language code must be provided for RFC_LANGUAGES statement',
 327                                     File=self.MetaFile, Line=Record[-1])
 328                 LanguageList = GetSplitValueList(LanguageCodes, TAB_SEMI_COLON_SPLIT)
 329                 # check whether there is empty entries in the list
 330                 if None in LanguageList:
 331                     EdkLogger.error('build', FORMAT_NOT_SUPPORTED, 'one or more empty language code is in RFC_LANGUAGES statement',
 332                                     File=self.MetaFile, Line=Record[-1])
 333                 self._RFCLanguages = LanguageList
 334             elif Name == TAB_DSC_DEFINES_ISO_LANGUAGES:
 335                 if not Record[2] or Record[2][0] != '"' or Record[2][-1] != '"' or len(Record[2]) == 1:
 336                     EdkLogger.error('build', FORMAT_NOT_SUPPORTED, 'language code for ISO_LANGUAGES must have double quotes around it, for example: ISO_LANGUAGES = "engchn"',
 337                                     File=self.MetaFile, Line=Record[-1])
 338                 LanguageCodes = Record[2][1:-1]
 339                 if not LanguageCodes:
 340                     EdkLogger.error('build', FORMAT_NOT_SUPPORTED, 'one or more ISO639-2 format language code must be provided for ISO_LANGUAGES statement',
 341                                     File=self.MetaFile, Line=Record[-1])
 342                 if len(LanguageCodes) % 3:
 343                     EdkLogger.error('build', FORMAT_NOT_SUPPORTED, 'bad ISO639-2 format for ISO_LANGUAGES',
 344                                     File=self.MetaFile, Line=Record[-1])
 345                 LanguageList = []
 346                 for i in range(0, len(LanguageCodes), 3):
 347                     LanguageList.append(LanguageCodes[i:i + 3])
 348                 self._ISOLanguages = LanguageList
 349             elif Name == TAB_DSC_DEFINES_VPD_TOOL_GUID:
 350                 #
 351                 # try to convert GUID to a real UUID value to see whether the GUID is format
 352                 # for VPD_TOOL_GUID is correct.
 353                 #
 354                 try:
 355                     uuid.UUID(Record[2])
 356                 except:
 357                     EdkLogger.error("build", FORMAT_INVALID, "Invalid GUID format for VPD_TOOL_GUID", File=self.MetaFile)
 358                 self._VpdToolGuid = Record[2]
 359             elif Name in self:
 360                 self[Name] = Record[2]
 361         # set _Header to non-None in order to avoid database re-querying
 362         self._Header = 'DUMMY'
 363
 364     ## Retrieve platform name
 365     def _GetPlatformName(self):
 366         if self._PlatformName == None:
 367             if self._Header == None:
 368                 self._GetHeaderInfo()
 369             if self._PlatformName == None:
 370                 EdkLogger.error('build', ATTRIBUTE_NOT_AVAILABLE, "No PLATFORM_NAME", File=self.MetaFile)
 371         return self._PlatformName
 372
 373     ## Retrieve file guid
 374     def _GetFileGuid(self):
 375         if self._Guid == None:
 376             if self._Header == None:
 377                 self._GetHeaderInfo()
 378             if self._Guid == None:
 379                 EdkLogger.error('build', ATTRIBUTE_NOT_AVAILABLE, "No PLATFORM_GUID", File=self.MetaFile)
 380         return self._Guid
 381
 382     ## Retrieve platform version
 383     def _GetVersion(self):
 384         if self._Version == None:
 385             if self._Header == None:
 386                 self._GetHeaderInfo()
 387             if self._Version == None:
 388                 EdkLogger.error('build', ATTRIBUTE_NOT_AVAILABLE, "No PLATFORM_VERSION", File=self.MetaFile)
 389         return self._Version
 390
 391     ## Retrieve platform description file version
 392     def _GetDscSpec(self):
 393         if self._DscSpecification == None:
 394             if self._Header == None:
 395                 self._GetHeaderInfo()
 396             if self._DscSpecification == None:
 397                 EdkLogger.error('build', ATTRIBUTE_NOT_AVAILABLE, "No DSC_SPECIFICATION", File=self.MetaFile)
 398         return self._DscSpecification
 399
 400     ## Retrieve OUTPUT_DIRECTORY
 401     def _GetOutpuDir(self):
 402         if self._OutputDirectory == None:
 403             if self._Header == None:
 404                 self._GetHeaderInfo()
 405             if self._OutputDirectory == None:
 406                 self._OutputDirectory = os.path.join("Build", self._PlatformName)
 407         return self._OutputDirectory
 408
 409     ## Retrieve SUPPORTED_ARCHITECTURES
 410     def _GetSupArch(self):
 411         if self._SupArchList == None:
 412             if self._Header == None:
 413                 self._GetHeaderInfo()
 414             if self._SupArchList == None:
 415                 EdkLogger.error('build', ATTRIBUTE_NOT_AVAILABLE, "No SUPPORTED_ARCHITECTURES", File=self.MetaFile)
 416         return self._SupArchList
 417
 418     ## Retrieve BUILD_TARGETS
 419     def _GetBuildTarget(self):
 420         if self._BuildTargets == None:
 421             if self._Header == None:
 422                 self._GetHeaderInfo()
 423             if self._BuildTargets == None:
 424                 EdkLogger.error('build', ATTRIBUTE_NOT_AVAILABLE, "No BUILD_TARGETS", File=self.MetaFile)
 425         return self._BuildTargets
 426
 427     def _GetPcdInfoFlag(self):
 428         if self._PcdInfoFlag == None or self._PcdInfoFlag.upper() == 'FALSE':
 429             return False
 430         elif self._PcdInfoFlag.upper() == 'TRUE':
 431             return True
 432         else:
 433             return False
 434     def _GetVarCheckFlag(self):
 435         if self._VarCheckFlag == None or self._VarCheckFlag.upper() == 'FALSE':
 436             return False
 437         elif self._VarCheckFlag.upper() == 'TRUE':
 438             return True
 439         else:
 440             return False
 441
 442     # # Retrieve SKUID_IDENTIFIER
 443     def _GetSkuName(self):
 444         if self._SkuName == None:
 445             if self._Header == None:
 446                 self._GetHeaderInfo()
 447             if self._SkuName == None:
 448                 self._SkuName = 'DEFAULT'
 449         return self._SkuName
 450
 451     ## Override SKUID_IDENTIFIER
 452     def _SetSkuName(self, Value):
 453         self._SkuName = Value
 454         self._Pcds = None
 455
 456     def _GetFdfFile(self):
 457         if self._FlashDefinition == None:
 458             if self._Header == None:
 459                 self._GetHeaderInfo()
 460             if self._FlashDefinition == None:
 461                 self._FlashDefinition = ''
 462         return self._FlashDefinition
 463
 464     def _GetPrebuild(self):
 465         if self._Prebuild == None:
 466             if self._Header == None:
 467                 self._GetHeaderInfo()
 468             if self._Prebuild == None:
 469                 self._Prebuild = ''
 470         return self._Prebuild
 471
 472     def _GetPostbuild(self):
 473         if self._Postbuild == None:
 474             if self._Header == None:
 475                 self._GetHeaderInfo()
 476             if self._Postbuild == None:
 477                 self._Postbuild = ''
 478         return self._Postbuild
 479
 480     ## Retrieve FLASH_DEFINITION
 481     def _GetBuildNumber(self):
 482         if self._BuildNumber == None:
 483             if self._Header == None:
 484                 self._GetHeaderInfo()
 485             if self._BuildNumber == None:
 486                 self._BuildNumber = ''
 487         return self._BuildNumber
 488
 489     ## Retrieve MAKEFILE_NAME
 490     def _GetMakefileName(self):
 491         if self._MakefileName == None:
 492             if self._Header == None:
 493                 self._GetHeaderInfo()
 494             if self._MakefileName == None:
 495                 self._MakefileName = ''
 496         return self._MakefileName
 497
 498     ## Retrieve BsBaseAddress
 499     def _GetBsBaseAddress(self):
 500         if self._BsBaseAddress == None:
 501             if self._Header == None:
 502                 self._GetHeaderInfo()
 503             if self._BsBaseAddress == None:
 504                 self._BsBaseAddress = ''
 505         return self._BsBaseAddress
 506
 507     ## Retrieve RtBaseAddress
 508     def _GetRtBaseAddress(self):
 509         if self._RtBaseAddress == None:
 510             if self._Header == None:
 511                 self._GetHeaderInfo()
 512             if self._RtBaseAddress == None:
 513                 self._RtBaseAddress = ''
 514         return self._RtBaseAddress
 515
 516     ## Retrieve the top address for the load fix address
 517     def _GetLoadFixAddress(self):
 518         if self._LoadFixAddress == None:
 519             if self._Header == None:
 520                 self._GetHeaderInfo()
 521
 522             if self._LoadFixAddress == None:
 523                 self._LoadFixAddress = self._Macros.get(TAB_FIX_LOAD_TOP_MEMORY_ADDRESS, '0')
 524
 525             try:
 526                 self._LoadFixAddress = int (self._LoadFixAddress, 0)
 527             except:
 528                 EdkLogger.error("build", PARAMETER_INVALID, "FIX_LOAD_TOP_MEMORY_ADDRESS %s is not valid dec or hex string" % (self._LoadFixAddress))
 529
 530         #
 531         # If command line defined, should override the value in DSC file.
 532         #
 533         if 'FIX_LOAD_TOP_MEMORY_ADDRESS' in GlobalData.gCommandLineDefines.keys():
 534             try:
 535                 self._LoadFixAddress = int(GlobalData.gCommandLineDefines['FIX_LOAD_TOP_MEMORY_ADDRESS'], 0)
 536             except:
 537                 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']))
 538
 539         if self._LoadFixAddress < 0:
 540             EdkLogger.error("build", PARAMETER_INVALID, "FIX_LOAD_TOP_MEMORY_ADDRESS is set to the invalid negative value 0x%x" % (self._LoadFixAddress))
 541         if self._LoadFixAddress != 0xFFFFFFFFFFFFFFFF and self._LoadFixAddress % 0x1000 != 0:
 542             EdkLogger.error("build", PARAMETER_INVALID, "FIX_LOAD_TOP_MEMORY_ADDRESS is set to the invalid unaligned 4K value 0x%x" % (self._LoadFixAddress))
 543
 544         return self._LoadFixAddress
 545
 546     ## Retrieve RFCLanguage filter
 547     def _GetRFCLanguages(self):
 548         if self._RFCLanguages == None:
 549             if self._Header == None:
 550                 self._GetHeaderInfo()
 551             if self._RFCLanguages == None:
 552                 self._RFCLanguages = []
 553         return self._RFCLanguages
 554
 555     ## Retrieve ISOLanguage filter
 556     def _GetISOLanguages(self):
 557         if self._ISOLanguages == None:
 558             if self._Header == None:
 559                 self._GetHeaderInfo()
 560             if self._ISOLanguages == None:
 561                 self._ISOLanguages = []
 562         return self._ISOLanguages
 563     ## Retrieve the GUID string for VPD tool
 564     def _GetVpdToolGuid(self):
 565         if self._VpdToolGuid == None:
 566             if self._Header == None:
 567                 self._GetHeaderInfo()
 568             if self._VpdToolGuid == None:
 569                 self._VpdToolGuid = ''
 570         return self._VpdToolGuid
 571
 572     ## Retrieve [SkuIds] section information
 573     def _GetSkuIds(self):
 574         if self._SkuIds == None:
 575             self._SkuIds = sdict()
 576             RecordList = self._RawData[MODEL_EFI_SKU_ID, self._Arch]
 577             for Record in RecordList:
 578                 if Record[0] in [None, '']:
 579                     EdkLogger.error('build', FORMAT_INVALID, 'No Sku ID number',
 580                                     File=self.MetaFile, Line=Record[-1])
 581                 if Record[1] in [None, '']:
 582                     EdkLogger.error('build', FORMAT_INVALID, 'No Sku ID name',
 583                                     File=self.MetaFile, Line=Record[-1])
 584                 Pattern = re.compile('^[1-9]\d*|0$')
 585                 HexPattern = re.compile(r'0[xX][0-9a-fA-F]+$')
 586                 if Pattern.match(Record[0]) == None and HexPattern.match(Record[0]) == None:
 587                     EdkLogger.error('build', FORMAT_INVALID, "The format of the Sku ID number is invalid. It only support Integer and HexNumber",
 588                                     File=self.MetaFile, Line=Record[-1])
 589                 if not IsValidWord(Record[1]):
 590                     EdkLogger.error('build', FORMAT_INVALID, "The format of the Sku ID name is invalid. The correct format is '(a-zA-Z0-9_)(a-zA-Z0-9_-.)*'",
 591                                     File=self.MetaFile, Line=Record[-1])
 592                 self._SkuIds[Record[1].upper()] = (str(self.ToInt(Record[0])), Record[1].upper(), Record[2].upper())
 593             if 'DEFAULT' not in self._SkuIds:
 594                 self._SkuIds['DEFAULT'] = ("0","DEFAULT","DEFAULT")
 595             if 'COMMON' not in self._SkuIds:
 596                 self._SkuIds['COMMON'] = ("0","DEFAULT","DEFAULT")
 597         return self._SkuIds
 598     def ToInt(self,intstr):
 599         return int(intstr,16) if intstr.upper().startswith("0X") else int(intstr)
 600     def _GetDefaultStores(self):
 601         if self.DefaultStores == None:
 602             self.DefaultStores = sdict()
 603             RecordList = self._RawData[MODEL_EFI_DEFAULT_STORES, self._Arch]
 604             for Record in RecordList:
 605                 if Record[0] in [None, '']:
 606                     EdkLogger.error('build', FORMAT_INVALID, 'No DefaultStores ID number',
 607                                     File=self.MetaFile, Line=Record[-1])
 608                 if Record[1] in [None, '']:
 609                     EdkLogger.error('build', FORMAT_INVALID, 'No DefaultStores ID name',
 610                                     File=self.MetaFile, Line=Record[-1])
 611                 Pattern = re.compile('^[1-9]\d*|0$')
 612                 HexPattern = re.compile(r'0[xX][0-9a-fA-F]+$')
 613                 if Pattern.match(Record[0]) == None and HexPattern.match(Record[0]) == None:
 614                     EdkLogger.error('build', FORMAT_INVALID, "The format of the DefaultStores ID number is invalid. It only support Integer and HexNumber",
 615                                     File=self.MetaFile, Line=Record[-1])
 616                 if not IsValidWord(Record[1]):
 617                     EdkLogger.error('build', FORMAT_INVALID, "The format of the DefaultStores ID name is invalid. The correct format is '(a-zA-Z0-9_)(a-zA-Z0-9_-.)*'",
 618                                     File=self.MetaFile, Line=Record[-1])
 619                 self.DefaultStores[Record[1].upper()] = (self.ToInt(Record[0]),Record[1].upper())
 620             if TAB_DEFAULT_STORES_DEFAULT not in self.DefaultStores:
 621                 self.DefaultStores[TAB_DEFAULT_STORES_DEFAULT] = (0,TAB_DEFAULT_STORES_DEFAULT)
 622             GlobalData.gDefaultStores = self.DefaultStores.keys()
 623             if GlobalData.gDefaultStores:
 624                 GlobalData.gDefaultStores.sort()
 625         return self.DefaultStores
 626
 627     ## Retrieve [Components] section information
 628     def _GetModules(self):
 629         if self._Modules != None:
 630             return self._Modules
 631
 632         self._Modules = sdict()
 633         RecordList = self._RawData[MODEL_META_DATA_COMPONENT, self._Arch]
 634         Macros = self._Macros
 635         Macros["EDK_SOURCE"] = GlobalData.gEcpSource
 636         for Record in RecordList:
 637             DuplicatedFile = False
 638
 639             ModuleFile = PathClass(NormPath(Record[0], Macros), GlobalData.gWorkspace, Arch=self._Arch)
 640             ModuleId = Record[6]
 641             LineNo = Record[7]
 642
 643             # check the file validation
 644             ErrorCode, ErrorInfo = ModuleFile.Validate('.inf')
 645             if ErrorCode != 0:
 646                 EdkLogger.error('build', ErrorCode, File=self.MetaFile, Line=LineNo,
 647                                 ExtraData=ErrorInfo)
 648             # Check duplication
 649             # If arch is COMMON, no duplicate module is checked since all modules in all component sections are selected
 650             if self._Arch != 'COMMON' and ModuleFile in self._Modules:
 651                 DuplicatedFile = True
 652
 653             Module = ModuleBuildClassObject()
 654             Module.MetaFile = ModuleFile
 655
 656             # get module private library instance
 657             RecordList = self._RawData[MODEL_EFI_LIBRARY_CLASS, self._Arch, None, ModuleId]
 658             for Record in RecordList:
 659                 LibraryClass = Record[0]
 660                 LibraryPath = PathClass(NormPath(Record[1], Macros), GlobalData.gWorkspace, Arch=self._Arch)
 661                 LineNo = Record[-1]
 662
 663                 # check the file validation
 664                 ErrorCode, ErrorInfo = LibraryPath.Validate('.inf')
 665                 if ErrorCode != 0:
 666                     EdkLogger.error('build', ErrorCode, File=self.MetaFile, Line=LineNo,
 667                                     ExtraData=ErrorInfo)
 668
 669                 if LibraryClass == '' or LibraryClass == 'NULL':
 670                     self._NullLibraryNumber += 1
 671                     LibraryClass = 'NULL%d' % self._NullLibraryNumber
 672                     EdkLogger.verbose("Found forced library for %s\n\t%s [%s]" % (ModuleFile, LibraryPath, LibraryClass))
 673                 Module.LibraryClasses[LibraryClass] = LibraryPath
 674                 if LibraryPath not in self.LibraryInstances:
 675                     self.LibraryInstances.append(LibraryPath)
 676
 677             # get module private PCD setting
 678             for Type in [MODEL_PCD_FIXED_AT_BUILD, MODEL_PCD_PATCHABLE_IN_MODULE, \
 679                          MODEL_PCD_FEATURE_FLAG, MODEL_PCD_DYNAMIC, MODEL_PCD_DYNAMIC_EX]:
 680                 RecordList = self._RawData[Type, self._Arch, None, ModuleId]
 681                 for TokenSpaceGuid, PcdCName, Setting, Dummy1, Dummy2, Dummy3, Dummy4,Dummy5 in RecordList:
 682                     TokenList = GetSplitValueList(Setting)
 683                     DefaultValue = TokenList[0]
 684                     if len(TokenList) > 1:
 685                         MaxDatumSize = TokenList[1]
 686                     else:
 687                         MaxDatumSize = ''
 688                     TypeString = self._PCD_TYPE_STRING_[Type]
 689                     Pcd = PcdClassObject(
 690                             PcdCName,
 691                             TokenSpaceGuid,
 692                             TypeString,
 693                             '',
 694                             DefaultValue,
 695                             '',
 696                             MaxDatumSize,
 697                             {},
 698                             False,
 699                             None
 700                             )
 701                     Module.Pcds[PcdCName, TokenSpaceGuid] = Pcd
 702
 703             # get module private build options
 704             RecordList = self._RawData[MODEL_META_DATA_BUILD_OPTION, self._Arch, None, ModuleId]
 705             for ToolChainFamily, ToolChain, Option, Dummy1, Dummy2, Dummy3, Dummy4,Dummy5 in RecordList:
 706                 if (ToolChainFamily, ToolChain) not in Module.BuildOptions:
 707                     Module.BuildOptions[ToolChainFamily, ToolChain] = Option
 708                 else:
 709                     OptionString = Module.BuildOptions[ToolChainFamily, ToolChain]
 710                     Module.BuildOptions[ToolChainFamily, ToolChain] = OptionString + " " + Option
 711
 712             RecordList = self._RawData[MODEL_META_DATA_HEADER, self._Arch, None, ModuleId]
 713             if DuplicatedFile and not RecordList:
 714                 EdkLogger.error('build', FILE_DUPLICATED, File=self.MetaFile, ExtraData=str(ModuleFile), Line=LineNo)
 715             if RecordList:
 716                 if len(RecordList) != 1:
 717                     EdkLogger.error('build', OPTION_UNKNOWN, 'Only FILE_GUID can be listed in <Defines> section.',
 718                                     File=self.MetaFile, ExtraData=str(ModuleFile), Line=LineNo)
 719                 ModuleFile = ProcessDuplicatedInf(ModuleFile, RecordList[0][2], GlobalData.gWorkspace)
 720                 ModuleFile.Arch = self._Arch
 721
 722             self._Modules[ModuleFile] = Module
 723         return self._Modules
 724
 725     ## Retrieve all possible library instances used in this platform
 726     def _GetLibraryInstances(self):
 727         if self._LibraryInstances == None:
 728             self._GetLibraryClasses()
 729         return self._LibraryInstances
 730
 731     ## Retrieve [LibraryClasses] information
 732     def _GetLibraryClasses(self):
 733         if self._LibraryClasses == None:
 734             self._LibraryInstances = []
 735             #
 736             # tdict is a special dict kind of type, used for selecting correct
 737             # library instance for given library class and module type
 738             #
 739             LibraryClassDict = tdict(True, 3)
 740             # track all library class names
 741             LibraryClassSet = set()
 742             RecordList = self._RawData[MODEL_EFI_LIBRARY_CLASS, self._Arch, None, -1]
 743             Macros = self._Macros
 744             for Record in RecordList:
 745                 LibraryClass, LibraryInstance, Dummy, Arch, ModuleType, Dummy,Dummy, LineNo = Record
 746                 if LibraryClass == '' or LibraryClass == 'NULL':
 747                     self._NullLibraryNumber += 1
 748                     LibraryClass = 'NULL%d' % self._NullLibraryNumber
 749                     EdkLogger.verbose("Found forced library for arch=%s\n\t%s [%s]" % (Arch, LibraryInstance, LibraryClass))
 750                 LibraryClassSet.add(LibraryClass)
 751                 LibraryInstance = PathClass(NormPath(LibraryInstance, Macros), GlobalData.gWorkspace, Arch=self._Arch)
 752                 # check the file validation
 753                 ErrorCode, ErrorInfo = LibraryInstance.Validate('.inf')
 754                 if ErrorCode != 0:
 755                     EdkLogger.error('build', ErrorCode, File=self.MetaFile, Line=LineNo,
 756                                     ExtraData=ErrorInfo)
 757
 758                 if ModuleType != 'COMMON' and ModuleType not in SUP_MODULE_LIST:
 759                     EdkLogger.error('build', OPTION_UNKNOWN, "Unknown module type [%s]" % ModuleType,
 760                                     File=self.MetaFile, ExtraData=LibraryInstance, Line=LineNo)
 761                 LibraryClassDict[Arch, ModuleType, LibraryClass] = LibraryInstance
 762                 if LibraryInstance not in self._LibraryInstances:
 763                     self._LibraryInstances.append(LibraryInstance)
 764
 765             # resolve the specific library instance for each class and each module type
 766             self._LibraryClasses = tdict(True)
 767             for LibraryClass in LibraryClassSet:
 768                 # try all possible module types
 769                 for ModuleType in SUP_MODULE_LIST:
 770                     LibraryInstance = LibraryClassDict[self._Arch, ModuleType, LibraryClass]
 771                     if LibraryInstance == None:
 772                         continue
 773                     self._LibraryClasses[LibraryClass, ModuleType] = LibraryInstance
 774
 775             # for Edk style library instances, which are listed in different section
 776             Macros["EDK_SOURCE"] = GlobalData.gEcpSource
 777             RecordList = self._RawData[MODEL_EFI_LIBRARY_INSTANCE, self._Arch]
 778             for Record in RecordList:
 779                 File = PathClass(NormPath(Record[0], Macros), GlobalData.gWorkspace, Arch=self._Arch)
 780                 LineNo = Record[-1]
 781                 # check the file validation
 782                 ErrorCode, ErrorInfo = File.Validate('.inf')
 783                 if ErrorCode != 0:
 784                     EdkLogger.error('build', ErrorCode, File=self.MetaFile, Line=LineNo,
 785                                     ExtraData=ErrorInfo)
 786                 if File not in self._LibraryInstances:
 787                     self._LibraryInstances.append(File)
 788                 #
 789                 # we need the module name as the library class name, so we have
 790                 # to parse it here. (self._Bdb[] will trigger a file parse if it
 791                 # hasn't been parsed)
 792                 #
 793                 Library = self._Bdb[File, self._Arch, self._Target, self._Toolchain]
 794                 self._LibraryClasses[Library.BaseName, ':dummy:'] = Library
 795         return self._LibraryClasses
 796
 797     def _ValidatePcd(self, PcdCName, TokenSpaceGuid, Setting, PcdType, LineNo):
 798         if self._DecPcds == None:
 799
 800             FdfInfList = []
 801             if GlobalData.gFdfParser:
 802                 FdfInfList = GlobalData.gFdfParser.Profile.InfList
 803
 804             PkgSet = set()
 805             for Inf in FdfInfList:
 806                 ModuleFile = PathClass(NormPath(Inf), GlobalData.gWorkspace, Arch=self._Arch)
 807                 if ModuleFile in self._Modules:
 808                     continue
 809                 ModuleData = self._Bdb[ModuleFile, self._Arch, self._Target, self._Toolchain]
 810                 PkgSet.update(ModuleData.Packages)
 811
 812             self._DecPcds, self._GuidDict = GetDeclaredPcd(self, self._Bdb, self._Arch, self._Target, self._Toolchain,PkgSet)
 813
 814
 815         if (PcdCName, TokenSpaceGuid) not in self._DecPcds:
 816             EdkLogger.error('build', PARSER_ERROR,
 817                             "Pcd (%s.%s) defined in DSC is not declared in DEC files. Arch: ['%s']" % (TokenSpaceGuid, PcdCName, self._Arch),
 818                             File=self.MetaFile, Line=LineNo)
 819         ValueList, IsValid, Index = AnalyzeDscPcd(Setting, PcdType, self._DecPcds[PcdCName, TokenSpaceGuid].DatumType)
 820         if not IsValid:
 821             if PcdType not in [MODEL_PCD_FEATURE_FLAG, MODEL_PCD_FIXED_AT_BUILD]:
 822                 EdkLogger.error('build', FORMAT_INVALID, "Pcd format incorrect.", File=self.MetaFile, Line=LineNo,
 823                                 ExtraData="%s.%s|%s" % (TokenSpaceGuid, PcdCName, Setting))
 824             else:
 825                 if ValueList[2] == '-1':
 826                     EdkLogger.error('build', FORMAT_INVALID, "Pcd format incorrect.", File=self.MetaFile, Line=LineNo,
 827                                 ExtraData="%s.%s|%s" % (TokenSpaceGuid, PcdCName, Setting))
 828         if ValueList[Index] and PcdType not in [MODEL_PCD_FEATURE_FLAG, MODEL_PCD_FIXED_AT_BUILD]:
 829             try:
 830                 ValueList[Index] = ValueExpression(ValueList[Index], GlobalData.gPlatformPcds)(True)
 831             except WrnExpression, Value:
 832                 ValueList[Index] = Value.result
 833             except BadExpression, Value:
 834                 EdkLogger.error('Parser', FORMAT_INVALID, Value, File=self.MetaFile, Line=self._LineIndex + 1)
 835             except EvaluationException, Excpt:
 836                 if hasattr(Excpt, 'Pcd'):
 837                     if Excpt.Pcd in GlobalData.gPlatformOtherPcds:
 838                         EdkLogger.error('Parser', FORMAT_INVALID, "Cannot use this PCD (%s) in an expression as"
 839                                         " it must be defined in a [PcdsFixedAtBuild] or [PcdsFeatureFlag] section"
 840                                         " of the DSC file" % Excpt.Pcd,
 841                                         File=self.MetaFile, Line=LineNo)
 842                     else:
 843                         EdkLogger.error('Parser', FORMAT_INVALID, "PCD (%s) is not defined in DSC file" % Excpt.Pcd,
 844                                         File=self.MetaFile, Line=LineNo)
 845                 else:
 846                     EdkLogger.error('Parser', FORMAT_INVALID, "Invalid expression: %s" % str(Excpt),
 847                                     File=self.MetaFile, Line=LineNo)
 848         if ValueList[Index]:
 849             DatumType = self._DecPcds[PcdCName, TokenSpaceGuid].DatumType
 850             try:
 851                 ValueList[Index] = ValueExpressionEx(ValueList[Index], DatumType, self._GuidDict)(True)
 852             except BadExpression, Value:
 853                 EdkLogger.error('Parser', FORMAT_INVALID, Value, File=self.MetaFile, Line=LineNo,
 854                                 ExtraData="PCD [%s.%s] Value \"%s\" " % (TokenSpaceGuid, PcdCName, ValueList[Index]))
 855             Valid, ErrStr = CheckPcdDatum(self._DecPcds[PcdCName, TokenSpaceGuid].DatumType, ValueList[Index])
 856             if not Valid:
 857                 EdkLogger.error('build', FORMAT_INVALID, ErrStr, File=self.MetaFile, Line=LineNo,
 858                                 ExtraData="%s.%s" % (TokenSpaceGuid, PcdCName))
 859             if PcdType in (MODEL_PCD_DYNAMIC_DEFAULT, MODEL_PCD_DYNAMIC_EX_DEFAULT):
 860                 if self._DecPcds[PcdCName, TokenSpaceGuid].DatumType.strip() != ValueList[1].strip():
 861                     EdkLogger.error('build', FORMAT_INVALID, ErrStr , File=self.MetaFile, Line=LineNo,
 862                                 ExtraData="%s.%s|%s" % (TokenSpaceGuid, PcdCName, Setting))
 863         return ValueList
 864
 865     def _FilterPcdBySkuUsage(self,Pcds):
 866         available_sku = self.SkuIdMgr.AvailableSkuIdSet
 867         sku_usage = self.SkuIdMgr.SkuUsageType
 868         if sku_usage == SkuClass.SINGLE:
 869             for pcdname in Pcds:
 870                 pcd = Pcds[pcdname]
 871                 Pcds[pcdname].SkuInfoList = {"DEFAULT":pcd.SkuInfoList[skuid] for skuid in pcd.SkuInfoList if skuid in available_sku}
 872                 if type(pcd) is StructurePcd and pcd.SkuOverrideValues:
 873                     Pcds[pcdname].SkuOverrideValues = {"DEFAULT":pcd.SkuOverrideValues[skuid] for skuid in pcd.SkuOverrideValues if skuid in available_sku}
 874         else:
 875             for pcdname in Pcds:
 876                 pcd = Pcds[pcdname]
 877                 Pcds[pcdname].SkuInfoList = {skuid:pcd.SkuInfoList[skuid] for skuid in pcd.SkuInfoList if skuid in available_sku}
 878                 if type(pcd) is StructurePcd and pcd.SkuOverrideValues:
 879                     Pcds[pcdname].SkuOverrideValues = {skuid:pcd.SkuOverrideValues[skuid] for skuid in pcd.SkuOverrideValues if skuid in available_sku}
 880         return Pcds
 881     def CompleteHiiPcdsDefaultStores(self,Pcds):
 882         HiiPcd = [Pcds[pcd] for pcd in Pcds if Pcds[pcd].Type in [self._PCD_TYPE_STRING_[MODEL_PCD_DYNAMIC_HII], self._PCD_TYPE_STRING_[MODEL_PCD_DYNAMIC_EX_HII]]]
 883         DefaultStoreMgr = DefaultStore(self.DefaultStores)
 884         for pcd in HiiPcd:
 885             for skuid in pcd.SkuInfoList:
 886                 skuobj = pcd.SkuInfoList.get(skuid)
 887                 if "STANDARD" not in skuobj.DefaultStoreDict:
 888                     PcdDefaultStoreSet = set([defaultstorename  for defaultstorename in skuobj.DefaultStoreDict])
 889                     mindefaultstorename = DefaultStoreMgr.GetMin(PcdDefaultStoreSet)
 890                     skuobj.DefaultStoreDict['STANDARD'] = copy.deepcopy(skuobj.DefaultStoreDict[mindefaultstorename])
 891         return Pcds
 892
 893     ## Retrieve all PCD settings in platform
 894     def _GetPcds(self):
 895         if self._Pcds == None:
 896             self._Pcds = sdict()
 897             self._Pcds.update(self._GetPcd(MODEL_PCD_FIXED_AT_BUILD))
 898             self._Pcds.update(self._GetPcd(MODEL_PCD_PATCHABLE_IN_MODULE))
 899             self._Pcds.update(self._GetPcd(MODEL_PCD_FEATURE_FLAG))
 900             self._Pcds.update(self._GetDynamicPcd(MODEL_PCD_DYNAMIC_DEFAULT))
 901             self._Pcds.update(self._GetDynamicHiiPcd(MODEL_PCD_DYNAMIC_HII))
 902             self._Pcds.update(self._GetDynamicVpdPcd(MODEL_PCD_DYNAMIC_VPD))
 903             self._Pcds.update(self._GetDynamicPcd(MODEL_PCD_DYNAMIC_EX_DEFAULT))
 904             self._Pcds.update(self._GetDynamicHiiPcd(MODEL_PCD_DYNAMIC_EX_HII))
 905             self._Pcds.update(self._GetDynamicVpdPcd(MODEL_PCD_DYNAMIC_EX_VPD))
 906
 907             self._Pcds = self.CompletePcdValues(self._Pcds)
 908             self._Pcds = self.UpdateStructuredPcds(MODEL_PCD_TYPE_LIST, self._Pcds)
 909             self._Pcds = self.CompleteHiiPcdsDefaultStores(self._Pcds)
 910             self._Pcds = self._FilterPcdBySkuUsage(self._Pcds)
 911         return self._Pcds
 912
 913     def _dumpPcdInfo(self,Pcds):
 914         for pcd in Pcds:
 915             pcdobj = Pcds[pcd]
 916             if not pcdobj.TokenCName.startswith("Test"):
 917                 continue
 918             for skuid in pcdobj.SkuInfoList:
 919                 if pcdobj.Type in (self._PCD_TYPE_STRING_[MODEL_PCD_DYNAMIC_HII],self._PCD_TYPE_STRING_[MODEL_PCD_DYNAMIC_EX_HII]):
 920                     for storename in pcdobj.SkuInfoList[skuid].DefaultStoreDict:
 921                         print "PcdCName: %s, SkuName: %s, StoreName: %s, Value: %s" % (".".join((pcdobj.TokenSpaceGuidCName, pcdobj.TokenCName)), skuid,storename,str(pcdobj.SkuInfoList[skuid].DefaultStoreDict[storename]))
 922                 else:
 923                     print "PcdCName: %s, SkuName: %s, Value: %s" % (".".join((pcdobj.TokenSpaceGuidCName, pcdobj.TokenCName)), skuid,str(pcdobj.SkuInfoList[skuid].DefaultValue))
 924     ## Retrieve [BuildOptions]
 925     def _GetBuildOptions(self):
 926         if self._BuildOptions == None:
 927             self._BuildOptions = sdict()
 928             #
 929             # Retrieve build option for EDKII and EDK style module
 930             #
 931             for CodeBase in (EDKII_NAME, EDK_NAME):
 932                 RecordList = self._RawData[MODEL_META_DATA_BUILD_OPTION, self._Arch, CodeBase]
 933                 for ToolChainFamily, ToolChain, Option, Dummy1, Dummy2, Dummy3, Dummy4,Dummy5 in RecordList:
 934                     if Dummy3.upper() != 'COMMON':
 935                         continue
 936                     CurKey = (ToolChainFamily, ToolChain, CodeBase)
 937                     #
 938                     # Only flags can be appended
 939                     #
 940                     if CurKey not in self._BuildOptions or not ToolChain.endswith('_FLAGS') or Option.startswith('='):
 941                         self._BuildOptions[CurKey] = Option
 942                     else:
 943                         if ' ' + Option not in self._BuildOptions[CurKey]:
 944                             self._BuildOptions[CurKey] += ' ' + Option
 945         return self._BuildOptions
 946
 947     def GetBuildOptionsByModuleType(self, Edk, ModuleType):
 948         if self._ModuleTypeOptions == None:
 949             self._ModuleTypeOptions = sdict()
 950         if (Edk, ModuleType) not in self._ModuleTypeOptions:
 951             options = sdict()
 952             self._ModuleTypeOptions[Edk, ModuleType] = options
 953             DriverType = '%s.%s' % (Edk, ModuleType)
 954             CommonDriverType = '%s.%s' % ('COMMON', ModuleType)
 955             RecordList = self._RawData[MODEL_META_DATA_BUILD_OPTION, self._Arch]
 956             for ToolChainFamily, ToolChain, Option, Dummy1, Dummy2, Dummy3, Dummy4,Dummy5 in RecordList:
 957                 Type = Dummy2 + '.' + Dummy3
 958                 if Type.upper() == DriverType.upper() or Type.upper() == CommonDriverType.upper():
 959                     Key = (ToolChainFamily, ToolChain, Edk)
 960                     if Key not in options or not ToolChain.endswith('_FLAGS') or Option.startswith('='):
 961                         options[Key] = Option
 962                     else:
 963                         if ' ' + Option not in options[Key]:
 964                             options[Key] += ' ' + Option
 965         return self._ModuleTypeOptions[Edk, ModuleType]
 966
 967     def GetStructurePcdInfo(self, PcdSet):
 968         structure_pcd_data = {}
 969         for item in PcdSet:
 970             if (item[0],item[1]) not in structure_pcd_data:
 971                 structure_pcd_data[(item[0],item[1])] = []
 972             structure_pcd_data[(item[0],item[1])].append(item)
 973
 974         return structure_pcd_data
 975
 976     def UpdateStructuredPcds(self, TypeList, AllPcds):
 977
 978         DynamicPcdType = [self._PCD_TYPE_STRING_[MODEL_PCD_DYNAMIC_DEFAULT],
 979                         self._PCD_TYPE_STRING_[MODEL_PCD_DYNAMIC_HII],
 980                         self._PCD_TYPE_STRING_[MODEL_PCD_DYNAMIC_VPD],
 981                         self._PCD_TYPE_STRING_[MODEL_PCD_DYNAMIC_EX_DEFAULT],
 982                         self._PCD_TYPE_STRING_[MODEL_PCD_DYNAMIC_EX_HII],
 983                         self._PCD_TYPE_STRING_[MODEL_PCD_DYNAMIC_EX_VPD]]
 984
 985         Pcds = AllPcds
 986         DefaultStoreMgr = DefaultStore(self.DefaultStores)
 987         SkuIds = self.SkuIdMgr.AvailableSkuIdSet
 988         SkuIds.update({'DEFAULT':0})
 989         DefaultStores = set([storename for pcdobj in AllPcds.values() for skuobj in pcdobj.SkuInfoList.values() for storename in skuobj.DefaultStoreDict.keys()])
 990
 991         S_PcdSet = []
 992         # Find out all possible PCD candidates for self._Arch
 993         RecordList = []
 994
 995         for Type in TypeList:
 996             RecordList.extend(self._RawData[Type, self._Arch])
 997
 998         for TokenSpaceGuid, PcdCName, Setting, Arch, SkuName, default_store, Dummy4,Dummy5 in RecordList:
 999             SkuName = SkuName.upper()
1000             default_store = default_store.upper()
1001             SkuName = 'DEFAULT' if SkuName == 'COMMON' else SkuName
1002             if SkuName not in SkuIds:
1003                 continue
1004
1005             if SkuName in SkuIds and "." in TokenSpaceGuid:
1006                 S_PcdSet.append(( TokenSpaceGuid.split(".")[0],TokenSpaceGuid.split(".")[1], PcdCName,SkuName, default_store,Dummy5, AnalyzePcdExpression(Setting)[0]))
1007
1008         # handle pcd value override
1009         StrPcdSet = self.GetStructurePcdInfo(S_PcdSet)
1010         S_pcd_set = {}
1011         for str_pcd in StrPcdSet:
1012             str_pcd_obj = Pcds.get((str_pcd[1], str_pcd[0]), None)
1013             str_pcd_dec = self._DecPcds.get((str_pcd[1], str_pcd[0]), None)
1014             if str_pcd_dec:
1015                 str_pcd_obj_str = StructurePcd()
1016                 str_pcd_obj_str.copy(str_pcd_dec)
1017                 if str_pcd_obj:
1018                     str_pcd_obj_str.copy(str_pcd_obj)
1019                     if str_pcd_obj.DefaultValue:
1020                         str_pcd_obj_str.DefaultFromDSC = str_pcd_obj.DefaultValue
1021                 for str_pcd_data in StrPcdSet[str_pcd]:
1022                     if str_pcd_data[3] in SkuIds:
1023                         str_pcd_obj_str.AddOverrideValue(str_pcd_data[2], str(str_pcd_data[6]), 'DEFAULT' if str_pcd_data[3] == 'COMMON' else str_pcd_data[3],'STANDARD' if str_pcd_data[4] == 'COMMON' else str_pcd_data[4], self.MetaFile.File,LineNo=str_pcd_data[5])
1024                 S_pcd_set[str_pcd[1], str_pcd[0]] = str_pcd_obj_str
1025             else:
1026                 EdkLogger.error('build', PARSER_ERROR,
1027                             "Pcd (%s.%s) defined in DSC is not declared in DEC files. Arch: ['%s']" % (str_pcd[0], str_pcd[1], self._Arch),
1028                             File=self.MetaFile,Line = StrPcdSet[str_pcd][0][5])
1029         # Add the Structure PCD that only defined in DEC, don't have override in DSC file
1030         for Pcd in self.DecPcds:
1031             if type (self._DecPcds[Pcd]) is StructurePcd:
1032                 if Pcd not in S_pcd_set:
1033                     str_pcd_obj_str = StructurePcd()
1034                     str_pcd_obj_str.copy(self._DecPcds[Pcd])
1035                     str_pcd_obj = Pcds.get(Pcd, None)
1036                     if str_pcd_obj:
1037                         str_pcd_obj_str.copy(str_pcd_obj)
1038                         if str_pcd_obj.DefaultValue:
1039                             str_pcd_obj_str.DefaultFromDSC = str_pcd_obj.DefaultValue
1040                     S_pcd_set[Pcd] = str_pcd_obj_str
1041         if S_pcd_set:
1042             GlobalData.gStructurePcd[self.Arch] = S_pcd_set
1043         for stru_pcd in S_pcd_set.values():
1044             for skuid in SkuIds:
1045                 if skuid in stru_pcd.SkuOverrideValues:
1046                     continue
1047                 nextskuid = self.SkuIdMgr.GetNextSkuId(skuid)
1048                 NoDefault = False
1049                 while nextskuid not in stru_pcd.SkuOverrideValues:
1050                     if nextskuid == "DEFAULT":
1051                         NoDefault = True
1052                         break
1053                     nextskuid = self.SkuIdMgr.GetNextSkuId(nextskuid)
1054                 stru_pcd.SkuOverrideValues[skuid] = copy.deepcopy(stru_pcd.SkuOverrideValues[nextskuid]) if not NoDefault else copy.deepcopy({defaultstorename: stru_pcd.DefaultValues for defaultstorename in DefaultStores} if DefaultStores else {'STANDARD':stru_pcd.DefaultValues})
1055             if stru_pcd.Type in [self._PCD_TYPE_STRING_[MODEL_PCD_DYNAMIC_HII], self._PCD_TYPE_STRING_[MODEL_PCD_DYNAMIC_EX_HII]]:
1056                 for skuid in SkuIds:
1057                     nextskuid = skuid
1058                     NoDefault = False
1059                     if skuid not in stru_pcd.SkuOverrideValues:
1060                         while nextskuid not in stru_pcd.SkuOverrideValues:
1061                             if nextskuid == "DEFAULT":
1062                                 NoDefault = True
1063                                 break
1064                             nextskuid = self.SkuIdMgr.GetNextSkuId(nextskuid)
1065                     if NoDefault:
1066                         continue
1067                     PcdDefaultStoreSet = set([defaultstorename  for defaultstorename in stru_pcd.SkuOverrideValues[nextskuid]])
1068                     mindefaultstorename = DefaultStoreMgr.GetMin(PcdDefaultStoreSet)
1069
1070                     for defaultstoreid in DefaultStores:
1071                         if defaultstoreid not in stru_pcd.SkuOverrideValues[skuid]:
1072                             stru_pcd.SkuOverrideValues[skuid][defaultstoreid] = copy.deepcopy(stru_pcd.SkuOverrideValues[nextskuid][mindefaultstorename])
1073
1074         Str_Pcd_Values = self.GenerateByteArrayValue(S_pcd_set)
1075         if Str_Pcd_Values:
1076             for (skuname,StoreName,PcdGuid,PcdName,PcdValue) in Str_Pcd_Values:
1077                 str_pcd_obj = S_pcd_set.get((PcdName, PcdGuid))
1078                 if str_pcd_obj is None:
1079                     print PcdName, PcdGuid
1080                     raise
1081                 if str_pcd_obj.Type in [self._PCD_TYPE_STRING_[MODEL_PCD_DYNAMIC_HII],
1082                                         self._PCD_TYPE_STRING_[MODEL_PCD_DYNAMIC_EX_HII]]:
1083                     if skuname not in str_pcd_obj.SkuInfoList:
1084                         str_pcd_obj.SkuInfoList[skuname] = SkuInfoClass(SkuIdName=skuname, SkuId=self.SkuIds[skuname][0], HiiDefaultValue=PcdValue, DefaultStore = {StoreName:PcdValue})
1085                     else:
1086                         str_pcd_obj.SkuInfoList[skuname].HiiDefaultValue = PcdValue
1087                         str_pcd_obj.SkuInfoList[skuname].DefaultStoreDict.update({StoreName:PcdValue})
1088                 elif str_pcd_obj.Type in [self._PCD_TYPE_STRING_[MODEL_PCD_FIXED_AT_BUILD],
1089                                         self._PCD_TYPE_STRING_[MODEL_PCD_PATCHABLE_IN_MODULE]]:
1090                     if skuname in (self.SkuIdMgr.SystemSkuId, 'DEFAULT', 'COMMON'):
1091                         str_pcd_obj.DefaultValue = PcdValue
1092                 else:
1093                     if skuname not in str_pcd_obj.SkuInfoList:
1094                         nextskuid = self.SkuIdMgr.GetNextSkuId(skuname)
1095                         NoDefault = False
1096                         while nextskuid not in str_pcd_obj.SkuInfoList:
1097                             if nextskuid == "DEFAULT":
1098                                 NoDefault = True
1099                                 break
1100                             nextskuid = self.SkuIdMgr.GetNextSkuId(nextskuid)
1101                         str_pcd_obj.SkuInfoList[skuname] = copy.deepcopy(str_pcd_obj.SkuInfoList[nextskuid]) if not NoDefault else SkuInfoClass(SkuIdName=skuname, SkuId=self.SkuIds[skuname][0], DefaultValue=PcdValue)
1102                         str_pcd_obj.SkuInfoList[skuname].SkuId = self.SkuIds[skuname][0]
1103                         str_pcd_obj.SkuInfoList[skuname].SkuIdName = skuname
1104                     else:
1105                         str_pcd_obj.SkuInfoList[skuname].DefaultValue = PcdValue
1106             for str_pcd_obj in S_pcd_set.values():
1107                 if str_pcd_obj.Type not in [self._PCD_TYPE_STRING_[MODEL_PCD_DYNAMIC_HII],
1108                                         self._PCD_TYPE_STRING_[MODEL_PCD_DYNAMIC_EX_HII]]:
1109                     continue
1110                 PcdDefaultStoreSet = set([defaultstorename  for skuobj in str_pcd_obj.SkuInfoList.values() for defaultstorename in skuobj.DefaultStoreDict])
1111                 DefaultStoreObj = DefaultStore(self._GetDefaultStores())
1112                 mindefaultstorename = DefaultStoreObj.GetMin(PcdDefaultStoreSet)
1113                 str_pcd_obj.SkuInfoList[self.SkuIdMgr.SystemSkuId].HiiDefaultValue = str_pcd_obj.SkuInfoList[self.SkuIdMgr.SystemSkuId].DefaultStoreDict[mindefaultstorename]
1114
1115             for str_pcd_obj in S_pcd_set.values():
1116
1117                 str_pcd_obj.MaxDatumSize = self.GetStructurePcdMaxSize(str_pcd_obj)
1118                 Pcds[str_pcd_obj.TokenCName, str_pcd_obj.TokenSpaceGuidCName] = str_pcd_obj
1119
1120             for pcdkey in Pcds:
1121                 pcd = Pcds[pcdkey]
1122                 if 'DEFAULT' not in pcd.SkuInfoList.keys() and 'COMMON' in pcd.SkuInfoList.keys():
1123                     pcd.SkuInfoList['DEFAULT'] = pcd.SkuInfoList['COMMON']
1124                     del(pcd.SkuInfoList['COMMON'])
1125                 elif 'DEFAULT' in pcd.SkuInfoList.keys() and 'COMMON' in pcd.SkuInfoList.keys():
1126                     del(pcd.SkuInfoList['COMMON'])
1127
1128         map(self.FilterSkuSettings,[Pcds[pcdkey] for pcdkey in Pcds if Pcds[pcdkey].Type in DynamicPcdType])
1129         return Pcds
1130
1131     ## Retrieve non-dynamic PCD settings
1132     #
1133     #   @param  Type    PCD type
1134     #
1135     #   @retval a dict object contains settings of given PCD type
1136     #
1137     def _GetPcd(self, Type):
1138         Pcds = sdict()
1139         #
1140         # tdict is a special dict kind of type, used for selecting correct
1141         # PCD settings for certain ARCH
1142         #
1143         AvailableSkuIdSet = copy.copy(self.SkuIds)
1144
1145         PcdDict = tdict(True, 3)
1146         PcdSet = set()
1147         # Find out all possible PCD candidates for self._Arch
1148         RecordList = self._RawData[Type, self._Arch]
1149         PcdValueDict = sdict()
1150         for TokenSpaceGuid, PcdCName, Setting, Arch, SkuName, Dummy3, Dummy4,Dummy5 in RecordList:
1151             SkuName = SkuName.upper()
1152             SkuName = 'DEFAULT' if SkuName == 'COMMON' else SkuName
1153             if SkuName not in AvailableSkuIdSet:
1154                 EdkLogger.error('build ', PARAMETER_INVALID, 'Sku %s is not defined in [SkuIds] section' % SkuName,
1155                                             File=self.MetaFile, Line=Dummy5)
1156             if SkuName in (self.SkuIdMgr.SystemSkuId, 'DEFAULT', 'COMMON'):
1157                 if "." not in TokenSpaceGuid:
1158                     PcdSet.add((PcdCName, TokenSpaceGuid, SkuName, Dummy4))
1159                 PcdDict[Arch, PcdCName, TokenSpaceGuid, SkuName] = Setting
1160
1161         for PcdCName, TokenSpaceGuid, SkuName, Dummy4 in PcdSet:
1162             Setting = PcdDict[self._Arch, PcdCName, TokenSpaceGuid, SkuName]
1163             if Setting == None:
1164                 continue
1165             PcdValue, DatumType, MaxDatumSize = self._ValidatePcd(PcdCName, TokenSpaceGuid, Setting, Type, Dummy4)
1166             if (PcdCName, TokenSpaceGuid) in PcdValueDict:
1167                 PcdValueDict[PcdCName, TokenSpaceGuid][SkuName] = (PcdValue, DatumType, MaxDatumSize)
1168             else:
1169                 PcdValueDict[PcdCName, TokenSpaceGuid] = {SkuName:(PcdValue, DatumType, MaxDatumSize)}
1170
1171         PcdsKeys = PcdValueDict.keys()
1172         for PcdCName, TokenSpaceGuid in PcdsKeys:
1173
1174             PcdSetting = PcdValueDict[PcdCName, TokenSpaceGuid]
1175             PcdValue = None
1176             DatumType = None
1177             MaxDatumSize = None
1178             if 'COMMON' in PcdSetting:
1179                 PcdValue, DatumType, MaxDatumSize = PcdSetting['COMMON']
1180             if 'DEFAULT' in PcdSetting:
1181                 PcdValue, DatumType, MaxDatumSize = PcdSetting['DEFAULT']
1182             if self.SkuIdMgr.SystemSkuId in PcdSetting:
1183                 PcdValue, DatumType, MaxDatumSize = PcdSetting[self.SkuIdMgr.SystemSkuId]
1184
1185             Pcds[PcdCName, TokenSpaceGuid] = PcdClassObject(
1186                                                 PcdCName,
1187                                                 TokenSpaceGuid,
1188                                                 self._PCD_TYPE_STRING_[Type],
1189                                                 DatumType,
1190                                                 PcdValue,
1191                                                 '',
1192                                                 MaxDatumSize,
1193                                                 {},
1194                                                 False,
1195                                                 None,
1196                                                 IsDsc=True)
1197
1198
1199         return Pcds
1200
1201     def __UNICODE2OCTList(self,Value):
1202         Value = Value.strip()
1203         Value = Value[2:-1]
1204         List = []
1205         for Item in Value:
1206             Temp = '%04X' % ord(Item)
1207             List.append('0x' + Temp[2:4])
1208             List.append('0x' + Temp[0:2])
1209         List.append('0x00')
1210         List.append('0x00')
1211         return List
1212     def __STRING2OCTList(self,Value):
1213         OCTList = []
1214         Value = Value.strip('"')
1215         for char in Value:
1216             Temp = '%02X' % ord(char)
1217             OCTList.append('0x' + Temp)
1218         OCTList.append('0x00')
1219         return OCTList
1220
1221     def GetStructurePcdMaxSize(self, str_pcd):
1222         pcd_default_value = str_pcd.DefaultValue
1223         sku_values = [skuobj.HiiDefaultValue if str_pcd.Type in [self._PCD_TYPE_STRING_[MODEL_PCD_DYNAMIC_HII], self._PCD_TYPE_STRING_[MODEL_PCD_DYNAMIC_EX_HII]] else skuobj.DefaultValue for skuobj in str_pcd.SkuInfoList.values()]
1224         sku_values.append(pcd_default_value)
1225
1226         def get_length(value):
1227             Value = value.strip()
1228             if len(value) > 1:
1229                 if Value.startswith('GUID') and Value.endswith(')'):
1230                     return 16
1231                 if Value.startswith('L"') and Value.endswith('"'):
1232                     return len(Value[2:-1])
1233                 if Value[0] == '"' and Value[-1] == '"':
1234                     return len(Value) - 2
1235                 if Value[0] == '{' and Value[-1] == '}':
1236                     return len(Value.split(","))
1237                 if Value.startswith("L'") and Value.endswith("'") and len(list(Value[2:-1])) > 1:
1238                     return  len(list(Value[2:-1]))
1239                 if Value[0] == "'" and Value[-1] == "'" and len(list(Value[1:-1])) > 1:
1240                     return len(Value) - 2
1241             return len(Value)
1242
1243         return str(max([pcd_size for pcd_size in [get_length(item) for item in sku_values]]))
1244
1245     def IsFieldValueAnArray (self, Value):
1246         Value = Value.strip()
1247         if Value.startswith('GUID') and Value.endswith(')'):
1248             return True
1249         if Value.startswith('L"') and Value.endswith('"')  and len(list(Value[2:-1])) > 1:
1250             return True
1251         if Value[0] == '"' and Value[-1] == '"' and len(list(Value[1:-1])) > 1:
1252             return True
1253         if Value[0] == '{' and Value[-1] == '}':
1254             return True
1255         if Value.startswith("L'") and Value.endswith("'") and len(list(Value[2:-1])) > 1:
1256             print 'foo = ', list(Value[2:-1])
1257             return True
1258         if Value[0] == "'" and Value[-1] == "'" and len(list(Value[1:-1])) > 1:
1259             print 'bar = ', list(Value[1:-1])
1260             return True
1261         return False
1262
1263     def ExecuteCommand (self, Command):
1264         try:
1265             Process = subprocess.Popen(Command, stdout=subprocess.PIPE, stderr=subprocess.PIPE, shell=True)
1266         except:
1267             print 'ERROR: Can not execute command:', Command
1268             sys.exit(1)
1269         Result = Process.communicate()
1270         if Process.returncode <> 0:
1271             print 'ERROR: Can not collect output from command:', Command
1272         return Result[0], Result[1]
1273
1274     def IntToCString(self, Value, ValueSize):
1275         Result = '"'
1276         if not isinstance (Value, str):
1277             for Index in range(0, ValueSize):
1278                 Result = Result + '\\x%02x' % (Value & 0xff)
1279                 Value = Value >> 8
1280         Result = Result + '"'
1281         return Result
1282
1283     def GenerateInitializeFunc(self, SkuName, DefaultStoreName, Pcd, InitByteValue, CApp):
1284         OverrideValues = {DefaultStoreName:""}
1285         if Pcd.SkuOverrideValues:
1286             OverrideValues = Pcd.SkuOverrideValues[SkuName]
1287         for DefaultStoreName in OverrideValues.keys():
1288             CApp = CApp + 'void\n'
1289             CApp = CApp + 'Initialize_%s_%s_%s_%s(\n' % (SkuName, DefaultStoreName, Pcd.TokenSpaceGuidCName, Pcd.TokenCName)
1290             CApp = CApp + '  void\n'
1291             CApp = CApp + '  )\n'
1292             CApp = CApp + '{\n'
1293             CApp = CApp + '  UINT32  Size;\n'
1294             CApp = CApp + '  UINT32  FieldSize;\n'
1295             CApp = CApp + '  CHAR8   *Value;\n'
1296             CApp = CApp + '  UINT32  OriginalSize;\n'
1297             CApp = CApp + '  VOID    *OriginalPcd;\n'
1298             CApp = CApp + '  %s      *Pcd;  // From %s Line %d \n' % (Pcd.DatumType, Pcd.PkgPath, Pcd.PcdDefineLineNo)
1299             CApp = CApp + '\n'
1300
1301             if SkuName in Pcd.SkuInfoList:
1302                 DefaultValue = Pcd.SkuInfoList[SkuName].DefaultStoreDict.get(DefaultStoreName,Pcd.SkuInfoList[SkuName].HiiDefaultValue) if Pcd.SkuInfoList[SkuName].HiiDefaultValue  else Pcd.SkuInfoList[SkuName].DefaultValue
1303             else:
1304                 DefaultValue = Pcd.DefaultValue
1305             PcdDefaultValue = StringToArray(DefaultValue.strip())
1306
1307             InitByteValue += '%s.%s.%s.%s|%s|%s\n' % (SkuName, DefaultStoreName, Pcd.TokenSpaceGuidCName, Pcd.TokenCName, Pcd.DatumType, PcdDefaultValue)
1308
1309             #
1310             # Get current PCD value and size
1311             #
1312             CApp = CApp + '  OriginalPcd = PcdGetPtr (%s, %s, %s, %s, &OriginalSize);\n' % (SkuName, DefaultStoreName, Pcd.TokenSpaceGuidCName, Pcd.TokenCName)
1313
1314             #
1315             # Determine the size of the PCD.  For simple structures, sizeof(TYPE) provides
1316             # the correct value.  For structures with a flexible array member, the flexible
1317             # array member is detected, and the size is based on the highest index used with
1318             # the flexible array member.  The flexible array member must be the last field
1319             # in a structure.  The size formula for this case is:
1320             # OFFSET_OF(FlexbleArrayField) + sizeof(FlexibleArray[0]) * (HighestIndex + 1)
1321             #
1322             CApp = CApp + '  Size = sizeof(%s);\n' % (Pcd.DatumType)
1323             for FieldList in [Pcd.DefaultValues]:
1324                 if not FieldList:
1325                     continue
1326                 for FieldName in FieldList:
1327                     FieldName = "." + FieldName
1328                     IsArray = self.IsFieldValueAnArray(FieldList[FieldName.strip(".")][0])
1329                     if IsArray:
1330                         Value, ValueSize = ParseFieldValue (FieldList[FieldName.strip(".")][0])
1331                         CApp = CApp + '  __FLEXIBLE_SIZE(Size, %s, %s, %d / __ARRAY_ELEMENT_SIZE(%s, %s) + ((%d %% __ARRAY_ELEMENT_SIZE(%s, %s)) ? 1 : 0));\n' % (Pcd.DatumType, FieldName.strip("."), ValueSize, Pcd.DatumType, FieldName.strip("."), ValueSize, Pcd.DatumType, FieldName.strip("."));
1332                     else:
1333                         NewFieldName = ''
1334                         while '[' in  FieldName:
1335                             NewFieldName = NewFieldName + FieldName.split('[', 1)[0] + '[0]'
1336                             ArrayIndex = int(FieldName.split('[', 1)[1].split(']', 1)[0])
1337                             FieldName = FieldName.split(']', 1)[1]
1338                         FieldName = NewFieldName + FieldName
1339                         while '[' in FieldName:
1340                             FieldName = FieldName.rsplit('[', 1)[0]
1341                             CApp = CApp + '  __FLEXIBLE_SIZE(Size, %s, %s, %d);\n' % (Pcd.DatumType, FieldName.strip("."), ArrayIndex + 1)
1342             for skuname in self.SkuIdMgr.GetSkuChain(SkuName):
1343                 inherit_OverrideValues = Pcd.SkuOverrideValues[skuname]
1344                 for FieldList in [inherit_OverrideValues.get(DefaultStoreName)]:
1345                     if not FieldList:
1346                         continue
1347                     for FieldName in FieldList:
1348                         FieldName = "." + FieldName
1349                         IsArray = self.IsFieldValueAnArray(FieldList[FieldName.strip(".")][0])
1350                         if IsArray:
1351                             Value, ValueSize = ParseFieldValue (FieldList[FieldName.strip(".")][0])
1352                             CApp = CApp + '  __FLEXIBLE_SIZE(Size, %s, %s, %d / __ARRAY_ELEMENT_SIZE(%s, %s) + ((%d %% __ARRAY_ELEMENT_SIZE(%s, %s)) ? 1 : 0));\n' % (Pcd.DatumType, FieldName.strip("."), ValueSize, Pcd.DatumType, FieldName.strip("."), ValueSize, Pcd.DatumType, FieldName.strip("."));
1353                         else:
1354                             NewFieldName = ''
1355                             while '[' in  FieldName:
1356                                 NewFieldName = NewFieldName + FieldName.split('[', 1)[0] + '[0]'
1357                                 ArrayIndex = int(FieldName.split('[', 1)[1].split(']', 1)[0])
1358                                 FieldName = FieldName.split(']', 1)[1]
1359                             FieldName = NewFieldName + FieldName
1360                             while '[' in FieldName:
1361                                 FieldName = FieldName.rsplit('[', 1)[0]
1362                                 CApp = CApp + '  __FLEXIBLE_SIZE(Size, %s, %s, %d);\n' % (Pcd.DatumType, FieldName.strip("."), ArrayIndex + 1)
1363                 if skuname == SkuName:
1364                     break
1365
1366             #
1367             # Allocate and zero buffer for the PCD
1368             # Must handle cases where current value is smaller, larger, or same size
1369             # Always keep that larger one as the current size
1370             #
1371             CApp = CApp + '  Size = (OriginalSize > Size ? OriginalSize : Size);\n'
1372             CApp = CApp + '  Pcd     = (%s *)malloc (Size);\n' % (Pcd.DatumType)
1373             CApp = CApp + '  memset (Pcd, 0, Size);\n'
1374
1375             #
1376             # Copy current PCD value into allocated buffer.
1377             #
1378             CApp = CApp + '  memcpy (Pcd, OriginalPcd, OriginalSize);\n'
1379
1380             #
1381             # Assign field values in PCD
1382             #
1383             for FieldList in [Pcd.DefaultValues]:
1384                 if not FieldList:
1385                     continue
1386                 for FieldName in FieldList:
1387                     IsArray = self.IsFieldValueAnArray(FieldList[FieldName][0])
1388                     try:
1389                         Value, ValueSize = ParseFieldValue (FieldList[FieldName][0])
1390                     except Exception:
1391                         print FieldList[FieldName][0]
1392                     if isinstance(Value, str):
1393                         CApp = CApp + '  Pcd->%s = %s; // From %s Line %d Value %s\n' % (FieldName, Value, FieldList[FieldName][1], FieldList[FieldName][2], FieldList[FieldName][0])
1394                     elif IsArray:
1395                         #
1396                         # Use memcpy() to copy value into field
1397                         #
1398                         CApp = CApp + '  FieldSize = __FIELD_SIZE(%s, %s);\n' % (Pcd.DatumType, FieldName)
1399                         CApp = CApp + '  Value     = %s; // From %s Line %d Value %s\n' % (self.IntToCString(Value, ValueSize), FieldList[FieldName][1], FieldList[FieldName][2], FieldList[FieldName][0])
1400                         CApp = CApp + '  memcpy (&Pcd->%s[0], Value, (FieldSize > 0 && FieldSize < %d) ? FieldSize : %d);\n' % (FieldName, ValueSize, ValueSize)
1401                     else:
1402                         if ValueSize > 4:
1403                             CApp = CApp + '  Pcd->%s = %dULL; // From %s Line %d Value %s\n' % (FieldName, Value, FieldList[FieldName][1], FieldList[FieldName][2], FieldList[FieldName][0])
1404                         else:
1405                             CApp = CApp + '  Pcd->%s = %d; // From %s Line %d Value %s\n' % (FieldName, Value, FieldList[FieldName][1], FieldList[FieldName][2], FieldList[FieldName][0])
1406             for skuname in self.SkuIdMgr.GetSkuChain(SkuName):
1407                 inherit_OverrideValues = Pcd.SkuOverrideValues[skuname]
1408                 for FieldList in [Pcd.DefaultFromDSC,inherit_OverrideValues.get(DefaultStoreName)]:
1409                     if not FieldList:
1410                         continue
1411                     if Pcd.DefaultFromDSC and FieldList == Pcd.DefaultFromDSC:
1412                         IsArray = self.IsFieldValueAnArray(FieldList)
1413                         Value, ValueSize = ParseFieldValue (FieldList)
1414                         if isinstance(Value, str):
1415                             CApp = CApp + '  Pcd = %s; // From DSC Default Value %s\n' % (Value, Pcd.DefaultFromDSC)
1416                         elif IsArray:
1417                         #
1418                         # Use memcpy() to copy value into field
1419                         #
1420                             CApp = CApp + '  Value     = %s; // From DSC Default Value %s\n' % (self.IntToCString(Value, ValueSize), Pcd.DefaultFromDSC)
1421                             CApp = CApp + '  memcpy (Pcd, Value, %d);\n' % (ValueSize)
1422                         continue
1423
1424                     for FieldName in FieldList:
1425                         IsArray = self.IsFieldValueAnArray(FieldList[FieldName][0])
1426                         try:
1427                             Value, ValueSize = ParseFieldValue (FieldList[FieldName][0])
1428                         except Exception:
1429                             print FieldList[FieldName][0]
1430                         if isinstance(Value, str):
1431                             CApp = CApp + '  Pcd->%s = %s; // From %s Line %d Value %s\n' % (FieldName, Value, FieldList[FieldName][1], FieldList[FieldName][2], FieldList[FieldName][0])
1432                         elif IsArray:
1433                         #
1434                         # Use memcpy() to copy value into field
1435                         #
1436                             CApp = CApp + '  FieldSize = __FIELD_SIZE(%s, %s);\n' % (Pcd.DatumType, FieldName)
1437                             CApp = CApp + '  Value     = %s; // From %s Line %d Value %s\n' % (self.IntToCString(Value, ValueSize), FieldList[FieldName][1], FieldList[FieldName][2], FieldList[FieldName][0])
1438                             CApp = CApp + '  memcpy (&Pcd->%s[0], Value, (FieldSize > 0 && FieldSize < %d) ? FieldSize : %d);\n' % (FieldName, ValueSize, ValueSize)
1439                         else:
1440                             if ValueSize > 4:
1441                                 CApp = CApp + '  Pcd->%s = %dULL; // From %s Line %d Value %s\n' % (FieldName, Value, FieldList[FieldName][1], FieldList[FieldName][2], FieldList[FieldName][0])
1442                             else:
1443                                 CApp = CApp + '  Pcd->%s = %d; // From %s Line %d Value %s\n' % (FieldName, Value, FieldList[FieldName][1], FieldList[FieldName][2], FieldList[FieldName][0])
1444                 if skuname == SkuName:
1445                     break
1446             #
1447             # Set new PCD value and size
1448             #
1449             CApp = CApp + '  PcdSetPtr (%s, %s, %s, %s, Size, (UINT8 *)Pcd);\n' % (SkuName, DefaultStoreName, Pcd.TokenSpaceGuidCName, Pcd.TokenCName)
1450
1451             #
1452             # Free PCD
1453             #
1454             CApp = CApp + '  free (Pcd);\n'
1455             CApp = CApp + '}\n'
1456             CApp = CApp + '\n'
1457         return InitByteValue, CApp
1458
1459     def GenerateByteArrayValue (self, StructuredPcds):
1460         #
1461         # Generate/Compile/Run C application to determine if there are any flexible array members
1462         #
1463         if not StructuredPcds:
1464             return
1465
1466         InitByteValue = ""
1467         CApp = PcdMainCHeader
1468
1469         Includes = {}
1470         for PcdName in StructuredPcds:
1471             Pcd = StructuredPcds[PcdName]
1472             IncludeFile = Pcd.StructuredPcdIncludeFile
1473             if IncludeFile not in Includes:
1474                 Includes[IncludeFile] = True
1475                 CApp = CApp + '#include <%s>\n' % (IncludeFile)
1476         CApp = CApp + '\n'
1477
1478         for PcdName in StructuredPcds:
1479             Pcd = StructuredPcds[PcdName]
1480             if not Pcd.SkuOverrideValues:
1481                 InitByteValue, CApp = self.GenerateInitializeFunc(self.SkuIdMgr.SystemSkuId, 'STANDARD', Pcd, InitByteValue, CApp)
1482             else:
1483                 for SkuName in self.SkuIdMgr.SkuOverrideOrder():
1484                     if SkuName not in Pcd.SkuOverrideValues:
1485                         continue
1486                     for DefaultStoreName in Pcd.DefaultStoreName:
1487                         Pcd = StructuredPcds[PcdName]
1488                         InitByteValue, CApp = self.GenerateInitializeFunc(SkuName, DefaultStoreName, Pcd, InitByteValue, CApp)
1489
1490         CApp = CApp + 'VOID\n'
1491         CApp = CApp + 'PcdEntryPoint(\n'
1492         CApp = CApp + '  VOID\n'
1493         CApp = CApp + '  )\n'
1494         CApp = CApp + '{\n'
1495         for Pcd in StructuredPcds.values():
1496             if not Pcd.SkuOverrideValues:
1497                 CApp = CApp + '  Initialize_%s_%s_%s_%s();\n' % (self.SkuIdMgr.SystemSkuId, 'STANDARD', Pcd.TokenSpaceGuidCName, Pcd.TokenCName)
1498             else:
1499                 for SkuName in self.SkuIdMgr.SkuOverrideOrder():
1500                     if SkuName not in Pcd.SkuOverrideValues:
1501                         continue
1502                     for DefaultStoreName in Pcd.SkuOverrideValues[SkuName]:
1503                         CApp = CApp + '  Initialize_%s_%s_%s_%s();\n' % (SkuName, DefaultStoreName, Pcd.TokenSpaceGuidCName, Pcd.TokenCName)
1504         CApp = CApp + '}\n'
1505
1506         CApp = CApp + PcdMainCEntry + '\n'
1507
1508         if not os.path.exists(self.OutputPath):
1509             os.makedirs(self.OutputPath)
1510         CAppBaseFileName = os.path.join(self.OutputPath, PcdValueInitName)
1511         File = open (CAppBaseFileName + '.c', 'w')
1512         File.write(CApp)
1513         File.close()
1514
1515         MakeApp = PcdMakefileHeader
1516         if sys.platform == "win32":
1517             MakeApp = MakeApp + 'ARCH = IA32\nAPPNAME = %s\n' % (PcdValueInitName) + 'OBJECTS = %s\%s.obj\n' % (self.OutputPath, PcdValueInitName) + 'INC = '
1518         else:
1519             MakeApp = MakeApp + PcdGccMakefile
1520             MakeApp = MakeApp + 'APPNAME = %s\n' % (PcdValueInitName) + 'OBJECTS = %s/%s.o\n' % (self.OutputPath, PcdValueInitName) + \
1521                       'include $(MAKEROOT)/Makefiles/app.makefile\n' + 'INCLUDE +='
1522
1523         PlatformInc = {}
1524         for Cache in self._Bdb._CACHE_.values():
1525             if Cache.MetaFile.Ext.lower() != '.dec':
1526                 continue
1527             if Cache.Includes:
1528                 if str(Cache.MetaFile.Path) not in PlatformInc:
1529                     PlatformInc[str(Cache.MetaFile.Path)] = Cache.Includes
1530
1531         PcdDependDEC = []
1532         for Pcd in StructuredPcds.values():
1533             for PackageDec in Pcd.PackageDecs:
1534                 Package = os.path.normpath(mws.join(GlobalData.gWorkspace, PackageDec))
1535                 if not os.path.exists(Package):
1536                     EdkLogger.error('Build', RESOURCE_NOT_AVAILABLE, "The dependent Package %s of PCD %s.%s is not exist." % (PackageDec, Pcd.TokenSpaceGuidCName, Pcd.TokenCName))
1537                 if Package not in PcdDependDEC:
1538                     PcdDependDEC.append(Package)
1539
1540         if PlatformInc and PcdDependDEC:
1541             for pkg in PcdDependDEC:
1542                 if pkg in PlatformInc:
1543                     for inc in PlatformInc[pkg]:
1544                         MakeApp += '-I'  + str(inc) + ' '
1545         MakeApp = MakeApp + '\n'
1546
1547         CC_FLAGS = LinuxCFLAGS
1548         if sys.platform == "win32":
1549             CC_FLAGS = WindowsCFLAGS
1550         BuildOptions = {}
1551         for Options in self.BuildOptions:
1552             if Options[2] != EDKII_NAME:
1553                 continue
1554             Family = Options[0]
1555             if Family and Family != self.ToolChainFamily:
1556                 continue
1557             Target, Tag, Arch, Tool, Attr = Options[1].split("_")
1558             if Tool != 'CC':
1559                 continue
1560
1561             if Target == "*" or Target == self._Target:
1562                 if Tag == "*" or Tag == self._Toolchain:
1563                     if Arch == "*" or Arch == self.Arch:
1564                         if Tool not in BuildOptions:
1565                             BuildOptions[Tool] = {}
1566                         if Attr != "FLAGS" or Attr not in BuildOptions[Tool] or self.BuildOptions[Options].startswith('='):
1567                             BuildOptions[Tool][Attr] = self.BuildOptions[Options]
1568                         else:
1569                             # append options for the same tool except PATH
1570                             if Attr != 'PATH':
1571                                 BuildOptions[Tool][Attr] += " " + self.BuildOptions[Options]
1572                             else:
1573                                 BuildOptions[Tool][Attr] = self.BuildOptions[Options]
1574         if BuildOptions:
1575             for Tool in BuildOptions:
1576                 for Attr in BuildOptions[Tool]:
1577                     if Attr == "FLAGS":
1578                         Value = BuildOptions[Tool][Attr]
1579                         ValueList = Value.split()
1580                         if ValueList:
1581                             for Id, Item in enumerate(ValueList):
1582                                 if Item == '-D' or Item == '/D':
1583                                     CC_FLAGS += ' ' + Item
1584                                     if Id + 1 < len(ValueList):
1585                                         CC_FLAGS += ' ' + ValueList[Id + 1]
1586                                 elif Item.startswith('/D') or Item.startswith('-D'):
1587                                     CC_FLAGS += ' ' + Item
1588         MakeApp += CC_FLAGS
1589
1590         if sys.platform == "win32":
1591             MakeApp = MakeApp + PcdMakefileEnd
1592         MakeFileName = os.path.join(self.OutputPath, 'Makefile')
1593         File = open (MakeFileName, 'w')
1594         File.write(MakeApp)
1595         File.close()
1596
1597         InputValueFile = os.path.join(self.OutputPath, 'Input.txt')
1598         OutputValueFile = os.path.join(self.OutputPath, 'Output.txt')
1599         File = open (InputValueFile, 'w')
1600         File.write(InitByteValue)
1601         File.close()
1602
1603         Messages = ''
1604         if sys.platform == "win32":
1605             StdOut, StdErr = self.ExecuteCommand ('nmake clean & nmake -f %s' % (MakeFileName))
1606             Messages = StdOut
1607         else:
1608             StdOut, StdErr = self.ExecuteCommand ('make clean & make -f %s' % (MakeFileName))
1609             Messages = StdErr
1610         Messages = Messages.split('\n')
1611         for Message in Messages:
1612             if " error" in Message:
1613                 FileInfo = Message.strip().split('(')
1614                 if len (FileInfo) > 1:
1615                     FileName = FileInfo [0]
1616                     FileLine = FileInfo [1].split (')')[0]
1617                 else:
1618                     FileInfo = Message.strip().split(':')
1619                     FileName = FileInfo [0]
1620                     FileLine = FileInfo [1]
1621
1622                 File = open (FileName, 'r')
1623                 FileData = File.readlines()
1624                 File.close()
1625                 error_line = FileData[int (FileLine) - 1]
1626                 if r"//" in error_line:
1627                     c_line,dsc_line = error_line.split(r"//")
1628                 else:
1629                     dsc_line = error_line
1630
1631                 message_itmes = Message.split(":")
1632                 Index = 0
1633                 for item in message_itmes:
1634                     if "PcdValueInit.c" in item:
1635                         Index = message_itmes.index(item)
1636                         message_itmes[Index] = dsc_line.strip()
1637                         break
1638
1639                 EdkLogger.error("build", PCD_STRUCTURE_PCD_ERROR, ":".join(message_itmes[Index:]))
1640
1641         PcdValueInitExe = PcdValueInitName
1642         if not sys.platform == "win32":
1643             PcdValueInitExe = os.path.join(os.getenv("EDK_TOOLS_PATH"), 'Source', 'C', 'bin', PcdValueInitName)
1644
1645         StdOut, StdErr = self.ExecuteCommand (PcdValueInitExe + ' -i %s -o %s' % (InputValueFile, OutputValueFile))
1646         File = open (OutputValueFile, 'r')
1647         FileBuffer = File.readlines()
1648         File.close()
1649
1650         StructurePcdSet = []
1651         for Pcd in FileBuffer:
1652             PcdValue = Pcd.split ('|')
1653             PcdInfo = PcdValue[0].split ('.')
1654             StructurePcdSet.append((PcdInfo[0],PcdInfo[1], PcdInfo[2], PcdInfo[3], PcdValue[2].strip()))
1655         return StructurePcdSet
1656
1657     ## Retrieve dynamic PCD settings
1658     #
1659     #   @param  Type    PCD type
1660     #
1661     #   @retval a dict object contains settings of given PCD type
1662     #
1663     def _GetDynamicPcd(self, Type):
1664
1665
1666         Pcds = sdict()
1667         #
1668         # tdict is a special dict kind of type, used for selecting correct
1669         # PCD settings for certain ARCH and SKU
1670         #
1671         PcdDict = tdict(True, 4)
1672         PcdList = []
1673         # Find out all possible PCD candidates for self._Arch
1674         RecordList = self._RawData[Type, self._Arch]
1675         AvailableSkuIdSet = copy.copy(self.SkuIds)
1676
1677
1678         for TokenSpaceGuid, PcdCName, Setting, Arch, SkuName, Dummy3, Dummy4,Dummy5 in RecordList:
1679             SkuName = SkuName.upper()
1680             SkuName = 'DEFAULT' if SkuName == 'COMMON' else SkuName
1681             if SkuName not in AvailableSkuIdSet:
1682                 EdkLogger.error('build', PARAMETER_INVALID, 'Sku %s is not defined in [SkuIds] section' % SkuName,
1683                                             File=self.MetaFile, Line=Dummy5)
1684             if "." not in TokenSpaceGuid:
1685                 PcdList.append((PcdCName, TokenSpaceGuid, SkuName, Dummy4))
1686             PcdDict[Arch, SkuName, PcdCName, TokenSpaceGuid] = Setting
1687
1688         # Remove redundant PCD candidates, per the ARCH and SKU
1689         for PcdCName, TokenSpaceGuid, SkuName, Dummy4 in PcdList:
1690
1691             Setting = PcdDict[self._Arch, SkuName, PcdCName, TokenSpaceGuid]
1692             if Setting == None:
1693                 continue
1694
1695             PcdValue, DatumType, MaxDatumSize = self._ValidatePcd(PcdCName, TokenSpaceGuid, Setting, Type, Dummy4)
1696             SkuInfo = SkuInfoClass(SkuName, self.SkuIds[SkuName][0], '', '', '', '', '', PcdValue)
1697             if (PcdCName, TokenSpaceGuid) in Pcds.keys():
1698                 pcdObject = Pcds[PcdCName, TokenSpaceGuid]
1699                 pcdObject.SkuInfoList[SkuName] = SkuInfo
1700                 if MaxDatumSize.strip():
1701                     CurrentMaxSize = int(MaxDatumSize.strip(), 0)
1702                 else:
1703                     CurrentMaxSize = 0
1704                 if pcdObject.MaxDatumSize:
1705                     PcdMaxSize = int(pcdObject.MaxDatumSize, 0)
1706                 else:
1707                     PcdMaxSize = 0
1708                 if CurrentMaxSize > PcdMaxSize:
1709                     pcdObject.MaxDatumSize = str(CurrentMaxSize)
1710             else:
1711                 Pcds[PcdCName, TokenSpaceGuid] = PcdClassObject(
1712                                                     PcdCName,
1713                                                     TokenSpaceGuid,
1714                                                     self._PCD_TYPE_STRING_[Type],
1715                                                     DatumType,
1716                                                     PcdValue,
1717                                                     '',
1718                                                     MaxDatumSize,
1719                                                     {SkuName : SkuInfo},
1720                                                     False,
1721                                                     None,
1722                                                     IsDsc=True)
1723
1724         for pcd in Pcds.values():
1725             pcdDecObject = self._DecPcds[pcd.TokenCName, pcd.TokenSpaceGuidCName]
1726             # Only fix the value while no value provided in DSC file.
1727             for sku in pcd.SkuInfoList.values():
1728                 if (sku.DefaultValue == "" or sku.DefaultValue==None):
1729                     sku.DefaultValue = pcdDecObject.DefaultValue
1730             if 'DEFAULT' not in pcd.SkuInfoList.keys() and 'COMMON' not in pcd.SkuInfoList.keys():
1731                 valuefromDec = pcdDecObject.DefaultValue
1732                 SkuInfo = SkuInfoClass('DEFAULT', '0', '', '', '', '', '', valuefromDec)
1733                 pcd.SkuInfoList['DEFAULT'] = SkuInfo
1734             elif 'DEFAULT' not in pcd.SkuInfoList.keys() and 'COMMON' in pcd.SkuInfoList.keys():
1735                 pcd.SkuInfoList['DEFAULT'] = pcd.SkuInfoList['COMMON']
1736                 del(pcd.SkuInfoList['COMMON'])
1737             elif 'DEFAULT' in pcd.SkuInfoList.keys() and 'COMMON' in pcd.SkuInfoList.keys():
1738                 del(pcd.SkuInfoList['COMMON'])
1739
1740         map(self.FilterSkuSettings,Pcds.values())
1741
1742         return Pcds
1743
1744     def FilterSkuSettings(self, PcdObj):
1745
1746         if self.SkuIdMgr.SkuUsageType == self.SkuIdMgr.SINGLE:
1747             if 'DEFAULT' in PcdObj.SkuInfoList.keys() and self.SkuIdMgr.SystemSkuId not in PcdObj.SkuInfoList.keys():
1748                 PcdObj.SkuInfoList[self.SkuIdMgr.SystemSkuId] = PcdObj.SkuInfoList['DEFAULT']
1749             PcdObj.SkuInfoList = {'DEFAULT':PcdObj.SkuInfoList[self.SkuIdMgr.SystemSkuId]}
1750             PcdObj.SkuInfoList['DEFAULT'].SkuIdName = 'DEFAULT'
1751             PcdObj.SkuInfoList['DEFAULT'].SkuId = '0'
1752
1753         elif self.SkuIdMgr.SkuUsageType == self.SkuIdMgr.DEFAULT:
1754             PcdObj.SkuInfoList = {'DEFAULT':PcdObj.SkuInfoList['DEFAULT']}
1755
1756         return PcdObj
1757
1758
1759     def CompareVarAttr(self, Attr1, Attr2):
1760         if not Attr1 or not Attr2:  # for empty string
1761             return True
1762         Attr1s = [attr.strip() for attr in Attr1.split(",")]
1763         Attr1Set = set(Attr1s)
1764         Attr2s = [attr.strip() for attr in Attr2.split(",")]
1765         Attr2Set = set(Attr2s)
1766         if Attr2Set == Attr1Set:
1767             return True
1768         else:
1769             return False
1770     def CompletePcdValues(self,PcdSet):
1771         Pcds = {}
1772         DefaultStoreObj = DefaultStore(self._GetDefaultStores())
1773         SkuIds = {skuname:skuid for skuname,skuid in self.SkuIdMgr.AvailableSkuIdSet.items() if skuname !='COMMON'}
1774         DefaultStores = set([storename for pcdobj in PcdSet.values() for skuobj in pcdobj.SkuInfoList.values() for storename in skuobj.DefaultStoreDict.keys()])
1775         for PcdCName, TokenSpaceGuid in PcdSet:
1776             PcdObj = PcdSet[(PcdCName, TokenSpaceGuid)]
1777             if PcdObj.Type not in [self._PCD_TYPE_STRING_[MODEL_PCD_DYNAMIC_DEFAULT],
1778                         self._PCD_TYPE_STRING_[MODEL_PCD_DYNAMIC_HII],
1779                         self._PCD_TYPE_STRING_[MODEL_PCD_DYNAMIC_VPD],
1780                         self._PCD_TYPE_STRING_[MODEL_PCD_DYNAMIC_EX_DEFAULT],
1781                         self._PCD_TYPE_STRING_[MODEL_PCD_DYNAMIC_EX_HII],
1782                         self._PCD_TYPE_STRING_[MODEL_PCD_DYNAMIC_EX_VPD]]:
1783                 Pcds[PcdCName, TokenSpaceGuid]= PcdObj
1784                 continue
1785             PcdType = PcdObj.Type
1786             if PcdType in [self._PCD_TYPE_STRING_[MODEL_PCD_DYNAMIC_HII], self._PCD_TYPE_STRING_[MODEL_PCD_DYNAMIC_EX_HII]]:
1787                 for skuid in PcdObj.SkuInfoList:
1788                     skuobj = PcdObj.SkuInfoList[skuid]
1789                     mindefaultstorename = DefaultStoreObj.GetMin(set([defaultstorename  for defaultstorename in skuobj.DefaultStoreDict]))
1790                     for defaultstorename in DefaultStores:
1791                         if defaultstorename not in skuobj.DefaultStoreDict:
1792                             skuobj.DefaultStoreDict[defaultstorename] = copy.deepcopy(skuobj.DefaultStoreDict[mindefaultstorename])
1793                     skuobj.HiiDefaultValue = skuobj.DefaultStoreDict[mindefaultstorename]
1794             for skuname,skuid in SkuIds.items():
1795                 if skuname not in PcdObj.SkuInfoList:
1796                     nextskuid = self.SkuIdMgr.GetNextSkuId(skuname)
1797                     while nextskuid not in PcdObj.SkuInfoList:
1798                         nextskuid = self.SkuIdMgr.GetNextSkuId(nextskuid)
1799                     PcdObj.SkuInfoList[skuname] = copy.deepcopy(PcdObj.SkuInfoList[nextskuid])
1800                     PcdObj.SkuInfoList[skuname].SkuId = skuid
1801                     PcdObj.SkuInfoList[skuname].SkuIdName = skuname
1802             if PcdType in [self._PCD_TYPE_STRING_[MODEL_PCD_DYNAMIC_HII], self._PCD_TYPE_STRING_[MODEL_PCD_DYNAMIC_EX_HII]]:
1803                 PcdObj.DefaultValue = PcdObj.SkuInfoList.values()[0].HiiDefaultValue if self.SkuIdMgr.SkuUsageType == self.SkuIdMgr.SINGLE else PcdObj.SkuInfoList["DEFAULT"].HiiDefaultValue
1804             Pcds[PcdCName, TokenSpaceGuid]= PcdObj
1805         return Pcds
1806     ## Retrieve dynamic HII PCD settings
1807     #
1808     #   @param  Type    PCD type
1809     #
1810     #   @retval a dict object contains settings of given PCD type
1811     #
1812     def _GetDynamicHiiPcd(self, Type):
1813
1814         VariableAttrs = {}
1815
1816         Pcds = sdict()
1817         #
1818         # tdict is a special dict kind of type, used for selecting correct
1819         # PCD settings for certain ARCH and SKU
1820         #
1821         PcdDict = tdict(True, 5)
1822         PcdSet = set()
1823         RecordList = self._RawData[Type, self._Arch]
1824         # Find out all possible PCD candidates for self._Arch
1825         AvailableSkuIdSet = copy.copy(self.SkuIds)
1826         DefaultStoresDefine = self._GetDefaultStores()
1827
1828         for TokenSpaceGuid, PcdCName, Setting, Arch, SkuName, DefaultStore, Dummy4,Dummy5 in RecordList:
1829             SkuName = SkuName.upper()
1830             SkuName = 'DEFAULT' if SkuName == 'COMMON' else SkuName
1831             DefaultStore = DefaultStore.upper()
1832             if DefaultStore == "COMMON":
1833                 DefaultStore = "STANDARD"
1834             if SkuName not in AvailableSkuIdSet:
1835                 EdkLogger.error('build', PARAMETER_INVALID, 'Sku %s is not defined in [SkuIds] section' % SkuName,
1836                                             File=self.MetaFile, Line=Dummy5)
1837             if DefaultStore not in DefaultStoresDefine:
1838                 EdkLogger.error('build', PARAMETER_INVALID, 'DefaultStores %s is not defined in [DefaultStores] section' % DefaultStore,
1839                                             File=self.MetaFile, Line=Dummy5)
1840             if "." not in TokenSpaceGuid:
1841                 PcdSet.add((PcdCName, TokenSpaceGuid, SkuName,DefaultStore, Dummy4))
1842             PcdDict[Arch, SkuName, PcdCName, TokenSpaceGuid,DefaultStore] = Setting
1843
1844
1845         # Remove redundant PCD candidates, per the ARCH and SKU
1846         for PcdCName, TokenSpaceGuid, SkuName,DefaultStore, Dummy4 in PcdSet:
1847
1848             Setting = PcdDict[self._Arch, SkuName, PcdCName, TokenSpaceGuid,DefaultStore]
1849             if Setting == None:
1850                 continue
1851             VariableName, VariableGuid, VariableOffset, DefaultValue, VarAttribute = self._ValidatePcd(PcdCName, TokenSpaceGuid, Setting, Type, Dummy4)
1852
1853             rt, Msg = VariableAttributes.ValidateVarAttributes(VarAttribute)
1854             if not rt:
1855                 EdkLogger.error("build", PCD_VARIABLE_ATTRIBUTES_ERROR, "Variable attributes settings for %s is incorrect.\n %s" % (".".join((TokenSpaceGuid, PcdCName)), Msg),
1856                         ExtraData="[%s]" % VarAttribute)
1857             ExceedMax = False
1858             FormatCorrect = True
1859             if VariableOffset.isdigit():
1860                 if int(VariableOffset, 10) > 0xFFFF:
1861                     ExceedMax = True
1862             elif re.match(r'[\t\s]*0[xX][a-fA-F0-9]+$', VariableOffset):
1863                 if int(VariableOffset, 16) > 0xFFFF:
1864                     ExceedMax = True
1865             # For Offset written in "A.B"
1866             elif VariableOffset.find('.') > -1:
1867                 VariableOffsetList = VariableOffset.split(".")
1868                 if not (len(VariableOffsetList) == 2
1869                         and IsValidWord(VariableOffsetList[0])
1870                         and IsValidWord(VariableOffsetList[1])):
1871                     FormatCorrect = False
1872             else:
1873                 FormatCorrect = False
1874             if not FormatCorrect:
1875                 EdkLogger.error('Build', FORMAT_INVALID, "Invalid syntax or format of the variable offset value is incorrect for %s." % ".".join((TokenSpaceGuid, PcdCName)))
1876
1877             if ExceedMax:
1878                 EdkLogger.error('Build', OPTION_VALUE_INVALID, "The variable offset value must not exceed the maximum value of 0xFFFF (UINT16) for %s." % ".".join((TokenSpaceGuid, PcdCName)))
1879             if (VariableName, VariableGuid) not in VariableAttrs:
1880                 VariableAttrs[(VariableName, VariableGuid)] = VarAttribute
1881             else:
1882                 if not self.CompareVarAttr(VariableAttrs[(VariableName, VariableGuid)], VarAttribute):
1883                     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)]))
1884
1885             pcdDecObject = self._DecPcds[PcdCName, TokenSpaceGuid]
1886             if (PcdCName, TokenSpaceGuid) in Pcds.keys():
1887                 pcdObject = Pcds[PcdCName, TokenSpaceGuid]
1888                 if SkuName in pcdObject.SkuInfoList:
1889                     Skuitem = pcdObject.SkuInfoList[SkuName]
1890                     Skuitem.DefaultStoreDict.update({DefaultStore:DefaultValue})
1891                 else:
1892                     SkuInfo = SkuInfoClass(SkuName, self.SkuIds[SkuName][0], VariableName, VariableGuid, VariableOffset, DefaultValue, VariableAttribute=VarAttribute,DefaultStore={DefaultStore:DefaultValue})
1893                     pcdObject.SkuInfoList[SkuName] = SkuInfo
1894             else:
1895                 SkuInfo = SkuInfoClass(SkuName, self.SkuIds[SkuName][0], VariableName, VariableGuid, VariableOffset, DefaultValue, VariableAttribute=VarAttribute,DefaultStore={DefaultStore:DefaultValue})
1896                 Pcds[PcdCName, TokenSpaceGuid] = PcdClassObject(
1897                                                 PcdCName,
1898                                                 TokenSpaceGuid,
1899                                                 self._PCD_TYPE_STRING_[Type],
1900                                                 '',
1901                                                 DefaultValue,
1902                                                 '',
1903                                                 '',
1904                                                 {SkuName : SkuInfo},
1905                                                 False,
1906                                                 None,
1907                                                 pcdDecObject.validateranges,
1908                                                 pcdDecObject.validlists,
1909                                                 pcdDecObject.expressions,
1910                                                 IsDsc=True)
1911
1912
1913         for pcd in Pcds.values():
1914             SkuInfoObj = pcd.SkuInfoList.values()[0]
1915             pcdDecObject = self._DecPcds[pcd.TokenCName, pcd.TokenSpaceGuidCName]
1916             # Only fix the value while no value provided in DSC file.
1917             for sku in pcd.SkuInfoList.values():
1918                 if (sku.HiiDefaultValue == "" or sku.HiiDefaultValue == None):
1919                     sku.HiiDefaultValue = pcdDecObject.DefaultValue
1920             if 'DEFAULT' not in pcd.SkuInfoList.keys() and 'COMMON' not in pcd.SkuInfoList.keys():
1921                 valuefromDec = pcdDecObject.DefaultValue
1922                 SkuInfo = SkuInfoClass('DEFAULT', '0', SkuInfoObj.VariableName, SkuInfoObj.VariableGuid, SkuInfoObj.VariableOffset, valuefromDec,VariableAttribute=SkuInfoObj.VariableAttribute,DefaultStore={DefaultStore:valuefromDec})
1923                 pcd.SkuInfoList['DEFAULT'] = SkuInfo
1924             elif 'DEFAULT' not in pcd.SkuInfoList.keys() and 'COMMON' in pcd.SkuInfoList.keys():
1925                 pcd.SkuInfoList['DEFAULT'] = pcd.SkuInfoList['COMMON']
1926                 del(pcd.SkuInfoList['COMMON'])
1927             elif 'DEFAULT' in pcd.SkuInfoList.keys() and 'COMMON' in pcd.SkuInfoList.keys():
1928                 del(pcd.SkuInfoList['COMMON'])
1929
1930             if pcd.MaxDatumSize.strip():
1931                 MaxSize = int(pcd.MaxDatumSize, 0)
1932             else:
1933                 MaxSize = 0
1934             if pcdDecObject.DatumType == 'VOID*':
1935                 for (_, skuobj) in pcd.SkuInfoList.items():
1936                     datalen = 0
1937                     skuobj.HiiDefaultValue = StringToArray(skuobj.HiiDefaultValue)
1938                     datalen = len(skuobj.HiiDefaultValue.split(","))
1939                     if datalen > MaxSize:
1940                         MaxSize = datalen
1941                     for defaultst in skuobj.DefaultStoreDict:
1942                         skuobj.DefaultStoreDict[defaultst] = StringToArray(skuobj.DefaultStoreDict[defaultst])
1943                 pcd.DefaultValue = StringToArray(pcd.DefaultValue)
1944                 pcd.MaxDatumSize = str(MaxSize)
1945         rt, invalidhii = self.CheckVariableNameAssignment(Pcds)
1946         if not rt:
1947             invalidpcd = ",".join(invalidhii)
1948             EdkLogger.error('build', PCD_VARIABLE_INFO_ERROR, Message='The same HII PCD must map to the same EFI variable for all SKUs', File=self.MetaFile, ExtraData=invalidpcd)
1949
1950         map(self.FilterSkuSettings,Pcds.values())
1951
1952         return Pcds
1953
1954     def CheckVariableNameAssignment(self,Pcds):
1955         invalidhii = []
1956         for pcdname in Pcds:
1957             pcd = Pcds[pcdname]
1958             varnameset = set([sku.VariableName for (skuid,sku) in pcd.SkuInfoList.items()])
1959             if len(varnameset) > 1:
1960                 invalidhii.append(".".join((pcdname[1],pcdname[0])))
1961         if len(invalidhii):
1962             return False,invalidhii
1963         else:
1964             return True, []
1965     ## Retrieve dynamic VPD PCD settings
1966     #
1967     #   @param  Type    PCD type
1968     #
1969     #   @retval a dict object contains settings of given PCD type
1970     #
1971     def _GetDynamicVpdPcd(self, Type):
1972
1973
1974         Pcds = sdict()
1975         #
1976         # tdict is a special dict kind of type, used for selecting correct
1977         # PCD settings for certain ARCH and SKU
1978         #
1979         PcdDict = tdict(True, 4)
1980         PcdList = []
1981
1982         # Find out all possible PCD candidates for self._Arch
1983         RecordList = self._RawData[Type, self._Arch]
1984         AvailableSkuIdSet = copy.copy(self.SkuIds)
1985
1986         for TokenSpaceGuid, PcdCName, Setting, Arch, SkuName, Dummy3, Dummy4,Dummy5 in RecordList:
1987             SkuName = SkuName.upper()
1988             SkuName = 'DEFAULT' if SkuName == 'COMMON' else SkuName
1989             if SkuName not in AvailableSkuIdSet:
1990                 EdkLogger.error('build', PARAMETER_INVALID, 'Sku %s is not defined in [SkuIds] section' % SkuName,
1991                                             File=self.MetaFile, Line=Dummy5)
1992             if "." not in TokenSpaceGuid:
1993                 PcdList.append((PcdCName, TokenSpaceGuid, SkuName, Dummy4))
1994             PcdDict[Arch, SkuName, PcdCName, TokenSpaceGuid] = Setting
1995
1996         # Remove redundant PCD candidates, per the ARCH and SKU
1997         for PcdCName, TokenSpaceGuid, SkuName, Dummy4 in PcdList:
1998             Setting = PcdDict[self._Arch, SkuName, PcdCName, TokenSpaceGuid]
1999             if Setting == None:
2000                 continue
2001             #
2002             # For the VOID* type, it can have optional data of MaxDatumSize and InitialValue
2003             # For the Integer & Boolean type, the optional data can only be InitialValue.
2004             # At this point, we put all the data into the PcdClssObject for we don't know the PCD's datumtype
2005             # until the DEC parser has been called.
2006             #
2007             VpdOffset, MaxDatumSize, InitialValue = self._ValidatePcd(PcdCName, TokenSpaceGuid, Setting, Type, Dummy4)
2008             SkuInfo = SkuInfoClass(SkuName, self.SkuIds[SkuName][0], '', '', '', '', VpdOffset, InitialValue)
2009             if (PcdCName, TokenSpaceGuid) in Pcds.keys():
2010                 pcdObject = Pcds[PcdCName, TokenSpaceGuid]
2011                 pcdObject.SkuInfoList[SkuName] = SkuInfo
2012                 if MaxDatumSize.strip():
2013                     CurrentMaxSize = int(MaxDatumSize.strip(), 0)
2014                 else:
2015                     CurrentMaxSize = 0
2016                 if pcdObject.MaxDatumSize:
2017                     PcdMaxSize = int(pcdObject.MaxDatumSize, 0)
2018                 else:
2019                     PcdMaxSize = 0
2020                 if CurrentMaxSize > PcdMaxSize:
2021                     pcdObject.MaxDatumSize = str(CurrentMaxSize)
2022             else:
2023                 Pcds[PcdCName, TokenSpaceGuid] = PcdClassObject(
2024                                                 PcdCName,
2025                                                 TokenSpaceGuid,
2026                                                 self._PCD_TYPE_STRING_[Type],
2027                                                 '',
2028                                                 InitialValue,
2029                                                 '',
2030                                                 MaxDatumSize,
2031                                                 {SkuName : SkuInfo},
2032                                                 False,
2033                                                 None,
2034                                                 IsDsc=True)
2035         for pcd in Pcds.values():
2036             SkuInfoObj = pcd.SkuInfoList.values()[0]
2037             pcdDecObject = self._DecPcds[pcd.TokenCName, pcd.TokenSpaceGuidCName]
2038             # Only fix the value while no value provided in DSC file.
2039             for sku in pcd.SkuInfoList.values():
2040                 if (sku.DefaultValue == "" or sku.DefaultValue==None):
2041                     sku.DefaultValue = pcdDecObject.DefaultValue
2042             if 'DEFAULT' not in pcd.SkuInfoList.keys() and 'COMMON' not in pcd.SkuInfoList.keys():
2043                 valuefromDec = pcdDecObject.DefaultValue
2044                 SkuInfo = SkuInfoClass('DEFAULT', '0', '', '', '', '', SkuInfoObj.VpdOffset, valuefromDec)
2045                 pcd.SkuInfoList['DEFAULT'] = SkuInfo
2046             elif 'DEFAULT' not in pcd.SkuInfoList.keys() and 'COMMON' in pcd.SkuInfoList.keys():
2047                 pcd.SkuInfoList['DEFAULT'] = pcd.SkuInfoList['COMMON']
2048                 del(pcd.SkuInfoList['COMMON'])
2049             elif 'DEFAULT' in pcd.SkuInfoList.keys() and 'COMMON' in pcd.SkuInfoList.keys():
2050                 del(pcd.SkuInfoList['COMMON'])
2051
2052
2053         map(self.FilterSkuSettings,Pcds.values())
2054         return Pcds
2055
2056     ## Add external modules
2057     #
2058     #   The external modules are mostly those listed in FDF file, which don't
2059     # need "build".
2060     #
2061     #   @param  FilePath    The path of module description file
2062     #
2063     def AddModule(self, FilePath):
2064         FilePath = NormPath(FilePath)
2065         if FilePath not in self.Modules:
2066             Module = ModuleBuildClassObject()
2067             Module.MetaFile = FilePath
2068             self.Modules.append(Module)
2069
2070     def _GetToolChainFamily(self):
2071         self._ToolChainFamily = "MSFT"
2072         BuildConfigurationFile = os.path.normpath(os.path.join(GlobalData.gConfDirectory, "target.txt"))
2073         if os.path.isfile(BuildConfigurationFile) == True:
2074             TargetTxt      = TargetTxtClassObject()
2075             TargetTxt.LoadTargetTxtFile(BuildConfigurationFile)
2076             ToolDefinitionFile = TargetTxt.TargetTxtDictionary[DataType.TAB_TAT_DEFINES_TOOL_CHAIN_CONF]
2077             if ToolDefinitionFile == '':
2078                 ToolDefinitionFile = "tools_def.txt"
2079                 ToolDefinitionFile = os.path.normpath(mws.join(self.WorkspaceDir, 'Conf', ToolDefinitionFile))
2080             if os.path.isfile(ToolDefinitionFile) == True:
2081                 ToolDef        = ToolDefClassObject()
2082                 ToolDef.LoadToolDefFile(ToolDefinitionFile)
2083                 ToolDefinition = ToolDef.ToolsDefTxtDatabase
2084                 if TAB_TOD_DEFINES_FAMILY not in ToolDefinition \
2085                    or self._Toolchain not in ToolDefinition[TAB_TOD_DEFINES_FAMILY] \
2086                    or not ToolDefinition[TAB_TOD_DEFINES_FAMILY][self._Toolchain]:
2087                     self._ToolChainFamily = "MSFT"
2088                 else:
2089                     self._ToolChainFamily = ToolDefinition[TAB_TOD_DEFINES_FAMILY][self._Toolchain]
2090         return self._ToolChainFamily
2091
2092     ## Add external PCDs
2093     #
2094     #   The external PCDs are mostly those listed in FDF file to specify address
2095     # or offset information.
2096     #
2097     #   @param  Name    Name of the PCD
2098     #   @param  Guid    Token space guid of the PCD
2099     #   @param  Value   Value of the PCD
2100     #
2101     def AddPcd(self, Name, Guid, Value):
2102         if (Name, Guid) not in self.Pcds:
2103             self.Pcds[Name, Guid] = PcdClassObject(Name, Guid, '', '', '', '', '', {}, False, None)
2104         self.Pcds[Name, Guid].DefaultValue = Value
2105     @property
2106     def DecPcds(self):
2107         if self._DecPcds == None:
2108             FdfInfList = []
2109             if GlobalData.gFdfParser:
2110                 FdfInfList = GlobalData.gFdfParser.Profile.InfList
2111             PkgSet = set()
2112             for Inf in FdfInfList:
2113                 ModuleFile = PathClass(NormPath(Inf), GlobalData.gWorkspace, Arch=self._Arch)
2114                 if ModuleFile in self._Modules:
2115                     continue
2116                 ModuleData = self._Bdb[ModuleFile, self._Arch, self._Target, self._Toolchain]
2117                 PkgSet.update(ModuleData.Packages)
2118             self._DecPcds, self._GuidDict = GetDeclaredPcd(self, self._Bdb, self._Arch, self._Target, self._Toolchain,PkgSet)
2119         return self._DecPcds
2120     _Macros             = property(_GetMacros)
2121     Arch                = property(_GetArch, _SetArch)
2122     Platform            = property(_GetPlatformName)
2123     PlatformName        = property(_GetPlatformName)
2124     Guid                = property(_GetFileGuid)
2125     Version             = property(_GetVersion)
2126     DscSpecification    = property(_GetDscSpec)
2127     OutputDirectory     = property(_GetOutpuDir)
2128     SupArchList         = property(_GetSupArch)
2129     BuildTargets        = property(_GetBuildTarget)
2130     SkuName             = property(_GetSkuName, _SetSkuName)
2131     PcdInfoFlag         = property(_GetPcdInfoFlag)
2132     VarCheckFlag        = property(_GetVarCheckFlag)
2133     FlashDefinition     = property(_GetFdfFile)
2134     Prebuild            = property(_GetPrebuild)
2135     Postbuild           = property(_GetPostbuild)
2136     BuildNumber         = property(_GetBuildNumber)
2137     MakefileName        = property(_GetMakefileName)
2138     BsBaseAddress       = property(_GetBsBaseAddress)
2139     RtBaseAddress       = property(_GetRtBaseAddress)
2140     LoadFixAddress      = property(_GetLoadFixAddress)
2141     RFCLanguages        = property(_GetRFCLanguages)
2142     ISOLanguages        = property(_GetISOLanguages)
2143     VpdToolGuid         = property(_GetVpdToolGuid)
2144     SkuIds              = property(_GetSkuIds)
2145     Modules             = property(_GetModules)
2146     LibraryInstances    = property(_GetLibraryInstances)
2147     LibraryClasses      = property(_GetLibraryClasses)
2148     Pcds                = property(_GetPcds)
2149     BuildOptions        = property(_GetBuildOptions)
2150     ToolChainFamily     = property(_GetToolChainFamily)