BaseTools/Source/Python/Workspace/DscBuildData.py

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