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
1567         return Pcds
1568
1569     def GetStructurePcdMaxSize(self, str_pcd):
1570         pcd_default_value = str_pcd.DefaultValue
1571         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()]
1572         sku_values.append(pcd_default_value)
1573
1574         def get_length(value):
1575             Value = value.strip()
1576             if len(value) > 1:
1577                 if Value.startswith(TAB_GUID) and Value.endswith(')'):
1578                     return 16
1579                 if Value.startswith('L"') and Value.endswith('"'):
1580                     return len(Value[2:-1])
1581                 if Value[0] == '"' and Value[-1] == '"':
1582                     return len(Value) - 2
1583                 if Value[0] == '{' and Value[-1] == '}':
1584                     return len(Value.split(","))
1585                 if Value.startswith("L'") and Value.endswith("'") and len(list(Value[2:-1])) > 1:
1586                     return  len(list(Value[2:-1]))
1587                 if Value[0] == "'" and Value[-1] == "'" and len(list(Value[1:-1])) > 1:
1588                     return len(Value) - 2
1589             return len(Value)
1590
1591         return str(max(get_length(item) for item in sku_values))
1592
1593     @staticmethod
1594     def ExecuteCommand (Command):
1595         try:
1596             Process = subprocess.Popen(Command, stdout=subprocess.PIPE, stderr=subprocess.PIPE, shell=True)
1597         except:
1598             EdkLogger.error('Build', COMMAND_FAILURE, 'Can not execute command: %s' % Command)
1599         Result = Process.communicate()
1600         return Process.returncode, Result[0], Result[1]
1601
1602     @staticmethod
1603     def IntToCString(Value, ValueSize):
1604         Result = '"'
1605         if not isinstance (Value, str):
1606             for Index in range(0, ValueSize):
1607                 Result = Result + '\\x%02x' % (Value & 0xff)
1608                 Value = Value >> 8
1609         Result = Result + '"'
1610         return Result
1611
1612     def GenerateSizeFunction(self, Pcd):
1613         CApp = "// Default Value in Dec \n"
1614         CApp = CApp + "void Cal_%s_%s_Size(UINT32 *Size){\n" % (Pcd.TokenSpaceGuidCName, Pcd.TokenCName)
1615         for FieldList in [Pcd.DefaultValues]:
1616             if not FieldList:
1617                 continue
1618             for FieldName in FieldList:
1619                 FieldName = "." + FieldName
1620                 IsArray = IsFieldValueAnArray(FieldList[FieldName.strip(".")][0])
1621                 if IsArray and not (FieldList[FieldName.strip(".")][0].startswith('{GUID') and FieldList[FieldName.strip(".")][0].endswith('}')):
1622                     try:
1623                         Value = ValueExpressionEx(FieldList[FieldName.strip(".")][0], TAB_VOID, self._GuidDict)(True)
1624                     except BadExpression:
1625                         EdkLogger.error('Build', FORMAT_INVALID, "Invalid value format for %s. From %s Line %d " %
1626                                         (".".join((Pcd.TokenSpaceGuidCName, Pcd.TokenCName, FieldName.strip('.'))), FieldList[FieldName.strip(".")][1], FieldList[FieldName.strip(".")][2]))
1627                     Value, ValueSize = ParseFieldValue(Value)
1628                     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]);
1629                 else:
1630                     NewFieldName = ''
1631                     FieldName_ori = FieldName.strip('.')
1632                     while '[' in  FieldName:
1633                         NewFieldName = NewFieldName + FieldName.split('[', 1)[0] + '[0]'
1634                         ArrayIndex = int(FieldName.split('[', 1)[1].split(']', 1)[0])
1635                         FieldName = FieldName.split(']', 1)[1]
1636                     FieldName = NewFieldName + FieldName
1637                     while '[' in FieldName:
1638                         FieldName = FieldName.rsplit('[', 1)[0]
1639                         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])
1640         for skuname in Pcd.SkuOverrideValues:
1641             if skuname == TAB_COMMON:
1642                 continue
1643             for defaultstorenameitem in Pcd.SkuOverrideValues[skuname]:
1644                 CApp = CApp + "// SkuName: %s,  DefaultStoreName: %s \n" % (skuname, defaultstorenameitem)
1645                 for FieldList in [Pcd.SkuOverrideValues[skuname].get(defaultstorenameitem)]:
1646                     if not FieldList:
1647                         continue
1648                     for FieldName in FieldList:
1649                         FieldName = "." + FieldName
1650                         IsArray = IsFieldValueAnArray(FieldList[FieldName.strip(".")][0])
1651                         if IsArray and not (FieldList[FieldName.strip(".")][0].startswith('{GUID') and FieldList[FieldName.strip(".")][0].endswith('}')):
1652                             try:
1653                                 Value = ValueExpressionEx(FieldList[FieldName.strip(".")][0], TAB_VOID, self._GuidDict)(True)
1654                             except BadExpression:
1655                                 EdkLogger.error('Build', FORMAT_INVALID, "Invalid value format for %s. From %s Line %d " %
1656                                                 (".".join((Pcd.TokenSpaceGuidCName, Pcd.TokenCName, FieldName.strip('.'))), FieldList[FieldName.strip(".")][1], FieldList[FieldName.strip(".")][2]))
1657                             Value, ValueSize = ParseFieldValue(Value)
1658                             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]);
1659                         else:
1660                             NewFieldName = ''
1661                             FieldName_ori = FieldName.strip('.')
1662                             while '[' in  FieldName:
1663                                 NewFieldName = NewFieldName + FieldName.split('[', 1)[0] + '[0]'
1664                                 ArrayIndex = int(FieldName.split('[', 1)[1].split(']', 1)[0])
1665                                 FieldName = FieldName.split(']', 1)[1]
1666                             FieldName = NewFieldName + FieldName
1667                             while '[' in FieldName:
1668                                 FieldName = FieldName.rsplit('[', 1)[0]
1669                                 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])
1670         if Pcd.PcdFieldValueFromFdf:
1671             CApp = CApp + "// From fdf \n"
1672         for FieldName in Pcd.PcdFieldValueFromFdf:
1673             FieldName = "." + FieldName
1674             IsArray = IsFieldValueAnArray(Pcd.PcdFieldValueFromFdf[FieldName.strip(".")][0])
1675             if IsArray and not (Pcd.PcdFieldValueFromFdf[FieldName.strip(".")][0].startswith('{GUID') and Pcd.PcdFieldValueFromFdf[FieldName.strip(".")][0].endswith('}')):
1676                 try:
1677                     Value = ValueExpressionEx(Pcd.PcdFieldValueFromFdf[FieldName.strip(".")][0], TAB_VOID, self._GuidDict)(True)
1678                 except BadExpression:
1679                     EdkLogger.error('Build', FORMAT_INVALID, "Invalid value format for %s. From %s Line %d " %
1680                                     (".".join((Pcd.TokenSpaceGuidCName, Pcd.TokenCName, FieldName.strip('.'))), Pcd.PcdFieldValueFromFdf[FieldName.strip(".")][1], Pcd.PcdFieldValueFromFdf[FieldName.strip(".")][2]))
1681                 Value, ValueSize = ParseFieldValue(Value)
1682                 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]);
1683             else:
1684                 NewFieldName = ''
1685                 FieldName_ori = FieldName.strip('.')
1686                 while '[' in  FieldName:
1687                     NewFieldName = NewFieldName + FieldName.split('[', 1)[0] + '[0]'
1688                     ArrayIndex = int(FieldName.split('[', 1)[1].split(']', 1)[0])
1689                     FieldName = FieldName.split(']', 1)[1]
1690                 FieldName = NewFieldName + FieldName
1691                 while '[' in FieldName:
1692                     FieldName = FieldName.rsplit('[', 1)[0]
1693                     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])
1694         if Pcd.PcdFieldValueFromComm:
1695             CApp = CApp + "// From Command Line \n"
1696         for FieldName in Pcd.PcdFieldValueFromComm:
1697             FieldName = "." + FieldName
1698             IsArray = IsFieldValueAnArray(Pcd.PcdFieldValueFromComm[FieldName.strip(".")][0])
1699             if IsArray and not (Pcd.PcdFieldValueFromComm[FieldName.strip(".")][0].startswith('{GUID') and Pcd.PcdFieldValueFromComm[FieldName.strip(".")][0].endswith('}')):
1700                 try:
1701                     Value = ValueExpressionEx(Pcd.PcdFieldValueFromComm[FieldName.strip(".")][0], TAB_VOID, self._GuidDict)(True)
1702                 except BadExpression:
1703                     EdkLogger.error('Build', FORMAT_INVALID, "Invalid value format for %s. From %s Line %d " %
1704                                     (".".join((Pcd.TokenSpaceGuidCName, Pcd.TokenCName, FieldName.strip('.'))), Pcd.PcdFieldValueFromComm[FieldName.strip(".")][1], Pcd.PcdFieldValueFromComm[FieldName.strip(".")][2]))
1705                 Value, ValueSize = ParseFieldValue(Value)
1706                 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]);
1707             else:
1708                 NewFieldName = ''
1709                 FieldName_ori = FieldName.strip('.')
1710                 while '[' in  FieldName:
1711                     NewFieldName = NewFieldName + FieldName.split('[', 1)[0] + '[0]'
1712                     ArrayIndex = int(FieldName.split('[', 1)[1].split(']', 1)[0])
1713                     FieldName = FieldName.split(']', 1)[1]
1714                 FieldName = NewFieldName + FieldName
1715                 while '[' in FieldName:
1716                     FieldName = FieldName.rsplit('[', 1)[0]
1717                     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])
1718         CApp = CApp + "  *Size = (%d > *Size ? %d : *Size); // The Pcd maxsize is %d \n" % (Pcd.GetPcdMaxSize(), Pcd.GetPcdMaxSize(), Pcd.GetPcdMaxSize())
1719         CApp = CApp + "}\n"
1720         return CApp
1721
1722     @staticmethod
1723     def GenerateSizeStatments(Pcd):
1724         CApp = '  Size = sizeof(%s);\n' % (Pcd.DatumType)
1725         CApp = CApp + '  Cal_%s_%s_Size(&Size);\n' % (Pcd.TokenSpaceGuidCName, Pcd.TokenCName)
1726         return CApp
1727
1728     def GenerateDefaultValueAssignFunction(self, Pcd):
1729         CApp = "// Default value in Dec \n"
1730         CApp = CApp + "void Assign_%s_%s_Default_Value(%s *Pcd){\n" % (Pcd.TokenSpaceGuidCName, Pcd.TokenCName, Pcd.DatumType)
1731         CApp = CApp + '  UINT32  FieldSize;\n'
1732         CApp = CApp + '  CHAR8   *Value;\n'
1733         DefaultValueFromDec = Pcd.DefaultValueFromDec
1734         IsArray = IsFieldValueAnArray(Pcd.DefaultValueFromDec)
1735         if IsArray:
1736             try:
1737                 DefaultValueFromDec = ValueExpressionEx(Pcd.DefaultValueFromDec, TAB_VOID)(True)
1738             except BadExpression:
1739                 EdkLogger.error("Build", FORMAT_INVALID, "Invalid value format for %s.%s, from DEC: %s" %
1740                                 (Pcd.TokenSpaceGuidCName, Pcd.TokenCName, DefaultValueFromDec))
1741         DefaultValueFromDec = StringToArray(DefaultValueFromDec)
1742         Value, ValueSize = ParseFieldValue (DefaultValueFromDec)
1743         if isinstance(Value, str):
1744             CApp = CApp + '  Pcd = %s; // From DEC Default Value %s\n' % (Value, Pcd.DefaultValueFromDec)
1745         elif IsArray:
1746         #
1747         # Use memcpy() to copy value into field
1748         #
1749             CApp = CApp + '  Value     = %s; // From DEC Default Value %s\n' % (DscBuildData.IntToCString(Value, ValueSize), Pcd.DefaultValueFromDec)
1750             CApp = CApp + '  memcpy (Pcd, Value, %d);\n' % (ValueSize)
1751         for FieldList in [Pcd.DefaultValues]:
1752             if not FieldList:
1753                 continue
1754             for FieldName in FieldList:
1755                 IsArray = IsFieldValueAnArray(FieldList[FieldName][0])
1756                 if IsArray:
1757                     try:
1758                         FieldList[FieldName][0] = ValueExpressionEx(FieldList[FieldName][0], TAB_VOID, self._GuidDict)(True)
1759                     except BadExpression:
1760                         EdkLogger.error('Build', FORMAT_INVALID, "Invalid value format for %s. From %s Line %d " %
1761                                         (".".join((Pcd.TokenSpaceGuidCName, Pcd.TokenCName, FieldName)), FieldList[FieldName][1], FieldList[FieldName][2]))
1762
1763                 try:
1764                     Value, ValueSize = ParseFieldValue (FieldList[FieldName][0])
1765                 except Exception:
1766                     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]))
1767                 if isinstance(Value, str):
1768                     CApp = CApp + '  Pcd->%s = %s; // From %s Line %d Value %s\n' % (FieldName, Value, FieldList[FieldName][1], FieldList[FieldName][2], FieldList[FieldName][0])
1769                 elif IsArray:
1770                     #
1771                     # Use memcpy() to copy value into field
1772                     #
1773                     CApp = CApp + '  FieldSize = __FIELD_SIZE(%s, %s);\n' % (Pcd.DatumType, FieldName)
1774                     CApp = CApp + '  Value     = %s; // From %s Line %d Value %s\n' % (DscBuildData.IntToCString(Value, ValueSize), FieldList[FieldName][1], FieldList[FieldName][2], FieldList[FieldName][0])
1775                     CApp = CApp + '  memcpy (&Pcd->%s, Value, (FieldSize > 0 && FieldSize < %d) ? FieldSize : %d);\n' % (FieldName, ValueSize, ValueSize)
1776                 else:
1777                     if ValueSize > 4:
1778                         CApp = CApp + '  Pcd->%s = %dULL; // From %s Line %d Value %s\n' % (FieldName, Value, FieldList[FieldName][1], FieldList[FieldName][2], FieldList[FieldName][0])
1779                     else:
1780                         CApp = CApp + '  Pcd->%s = %d; // From %s Line %d Value %s\n' % (FieldName, Value, FieldList[FieldName][1], FieldList[FieldName][2], FieldList[FieldName][0])
1781         CApp = CApp + "}\n"
1782         return CApp
1783
1784     @staticmethod
1785     def GenerateDefaultValueAssignStatement(Pcd):
1786         CApp = '  Assign_%s_%s_Default_Value(Pcd);\n' % (Pcd.TokenSpaceGuidCName, Pcd.TokenCName)
1787         return CApp
1788
1789     def GenerateInitValueFunction(self, Pcd, SkuName, DefaultStoreName):
1790         CApp = "// Value in Dsc for Sku: %s, DefaultStore %s\n" % (SkuName, DefaultStoreName)
1791         CApp = CApp + "void Assign_%s_%s_%s_%s_Value(%s *Pcd){\n" % (Pcd.TokenSpaceGuidCName, Pcd.TokenCName, SkuName, DefaultStoreName, Pcd.DatumType)
1792         CApp = CApp + '  UINT32  FieldSize;\n'
1793         CApp = CApp + '  CHAR8   *Value;\n'
1794
1795         CApp = CApp + "// SkuName: %s,  DefaultStoreName: %s \n" % (TAB_DEFAULT, TAB_DEFAULT_STORES_DEFAULT)
1796         inherit_OverrideValues = Pcd.SkuOverrideValues[SkuName]
1797         if (SkuName, DefaultStoreName) == (TAB_DEFAULT, TAB_DEFAULT_STORES_DEFAULT):
1798             pcddefaultvalue = Pcd.DefaultFromDSC.get(TAB_DEFAULT, {}).get(TAB_DEFAULT_STORES_DEFAULT, Pcd.DefaultValue) if Pcd.DefaultFromDSC else Pcd.DefaultValue
1799         else:
1800             if not Pcd.DscRawValue:
1801                 # handle the case that structure pcd is not appear in DSC
1802                 self.CopyDscRawValue(Pcd)
1803             pcddefaultvalue = Pcd.DscRawValue.get(SkuName, {}).get(DefaultStoreName)
1804         for FieldList in [pcddefaultvalue, inherit_OverrideValues.get(DefaultStoreName)]:
1805             if not FieldList:
1806                 continue
1807             if pcddefaultvalue and FieldList == pcddefaultvalue:
1808                 IsArray = IsFieldValueAnArray(FieldList)
1809                 if IsArray:
1810                     try:
1811                         FieldList = ValueExpressionEx(FieldList, TAB_VOID)(True)
1812                     except BadExpression:
1813                         EdkLogger.error("Build", FORMAT_INVALID, "Invalid value format for %s.%s, from DSC: %s" %
1814                                         (Pcd.TokenSpaceGuidCName, Pcd.TokenCName, FieldList))
1815                 Value, ValueSize = ParseFieldValue (FieldList)
1816
1817                 if (SkuName, DefaultStoreName) == (TAB_DEFAULT, TAB_DEFAULT_STORES_DEFAULT):
1818                     if isinstance(Value, str):
1819                         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)
1820                     elif IsArray:
1821                     #
1822                     # Use memcpy() to copy value into field
1823                     #
1824                         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)
1825                         CApp = CApp + '  memcpy (Pcd, Value, %d);\n' % (ValueSize)
1826                 else:
1827                     if isinstance(Value, str):
1828                         CApp = CApp + '  Pcd = %s; // From DSC Default Value %s\n' % (Value, Pcd.DscRawValue.get(SkuName, {}).get(DefaultStoreName))
1829                     elif IsArray:
1830                     #
1831                     # Use memcpy() to copy value into field
1832                     #
1833                         CApp = CApp + '  Value     = %s; // From DSC Default Value %s\n' % (DscBuildData.IntToCString(Value, ValueSize), Pcd.DscRawValue.get(SkuName, {}).get(DefaultStoreName))
1834                         CApp = CApp + '  memcpy (Pcd, Value, %d);\n' % (ValueSize)
1835                 continue
1836             if (SkuName, DefaultStoreName) == (TAB_DEFAULT, TAB_DEFAULT_STORES_DEFAULT) or (( (SkuName, '') not in Pcd.ValueChain) and ( (SkuName, DefaultStoreName) not in Pcd.ValueChain )):
1837                 for FieldName in FieldList:
1838                     IsArray = IsFieldValueAnArray(FieldList[FieldName][0])
1839                     if IsArray:
1840                         try:
1841                             FieldList[FieldName][0] = ValueExpressionEx(FieldList[FieldName][0], TAB_VOID, self._GuidDict)(True)
1842                         except BadExpression:
1843                             EdkLogger.error('Build', FORMAT_INVALID, "Invalid value format for %s. From %s Line %d " %
1844                                             (".".join((Pcd.TokenSpaceGuidCName, Pcd.TokenCName, FieldName)), FieldList[FieldName][1], FieldList[FieldName][2]))
1845                     try:
1846                         Value, ValueSize = ParseFieldValue (FieldList[FieldName][0])
1847                     except Exception:
1848                         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]))
1849                     if isinstance(Value, str):
1850                         CApp = CApp + '  Pcd->%s = %s; // From %s Line %d Value %s\n' % (FieldName, Value, FieldList[FieldName][1], FieldList[FieldName][2], FieldList[FieldName][0])
1851                     elif IsArray:
1852                     #
1853                     # Use memcpy() to copy value into field
1854                     #
1855                         CApp = CApp + '  FieldSize = __FIELD_SIZE(%s, %s);\n' % (Pcd.DatumType, FieldName)
1856                         CApp = CApp + '  Value     = %s; // From %s Line %d Value %s\n' % (DscBuildData.IntToCString(Value, ValueSize), FieldList[FieldName][1], FieldList[FieldName][2], FieldList[FieldName][0])
1857                         CApp = CApp + '  memcpy (&Pcd->%s, Value, (FieldSize > 0 && FieldSize < %d) ? FieldSize : %d);\n' % (FieldName, ValueSize, ValueSize)
1858                     else:
1859                         if ValueSize > 4:
1860                             CApp = CApp + '  Pcd->%s = %dULL; // From %s Line %d Value %s\n' % (FieldName, Value, FieldList[FieldName][1], FieldList[FieldName][2], FieldList[FieldName][0])
1861                         else:
1862                             CApp = CApp + '  Pcd->%s = %d; // From %s Line %d Value %s\n' % (FieldName, Value, FieldList[FieldName][1], FieldList[FieldName][2], FieldList[FieldName][0])
1863         CApp = CApp + "}\n"
1864         return CApp
1865
1866     @staticmethod
1867     def GenerateInitValueStatement(Pcd, SkuName, DefaultStoreName):
1868         CApp = '  Assign_%s_%s_%s_%s_Value(Pcd);\n' % (Pcd.TokenSpaceGuidCName, Pcd.TokenCName, SkuName, DefaultStoreName)
1869         return CApp
1870
1871     def GenerateCommandLineValue(self, Pcd):
1872         CApp = "// Value in CommandLine\n"
1873         CApp = CApp + "void Assign_%s_%s_CommandLine_Value(%s *Pcd){\n" % (Pcd.TokenSpaceGuidCName, Pcd.TokenCName, Pcd.DatumType)
1874         CApp = CApp + '  UINT32  FieldSize;\n'
1875         CApp = CApp + '  CHAR8   *Value;\n'
1876
1877         pcddefaultvalue = Pcd.PcdValueFromComm
1878         for FieldList in [pcddefaultvalue, Pcd.PcdFieldValueFromComm]:
1879             if not FieldList:
1880                 continue
1881             if pcddefaultvalue and FieldList == pcddefaultvalue:
1882                 IsArray = IsFieldValueAnArray(FieldList)
1883                 if IsArray:
1884                     try:
1885                         FieldList = ValueExpressionEx(FieldList, TAB_VOID)(True)
1886                     except BadExpression:
1887                         EdkLogger.error("Build", FORMAT_INVALID, "Invalid value format for %s.%s, from Command: %s" %
1888                                         (Pcd.TokenSpaceGuidCName, Pcd.TokenCName, FieldList))
1889                 Value, ValueSize = ParseFieldValue (FieldList)
1890
1891                 if isinstance(Value, str):
1892                     CApp = CApp + '  Pcd = %s; // From Command Line \n' % (Value)
1893                 elif IsArray:
1894                 #
1895                 # Use memcpy() to copy value into field
1896                 #
1897                     CApp = CApp + '  Value     = %s; // From Command Line.\n' % (DscBuildData.IntToCString(Value, ValueSize))
1898                     CApp = CApp + '  memcpy (Pcd, Value, %d);\n' % (ValueSize)
1899                 continue
1900             for FieldName in FieldList:
1901                 IsArray = IsFieldValueAnArray(FieldList[FieldName][0])
1902                 if IsArray:
1903                     try:
1904                         FieldList[FieldName][0] = ValueExpressionEx(FieldList[FieldName][0], TAB_VOID, self._GuidDict)(True)
1905                     except BadExpression:
1906                         EdkLogger.error('Build', FORMAT_INVALID, "Invalid value format for %s. From %s Line %d " %
1907                                         (".".join((Pcd.TokenSpaceGuidCName, Pcd.TokenCName, FieldName)), FieldList[FieldName][1], FieldList[FieldName][2]))
1908                     except:
1909                         print("error")
1910                 try:
1911                     Value, ValueSize = ParseFieldValue (FieldList[FieldName][0])
1912                 except Exception:
1913                     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]))
1914                 if isinstance(Value, str):
1915                     CApp = CApp + '  Pcd->%s = %s; // From %s Line %d Value %s\n' % (FieldName, Value, FieldList[FieldName][1], FieldList[FieldName][2], FieldList[FieldName][0])
1916                 elif IsArray:
1917                 #
1918                 # Use memcpy() to copy value into field
1919                 #
1920                     CApp = CApp + '  FieldSize = __FIELD_SIZE(%s, %s);\n' % (Pcd.DatumType, FieldName)
1921                     CApp = CApp + '  Value     = %s; // From %s Line %d Value %s\n' % (DscBuildData.IntToCString(Value, ValueSize), FieldList[FieldName][1], FieldList[FieldName][2], FieldList[FieldName][0])
1922                     CApp = CApp + '  memcpy (&Pcd->%s, Value, (FieldSize > 0 && FieldSize < %d) ? FieldSize : %d);\n' % (FieldName, ValueSize, ValueSize)
1923                 else:
1924                     if ValueSize > 4:
1925                         CApp = CApp + '  Pcd->%s = %dULL; // From %s Line %d Value %s\n' % (FieldName, Value, FieldList[FieldName][1], FieldList[FieldName][2], FieldList[FieldName][0])
1926                     else:
1927                         CApp = CApp + '  Pcd->%s = %d; // From %s Line %d Value %s\n' % (FieldName, Value, FieldList[FieldName][1], FieldList[FieldName][2], FieldList[FieldName][0])
1928         CApp = CApp + "}\n"
1929         return CApp
1930
1931     @staticmethod
1932     def GenerateCommandLineValueStatement(Pcd):
1933         CApp = '  Assign_%s_%s_CommandLine_Value(Pcd);\n' % (Pcd.TokenSpaceGuidCName, Pcd.TokenCName)
1934         return CApp
1935     def GenerateFdfValue(self,Pcd):
1936         CApp = "// Value in Fdf\n"
1937         CApp = CApp + "void Assign_%s_%s_Fdf_Value(%s *Pcd){\n" % (Pcd.TokenSpaceGuidCName, Pcd.TokenCName,Pcd.DatumType)
1938         CApp = CApp + '  UINT32  FieldSize;\n'
1939         CApp = CApp + '  CHAR8   *Value;\n'
1940
1941         pcddefaultvalue = Pcd.PcdValueFromFdf
1942         for FieldList in [pcddefaultvalue,Pcd.PcdFieldValueFromFdf]:
1943             if not FieldList:
1944                 continue
1945             if pcddefaultvalue and FieldList == pcddefaultvalue:
1946                 IsArray = IsFieldValueAnArray(FieldList)
1947                 if IsArray:
1948                     try:
1949                         FieldList = ValueExpressionEx(FieldList, TAB_VOID)(True)
1950                     except BadExpression:
1951                         EdkLogger.error("Build", FORMAT_INVALID, "Invalid value format for %s.%s, from Fdf: %s" %
1952                                         (Pcd.TokenSpaceGuidCName, Pcd.TokenCName, FieldList))
1953                 Value, ValueSize = ParseFieldValue (FieldList)
1954
1955                 if isinstance(Value, str):
1956                     CApp = CApp + '  Pcd = %s; // From Fdf \n' % (Value)
1957                 elif IsArray:
1958                 #
1959                 # Use memcpy() to copy value into field
1960                 #
1961                     CApp = CApp + '  Value     = %s; // From Fdf .\n' % (DscBuildData.IntToCString(Value, ValueSize))
1962                     CApp = CApp + '  memcpy (Pcd, Value, %d);\n' % (ValueSize)
1963                 continue
1964             for FieldName in FieldList:
1965                 IsArray = IsFieldValueAnArray(FieldList[FieldName][0])
1966                 if IsArray:
1967                     try:
1968                         FieldList[FieldName][0] = ValueExpressionEx(FieldList[FieldName][0], TAB_VOID, self._GuidDict)(True)
1969                     except BadExpression:
1970                         EdkLogger.error('Build', FORMAT_INVALID, "Invalid value format for %s. From %s Line %d " %
1971                                         (".".join((Pcd.TokenSpaceGuidCName, Pcd.TokenCName, FieldName)), FieldList[FieldName][1], FieldList[FieldName][2]))
1972                     except:
1973                         print("error")
1974                 try:
1975                     Value, ValueSize = ParseFieldValue (FieldList[FieldName][0])
1976                 except Exception:
1977                     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]))
1978                 if isinstance(Value, str):
1979                     CApp = CApp + '  Pcd->%s = %s; // From %s Line %d Value %s\n' % (FieldName, Value, FieldList[FieldName][1], FieldList[FieldName][2], FieldList[FieldName][0])
1980                 elif IsArray:
1981                 #
1982                 # Use memcpy() to copy value into field
1983                 #
1984                     CApp = CApp + '  FieldSize = __FIELD_SIZE(%s, %s);\n' % (Pcd.DatumType, FieldName)
1985                     CApp = CApp + '  Value     = %s; // From %s Line %d Value %s\n' % (DscBuildData.IntToCString(Value, ValueSize), FieldList[FieldName][1], FieldList[FieldName][2], FieldList[FieldName][0])
1986                     CApp = CApp + '  memcpy (&Pcd->%s, Value, (FieldSize > 0 && FieldSize < %d) ? FieldSize : %d);\n' % (FieldName, ValueSize, ValueSize)
1987                 else:
1988                     if ValueSize > 4:
1989                         CApp = CApp + '  Pcd->%s = %dULL; // From %s Line %d Value %s\n' % (FieldName, Value, FieldList[FieldName][1], FieldList[FieldName][2], FieldList[FieldName][0])
1990                     else:
1991                         CApp = CApp + '  Pcd->%s = %d; // From %s Line %s Value %s\n' % (FieldName, Value, FieldList[FieldName][1], FieldList[FieldName][2], FieldList[FieldName][0])
1992         CApp = CApp + "}\n"
1993         return CApp
1994
1995     @staticmethod
1996     def GenerateFdfValueStatement(Pcd):
1997         CApp = '  Assign_%s_%s_Fdf_Value(Pcd);\n' % (Pcd.TokenSpaceGuidCName, Pcd.TokenCName)
1998         return CApp
1999
2000     def GenerateInitializeFunc(self, SkuName, DefaultStore, Pcd, InitByteValue, CApp):
2001         OverrideValues = {DefaultStore:""}
2002         if Pcd.SkuOverrideValues:
2003             OverrideValues = Pcd.SkuOverrideValues[SkuName]
2004         for DefaultStoreName in OverrideValues:
2005             CApp = CApp + 'void\n'
2006             CApp = CApp + 'Initialize_%s_%s_%s_%s(\n' % (SkuName, DefaultStoreName, Pcd.TokenSpaceGuidCName, Pcd.TokenCName)
2007             CApp = CApp + '  void\n'
2008             CApp = CApp + '  )\n'
2009             CApp = CApp + '{\n'
2010             CApp = CApp + '  UINT32  Size;\n'
2011             CApp = CApp + '  UINT32  FieldSize;\n'
2012             CApp = CApp + '  CHAR8   *Value;\n'
2013             CApp = CApp + '  UINT32  OriginalSize;\n'
2014             CApp = CApp + '  VOID    *OriginalPcd;\n'
2015             CApp = CApp + '  %s      *Pcd;  // From %s Line %d \n' % (Pcd.DatumType, Pcd.PkgPath, Pcd.PcdDefineLineNo)
2016             CApp = CApp + '\n'
2017
2018             if SkuName in Pcd.SkuInfoList:
2019                 DefaultValue = Pcd.SkuInfoList[SkuName].DefaultStoreDict.get(DefaultStoreName, Pcd.SkuInfoList[SkuName].HiiDefaultValue if Pcd.SkuInfoList[SkuName].HiiDefaultValue  else Pcd.SkuInfoList[SkuName].DefaultValue)
2020             else:
2021                 DefaultValue = Pcd.DefaultValue
2022             PcdDefaultValue = StringToArray(DefaultValue.strip())
2023
2024             InitByteValue += '%s.%s.%s.%s|%s|%s\n' % (SkuName, DefaultStoreName, Pcd.TokenSpaceGuidCName, Pcd.TokenCName, Pcd.DatumType, PcdDefaultValue)
2025
2026             #
2027             # Get current PCD value and size
2028             #
2029             CApp = CApp + '  OriginalPcd = PcdGetPtr (%s, %s, %s, %s, &OriginalSize);\n' % (SkuName, DefaultStoreName, Pcd.TokenSpaceGuidCName, Pcd.TokenCName)
2030
2031             #
2032             # Determine the size of the PCD.  For simple structures, sizeof(TYPE) provides
2033             # the correct value.  For structures with a flexible array member, the flexible
2034             # array member is detected, and the size is based on the highest index used with
2035             # the flexible array member.  The flexible array member must be the last field
2036             # in a structure.  The size formula for this case is:
2037             # OFFSET_OF(FlexbleArrayField) + sizeof(FlexibleArray[0]) * (HighestIndex + 1)
2038             #
2039             CApp = CApp + DscBuildData.GenerateSizeStatments(Pcd)
2040
2041             #
2042             # Allocate and zero buffer for the PCD
2043             # Must handle cases where current value is smaller, larger, or same size
2044             # Always keep that larger one as the current size
2045             #
2046             CApp = CApp + '  Size = (OriginalSize > Size ? OriginalSize : Size);\n'
2047             CApp = CApp + '  Pcd     = (%s *)malloc (Size);\n' % (Pcd.DatumType)
2048             CApp = CApp + '  memset (Pcd, 0, Size);\n'
2049
2050             #
2051             # Copy current PCD value into allocated buffer.
2052             #
2053             CApp = CApp + '  memcpy (Pcd, OriginalPcd, OriginalSize);\n'
2054
2055             #
2056             # Assign field values in PCD
2057             #
2058             CApp = CApp + DscBuildData.GenerateDefaultValueAssignStatement(Pcd)
2059             if Pcd.Type not in [self._PCD_TYPE_STRING_[MODEL_PCD_FIXED_AT_BUILD],
2060                         self._PCD_TYPE_STRING_[MODEL_PCD_PATCHABLE_IN_MODULE]]:
2061                 for skuname in self.SkuIdMgr.GetSkuChain(SkuName):
2062                     storeset = [DefaultStoreName] if DefaultStoreName == TAB_DEFAULT_STORES_DEFAULT else [TAB_DEFAULT_STORES_DEFAULT, DefaultStoreName]
2063                     for defaultstorenameitem in storeset:
2064                         CApp = CApp + "// SkuName: %s,  DefaultStoreName: %s \n" % (skuname, defaultstorenameitem)
2065                         CApp = CApp + DscBuildData.GenerateInitValueStatement(Pcd, skuname, defaultstorenameitem)
2066                     if skuname == SkuName:
2067                         break
2068             else:
2069                 CApp = CApp + "// SkuName: %s,  DefaultStoreName: STANDARD \n" % self.SkuIdMgr.SystemSkuId
2070                 CApp = CApp + DscBuildData.GenerateInitValueStatement(Pcd, self.SkuIdMgr.SystemSkuId, TAB_DEFAULT_STORES_DEFAULT)
2071             CApp = CApp + DscBuildData.GenerateFdfValueStatement(Pcd)
2072             CApp = CApp + DscBuildData.GenerateCommandLineValueStatement(Pcd)
2073             #
2074             # Set new PCD value and size
2075             #
2076             CApp = CApp + '  PcdSetPtr (%s, %s, %s, %s, Size, (UINT8 *)Pcd);\n' % (SkuName, DefaultStoreName, Pcd.TokenSpaceGuidCName, Pcd.TokenCName)
2077
2078             #
2079             # Free PCD
2080             #
2081             CApp = CApp + '  free (Pcd);\n'
2082             CApp = CApp + '}\n'
2083             CApp = CApp + '\n'
2084         return InitByteValue, CApp
2085
2086     def GenerateByteArrayValue (self, StructuredPcds):
2087         #
2088         # Generate/Compile/Run C application to determine if there are any flexible array members
2089         #
2090         if not StructuredPcds:
2091             return
2092
2093         InitByteValue = ""
2094         CApp = PcdMainCHeader
2095
2096         IncludeFiles = set()
2097         for PcdName in StructuredPcds:
2098             Pcd = StructuredPcds[PcdName]
2099             for IncludeFile in Pcd.StructuredPcdIncludeFile:
2100                 if IncludeFile not in IncludeFiles:
2101                     IncludeFiles.add(IncludeFile)
2102                     CApp = CApp + '#include <%s>\n' % (IncludeFile)
2103         CApp = CApp + '\n'
2104         for PcdName in StructuredPcds:
2105             Pcd = StructuredPcds[PcdName]
2106             CApp = CApp + self.GenerateSizeFunction(Pcd)
2107             CApp = CApp + self.GenerateDefaultValueAssignFunction(Pcd)
2108             CApp = CApp + self.GenerateFdfValue(Pcd)
2109             CApp = CApp + self.GenerateCommandLineValue(Pcd)
2110             if not Pcd.SkuOverrideValues or Pcd.Type in [self._PCD_TYPE_STRING_[MODEL_PCD_FIXED_AT_BUILD],
2111                         self._PCD_TYPE_STRING_[MODEL_PCD_PATCHABLE_IN_MODULE]]:
2112                 CApp = CApp + self.GenerateInitValueFunction(Pcd, self.SkuIdMgr.SystemSkuId, TAB_DEFAULT_STORES_DEFAULT)
2113             else:
2114                 for SkuName in self.SkuIdMgr.SkuOverrideOrder():
2115                     if SkuName not in Pcd.SkuOverrideValues:
2116                         continue
2117                     for DefaultStoreName in Pcd.SkuOverrideValues[SkuName]:
2118                         CApp = CApp + self.GenerateInitValueFunction(Pcd, SkuName, DefaultStoreName)
2119             if not Pcd.SkuOverrideValues or Pcd.Type in [self._PCD_TYPE_STRING_[MODEL_PCD_FIXED_AT_BUILD],
2120                         self._PCD_TYPE_STRING_[MODEL_PCD_PATCHABLE_IN_MODULE]]:
2121                 InitByteValue, CApp = self.GenerateInitializeFunc(self.SkuIdMgr.SystemSkuId, TAB_DEFAULT_STORES_DEFAULT, Pcd, InitByteValue, CApp)
2122             else:
2123                 for SkuName in self.SkuIdMgr.SkuOverrideOrder():
2124                     if SkuName not in Pcd.SkuOverrideValues:
2125                         continue
2126                     for DefaultStoreName in Pcd.DefaultStoreName:
2127                         Pcd = StructuredPcds[PcdName]
2128                         InitByteValue, CApp = self.GenerateInitializeFunc(SkuName, DefaultStoreName, Pcd, InitByteValue, CApp)
2129
2130         CApp = CApp + 'VOID\n'
2131         CApp = CApp + 'PcdEntryPoint(\n'
2132         CApp = CApp + '  VOID\n'
2133         CApp = CApp + '  )\n'
2134         CApp = CApp + '{\n'
2135         for Pcd in StructuredPcds.values():
2136             if not Pcd.SkuOverrideValues or Pcd.Type in [self._PCD_TYPE_STRING_[MODEL_PCD_FIXED_AT_BUILD], self._PCD_TYPE_STRING_[MODEL_PCD_PATCHABLE_IN_MODULE]]:
2137                 CApp = CApp + '  Initialize_%s_%s_%s_%s();\n' % (self.SkuIdMgr.SystemSkuId, TAB_DEFAULT_STORES_DEFAULT, Pcd.TokenSpaceGuidCName, Pcd.TokenCName)
2138             else:
2139                 for SkuName in self.SkuIdMgr.SkuOverrideOrder():
2140                     if SkuName not in Pcd.SkuOverrideValues:
2141                         continue
2142                     for DefaultStoreName in Pcd.SkuOverrideValues[SkuName]:
2143                         CApp = CApp + '  Initialize_%s_%s_%s_%s();\n' % (SkuName, DefaultStoreName, Pcd.TokenSpaceGuidCName, Pcd.TokenCName)
2144         CApp = CApp + '}\n'
2145
2146         CApp = CApp + PcdMainCEntry + '\n'
2147
2148         if not os.path.exists(self.OutputPath):
2149             os.makedirs(self.OutputPath)
2150         CAppBaseFileName = os.path.join(self.OutputPath, PcdValueInitName)
2151         SaveFileOnChange(CAppBaseFileName + '.c', CApp, False)
2152
2153         MakeApp = PcdMakefileHeader
2154         if sys.platform == "win32":
2155             MakeApp = MakeApp + 'APPNAME = %s\n' % (PcdValueInitName) + 'OBJECTS = %s\%s.obj\n' % (self.OutputPath, PcdValueInitName) + 'INC = '
2156         else:
2157             MakeApp = MakeApp + PcdGccMakefile
2158             MakeApp = MakeApp + 'APPNAME = %s\n' % (PcdValueInitName) + 'OBJECTS = %s/%s.o\n' % (self.OutputPath, PcdValueInitName) + \
2159                       'include $(MAKEROOT)/Makefiles/app.makefile\n' + 'INCLUDE +='
2160
2161         IncSearchList = []
2162         PlatformInc = {}
2163         for Cache in self._Bdb._CACHE_.values():
2164             if Cache.MetaFile.Ext.lower() != '.dec':
2165                 continue
2166             if Cache.Includes:
2167                 if str(Cache.MetaFile.Path) not in PlatformInc:
2168                     PlatformInc[str(Cache.MetaFile.Path)] = []
2169                     PlatformInc[str(Cache.MetaFile.Path)].append (os.path.dirname(Cache.MetaFile.Path))
2170                     PlatformInc[str(Cache.MetaFile.Path)].extend (Cache.CommonIncludes)
2171
2172         PcdDependDEC = []
2173         for Pcd in StructuredPcds.values():
2174             for PackageDec in Pcd.PackageDecs:
2175                 Package = os.path.normpath(mws.join(GlobalData.gWorkspace, PackageDec))
2176                 if not os.path.exists(Package):
2177                     EdkLogger.error('Build', RESOURCE_NOT_AVAILABLE, "The dependent Package %s of PCD %s.%s is not exist." % (PackageDec, Pcd.TokenSpaceGuidCName, Pcd.TokenCName))
2178                 if Package not in PcdDependDEC:
2179                     PcdDependDEC.append(Package)
2180
2181         if PlatformInc and PcdDependDEC:
2182             for pkg in PcdDependDEC:
2183                 if pkg in PlatformInc:
2184                     for inc in PlatformInc[pkg]:
2185                         MakeApp += '-I'  + str(inc) + ' '
2186                         IncSearchList.append(inc)
2187         MakeApp = MakeApp + '\n'
2188
2189         CC_FLAGS = LinuxCFLAGS
2190         if sys.platform == "win32":
2191             CC_FLAGS = WindowsCFLAGS
2192         BuildOptions = {}
2193         for Options in self.BuildOptions:
2194             if Options[2] != EDKII_NAME:
2195                 continue
2196             Family = Options[0]
2197             if Family and Family != self.ToolChainFamily:
2198                 continue
2199             Target, Tag, Arch, Tool, Attr = Options[1].split("_")
2200             if Tool != 'CC':
2201                 continue
2202
2203             if Target == "*" or Target == self._Target:
2204                 if Tag == "*" or Tag == self._Toolchain:
2205                     if Arch == "*" or Arch == self.Arch:
2206                         if Tool not in BuildOptions:
2207                             BuildOptions[Tool] = {}
2208                         if Attr != "FLAGS" or Attr not in BuildOptions[Tool] or self.BuildOptions[Options].startswith('='):
2209                             BuildOptions[Tool][Attr] = self.BuildOptions[Options]
2210                         else:
2211                             # append options for the same tool except PATH
2212                             if Attr != 'PATH':
2213                                 BuildOptions[Tool][Attr] += " " + self.BuildOptions[Options]
2214                             else:
2215                                 BuildOptions[Tool][Attr] = self.BuildOptions[Options]
2216         if BuildOptions:
2217             for Tool in BuildOptions:
2218                 for Attr in BuildOptions[Tool]:
2219                     if Attr == "FLAGS":
2220                         Value = BuildOptions[Tool][Attr]
2221                         ValueList = Value.split()
2222                         if ValueList:
2223                             for Id, Item in enumerate(ValueList):
2224                                 if Item in ['-D', '/D', '-U', '/U']:
2225                                     CC_FLAGS += ' ' + Item
2226                                     if Id + 1 < len(ValueList):
2227                                         CC_FLAGS += ' ' + ValueList[Id + 1]
2228                                 elif Item.startswith(('-D', '/D', '-U', '/U')):
2229                                     CC_FLAGS += ' ' + Item
2230         MakeApp += CC_FLAGS
2231
2232         if sys.platform == "win32":
2233             MakeApp = MakeApp + PcdMakefileEnd
2234         MakeApp = MakeApp + '\n'
2235         IncludeFileFullPaths = []
2236         for includefile in IncludeFiles:
2237             for includepath in IncSearchList:
2238                 includefullpath = os.path.join(str(includepath), includefile)
2239                 if os.path.exists(includefullpath):
2240                     IncludeFileFullPaths.append(os.path.normpath(includefullpath))
2241                     break
2242         SearchPathList = []
2243         SearchPathList.append(os.path.normpath(mws.join(GlobalData.gWorkspace, "BaseTools/Source/C/Include")))
2244         SearchPathList.append(os.path.normpath(mws.join(GlobalData.gWorkspace, "BaseTools/Source/C/Common")))
2245         SearchPathList.extend(str(item) for item in IncSearchList)
2246         IncFileList = GetDependencyList(IncludeFileFullPaths, SearchPathList)
2247         for include_file in IncFileList:
2248             MakeApp += "$(OBJECTS) : %s\n" % include_file
2249         MakeFileName = os.path.join(self.OutputPath, 'Makefile')
2250         MakeApp += "$(OBJECTS) : %s\n" % MakeFileName
2251         SaveFileOnChange(MakeFileName, MakeApp, False)
2252
2253         InputValueFile = os.path.join(self.OutputPath, 'Input.txt')
2254         OutputValueFile = os.path.join(self.OutputPath, 'Output.txt')
2255         SaveFileOnChange(InputValueFile, InitByteValue, False)
2256
2257         PcdValueInitExe = PcdValueInitName
2258         if not sys.platform == "win32":
2259             PcdValueInitExe = os.path.join(os.getenv("EDK_TOOLS_PATH"), 'Source', 'C', 'bin', PcdValueInitName)
2260         else:
2261             PcdValueInitExe = os.path.join(os.getenv("EDK_TOOLS_PATH"), 'Bin', 'Win32', PcdValueInitName) +".exe"
2262
2263         Messages = ''
2264         if sys.platform == "win32":
2265             MakeCommand = 'nmake -f %s' % (MakeFileName)
2266             returncode, StdOut, StdErr = DscBuildData.ExecuteCommand (MakeCommand)
2267             Messages = StdOut
2268         else:
2269             MakeCommand = 'make -f %s' % (MakeFileName)
2270             returncode, StdOut, StdErr = DscBuildData.ExecuteCommand (MakeCommand)
2271             Messages = StdErr
2272         Messages = Messages.split('\n')
2273         MessageGroup = []
2274         if returncode != 0:
2275             CAppBaseFileName = os.path.join(self.OutputPath, PcdValueInitName)
2276             File = open (CAppBaseFileName + '.c', 'r')
2277             FileData = File.readlines()
2278             File.close()
2279             for Message in Messages:
2280                 if " error" in Message or "warning" in Message:
2281                     FileInfo = Message.strip().split('(')
2282                     if len (FileInfo) > 1:
2283                         FileName = FileInfo [0]
2284                         FileLine = FileInfo [1].split (')')[0]
2285                     else:
2286                         FileInfo = Message.strip().split(':')
2287                         FileName = FileInfo [0]
2288                         FileLine = FileInfo [1]
2289                     if FileLine.isdigit():
2290                         error_line = FileData[int (FileLine) - 1]
2291                         if r"//" in error_line:
2292                             c_line, dsc_line = error_line.split(r"//")
2293                         else:
2294                             dsc_line = error_line
2295                         message_itmes = Message.split(":")
2296                         Index = 0
2297                         if "PcdValueInit.c" not in Message:
2298                             if not MessageGroup:
2299                                 MessageGroup.append(Message)
2300                             break
2301                         else:
2302                             for item in message_itmes:
2303                                 if "PcdValueInit.c" in item:
2304                                     Index = message_itmes.index(item)
2305                                     message_itmes[Index] = dsc_line.strip()
2306                                     break
2307                             MessageGroup.append(":".join(message_itmes[Index:]).strip())
2308                             continue
2309                     else:
2310                         MessageGroup.append(Message)
2311             if MessageGroup:
2312                 EdkLogger.error("build", PCD_STRUCTURE_PCD_ERROR, "\n".join(MessageGroup) )
2313             else:
2314                 EdkLogger.error('Build', COMMAND_FAILURE, 'Can not execute command: %s' % MakeCommand)
2315
2316         if DscBuildData.NeedUpdateOutput(OutputValueFile, PcdValueInitExe, InputValueFile):
2317             Command = PcdValueInitExe + ' -i %s -o %s' % (InputValueFile, OutputValueFile)
2318             returncode, StdOut, StdErr = DscBuildData.ExecuteCommand (Command)
2319             if returncode != 0:
2320                 EdkLogger.warn('Build', COMMAND_FAILURE, 'Can not collect output from command: %s' % Command)
2321
2322         File = open (OutputValueFile, 'r')
2323         FileBuffer = File.readlines()
2324         File.close()
2325
2326         StructurePcdSet = []
2327         for Pcd in FileBuffer:
2328             PcdValue = Pcd.split ('|')
2329             PcdInfo = PcdValue[0].split ('.')
2330             StructurePcdSet.append((PcdInfo[0], PcdInfo[1], PcdInfo[2], PcdInfo[3], PcdValue[2].strip()))
2331         return StructurePcdSet
2332
2333     @staticmethod
2334     def NeedUpdateOutput(OutputFile, ValueCFile, StructureInput):
2335         if not os.path.exists(OutputFile):
2336             return True
2337         if os.stat(OutputFile).st_mtime <= os.stat(ValueCFile).st_mtime:
2338             return True
2339         if os.stat(OutputFile).st_mtime <= os.stat(StructureInput).st_mtime:
2340             return True
2341         return False
2342
2343     ## Retrieve dynamic PCD settings
2344     #
2345     #   @param  Type    PCD type
2346     #
2347     #   @retval a dict object contains settings of given PCD type
2348     #
2349     def _GetDynamicPcd(self, Type):
2350
2351
2352         Pcds = OrderedDict()
2353         #
2354         # tdict is a special dict kind of type, used for selecting correct
2355         # PCD settings for certain ARCH and SKU
2356         #
2357         PcdDict = tdict(True, 4)
2358         PcdList = []
2359         # Find out all possible PCD candidates for self._Arch
2360         RecordList = self._RawData[Type, self._Arch]
2361         AvailableSkuIdSet = copy.copy(self.SkuIds)
2362
2363
2364         for TokenSpaceGuid, PcdCName, Setting, Arch, SkuName, Dummy3, Dummy4, Dummy5 in RecordList:
2365             SkuName = SkuName.upper()
2366             SkuName = TAB_DEFAULT if SkuName == TAB_COMMON else SkuName
2367             if SkuName not in AvailableSkuIdSet:
2368                 EdkLogger.error('build', PARAMETER_INVALID, 'Sku %s is not defined in [SkuIds] section' % SkuName,
2369                                             File=self.MetaFile, Line=Dummy5)
2370             if "." not in TokenSpaceGuid:
2371                 PcdList.append((PcdCName, TokenSpaceGuid, SkuName, Dummy5))
2372             PcdDict[Arch, SkuName, PcdCName, TokenSpaceGuid] = Setting
2373
2374         # Remove redundant PCD candidates, per the ARCH and SKU
2375         for PcdCName, TokenSpaceGuid, SkuName, Dummy4 in PcdList:
2376
2377             Setting = PcdDict[self._Arch, SkuName, PcdCName, TokenSpaceGuid]
2378             if Setting is None:
2379                 continue
2380
2381             PcdValue, DatumType, MaxDatumSize = self._ValidatePcd(PcdCName, TokenSpaceGuid, Setting, Type, Dummy4)
2382             if MaxDatumSize:
2383                 if int(MaxDatumSize, 0) > 0xFFFF:
2384                     EdkLogger.error('build', FORMAT_INVALID, "The size value must not exceed the maximum value of 0xFFFF (UINT16) for %s." % ".".join((TokenSpaceGuid, PcdCName)),
2385                                     File=self.MetaFile, Line=Dummy4)
2386                 if int(MaxDatumSize, 0) < 0:
2387                     EdkLogger.error('build', FORMAT_INVALID, "The size value can't be set to negative value for %s." % ".".join((TokenSpaceGuid, PcdCName)),
2388                                     File=self.MetaFile, Line=Dummy4)
2389             SkuInfo = SkuInfoClass(SkuName, self.SkuIds[SkuName][0], '', '', '', '', '', PcdValue)
2390             if (PcdCName, TokenSpaceGuid) in Pcds:
2391                 pcdObject = Pcds[PcdCName, TokenSpaceGuid]
2392                 pcdObject.SkuInfoList[SkuName] = SkuInfo
2393                 if MaxDatumSize.strip():
2394                     CurrentMaxSize = int(MaxDatumSize.strip(), 0)
2395                 else:
2396                     CurrentMaxSize = 0
2397                 if pcdObject.MaxDatumSize:
2398                     PcdMaxSize = int(pcdObject.MaxDatumSize, 0)
2399                 else:
2400                     PcdMaxSize = 0
2401                 if CurrentMaxSize > PcdMaxSize:
2402                     pcdObject.MaxDatumSize = str(CurrentMaxSize)
2403             else:
2404                 Pcds[PcdCName, TokenSpaceGuid] = PcdClassObject(
2405                                                     PcdCName,
2406                                                     TokenSpaceGuid,
2407                                                     self._PCD_TYPE_STRING_[Type],
2408                                                     DatumType,
2409                                                     PcdValue,
2410                                                     '',
2411                                                     MaxDatumSize,
2412                                                     {SkuName : SkuInfo},
2413                                                     False,
2414                                                     None,
2415                                                     IsDsc=True)
2416
2417         for pcd in Pcds.values():
2418             pcdDecObject = self._DecPcds[pcd.TokenCName, pcd.TokenSpaceGuidCName]
2419             # Only fix the value while no value provided in DSC file.
2420             for sku in pcd.SkuInfoList.values():
2421                 if not sku.DefaultValue:
2422                     sku.DefaultValue = pcdDecObject.DefaultValue
2423             if TAB_DEFAULT not in pcd.SkuInfoList and TAB_COMMON not in pcd.SkuInfoList:
2424                 valuefromDec = pcdDecObject.DefaultValue
2425                 SkuInfo = SkuInfoClass(TAB_DEFAULT, '0', '', '', '', '', '', valuefromDec)
2426                 pcd.SkuInfoList[TAB_DEFAULT] = SkuInfo
2427             elif TAB_DEFAULT not in pcd.SkuInfoList and TAB_COMMON in pcd.SkuInfoList:
2428                 pcd.SkuInfoList[TAB_DEFAULT] = pcd.SkuInfoList[TAB_COMMON]
2429                 del pcd.SkuInfoList[TAB_COMMON]
2430             elif TAB_DEFAULT in pcd.SkuInfoList and TAB_COMMON in pcd.SkuInfoList:
2431                 del pcd.SkuInfoList[TAB_COMMON]
2432
2433         map(self.FilterSkuSettings, Pcds.values())
2434
2435         return Pcds
2436
2437     def FilterSkuSettings(self, PcdObj):
2438
2439         if self.SkuIdMgr.SkuUsageType == self.SkuIdMgr.SINGLE:
2440             if TAB_DEFAULT in PcdObj.SkuInfoList and self.SkuIdMgr.SystemSkuId not in PcdObj.SkuInfoList:
2441                 PcdObj.SkuInfoList[self.SkuIdMgr.SystemSkuId] = PcdObj.SkuInfoList[TAB_DEFAULT]
2442             PcdObj.SkuInfoList = {TAB_DEFAULT:PcdObj.SkuInfoList[self.SkuIdMgr.SystemSkuId]}
2443             PcdObj.SkuInfoList[TAB_DEFAULT].SkuIdName = TAB_DEFAULT
2444             PcdObj.SkuInfoList[TAB_DEFAULT].SkuId = '0'
2445
2446         elif self.SkuIdMgr.SkuUsageType == self.SkuIdMgr.DEFAULT:
2447             PcdObj.SkuInfoList = {TAB_DEFAULT:PcdObj.SkuInfoList[TAB_DEFAULT]}
2448
2449         return PcdObj
2450
2451     @staticmethod
2452     def CompareVarAttr(Attr1, Attr2):
2453         if not Attr1 or not Attr2:  # for empty string
2454             return True
2455         Attr1s = [attr.strip() for attr in Attr1.split(",")]
2456         Attr1Set = set(Attr1s)
2457         Attr2s = [attr.strip() for attr in Attr2.split(",")]
2458         Attr2Set = set(Attr2s)
2459         if Attr2Set == Attr1Set:
2460             return True
2461         else:
2462             return False
2463
2464     def CopyDscRawValue(self, Pcd):
2465         if Pcd.DscRawValue is None:
2466             Pcd.DscRawValue = dict()
2467         if Pcd.Type in [self._PCD_TYPE_STRING_[MODEL_PCD_FIXED_AT_BUILD], self._PCD_TYPE_STRING_[MODEL_PCD_PATCHABLE_IN_MODULE]]:
2468             if self.SkuIdMgr.SystemSkuId not in Pcd.DscRawValue:
2469                 Pcd.DscRawValue[self.SkuIdMgr.SystemSkuId] = {}
2470             Pcd.DscRawValue[self.SkuIdMgr.SystemSkuId][TAB_DEFAULT_STORES_DEFAULT] = Pcd.DefaultValue
2471         for skuname in Pcd.SkuInfoList:
2472             Pcd.DscRawValue[skuname] = {}
2473             if Pcd.Type in [self._PCD_TYPE_STRING_[MODEL_PCD_DYNAMIC_HII], self._PCD_TYPE_STRING_[MODEL_PCD_DYNAMIC_EX_HII]]:
2474                 for defaultstore in Pcd.SkuInfoList[skuname].DefaultStoreDict:
2475                     Pcd.DscRawValue[skuname][defaultstore] = Pcd.SkuInfoList[skuname].DefaultStoreDict[defaultstore]
2476             else:
2477                 Pcd.DscRawValue[skuname][TAB_DEFAULT_STORES_DEFAULT] = Pcd.SkuInfoList[skuname].DefaultValue
2478     def CompletePcdValues(self, PcdSet):
2479         Pcds = {}
2480         DefaultStoreObj = DefaultStore(self._GetDefaultStores())
2481         SkuIds = {skuname:skuid for skuname, skuid in self.SkuIdMgr.AvailableSkuIdSet.items() if skuname != TAB_COMMON}
2482         DefaultStores = set(storename for pcdobj in PcdSet.values() for skuobj in pcdobj.SkuInfoList.values() for storename in skuobj.DefaultStoreDict)
2483         for PcdCName, TokenSpaceGuid in PcdSet:
2484             PcdObj = PcdSet[(PcdCName, TokenSpaceGuid)]
2485             self.CopyDscRawValue(PcdObj)
2486             if PcdObj.Type not in [self._PCD_TYPE_STRING_[MODEL_PCD_DYNAMIC_DEFAULT],
2487                         self._PCD_TYPE_STRING_[MODEL_PCD_DYNAMIC_HII],
2488                         self._PCD_TYPE_STRING_[MODEL_PCD_DYNAMIC_VPD],
2489                         self._PCD_TYPE_STRING_[MODEL_PCD_DYNAMIC_EX_DEFAULT],
2490                         self._PCD_TYPE_STRING_[MODEL_PCD_DYNAMIC_EX_HII],
2491                         self._PCD_TYPE_STRING_[MODEL_PCD_DYNAMIC_EX_VPD]]:
2492                 Pcds[PcdCName, TokenSpaceGuid]= PcdObj
2493                 continue
2494             PcdType = PcdObj.Type
2495             if PcdType in [self._PCD_TYPE_STRING_[MODEL_PCD_DYNAMIC_HII], self._PCD_TYPE_STRING_[MODEL_PCD_DYNAMIC_EX_HII]]:
2496                 for skuid in PcdObj.SkuInfoList:
2497                     skuobj = PcdObj.SkuInfoList[skuid]
2498                     mindefaultstorename = DefaultStoreObj.GetMin(set(defaultstorename for defaultstorename in skuobj.DefaultStoreDict))
2499                     for defaultstorename in DefaultStores:
2500                         if defaultstorename not in skuobj.DefaultStoreDict:
2501                             skuobj.DefaultStoreDict[defaultstorename] = copy.deepcopy(skuobj.DefaultStoreDict[mindefaultstorename])
2502                     skuobj.HiiDefaultValue = skuobj.DefaultStoreDict[mindefaultstorename]
2503             for skuname, skuid in SkuIds.items():
2504                 if skuname not in PcdObj.SkuInfoList:
2505                     nextskuid = self.SkuIdMgr.GetNextSkuId(skuname)
2506                     while nextskuid not in PcdObj.SkuInfoList:
2507                         nextskuid = self.SkuIdMgr.GetNextSkuId(nextskuid)
2508                     PcdObj.SkuInfoList[skuname] = copy.deepcopy(PcdObj.SkuInfoList[nextskuid])
2509                     PcdObj.SkuInfoList[skuname].SkuId = skuid
2510                     PcdObj.SkuInfoList[skuname].SkuIdName = skuname
2511             if PcdType in [self._PCD_TYPE_STRING_[MODEL_PCD_DYNAMIC_HII], self._PCD_TYPE_STRING_[MODEL_PCD_DYNAMIC_EX_HII]]:
2512                 PcdObj.DefaultValue = PcdObj.SkuInfoList.values()[0].HiiDefaultValue if self.SkuIdMgr.SkuUsageType == self.SkuIdMgr.SINGLE else PcdObj.SkuInfoList[TAB_DEFAULT].HiiDefaultValue
2513             Pcds[PcdCName, TokenSpaceGuid]= PcdObj
2514         return Pcds
2515     ## Retrieve dynamic HII PCD settings
2516     #
2517     #   @param  Type    PCD type
2518     #
2519     #   @retval a dict object contains settings of given PCD type
2520     #
2521     def _GetDynamicHiiPcd(self, Type):
2522
2523         VariableAttrs = {}
2524
2525         Pcds = OrderedDict()
2526         #
2527         # tdict is a special dict kind of type, used for selecting correct
2528         # PCD settings for certain ARCH and SKU
2529         #
2530         PcdDict = tdict(True, 5)
2531         PcdSet = set()
2532         RecordList = self._RawData[Type, self._Arch]
2533         # Find out all possible PCD candidates for self._Arch
2534         AvailableSkuIdSet = copy.copy(self.SkuIds)
2535         DefaultStoresDefine = self._GetDefaultStores()
2536
2537         for TokenSpaceGuid, PcdCName, Setting, Arch, SkuName, DefaultStore, Dummy4, Dummy5 in RecordList:
2538             SkuName = SkuName.upper()
2539             SkuName = TAB_DEFAULT if SkuName == TAB_COMMON else SkuName
2540             DefaultStore = DefaultStore.upper()
2541             if DefaultStore == TAB_COMMON:
2542                 DefaultStore = TAB_DEFAULT_STORES_DEFAULT
2543             if SkuName not in AvailableSkuIdSet:
2544                 EdkLogger.error('build', PARAMETER_INVALID, 'Sku %s is not defined in [SkuIds] section' % SkuName,
2545                                             File=self.MetaFile, Line=Dummy5)
2546             if DefaultStore not in DefaultStoresDefine:
2547                 EdkLogger.error('build', PARAMETER_INVALID, 'DefaultStores %s is not defined in [DefaultStores] section' % DefaultStore,
2548                                             File=self.MetaFile, Line=Dummy5)
2549             if "." not in TokenSpaceGuid:
2550                 PcdSet.add((PcdCName, TokenSpaceGuid, SkuName, DefaultStore, Dummy5))
2551             PcdDict[Arch, SkuName, PcdCName, TokenSpaceGuid, DefaultStore] = Setting
2552
2553
2554         # Remove redundant PCD candidates, per the ARCH and SKU
2555         for PcdCName, TokenSpaceGuid, SkuName, DefaultStore, Dummy4 in PcdSet:
2556
2557             Setting = PcdDict[self._Arch, SkuName, PcdCName, TokenSpaceGuid, DefaultStore]
2558             if Setting is None:
2559                 continue
2560             VariableName, VariableGuid, VariableOffset, DefaultValue, VarAttribute = self._ValidatePcd(PcdCName, TokenSpaceGuid, Setting, Type, Dummy4)
2561
2562             rt, Msg = VariableAttributes.ValidateVarAttributes(VarAttribute)
2563             if not rt:
2564                 EdkLogger.error("build", PCD_VARIABLE_ATTRIBUTES_ERROR, "Variable attributes settings for %s is incorrect.\n %s" % (".".join((TokenSpaceGuid, PcdCName)), Msg),
2565                         ExtraData="[%s]" % VarAttribute)
2566             ExceedMax = False
2567             FormatCorrect = True
2568             if VariableOffset.isdigit():
2569                 if int(VariableOffset, 10) > 0xFFFF:
2570                     ExceedMax = True
2571             elif variablePattern.match(VariableOffset):
2572                 if int(VariableOffset, 16) > 0xFFFF:
2573                     ExceedMax = True
2574             # For Offset written in "A.B"
2575             elif VariableOffset.find('.') > -1:
2576                 VariableOffsetList = VariableOffset.split(".")
2577                 if not (len(VariableOffsetList) == 2
2578                         and IsValidWord(VariableOffsetList[0])
2579                         and IsValidWord(VariableOffsetList[1])):
2580                     FormatCorrect = False
2581             else:
2582                 FormatCorrect = False
2583             if not FormatCorrect:
2584                 EdkLogger.error('Build', FORMAT_INVALID, "Invalid syntax or format of the variable offset value is incorrect for %s." % ".".join((TokenSpaceGuid, PcdCName)))
2585
2586             if ExceedMax:
2587                 EdkLogger.error('Build', OPTION_VALUE_INVALID, "The variable offset value must not exceed the maximum value of 0xFFFF (UINT16) for %s." % ".".join((TokenSpaceGuid, PcdCName)))
2588             if (VariableName, VariableGuid) not in VariableAttrs:
2589                 VariableAttrs[(VariableName, VariableGuid)] = VarAttribute
2590             else:
2591                 if not DscBuildData.CompareVarAttr(VariableAttrs[(VariableName, VariableGuid)], VarAttribute):
2592                     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)]))
2593
2594             pcdDecObject = self._DecPcds[PcdCName, TokenSpaceGuid]
2595             if (PcdCName, TokenSpaceGuid) in Pcds:
2596                 pcdObject = Pcds[PcdCName, TokenSpaceGuid]
2597                 if SkuName in pcdObject.SkuInfoList:
2598                     Skuitem = pcdObject.SkuInfoList[SkuName]
2599                     Skuitem.DefaultStoreDict.update({DefaultStore:DefaultValue})
2600                 else:
2601                     SkuInfo = SkuInfoClass(SkuName, self.SkuIds[SkuName][0], VariableName, VariableGuid, VariableOffset, DefaultValue, VariableAttribute=VarAttribute, DefaultStore={DefaultStore:DefaultValue})
2602                     pcdObject.SkuInfoList[SkuName] = SkuInfo
2603             else:
2604                 SkuInfo = SkuInfoClass(SkuName, self.SkuIds[SkuName][0], VariableName, VariableGuid, VariableOffset, DefaultValue, VariableAttribute=VarAttribute, DefaultStore={DefaultStore:DefaultValue})
2605                 Pcds[PcdCName, TokenSpaceGuid] = PcdClassObject(
2606                                                 PcdCName,
2607                                                 TokenSpaceGuid,
2608                                                 self._PCD_TYPE_STRING_[Type],
2609                                                 '',
2610                                                 DefaultValue,
2611                                                 '',
2612                                                 '',
2613                                                 {SkuName : SkuInfo},
2614                                                 False,
2615                                                 None,
2616                                                 pcdDecObject.validateranges,
2617                                                 pcdDecObject.validlists,
2618                                                 pcdDecObject.expressions,
2619                                                 IsDsc=True)
2620
2621
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         for pcd in Pcds.values():
2757             SkuInfoObj = pcd.SkuInfoList.values()[0]
2758             pcdDecObject = self._DecPcds[pcd.TokenCName, pcd.TokenSpaceGuidCName]
2759             pcd.DatumType = pcdDecObject.DatumType
2760             # Only fix the value while no value provided in DSC file.
2761             for sku in pcd.SkuInfoList.values():
2762                 if not sku.DefaultValue:
2763                     sku.DefaultValue = pcdDecObject.DefaultValue
2764             if TAB_DEFAULT not in pcd.SkuInfoList and TAB_COMMON not in pcd.SkuInfoList:
2765                 valuefromDec = pcdDecObject.DefaultValue
2766                 SkuInfo = SkuInfoClass(TAB_DEFAULT, '0', '', '', '', '', SkuInfoObj.VpdOffset, valuefromDec)
2767                 pcd.SkuInfoList[TAB_DEFAULT] = SkuInfo
2768             elif TAB_DEFAULT not in pcd.SkuInfoList and TAB_COMMON in pcd.SkuInfoList:
2769                 pcd.SkuInfoList[TAB_DEFAULT] = pcd.SkuInfoList[TAB_COMMON]
2770                 del pcd.SkuInfoList[TAB_COMMON]
2771             elif TAB_DEFAULT in pcd.SkuInfoList and TAB_COMMON in pcd.SkuInfoList:
2772                 del pcd.SkuInfoList[TAB_COMMON]
2773
2774
2775         map(self.FilterSkuSettings, Pcds.values())
2776         return Pcds
2777
2778     ## Add external modules
2779     #
2780     #   The external modules are mostly those listed in FDF file, which don't
2781     # need "build".
2782     #
2783     #   @param  FilePath    The path of module description file
2784     #
2785     def AddModule(self, FilePath):
2786         FilePath = NormPath(FilePath)
2787         if FilePath not in self.Modules:
2788             Module = ModuleBuildClassObject()
2789             Module.MetaFile = FilePath
2790             self.Modules.append(Module)
2791
2792     def _GetToolChainFamily(self):
2793         self._ToolChainFamily = TAB_COMPILER_MSFT
2794         BuildConfigurationFile = os.path.normpath(os.path.join(GlobalData.gConfDirectory, "target.txt"))
2795         if os.path.isfile(BuildConfigurationFile) == True:
2796             TargetTxt      = TargetTxtClassObject()
2797             TargetTxt.LoadTargetTxtFile(BuildConfigurationFile)
2798             ToolDefinitionFile = TargetTxt.TargetTxtDictionary[DataType.TAB_TAT_DEFINES_TOOL_CHAIN_CONF]
2799             if ToolDefinitionFile == '':
2800                 ToolDefinitionFile = "tools_def.txt"
2801                 ToolDefinitionFile = os.path.normpath(mws.join(self.WorkspaceDir, 'Conf', ToolDefinitionFile))
2802             if os.path.isfile(ToolDefinitionFile) == True:
2803                 ToolDef        = ToolDefClassObject()
2804                 ToolDef.LoadToolDefFile(ToolDefinitionFile)
2805                 ToolDefinition = ToolDef.ToolsDefTxtDatabase
2806                 if TAB_TOD_DEFINES_FAMILY not in ToolDefinition \
2807                    or self._Toolchain not in ToolDefinition[TAB_TOD_DEFINES_FAMILY] \
2808                    or not ToolDefinition[TAB_TOD_DEFINES_FAMILY][self._Toolchain]:
2809                     self._ToolChainFamily = TAB_COMPILER_MSFT
2810                 else:
2811                     self._ToolChainFamily = ToolDefinition[TAB_TOD_DEFINES_FAMILY][self._Toolchain]
2812         return self._ToolChainFamily
2813
2814     ## Add external PCDs
2815     #
2816     #   The external PCDs are mostly those listed in FDF file to specify address
2817     # or offset information.
2818     #
2819     #   @param  Name    Name of the PCD
2820     #   @param  Guid    Token space guid of the PCD
2821     #   @param  Value   Value of the PCD
2822     #
2823     def AddPcd(self, Name, Guid, Value):
2824         if (Name, Guid) not in self.Pcds:
2825             self.Pcds[Name, Guid] = PcdClassObject(Name, Guid, '', '', '', '', '', {}, False, None)
2826         self.Pcds[Name, Guid].DefaultValue = Value
2827     @property
2828     def DecPcds(self):
2829         if self._DecPcds is None:
2830             FdfInfList = []
2831             if GlobalData.gFdfParser:
2832                 FdfInfList = GlobalData.gFdfParser.Profile.InfList
2833             PkgSet = set()
2834             for Inf in FdfInfList:
2835                 ModuleFile = PathClass(NormPath(Inf), GlobalData.gWorkspace, Arch=self._Arch)
2836                 if ModuleFile in self._Modules:
2837                     continue
2838                 ModuleData = self._Bdb[ModuleFile, self._Arch, self._Target, self._Toolchain]
2839                 PkgSet.update(ModuleData.Packages)
2840             self._DecPcds, self._GuidDict = GetDeclaredPcd(self, self._Bdb, self._Arch, self._Target, self._Toolchain, PkgSet)
2841         return self._DecPcds
2842     _Macros             = property(_GetMacros)
2843     Arch                = property(_GetArch)
2844     Platform            = property(_GetPlatformName)
2845     PlatformName        = property(_GetPlatformName)
2846     Guid                = property(_GetFileGuid)
2847     Version             = property(_GetVersion)
2848     DscSpecification    = property(_GetDscSpec)
2849     OutputDirectory     = property(_GetOutpuDir)
2850     SupArchList         = property(_GetSupArch)
2851     BuildTargets        = property(_GetBuildTarget)
2852     SkuName             = property(_GetSkuName, _SetSkuName)
2853     PcdInfoFlag         = property(_GetPcdInfoFlag)
2854     VarCheckFlag        = property(_GetVarCheckFlag)
2855     FlashDefinition     = property(_GetFdfFile)
2856     Prebuild            = property(_GetPrebuild)
2857     Postbuild           = property(_GetPostbuild)
2858     BuildNumber         = property(_GetBuildNumber)
2859     MakefileName        = property(_GetMakefileName)
2860     BsBaseAddress       = property(_GetBsBaseAddress)
2861     RtBaseAddress       = property(_GetRtBaseAddress)
2862     LoadFixAddress      = property(_GetLoadFixAddress)
2863     RFCLanguages        = property(_GetRFCLanguages)
2864     ISOLanguages        = property(_GetISOLanguages)
2865     VpdToolGuid         = property(_GetVpdToolGuid)
2866     SkuIds              = property(_GetSkuIds)
2867     Modules             = property(_GetModules)
2868     LibraryInstances    = property(_GetLibraryInstances)
2869     LibraryClasses      = property(_GetLibraryClasses)
2870     Pcds                = property(_GetPcds)
2871     BuildOptions        = property(_GetBuildOptions)
2872     ToolChainFamily     = property(_GetToolChainFamily)