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