BaseTools/Source/Python/Workspace/DscBuildData.py

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