BaseTools/Source/Python/Workspace/DscBuildData.py

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