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