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