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