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
  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 IsValidWord(Record[1]):
 635                     EdkLogger.error('build', FORMAT_INVALID, "The format of the Sku ID name is invalid. The correct format is '(a-zA-Z0-9_)(a-zA-Z0-9_-.)*'",
 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.Pcds[Name, Guid] = copy.deepcopy(PcdInDec)
1275                         self.Pcds[Name, Guid].DefaultValue = NoFiledValues[( Guid, Name)][0]
1276         return AllPcds
1277
1278     def OverrideByFdfOverAll(self,AllPcds):
1279
1280         if GlobalData.gFdfParser is None:
1281             return AllPcds
1282         NoFiledValues = GlobalData.gFdfParser.Profile.PcdDict
1283         for Name,Guid,Field in NoFiledValues:
1284             if len(Field):
1285                 continue
1286             Value = NoFiledValues[(Name,Guid,Field)]
1287             if (Name,Guid) in AllPcds:
1288                 Pcd = AllPcds.get((Name,Guid))
1289                 if isinstance(self._DecPcds.get((Pcd.TokenCName,Pcd.TokenSpaceGuidCName), None),StructurePcd):
1290                     self._DecPcds.get((Pcd.TokenCName,Pcd.TokenSpaceGuidCName)).PcdValueFromComm = Value
1291                 else:
1292                     Pcd.PcdValueFromComm = Value
1293                     Pcd.DefaultValue = Value
1294                     for sku in Pcd.SkuInfoList:
1295                         SkuInfo = Pcd.SkuInfoList[sku]
1296                         if SkuInfo.DefaultValue:
1297                             SkuInfo.DefaultValue = Value
1298                         else:
1299                             SkuInfo.HiiDefaultValue = Value
1300                             for defaultstore in SkuInfo.DefaultStoreDict:
1301                                 SkuInfo.DefaultStoreDict[defaultstore] = Value
1302                     if Pcd.Type in [self._PCD_TYPE_STRING_[MODEL_PCD_DYNAMIC_EX_HII], self._PCD_TYPE_STRING_[MODEL_PCD_DYNAMIC_HII]]:
1303                         if Pcd.DatumType == TAB_VOID:
1304                             if not Pcd.MaxDatumSize:
1305                                 Pcd.MaxDatumSize = '0'
1306                             CurrentSize = int(Pcd.MaxDatumSize,16) if Pcd.MaxDatumSize.upper().startswith("0X") else int(Pcd.MaxDatumSize)
1307                             OptionSize = len((StringToArray(Pcd.PcdValueFromComm)).split(","))
1308                             MaxSize = max(CurrentSize, OptionSize)
1309                             Pcd.MaxDatumSize = str(MaxSize)
1310             else:
1311                 PcdInDec = self.DecPcds.get((Name,Guid))
1312                 if PcdInDec:
1313                     PcdInDec.PcdValueFromFdf = Value
1314                     if PcdInDec.Type in [self._PCD_TYPE_STRING_[MODEL_PCD_FIXED_AT_BUILD],
1315                                         self._PCD_TYPE_STRING_[MODEL_PCD_PATCHABLE_IN_MODULE],
1316                                         self._PCD_TYPE_STRING_[MODEL_PCD_FEATURE_FLAG]]:
1317                         self.Pcds[Name, Guid] = copy.deepcopy(PcdInDec)
1318                         self.Pcds[Name, Guid].DefaultValue = Value
1319         return AllPcds
1320
1321     def UpdateStructuredPcds(self, TypeList, AllPcds):
1322
1323         DynamicPcdType = [self._PCD_TYPE_STRING_[MODEL_PCD_DYNAMIC_DEFAULT],
1324                         self._PCD_TYPE_STRING_[MODEL_PCD_DYNAMIC_HII],
1325                         self._PCD_TYPE_STRING_[MODEL_PCD_DYNAMIC_VPD],
1326                         self._PCD_TYPE_STRING_[MODEL_PCD_DYNAMIC_EX_DEFAULT],
1327                         self._PCD_TYPE_STRING_[MODEL_PCD_DYNAMIC_EX_HII],
1328                         self._PCD_TYPE_STRING_[MODEL_PCD_DYNAMIC_EX_VPD]]
1329
1330         Pcds = AllPcds
1331         DefaultStoreMgr = DefaultStore(self.DefaultStores)
1332         SkuIds = self.SkuIdMgr.AvailableSkuIdSet
1333         SkuIds.update({TAB_DEFAULT:0})
1334         DefaultStores = {storename for pcdobj in AllPcds.values() for skuobj in pcdobj.SkuInfoList.values() for storename in skuobj.DefaultStoreDict}
1335
1336         S_PcdSet = []
1337         # Find out all possible PCD candidates for self._Arch
1338         RecordList = []
1339
1340         for Type in TypeList:
1341             RecordList.extend(self._RawData[Type, self._Arch])
1342
1343         for TokenSpaceGuid, PcdCName, Setting, Arch, SkuName, default_store, Dummy4, Dummy5 in RecordList:
1344             SkuName = SkuName.upper()
1345             default_store = default_store.upper()
1346             SkuName = TAB_DEFAULT if SkuName == TAB_COMMON else SkuName
1347             if SkuName not in SkuIds:
1348                 continue
1349
1350             if SkuName in SkuIds and "." in TokenSpaceGuid:
1351                 S_PcdSet.append([ TokenSpaceGuid.split(".")[0], TokenSpaceGuid.split(".")[1], PcdCName, SkuName, default_store, Dummy5, AnalyzePcdExpression(Setting)[0]])
1352
1353         # handle pcd value override
1354         StrPcdSet = DscBuildData.GetStructurePcdInfo(S_PcdSet)
1355         S_pcd_set = OrderedDict()
1356         for str_pcd in StrPcdSet:
1357             str_pcd_obj = Pcds.get((str_pcd[1], str_pcd[0]), None)
1358             str_pcd_dec = self._DecPcds.get((str_pcd[1], str_pcd[0]), None)
1359             if not isinstance (str_pcd_dec, StructurePcd):
1360                 EdkLogger.error('build', PARSER_ERROR,
1361                             "Pcd (%s.%s) is not declared as Structure PCD in DEC files. Arch: ['%s']" % (str_pcd[0], str_pcd[1], self._Arch),
1362                             File=self.MetaFile, Line = StrPcdSet[str_pcd][0][5])
1363             if str_pcd_dec:
1364                 str_pcd_obj_str = StructurePcd()
1365                 str_pcd_obj_str.copy(str_pcd_dec)
1366                 if str_pcd_obj:
1367                     str_pcd_obj_str.copy(str_pcd_obj)
1368                     if str_pcd_obj.Type in [self._PCD_TYPE_STRING_[MODEL_PCD_DYNAMIC_HII], self._PCD_TYPE_STRING_[MODEL_PCD_DYNAMIC_EX_HII]]:
1369                         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}
1370                     else:
1371                         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}
1372                 for str_pcd_data in StrPcdSet[str_pcd]:
1373                     if str_pcd_data[3] in SkuIds:
1374                         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])
1375                 S_pcd_set[str_pcd[1], str_pcd[0]] = str_pcd_obj_str
1376             else:
1377                 EdkLogger.error('build', PARSER_ERROR,
1378                             "Pcd (%s.%s) defined in DSC is not declared in DEC files. Arch: ['%s']" % (str_pcd[0], str_pcd[1], self._Arch),
1379                             File=self.MetaFile, Line = StrPcdSet[str_pcd][0][5])
1380         # Add the Structure PCD that only defined in DEC, don't have override in DSC file
1381         for Pcd in self.DecPcds:
1382             if isinstance(self._DecPcds[Pcd], StructurePcd):
1383                 if Pcd not in S_pcd_set:
1384                     str_pcd_obj_str = StructurePcd()
1385                     str_pcd_obj_str.copy(self._DecPcds[Pcd])
1386                     str_pcd_obj = Pcds.get(Pcd, None)
1387                     if str_pcd_obj:
1388                         str_pcd_obj_str.copy(str_pcd_obj)
1389                         if str_pcd_obj.Type in [self._PCD_TYPE_STRING_[MODEL_PCD_DYNAMIC_HII], self._PCD_TYPE_STRING_[MODEL_PCD_DYNAMIC_EX_HII]]:
1390                             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}
1391                         else:
1392                             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}
1393                     S_pcd_set[Pcd] = str_pcd_obj_str
1394         if S_pcd_set:
1395             GlobalData.gStructurePcd[self.Arch] = S_pcd_set
1396         for stru_pcd in S_pcd_set.values():
1397             for skuid in SkuIds:
1398                 if skuid in stru_pcd.SkuOverrideValues:
1399                     continue
1400                 nextskuid = self.SkuIdMgr.GetNextSkuId(skuid)
1401                 NoDefault = False
1402                 if skuid not in stru_pcd.SkuOverrideValues:
1403                     while nextskuid not in stru_pcd.SkuOverrideValues:
1404                         if nextskuid == TAB_DEFAULT:
1405                             NoDefault = True
1406                             break
1407                         nextskuid = self.SkuIdMgr.GetNextSkuId(nextskuid)
1408                     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})
1409                     if not NoDefault:
1410                         stru_pcd.ValueChain.add((skuid, ''))
1411             if stru_pcd.Type in [self._PCD_TYPE_STRING_[MODEL_PCD_DYNAMIC_HII], self._PCD_TYPE_STRING_[MODEL_PCD_DYNAMIC_EX_HII]]:
1412                 for skuid in SkuIds:
1413                     nextskuid = skuid
1414                     NoDefault = False
1415                     if skuid not in stru_pcd.SkuOverrideValues:
1416                         while nextskuid not in stru_pcd.SkuOverrideValues:
1417                             if nextskuid == TAB_DEFAULT:
1418                                 NoDefault = True
1419                                 break
1420                             nextskuid = self.SkuIdMgr.GetNextSkuId(nextskuid)
1421                     if NoDefault:
1422                         continue
1423                     PcdDefaultStoreSet = set(defaultstorename  for defaultstorename in stru_pcd.SkuOverrideValues[nextskuid])
1424                     mindefaultstorename = DefaultStoreMgr.GetMin(PcdDefaultStoreSet)
1425
1426                     for defaultstoreid in DefaultStores:
1427                         if defaultstoreid not in stru_pcd.SkuOverrideValues[skuid]:
1428                             stru_pcd.SkuOverrideValues[skuid][defaultstoreid] = copy.deepcopy(stru_pcd.SkuOverrideValues[nextskuid][mindefaultstorename])
1429                             stru_pcd.ValueChain.add((skuid, defaultstoreid))
1430         S_pcd_set = DscBuildData.OverrideByFdf(S_pcd_set,self.WorkspaceDir)
1431         S_pcd_set = DscBuildData.OverrideByComm(S_pcd_set)
1432         Str_Pcd_Values = self.GenerateByteArrayValue(S_pcd_set)
1433         if Str_Pcd_Values:
1434             for (skuname, StoreName, PcdGuid, PcdName, PcdValue) in Str_Pcd_Values:
1435                 str_pcd_obj = S_pcd_set.get((PcdName, PcdGuid))
1436                 if str_pcd_obj is None:
1437                     print(PcdName, PcdGuid)
1438                     raise
1439                 if str_pcd_obj.Type in [self._PCD_TYPE_STRING_[MODEL_PCD_DYNAMIC_HII],
1440                                         self._PCD_TYPE_STRING_[MODEL_PCD_DYNAMIC_EX_HII]]:
1441                     if skuname not in str_pcd_obj.SkuInfoList:
1442                         str_pcd_obj.SkuInfoList[skuname] = SkuInfoClass(SkuIdName=skuname, SkuId=self.SkuIds[skuname][0], HiiDefaultValue=PcdValue, DefaultStore = {StoreName:PcdValue})
1443                     else:
1444                         str_pcd_obj.SkuInfoList[skuname].HiiDefaultValue = PcdValue
1445                         str_pcd_obj.SkuInfoList[skuname].DefaultStoreDict.update({StoreName:PcdValue})
1446                 elif str_pcd_obj.Type in [self._PCD_TYPE_STRING_[MODEL_PCD_FIXED_AT_BUILD],
1447                                         self._PCD_TYPE_STRING_[MODEL_PCD_PATCHABLE_IN_MODULE]]:
1448                     if skuname in (self.SkuIdMgr.SystemSkuId, TAB_DEFAULT, TAB_COMMON):
1449                         str_pcd_obj.DefaultValue = PcdValue
1450                 else:
1451                     if skuname not in str_pcd_obj.SkuInfoList:
1452                         nextskuid = self.SkuIdMgr.GetNextSkuId(skuname)
1453                         NoDefault = False
1454                         while nextskuid not in str_pcd_obj.SkuInfoList:
1455                             if nextskuid == TAB_DEFAULT:
1456                                 NoDefault = True
1457                                 break
1458                             nextskuid = self.SkuIdMgr.GetNextSkuId(nextskuid)
1459                         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)
1460                         str_pcd_obj.SkuInfoList[skuname].SkuId = self.SkuIds[skuname][0]
1461                         str_pcd_obj.SkuInfoList[skuname].SkuIdName = skuname
1462                     else:
1463                         str_pcd_obj.SkuInfoList[skuname].DefaultValue = PcdValue
1464             for str_pcd_obj in S_pcd_set.values():
1465                 if str_pcd_obj.Type not in [self._PCD_TYPE_STRING_[MODEL_PCD_DYNAMIC_HII],
1466                                         self._PCD_TYPE_STRING_[MODEL_PCD_DYNAMIC_EX_HII]]:
1467                     continue
1468                 PcdDefaultStoreSet = set(defaultstorename for skuobj in str_pcd_obj.SkuInfoList.values() for defaultstorename in skuobj.DefaultStoreDict)
1469                 DefaultStoreObj = DefaultStore(self._GetDefaultStores())
1470                 mindefaultstorename = DefaultStoreObj.GetMin(PcdDefaultStoreSet)
1471                 str_pcd_obj.SkuInfoList[self.SkuIdMgr.SystemSkuId].HiiDefaultValue = str_pcd_obj.SkuInfoList[self.SkuIdMgr.SystemSkuId].DefaultStoreDict[mindefaultstorename]
1472
1473             for str_pcd_obj in S_pcd_set.values():
1474
1475                 str_pcd_obj.MaxDatumSize = self.GetStructurePcdMaxSize(str_pcd_obj)
1476                 Pcds[str_pcd_obj.TokenCName, str_pcd_obj.TokenSpaceGuidCName] = str_pcd_obj
1477
1478             for pcdkey in Pcds:
1479                 pcd = Pcds[pcdkey]
1480                 if TAB_DEFAULT not in pcd.SkuInfoList and TAB_COMMON in pcd.SkuInfoList:
1481                     pcd.SkuInfoList[TAB_DEFAULT] = pcd.SkuInfoList[TAB_COMMON]
1482                     del pcd.SkuInfoList[TAB_COMMON]
1483                 elif TAB_DEFAULT in pcd.SkuInfoList and TAB_COMMON in pcd.SkuInfoList:
1484                     del pcd.SkuInfoList[TAB_COMMON]
1485
1486         map(self.FilterSkuSettings, [Pcds[pcdkey] for pcdkey in Pcds if Pcds[pcdkey].Type in DynamicPcdType])
1487         return Pcds
1488
1489     ## Retrieve non-dynamic PCD settings
1490     #
1491     #   @param  Type    PCD type
1492     #
1493     #   @retval a dict object contains settings of given PCD type
1494     #
1495     def _GetPcd(self, Type):
1496         Pcds = OrderedDict()
1497         #
1498         # tdict is a special dict kind of type, used for selecting correct
1499         # PCD settings for certain ARCH
1500         #
1501         AvailableSkuIdSet = copy.copy(self.SkuIds)
1502
1503         PcdDict = tdict(True, 3)
1504         PcdSet = set()
1505         # Find out all possible PCD candidates for self._Arch
1506         RecordList = self._RawData[Type, self._Arch]
1507         PcdValueDict = OrderedDict()
1508         for TokenSpaceGuid, PcdCName, Setting, Arch, SkuName, Dummy3, Dummy4, Dummy5 in RecordList:
1509             SkuName = SkuName.upper()
1510             SkuName = TAB_DEFAULT if SkuName == TAB_COMMON else SkuName
1511             if SkuName not in AvailableSkuIdSet:
1512                 EdkLogger.error('build ', PARAMETER_INVALID, 'Sku %s is not defined in [SkuIds] section' % SkuName,
1513                                             File=self.MetaFile, Line=Dummy5)
1514             if SkuName in (self.SkuIdMgr.SystemSkuId, TAB_DEFAULT, TAB_COMMON):
1515                 if "." not in TokenSpaceGuid:
1516                     PcdSet.add((PcdCName, TokenSpaceGuid, SkuName, Dummy5))
1517                 PcdDict[Arch, PcdCName, TokenSpaceGuid, SkuName] = Setting
1518
1519         for PcdCName, TokenSpaceGuid, SkuName, Dummy4 in PcdSet:
1520             Setting = PcdDict[self._Arch, PcdCName, TokenSpaceGuid, SkuName]
1521             if Setting is None:
1522                 continue
1523             PcdValue, DatumType, MaxDatumSize = self._ValidatePcd(PcdCName, TokenSpaceGuid, Setting, Type, Dummy4)
1524             if MaxDatumSize:
1525                 if int(MaxDatumSize, 0) > 0xFFFF:
1526                     EdkLogger.error('build', FORMAT_INVALID, "The size value must not exceed the maximum value of 0xFFFF (UINT16) for %s." % ".".join((TokenSpaceGuid, PcdCName)),
1527                                     File=self.MetaFile, Line=Dummy4)
1528                 if int(MaxDatumSize, 0) < 0:
1529                     EdkLogger.error('build', FORMAT_INVALID, "The size value can't be set to negative value for %s." % ".".join((TokenSpaceGuid, PcdCName)),
1530                                     File=self.MetaFile, Line=Dummy4)
1531             if (PcdCName, TokenSpaceGuid) in PcdValueDict:
1532                 PcdValueDict[PcdCName, TokenSpaceGuid][SkuName] = (PcdValue, DatumType, MaxDatumSize)
1533             else:
1534                 PcdValueDict[PcdCName, TokenSpaceGuid] = {SkuName:(PcdValue, DatumType, MaxDatumSize)}
1535
1536         for ((PcdCName, TokenSpaceGuid), PcdSetting) in PcdValueDict.iteritems():
1537             if self.SkuIdMgr.SystemSkuId in PcdSetting:
1538                 PcdValue, DatumType, MaxDatumSize = PcdSetting[self.SkuIdMgr.SystemSkuId]
1539             elif TAB_DEFAULT in PcdSetting:
1540                 PcdValue, DatumType, MaxDatumSize = PcdSetting[TAB_DEFAULT]
1541             elif TAB_COMMON in PcdSetting:
1542                 PcdValue, DatumType, MaxDatumSize = PcdSetting[TAB_COMMON]
1543             else:
1544                 PcdValue = None
1545                 DatumType = None
1546                 MaxDatumSize = None
1547
1548             Pcds[PcdCName, TokenSpaceGuid] = PcdClassObject(
1549                                                 PcdCName,
1550                                                 TokenSpaceGuid,
1551                                                 self._PCD_TYPE_STRING_[Type],
1552                                                 DatumType,
1553                                                 PcdValue,
1554                                                 '',
1555                                                 MaxDatumSize,
1556                                                 {},
1557                                                 False,
1558                                                 None,
1559                                                 IsDsc=True)
1560
1561
1562         return Pcds
1563
1564     def GetStructurePcdMaxSize(self, str_pcd):
1565         pcd_default_value = str_pcd.DefaultValue
1566         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()]
1567         sku_values.append(pcd_default_value)
1568
1569         def get_length(value):
1570             Value = value.strip()
1571             if len(value) > 1:
1572                 if Value.startswith(TAB_GUID) and Value.endswith(')'):
1573                     return 16
1574                 if Value.startswith('L"') and Value.endswith('"'):
1575                     return len(Value[2:-1])
1576                 if Value[0] == '"' and Value[-1] == '"':
1577                     return len(Value) - 2
1578                 if Value[0] == '{' and Value[-1] == '}':
1579                     return len(Value.split(","))
1580                 if Value.startswith("L'") and Value.endswith("'") and len(list(Value[2:-1])) > 1:
1581                     return  len(list(Value[2:-1]))
1582                 if Value[0] == "'" and Value[-1] == "'" and len(list(Value[1:-1])) > 1:
1583                     return len(Value) - 2
1584             return len(Value)
1585
1586         return str(max(get_length(item) for item in sku_values))
1587
1588     @staticmethod
1589     def ExecuteCommand (Command):
1590         try:
1591             Process = subprocess.Popen(Command, stdout=subprocess.PIPE, stderr=subprocess.PIPE, shell=True)
1592         except:
1593             EdkLogger.error('Build', COMMAND_FAILURE, 'Can not execute command: %s' % Command)
1594         Result = Process.communicate()
1595         return Process.returncode, Result[0], Result[1]
1596
1597     @staticmethod
1598     def IntToCString(Value, ValueSize):
1599         Result = '"'
1600         if not isinstance (Value, str):
1601             for Index in range(0, ValueSize):
1602                 Result = Result + '\\x%02x' % (Value & 0xff)
1603                 Value = Value >> 8
1604         Result = Result + '"'
1605         return Result
1606
1607     def GenerateSizeFunction(self, Pcd):
1608         CApp = "// Default Value in Dec \n"
1609         CApp = CApp + "void Cal_%s_%s_Size(UINT32 *Size){\n" % (Pcd.TokenSpaceGuidCName, Pcd.TokenCName)
1610         for FieldList in [Pcd.DefaultValues]:
1611             if not FieldList:
1612                 continue
1613             for FieldName in FieldList:
1614                 FieldName = "." + FieldName
1615                 IsArray = IsFieldValueAnArray(FieldList[FieldName.strip(".")][0])
1616                 if IsArray and not (FieldList[FieldName.strip(".")][0].startswith('{GUID') and FieldList[FieldName.strip(".")][0].endswith('}')):
1617                     try:
1618                         Value = ValueExpressionEx(FieldList[FieldName.strip(".")][0], TAB_VOID, self._GuidDict)(True)
1619                     except BadExpression:
1620                         EdkLogger.error('Build', FORMAT_INVALID, "Invalid value format for %s. From %s Line %d " %
1621                                         (".".join((Pcd.TokenSpaceGuidCName, Pcd.TokenCName, FieldName.strip('.'))), FieldList[FieldName.strip(".")][1], FieldList[FieldName.strip(".")][2]))
1622                     Value, ValueSize = ParseFieldValue(Value)
1623                     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]);
1624                 else:
1625                     NewFieldName = ''
1626                     FieldName_ori = FieldName.strip('.')
1627                     while '[' in  FieldName:
1628                         NewFieldName = NewFieldName + FieldName.split('[', 1)[0] + '[0]'
1629                         ArrayIndex = int(FieldName.split('[', 1)[1].split(']', 1)[0])
1630                         FieldName = FieldName.split(']', 1)[1]
1631                     FieldName = NewFieldName + FieldName
1632                     while '[' in FieldName:
1633                         FieldName = FieldName.rsplit('[', 1)[0]
1634                         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])
1635         for skuname in Pcd.SkuOverrideValues:
1636             if skuname == TAB_COMMON:
1637                 continue
1638             for defaultstorenameitem in Pcd.SkuOverrideValues[skuname]:
1639                 CApp = CApp + "// SkuName: %s,  DefaultStoreName: %s \n" % (skuname, defaultstorenameitem)
1640                 for FieldList in [Pcd.SkuOverrideValues[skuname].get(defaultstorenameitem)]:
1641                     if not FieldList:
1642                         continue
1643                     for FieldName in FieldList:
1644                         FieldName = "." + FieldName
1645                         IsArray = IsFieldValueAnArray(FieldList[FieldName.strip(".")][0])
1646                         if IsArray and not (FieldList[FieldName.strip(".")][0].startswith('{GUID') and FieldList[FieldName.strip(".")][0].endswith('}')):
1647                             try:
1648                                 Value = ValueExpressionEx(FieldList[FieldName.strip(".")][0], TAB_VOID, self._GuidDict)(True)
1649                             except BadExpression:
1650                                 EdkLogger.error('Build', FORMAT_INVALID, "Invalid value format for %s. From %s Line %d " %
1651                                                 (".".join((Pcd.TokenSpaceGuidCName, Pcd.TokenCName, FieldName.strip('.'))), FieldList[FieldName.strip(".")][1], FieldList[FieldName.strip(".")][2]))
1652                             Value, ValueSize = ParseFieldValue(Value)
1653                             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]);
1654                         else:
1655                             NewFieldName = ''
1656                             FieldName_ori = FieldName.strip('.')
1657                             while '[' in  FieldName:
1658                                 NewFieldName = NewFieldName + FieldName.split('[', 1)[0] + '[0]'
1659                                 ArrayIndex = int(FieldName.split('[', 1)[1].split(']', 1)[0])
1660                                 FieldName = FieldName.split(']', 1)[1]
1661                             FieldName = NewFieldName + FieldName
1662                             while '[' in FieldName:
1663                                 FieldName = FieldName.rsplit('[', 1)[0]
1664                                 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])
1665         if Pcd.PcdFieldValueFromFdf:
1666             CApp = CApp + "// From fdf \n"
1667         for FieldName in Pcd.PcdFieldValueFromFdf:
1668             FieldName = "." + FieldName
1669             IsArray = IsFieldValueAnArray(Pcd.PcdFieldValueFromFdf[FieldName.strip(".")][0])
1670             if IsArray and not (Pcd.PcdFieldValueFromFdf[FieldName.strip(".")][0].startswith('{GUID') and Pcd.PcdFieldValueFromFdf[FieldName.strip(".")][0].endswith('}')):
1671                 try:
1672                     Value = ValueExpressionEx(Pcd.PcdFieldValueFromFdf[FieldName.strip(".")][0], TAB_VOID, self._GuidDict)(True)
1673                 except BadExpression:
1674                     EdkLogger.error('Build', FORMAT_INVALID, "Invalid value format for %s. From %s Line %d " %
1675                                     (".".join((Pcd.TokenSpaceGuidCName, Pcd.TokenCName, FieldName.strip('.'))), Pcd.PcdFieldValueFromFdf[FieldName.strip(".")][1], Pcd.PcdFieldValueFromFdf[FieldName.strip(".")][2]))
1676                 Value, ValueSize = ParseFieldValue(Value)
1677                 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]);
1678             else:
1679                 NewFieldName = ''
1680                 FieldName_ori = FieldName.strip('.')
1681                 while '[' in  FieldName:
1682                     NewFieldName = NewFieldName + FieldName.split('[', 1)[0] + '[0]'
1683                     ArrayIndex = int(FieldName.split('[', 1)[1].split(']', 1)[0])
1684                     FieldName = FieldName.split(']', 1)[1]
1685                 FieldName = NewFieldName + FieldName
1686                 while '[' in FieldName:
1687                     FieldName = FieldName.rsplit('[', 1)[0]
1688                     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])
1689         if Pcd.PcdFieldValueFromComm:
1690             CApp = CApp + "// From Command Line \n"
1691         for FieldName in Pcd.PcdFieldValueFromComm:
1692             FieldName = "." + FieldName
1693             IsArray = IsFieldValueAnArray(Pcd.PcdFieldValueFromComm[FieldName.strip(".")][0])
1694             if IsArray and not (Pcd.PcdFieldValueFromComm[FieldName.strip(".")][0].startswith('{GUID') and Pcd.PcdFieldValueFromComm[FieldName.strip(".")][0].endswith('}')):
1695                 try:
1696                     Value = ValueExpressionEx(Pcd.PcdFieldValueFromComm[FieldName.strip(".")][0], TAB_VOID, self._GuidDict)(True)
1697                 except BadExpression:
1698                     EdkLogger.error('Build', FORMAT_INVALID, "Invalid value format for %s. From %s Line %d " %
1699                                     (".".join((Pcd.TokenSpaceGuidCName, Pcd.TokenCName, FieldName.strip('.'))), Pcd.PcdFieldValueFromComm[FieldName.strip(".")][1], Pcd.PcdFieldValueFromComm[FieldName.strip(".")][2]))
1700                 Value, ValueSize = ParseFieldValue(Value)
1701                 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]);
1702             else:
1703                 NewFieldName = ''
1704                 FieldName_ori = FieldName.strip('.')
1705                 while '[' in  FieldName:
1706                     NewFieldName = NewFieldName + FieldName.split('[', 1)[0] + '[0]'
1707                     ArrayIndex = int(FieldName.split('[', 1)[1].split(']', 1)[0])
1708                     FieldName = FieldName.split(']', 1)[1]
1709                 FieldName = NewFieldName + FieldName
1710                 while '[' in FieldName:
1711                     FieldName = FieldName.rsplit('[', 1)[0]
1712                     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])
1713         CApp = CApp + "  *Size = (%d > *Size ? %d : *Size); // The Pcd maxsize is %d \n" % (Pcd.GetPcdMaxSize(), Pcd.GetPcdMaxSize(), Pcd.GetPcdMaxSize())
1714         CApp = CApp + "}\n"
1715         return CApp
1716
1717     @staticmethod
1718     def GenerateSizeStatments(Pcd):
1719         CApp = '  Size = sizeof(%s);\n' % (Pcd.DatumType)
1720         CApp = CApp + '  Cal_%s_%s_Size(&Size);\n' % (Pcd.TokenSpaceGuidCName, Pcd.TokenCName)
1721         return CApp
1722
1723     def GenerateDefaultValueAssignFunction(self, Pcd):
1724         CApp = "// Default value in Dec \n"
1725         CApp = CApp + "void Assign_%s_%s_Default_Value(%s *Pcd){\n" % (Pcd.TokenSpaceGuidCName, Pcd.TokenCName, Pcd.DatumType)
1726         CApp = CApp + '  UINT32  FieldSize;\n'
1727         CApp = CApp + '  CHAR8   *Value;\n'
1728         DefaultValueFromDec = Pcd.DefaultValueFromDec
1729         IsArray = IsFieldValueAnArray(Pcd.DefaultValueFromDec)
1730         if IsArray:
1731             try:
1732                 DefaultValueFromDec = ValueExpressionEx(Pcd.DefaultValueFromDec, TAB_VOID)(True)
1733             except BadExpression:
1734                 EdkLogger.error("Build", FORMAT_INVALID, "Invalid value format for %s.%s, from DEC: %s" %
1735                                 (Pcd.TokenSpaceGuidCName, Pcd.TokenCName, DefaultValueFromDec))
1736         DefaultValueFromDec = StringToArray(DefaultValueFromDec)
1737         Value, ValueSize = ParseFieldValue (DefaultValueFromDec)
1738         if isinstance(Value, str):
1739             CApp = CApp + '  Pcd = %s; // From DEC Default Value %s\n' % (Value, Pcd.DefaultValueFromDec)
1740         elif IsArray:
1741         #
1742         # Use memcpy() to copy value into field
1743         #
1744             CApp = CApp + '  Value     = %s; // From DEC Default Value %s\n' % (DscBuildData.IntToCString(Value, ValueSize), Pcd.DefaultValueFromDec)
1745             CApp = CApp + '  memcpy (Pcd, Value, %d);\n' % (ValueSize)
1746         for FieldList in [Pcd.DefaultValues]:
1747             if not FieldList:
1748                 continue
1749             for FieldName in FieldList:
1750                 IsArray = IsFieldValueAnArray(FieldList[FieldName][0])
1751                 if IsArray:
1752                     try:
1753                         FieldList[FieldName][0] = ValueExpressionEx(FieldList[FieldName][0], TAB_VOID, self._GuidDict)(True)
1754                     except BadExpression:
1755                         EdkLogger.error('Build', FORMAT_INVALID, "Invalid value format for %s. From %s Line %d " %
1756                                         (".".join((Pcd.TokenSpaceGuidCName, Pcd.TokenCName, FieldName)), FieldList[FieldName][1], FieldList[FieldName][2]))
1757
1758                 try:
1759                     Value, ValueSize = ParseFieldValue (FieldList[FieldName][0])
1760                 except Exception:
1761                     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]))
1762                 if isinstance(Value, str):
1763                     CApp = CApp + '  Pcd->%s = %s; // From %s Line %d Value %s\n' % (FieldName, Value, FieldList[FieldName][1], FieldList[FieldName][2], FieldList[FieldName][0])
1764                 elif IsArray:
1765                     #
1766                     # Use memcpy() to copy value into field
1767                     #
1768                     CApp = CApp + '  FieldSize = __FIELD_SIZE(%s, %s);\n' % (Pcd.DatumType, FieldName)
1769                     CApp = CApp + '  Value     = %s; // From %s Line %d Value %s\n' % (DscBuildData.IntToCString(Value, ValueSize), FieldList[FieldName][1], FieldList[FieldName][2], FieldList[FieldName][0])
1770                     CApp = CApp + '  memcpy (&Pcd->%s, Value, (FieldSize > 0 && FieldSize < %d) ? FieldSize : %d);\n' % (FieldName, ValueSize, ValueSize)
1771                 else:
1772                     if ValueSize > 4:
1773                         CApp = CApp + '  Pcd->%s = %dULL; // From %s Line %d Value %s\n' % (FieldName, Value, FieldList[FieldName][1], FieldList[FieldName][2], FieldList[FieldName][0])
1774                     else:
1775                         CApp = CApp + '  Pcd->%s = %d; // From %s Line %d Value %s\n' % (FieldName, Value, FieldList[FieldName][1], FieldList[FieldName][2], FieldList[FieldName][0])
1776         CApp = CApp + "}\n"
1777         return CApp
1778
1779     @staticmethod
1780     def GenerateDefaultValueAssignStatement(Pcd):
1781         CApp = '  Assign_%s_%s_Default_Value(Pcd);\n' % (Pcd.TokenSpaceGuidCName, Pcd.TokenCName)
1782         return CApp
1783
1784     def GenerateInitValueFunction(self, Pcd, SkuName, DefaultStoreName):
1785         CApp = "// Value in Dsc for Sku: %s, DefaultStore %s\n" % (SkuName, DefaultStoreName)
1786         CApp = CApp + "void Assign_%s_%s_%s_%s_Value(%s *Pcd){\n" % (Pcd.TokenSpaceGuidCName, Pcd.TokenCName, SkuName, DefaultStoreName, Pcd.DatumType)
1787         CApp = CApp + '  UINT32  FieldSize;\n'
1788         CApp = CApp + '  CHAR8   *Value;\n'
1789
1790         CApp = CApp + "// SkuName: %s,  DefaultStoreName: %s \n" % (TAB_DEFAULT, TAB_DEFAULT_STORES_DEFAULT)
1791         inherit_OverrideValues = Pcd.SkuOverrideValues[SkuName]
1792         if (SkuName, DefaultStoreName) == (TAB_DEFAULT, TAB_DEFAULT_STORES_DEFAULT):
1793             pcddefaultvalue = Pcd.DefaultFromDSC.get(TAB_DEFAULT, {}).get(TAB_DEFAULT_STORES_DEFAULT, Pcd.DefaultValue) if Pcd.DefaultFromDSC else Pcd.DefaultValue
1794         else:
1795             if not Pcd.DscRawValue:
1796                 # handle the case that structure pcd is not appear in DSC
1797                 self.CopyDscRawValue(Pcd)
1798             pcddefaultvalue = Pcd.DscRawValue.get(SkuName, {}).get(DefaultStoreName)
1799         for FieldList in [pcddefaultvalue, inherit_OverrideValues.get(DefaultStoreName)]:
1800             if not FieldList:
1801                 continue
1802             if pcddefaultvalue and FieldList == pcddefaultvalue:
1803                 IsArray = IsFieldValueAnArray(FieldList)
1804                 if IsArray:
1805                     try:
1806                         FieldList = ValueExpressionEx(FieldList, TAB_VOID)(True)
1807                     except BadExpression:
1808                         EdkLogger.error("Build", FORMAT_INVALID, "Invalid value format for %s.%s, from DSC: %s" %
1809                                         (Pcd.TokenSpaceGuidCName, Pcd.TokenCName, FieldList))
1810                 Value, ValueSize = ParseFieldValue (FieldList)
1811
1812                 if (SkuName, DefaultStoreName) == (TAB_DEFAULT, TAB_DEFAULT_STORES_DEFAULT):
1813                     if isinstance(Value, str):
1814                         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)
1815                     elif IsArray:
1816                     #
1817                     # Use memcpy() to copy value into field
1818                     #
1819                         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)
1820                         CApp = CApp + '  memcpy (Pcd, Value, %d);\n' % (ValueSize)
1821                 else:
1822                     if isinstance(Value, str):
1823                         CApp = CApp + '  Pcd = %s; // From DSC Default Value %s\n' % (Value, Pcd.DscRawValue.get(SkuName, {}).get(DefaultStoreName))
1824                     elif IsArray:
1825                     #
1826                     # Use memcpy() to copy value into field
1827                     #
1828                         CApp = CApp + '  Value     = %s; // From DSC Default Value %s\n' % (DscBuildData.IntToCString(Value, ValueSize), Pcd.DscRawValue.get(SkuName, {}).get(DefaultStoreName))
1829                         CApp = CApp + '  memcpy (Pcd, Value, %d);\n' % (ValueSize)
1830                 continue
1831             if (SkuName, DefaultStoreName) == (TAB_DEFAULT, TAB_DEFAULT_STORES_DEFAULT) or (( (SkuName, '') not in Pcd.ValueChain) and ( (SkuName, DefaultStoreName) not in Pcd.ValueChain )):
1832                 for FieldName in FieldList:
1833                     IsArray = IsFieldValueAnArray(FieldList[FieldName][0])
1834                     if IsArray:
1835                         try:
1836                             FieldList[FieldName][0] = ValueExpressionEx(FieldList[FieldName][0], TAB_VOID, self._GuidDict)(True)
1837                         except BadExpression:
1838                             EdkLogger.error('Build', FORMAT_INVALID, "Invalid value format for %s. From %s Line %d " %
1839                                             (".".join((Pcd.TokenSpaceGuidCName, Pcd.TokenCName, FieldName)), FieldList[FieldName][1], FieldList[FieldName][2]))
1840                     try:
1841                         Value, ValueSize = ParseFieldValue (FieldList[FieldName][0])
1842                     except Exception:
1843                         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]))
1844                     if isinstance(Value, str):
1845                         CApp = CApp + '  Pcd->%s = %s; // From %s Line %d Value %s\n' % (FieldName, Value, FieldList[FieldName][1], FieldList[FieldName][2], FieldList[FieldName][0])
1846                     elif IsArray:
1847                     #
1848                     # Use memcpy() to copy value into field
1849                     #
1850                         CApp = CApp + '  FieldSize = __FIELD_SIZE(%s, %s);\n' % (Pcd.DatumType, FieldName)
1851                         CApp = CApp + '  Value     = %s; // From %s Line %d Value %s\n' % (DscBuildData.IntToCString(Value, ValueSize), FieldList[FieldName][1], FieldList[FieldName][2], FieldList[FieldName][0])
1852                         CApp = CApp + '  memcpy (&Pcd->%s, Value, (FieldSize > 0 && FieldSize < %d) ? FieldSize : %d);\n' % (FieldName, ValueSize, ValueSize)
1853                     else:
1854                         if ValueSize > 4:
1855                             CApp = CApp + '  Pcd->%s = %dULL; // From %s Line %d Value %s\n' % (FieldName, Value, FieldList[FieldName][1], FieldList[FieldName][2], FieldList[FieldName][0])
1856                         else:
1857                             CApp = CApp + '  Pcd->%s = %d; // From %s Line %d Value %s\n' % (FieldName, Value, FieldList[FieldName][1], FieldList[FieldName][2], FieldList[FieldName][0])
1858         CApp = CApp + "}\n"
1859         return CApp
1860
1861     @staticmethod
1862     def GenerateInitValueStatement(Pcd, SkuName, DefaultStoreName):
1863         CApp = '  Assign_%s_%s_%s_%s_Value(Pcd);\n' % (Pcd.TokenSpaceGuidCName, Pcd.TokenCName, SkuName, DefaultStoreName)
1864         return CApp
1865
1866     def GenerateCommandLineValue(self, Pcd):
1867         CApp = "// Value in CommandLine\n"
1868         CApp = CApp + "void Assign_%s_%s_CommandLine_Value(%s *Pcd){\n" % (Pcd.TokenSpaceGuidCName, Pcd.TokenCName, Pcd.DatumType)
1869         CApp = CApp + '  UINT32  FieldSize;\n'
1870         CApp = CApp + '  CHAR8   *Value;\n'
1871
1872         pcddefaultvalue = Pcd.PcdValueFromComm
1873         for FieldList in [pcddefaultvalue, Pcd.PcdFieldValueFromComm]:
1874             if not FieldList:
1875                 continue
1876             if pcddefaultvalue and FieldList == pcddefaultvalue:
1877                 IsArray = IsFieldValueAnArray(FieldList)
1878                 if IsArray:
1879                     try:
1880                         FieldList = ValueExpressionEx(FieldList, TAB_VOID)(True)
1881                     except BadExpression:
1882                         EdkLogger.error("Build", FORMAT_INVALID, "Invalid value format for %s.%s, from Command: %s" %
1883                                         (Pcd.TokenSpaceGuidCName, Pcd.TokenCName, FieldList))
1884                 Value, ValueSize = ParseFieldValue (FieldList)
1885
1886                 if isinstance(Value, str):
1887                     CApp = CApp + '  Pcd = %s; // From Command Line \n' % (Value)
1888                 elif IsArray:
1889                 #
1890                 # Use memcpy() to copy value into field
1891                 #
1892                     CApp = CApp + '  Value     = %s; // From Command Line.\n' % (DscBuildData.IntToCString(Value, ValueSize))
1893                     CApp = CApp + '  memcpy (Pcd, Value, %d);\n' % (ValueSize)
1894                 continue
1895             for FieldName in FieldList:
1896                 IsArray = IsFieldValueAnArray(FieldList[FieldName][0])
1897                 if IsArray:
1898                     try:
1899                         FieldList[FieldName][0] = ValueExpressionEx(FieldList[FieldName][0], TAB_VOID, self._GuidDict)(True)
1900                     except BadExpression:
1901                         EdkLogger.error('Build', FORMAT_INVALID, "Invalid value format for %s. From %s Line %d " %
1902                                         (".".join((Pcd.TokenSpaceGuidCName, Pcd.TokenCName, FieldName)), FieldList[FieldName][1], FieldList[FieldName][2]))
1903                     except:
1904                         print("error")
1905                 try:
1906                     Value, ValueSize = ParseFieldValue (FieldList[FieldName][0])
1907                 except Exception:
1908                     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]))
1909                 if isinstance(Value, str):
1910                     CApp = CApp + '  Pcd->%s = %s; // From %s Line %d Value %s\n' % (FieldName, Value, FieldList[FieldName][1], FieldList[FieldName][2], FieldList[FieldName][0])
1911                 elif IsArray:
1912                 #
1913                 # Use memcpy() to copy value into field
1914                 #
1915                     CApp = CApp + '  FieldSize = __FIELD_SIZE(%s, %s);\n' % (Pcd.DatumType, FieldName)
1916                     CApp = CApp + '  Value     = %s; // From %s Line %d Value %s\n' % (DscBuildData.IntToCString(Value, ValueSize), FieldList[FieldName][1], FieldList[FieldName][2], FieldList[FieldName][0])
1917                     CApp = CApp + '  memcpy (&Pcd->%s, Value, (FieldSize > 0 && FieldSize < %d) ? FieldSize : %d);\n' % (FieldName, ValueSize, ValueSize)
1918                 else:
1919                     if ValueSize > 4:
1920                         CApp = CApp + '  Pcd->%s = %dULL; // From %s Line %d Value %s\n' % (FieldName, Value, FieldList[FieldName][1], FieldList[FieldName][2], FieldList[FieldName][0])
1921                     else:
1922                         CApp = CApp + '  Pcd->%s = %d; // From %s Line %d Value %s\n' % (FieldName, Value, FieldList[FieldName][1], FieldList[FieldName][2], FieldList[FieldName][0])
1923         CApp = CApp + "}\n"
1924         return CApp
1925
1926     @staticmethod
1927     def GenerateCommandLineValueStatement(Pcd):
1928         CApp = '  Assign_%s_%s_CommandLine_Value(Pcd);\n' % (Pcd.TokenSpaceGuidCName, Pcd.TokenCName)
1929         return CApp
1930     def GenerateFdfValue(self,Pcd):
1931         CApp = "// Value in Fdf\n"
1932         CApp = CApp + "void Assign_%s_%s_Fdf_Value(%s *Pcd){\n" % (Pcd.TokenSpaceGuidCName, Pcd.TokenCName,Pcd.DatumType)
1933         CApp = CApp + '  UINT32  FieldSize;\n'
1934         CApp = CApp + '  CHAR8   *Value;\n'
1935
1936         pcddefaultvalue = Pcd.PcdValueFromFdf
1937         for FieldList in [pcddefaultvalue,Pcd.PcdFieldValueFromFdf]:
1938             if not FieldList:
1939                 continue
1940             if pcddefaultvalue and FieldList == pcddefaultvalue:
1941                 IsArray = IsFieldValueAnArray(FieldList)
1942                 if IsArray:
1943                     try:
1944                         FieldList = ValueExpressionEx(FieldList, TAB_VOID)(True)
1945                     except BadExpression:
1946                         EdkLogger.error("Build", FORMAT_INVALID, "Invalid value format for %s.%s, from Fdf: %s" %
1947                                         (Pcd.TokenSpaceGuidCName, Pcd.TokenCName, FieldList))
1948                 Value, ValueSize = ParseFieldValue (FieldList)
1949
1950                 if isinstance(Value, str):
1951                     CApp = CApp + '  Pcd = %s; // From Fdf \n' % (Value)
1952                 elif IsArray:
1953                 #
1954                 # Use memcpy() to copy value into field
1955                 #
1956                     CApp = CApp + '  Value     = %s; // From Fdf .\n' % (DscBuildData.IntToCString(Value, ValueSize))
1957                     CApp = CApp + '  memcpy (Pcd, Value, %d);\n' % (ValueSize)
1958                 continue
1959             for FieldName in FieldList:
1960                 IsArray = IsFieldValueAnArray(FieldList[FieldName][0])
1961                 if IsArray:
1962                     try:
1963                         FieldList[FieldName][0] = ValueExpressionEx(FieldList[FieldName][0], TAB_VOID, self._GuidDict)(True)
1964                     except BadExpression:
1965                         EdkLogger.error('Build', FORMAT_INVALID, "Invalid value format for %s. From %s Line %d " %
1966                                         (".".join((Pcd.TokenSpaceGuidCName, Pcd.TokenCName, FieldName)), FieldList[FieldName][1], FieldList[FieldName][2]))
1967                     except:
1968                         print("error")
1969                 try:
1970                     Value, ValueSize = ParseFieldValue (FieldList[FieldName][0])
1971                 except Exception:
1972                     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]))
1973                 if isinstance(Value, str):
1974                     CApp = CApp + '  Pcd->%s = %s; // From %s Line %d Value %s\n' % (FieldName, Value, FieldList[FieldName][1], FieldList[FieldName][2], FieldList[FieldName][0])
1975                 elif IsArray:
1976                 #
1977                 # Use memcpy() to copy value into field
1978                 #
1979                     CApp = CApp + '  FieldSize = __FIELD_SIZE(%s, %s);\n' % (Pcd.DatumType, FieldName)
1980                     CApp = CApp + '  Value     = %s; // From %s Line %d Value %s\n' % (DscBuildData.IntToCString(Value, ValueSize), FieldList[FieldName][1], FieldList[FieldName][2], FieldList[FieldName][0])
1981                     CApp = CApp + '  memcpy (&Pcd->%s, Value, (FieldSize > 0 && FieldSize < %d) ? FieldSize : %d);\n' % (FieldName, ValueSize, ValueSize)
1982                 else:
1983                     if ValueSize > 4:
1984                         CApp = CApp + '  Pcd->%s = %dULL; // From %s Line %d Value %s\n' % (FieldName, Value, FieldList[FieldName][1], FieldList[FieldName][2], FieldList[FieldName][0])
1985                     else:
1986                         CApp = CApp + '  Pcd->%s = %d; // From %s Line %s Value %s\n' % (FieldName, Value, FieldList[FieldName][1], FieldList[FieldName][2], FieldList[FieldName][0])
1987         CApp = CApp + "}\n"
1988         return CApp
1989
1990     @staticmethod
1991     def GenerateFdfValueStatement(Pcd):
1992         CApp = '  Assign_%s_%s_Fdf_Value(Pcd);\n' % (Pcd.TokenSpaceGuidCName, Pcd.TokenCName)
1993         return CApp
1994
1995     def GenerateInitializeFunc(self, SkuName, DefaultStore, Pcd, InitByteValue, CApp):
1996         OverrideValues = {DefaultStore:""}
1997         if Pcd.SkuOverrideValues:
1998             OverrideValues = Pcd.SkuOverrideValues[SkuName]
1999         for DefaultStoreName in OverrideValues:
2000             CApp = CApp + 'void\n'
2001             CApp = CApp + 'Initialize_%s_%s_%s_%s(\n' % (SkuName, DefaultStoreName, Pcd.TokenSpaceGuidCName, Pcd.TokenCName)
2002             CApp = CApp + '  void\n'
2003             CApp = CApp + '  )\n'
2004             CApp = CApp + '{\n'
2005             CApp = CApp + '  UINT32  Size;\n'
2006             CApp = CApp + '  UINT32  FieldSize;\n'
2007             CApp = CApp + '  CHAR8   *Value;\n'
2008             CApp = CApp + '  UINT32  OriginalSize;\n'
2009             CApp = CApp + '  VOID    *OriginalPcd;\n'
2010             CApp = CApp + '  %s      *Pcd;  // From %s Line %d \n' % (Pcd.DatumType, Pcd.PkgPath, Pcd.PcdDefineLineNo)
2011             CApp = CApp + '\n'
2012
2013             if SkuName in Pcd.SkuInfoList:
2014                 DefaultValue = Pcd.SkuInfoList[SkuName].DefaultStoreDict.get(DefaultStoreName, Pcd.SkuInfoList[SkuName].HiiDefaultValue if Pcd.SkuInfoList[SkuName].HiiDefaultValue  else Pcd.SkuInfoList[SkuName].DefaultValue)
2015             else:
2016                 DefaultValue = Pcd.DefaultValue
2017             PcdDefaultValue = StringToArray(DefaultValue.strip())
2018
2019             InitByteValue += '%s.%s.%s.%s|%s|%s\n' % (SkuName, DefaultStoreName, Pcd.TokenSpaceGuidCName, Pcd.TokenCName, Pcd.DatumType, PcdDefaultValue)
2020
2021             #
2022             # Get current PCD value and size
2023             #
2024             CApp = CApp + '  OriginalPcd = PcdGetPtr (%s, %s, %s, %s, &OriginalSize);\n' % (SkuName, DefaultStoreName, Pcd.TokenSpaceGuidCName, Pcd.TokenCName)
2025
2026             #
2027             # Determine the size of the PCD.  For simple structures, sizeof(TYPE) provides
2028             # the correct value.  For structures with a flexible array member, the flexible
2029             # array member is detected, and the size is based on the highest index used with
2030             # the flexible array member.  The flexible array member must be the last field
2031             # in a structure.  The size formula for this case is:
2032             # OFFSET_OF(FlexbleArrayField) + sizeof(FlexibleArray[0]) * (HighestIndex + 1)
2033             #
2034             CApp = CApp + DscBuildData.GenerateSizeStatments(Pcd)
2035
2036             #
2037             # Allocate and zero buffer for the PCD
2038             # Must handle cases where current value is smaller, larger, or same size
2039             # Always keep that larger one as the current size
2040             #
2041             CApp = CApp + '  Size = (OriginalSize > Size ? OriginalSize : Size);\n'
2042             CApp = CApp + '  Pcd     = (%s *)malloc (Size);\n' % (Pcd.DatumType)
2043             CApp = CApp + '  memset (Pcd, 0, Size);\n'
2044
2045             #
2046             # Copy current PCD value into allocated buffer.
2047             #
2048             CApp = CApp + '  memcpy (Pcd, OriginalPcd, OriginalSize);\n'
2049
2050             #
2051             # Assign field values in PCD
2052             #
2053             CApp = CApp + DscBuildData.GenerateDefaultValueAssignStatement(Pcd)
2054             if Pcd.Type not in [self._PCD_TYPE_STRING_[MODEL_PCD_FIXED_AT_BUILD],
2055                         self._PCD_TYPE_STRING_[MODEL_PCD_PATCHABLE_IN_MODULE]]:
2056                 for skuname in self.SkuIdMgr.GetSkuChain(SkuName):
2057                     storeset = [DefaultStoreName] if DefaultStoreName == TAB_DEFAULT_STORES_DEFAULT else [TAB_DEFAULT_STORES_DEFAULT, DefaultStoreName]
2058                     for defaultstorenameitem in storeset:
2059                         CApp = CApp + "// SkuName: %s,  DefaultStoreName: %s \n" % (skuname, defaultstorenameitem)
2060                         CApp = CApp + DscBuildData.GenerateInitValueStatement(Pcd, skuname, defaultstorenameitem)
2061                     if skuname == SkuName:
2062                         break
2063             else:
2064                 CApp = CApp + "// SkuName: %s,  DefaultStoreName: STANDARD \n" % self.SkuIdMgr.SystemSkuId
2065                 CApp = CApp + DscBuildData.GenerateInitValueStatement(Pcd, self.SkuIdMgr.SystemSkuId, TAB_DEFAULT_STORES_DEFAULT)
2066             CApp = CApp + DscBuildData.GenerateFdfValueStatement(Pcd)
2067             CApp = CApp + DscBuildData.GenerateCommandLineValueStatement(Pcd)
2068             #
2069             # Set new PCD value and size
2070             #
2071             CApp = CApp + '  PcdSetPtr (%s, %s, %s, %s, Size, (UINT8 *)Pcd);\n' % (SkuName, DefaultStoreName, Pcd.TokenSpaceGuidCName, Pcd.TokenCName)
2072
2073             #
2074             # Free PCD
2075             #
2076             CApp = CApp + '  free (Pcd);\n'
2077             CApp = CApp + '}\n'
2078             CApp = CApp + '\n'
2079         return InitByteValue, CApp
2080
2081     def GenerateByteArrayValue (self, StructuredPcds):
2082         #
2083         # Generate/Compile/Run C application to determine if there are any flexible array members
2084         #
2085         if not StructuredPcds:
2086             return
2087
2088         InitByteValue = ""
2089         CApp = PcdMainCHeader
2090
2091         IncludeFiles = set()
2092         for PcdName in StructuredPcds:
2093             Pcd = StructuredPcds[PcdName]
2094             for IncludeFile in Pcd.StructuredPcdIncludeFile:
2095                 if IncludeFile not in IncludeFiles:
2096                     IncludeFiles.add(IncludeFile)
2097                     CApp = CApp + '#include <%s>\n' % (IncludeFile)
2098         CApp = CApp + '\n'
2099         for PcdName in StructuredPcds:
2100             Pcd = StructuredPcds[PcdName]
2101             CApp = CApp + self.GenerateSizeFunction(Pcd)
2102             CApp = CApp + self.GenerateDefaultValueAssignFunction(Pcd)
2103             CApp = CApp + self.GenerateFdfValue(Pcd)
2104             CApp = CApp + self.GenerateCommandLineValue(Pcd)
2105             if not Pcd.SkuOverrideValues or Pcd.Type in [self._PCD_TYPE_STRING_[MODEL_PCD_FIXED_AT_BUILD],
2106                         self._PCD_TYPE_STRING_[MODEL_PCD_PATCHABLE_IN_MODULE]]:
2107                 CApp = CApp + self.GenerateInitValueFunction(Pcd, self.SkuIdMgr.SystemSkuId, TAB_DEFAULT_STORES_DEFAULT)
2108             else:
2109                 for SkuName in self.SkuIdMgr.SkuOverrideOrder():
2110                     if SkuName not in Pcd.SkuOverrideValues:
2111                         continue
2112                     for DefaultStoreName in Pcd.SkuOverrideValues[SkuName]:
2113                         CApp = CApp + self.GenerateInitValueFunction(Pcd, SkuName, DefaultStoreName)
2114             if not Pcd.SkuOverrideValues or Pcd.Type in [self._PCD_TYPE_STRING_[MODEL_PCD_FIXED_AT_BUILD],
2115                         self._PCD_TYPE_STRING_[MODEL_PCD_PATCHABLE_IN_MODULE]]:
2116                 InitByteValue, CApp = self.GenerateInitializeFunc(self.SkuIdMgr.SystemSkuId, TAB_DEFAULT_STORES_DEFAULT, Pcd, InitByteValue, CApp)
2117             else:
2118                 for SkuName in self.SkuIdMgr.SkuOverrideOrder():
2119                     if SkuName not in Pcd.SkuOverrideValues:
2120                         continue
2121                     for DefaultStoreName in Pcd.DefaultStoreName:
2122                         Pcd = StructuredPcds[PcdName]
2123                         InitByteValue, CApp = self.GenerateInitializeFunc(SkuName, DefaultStoreName, Pcd, InitByteValue, CApp)
2124
2125         CApp = CApp + 'VOID\n'
2126         CApp = CApp + 'PcdEntryPoint(\n'
2127         CApp = CApp + '  VOID\n'
2128         CApp = CApp + '  )\n'
2129         CApp = CApp + '{\n'
2130         for Pcd in StructuredPcds.values():
2131             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]]:
2132                 CApp = CApp + '  Initialize_%s_%s_%s_%s();\n' % (self.SkuIdMgr.SystemSkuId, TAB_DEFAULT_STORES_DEFAULT, Pcd.TokenSpaceGuidCName, Pcd.TokenCName)
2133             else:
2134                 for SkuName in self.SkuIdMgr.SkuOverrideOrder():
2135                     if SkuName not in Pcd.SkuOverrideValues:
2136                         continue
2137                     for DefaultStoreName in Pcd.SkuOverrideValues[SkuName]:
2138                         CApp = CApp + '  Initialize_%s_%s_%s_%s();\n' % (SkuName, DefaultStoreName, Pcd.TokenSpaceGuidCName, Pcd.TokenCName)
2139         CApp = CApp + '}\n'
2140
2141         CApp = CApp + PcdMainCEntry + '\n'
2142
2143         if not os.path.exists(self.OutputPath):
2144             os.makedirs(self.OutputPath)
2145         CAppBaseFileName = os.path.join(self.OutputPath, PcdValueInitName)
2146         SaveFileOnChange(CAppBaseFileName + '.c', CApp, False)
2147
2148         MakeApp = PcdMakefileHeader
2149         if sys.platform == "win32":
2150             MakeApp = MakeApp + 'APPNAME = %s\n' % (PcdValueInitName) + 'OBJECTS = %s\%s.obj\n' % (self.OutputPath, PcdValueInitName) + 'INC = '
2151         else:
2152             MakeApp = MakeApp + PcdGccMakefile
2153             MakeApp = MakeApp + 'APPNAME = %s\n' % (PcdValueInitName) + 'OBJECTS = %s/%s.o\n' % (self.OutputPath, PcdValueInitName) + \
2154                       'include $(MAKEROOT)/Makefiles/app.makefile\n' + 'INCLUDE +='
2155
2156         IncSearchList = []
2157         PlatformInc = {}
2158         for Cache in self._Bdb._CACHE_.values():
2159             if Cache.MetaFile.Ext.lower() != '.dec':
2160                 continue
2161             if Cache.Includes:
2162                 if str(Cache.MetaFile.Path) not in PlatformInc:
2163                     PlatformInc[str(Cache.MetaFile.Path)] = []
2164                     PlatformInc[str(Cache.MetaFile.Path)].append (os.path.dirname(Cache.MetaFile.Path))
2165                     PlatformInc[str(Cache.MetaFile.Path)].extend (Cache.CommonIncludes)
2166
2167         PcdDependDEC = []
2168         for Pcd in StructuredPcds.values():
2169             for PackageDec in Pcd.PackageDecs:
2170                 Package = os.path.normpath(mws.join(GlobalData.gWorkspace, PackageDec))
2171                 if not os.path.exists(Package):
2172                     EdkLogger.error('Build', RESOURCE_NOT_AVAILABLE, "The dependent Package %s of PCD %s.%s is not exist." % (PackageDec, Pcd.TokenSpaceGuidCName, Pcd.TokenCName))
2173                 if Package not in PcdDependDEC:
2174                     PcdDependDEC.append(Package)
2175
2176         if PlatformInc and PcdDependDEC:
2177             for pkg in PcdDependDEC:
2178                 if pkg in PlatformInc:
2179                     for inc in PlatformInc[pkg]:
2180                         MakeApp += '-I'  + str(inc) + ' '
2181                         IncSearchList.append(inc)
2182         MakeApp = MakeApp + '\n'
2183
2184         CC_FLAGS = LinuxCFLAGS
2185         if sys.platform == "win32":
2186             CC_FLAGS = WindowsCFLAGS
2187         BuildOptions = {}
2188         for Options in self.BuildOptions:
2189             if Options[2] != EDKII_NAME:
2190                 continue
2191             Family = Options[0]
2192             if Family and Family != self.ToolChainFamily:
2193                 continue
2194             Target, Tag, Arch, Tool, Attr = Options[1].split("_")
2195             if Tool != 'CC':
2196                 continue
2197
2198             if Target == "*" or Target == self._Target:
2199                 if Tag == "*" or Tag == self._Toolchain:
2200                     if Arch == "*" or Arch == self.Arch:
2201                         if Tool not in BuildOptions:
2202                             BuildOptions[Tool] = {}
2203                         if Attr != "FLAGS" or Attr not in BuildOptions[Tool] or self.BuildOptions[Options].startswith('='):
2204                             BuildOptions[Tool][Attr] = self.BuildOptions[Options]
2205                         else:
2206                             # append options for the same tool except PATH
2207                             if Attr != 'PATH':
2208                                 BuildOptions[Tool][Attr] += " " + self.BuildOptions[Options]
2209                             else:
2210                                 BuildOptions[Tool][Attr] = self.BuildOptions[Options]
2211         if BuildOptions:
2212             for Tool in BuildOptions:
2213                 for Attr in BuildOptions[Tool]:
2214                     if Attr == "FLAGS":
2215                         Value = BuildOptions[Tool][Attr]
2216                         ValueList = Value.split()
2217                         if ValueList:
2218                             for Id, Item in enumerate(ValueList):
2219                                 if Item in ['-D', '/D', '-U', '/U']:
2220                                     CC_FLAGS += ' ' + Item
2221                                     if Id + 1 < len(ValueList):
2222                                         CC_FLAGS += ' ' + ValueList[Id + 1]
2223                                 elif Item.startswith(('-D', '/D', '-U', '/U')):
2224                                     CC_FLAGS += ' ' + Item
2225         MakeApp += CC_FLAGS
2226
2227         if sys.platform == "win32":
2228             MakeApp = MakeApp + PcdMakefileEnd
2229         MakeApp = MakeApp + '\n'
2230         IncludeFileFullPaths = []
2231         for includefile in IncludeFiles:
2232             for includepath in IncSearchList:
2233                 includefullpath = os.path.join(str(includepath), includefile)
2234                 if os.path.exists(includefullpath):
2235                     IncludeFileFullPaths.append(os.path.normpath(includefullpath))
2236                     break
2237         SearchPathList = []
2238         SearchPathList.append(os.path.normpath(mws.join(GlobalData.gWorkspace, "BaseTools/Source/C/Include")))
2239         SearchPathList.append(os.path.normpath(mws.join(GlobalData.gWorkspace, "BaseTools/Source/C/Common")))
2240         SearchPathList.extend(str(item) for item in IncSearchList)
2241         IncFileList = GetDependencyList(IncludeFileFullPaths, SearchPathList)
2242         for include_file in IncFileList:
2243             MakeApp += "$(OBJECTS) : %s\n" % include_file
2244         MakeFileName = os.path.join(self.OutputPath, 'Makefile')
2245         MakeApp += "$(OBJECTS) : %s\n" % MakeFileName
2246         SaveFileOnChange(MakeFileName, MakeApp, False)
2247
2248         InputValueFile = os.path.join(self.OutputPath, 'Input.txt')
2249         OutputValueFile = os.path.join(self.OutputPath, 'Output.txt')
2250         SaveFileOnChange(InputValueFile, InitByteValue, False)
2251
2252         PcdValueInitExe = PcdValueInitName
2253         if not sys.platform == "win32":
2254             PcdValueInitExe = os.path.join(os.getenv("EDK_TOOLS_PATH"), 'Source', 'C', 'bin', PcdValueInitName)
2255         else:
2256             PcdValueInitExe = os.path.join(os.getenv("EDK_TOOLS_PATH"), 'Bin', 'Win32', PcdValueInitName) +".exe"
2257
2258         Messages = ''
2259         if sys.platform == "win32":
2260             MakeCommand = 'nmake -f %s' % (MakeFileName)
2261             returncode, StdOut, StdErr = DscBuildData.ExecuteCommand (MakeCommand)
2262             Messages = StdOut
2263         else:
2264             MakeCommand = 'make -f %s' % (MakeFileName)
2265             returncode, StdOut, StdErr = DscBuildData.ExecuteCommand (MakeCommand)
2266             Messages = StdErr
2267         Messages = Messages.split('\n')
2268         MessageGroup = []
2269         if returncode != 0:
2270             CAppBaseFileName = os.path.join(self.OutputPath, PcdValueInitName)
2271             File = open (CAppBaseFileName + '.c', 'r')
2272             FileData = File.readlines()
2273             File.close()
2274             for Message in Messages:
2275                 if " error" in Message or "warning" in Message:
2276                     FileInfo = Message.strip().split('(')
2277                     if len (FileInfo) > 1:
2278                         FileName = FileInfo [0]
2279                         FileLine = FileInfo [1].split (')')[0]
2280                     else:
2281                         FileInfo = Message.strip().split(':')
2282                         FileName = FileInfo [0]
2283                         FileLine = FileInfo [1]
2284                     if FileLine.isdigit():
2285                         error_line = FileData[int (FileLine) - 1]
2286                         if r"//" in error_line:
2287                             c_line, dsc_line = error_line.split(r"//")
2288                         else:
2289                             dsc_line = error_line
2290                         message_itmes = Message.split(":")
2291                         Index = 0
2292                         if "PcdValueInit.c" not in Message:
2293                             if not MessageGroup:
2294                                 MessageGroup.append(Message)
2295                             break
2296                         else:
2297                             for item in message_itmes:
2298                                 if "PcdValueInit.c" in item:
2299                                     Index = message_itmes.index(item)
2300                                     message_itmes[Index] = dsc_line.strip()
2301                                     break
2302                             MessageGroup.append(":".join(message_itmes[Index:]).strip())
2303                             continue
2304                     else:
2305                         MessageGroup.append(Message)
2306             if MessageGroup:
2307                 EdkLogger.error("build", PCD_STRUCTURE_PCD_ERROR, "\n".join(MessageGroup) )
2308             else:
2309                 EdkLogger.error('Build', COMMAND_FAILURE, 'Can not execute command: %s' % MakeCommand)
2310
2311         if DscBuildData.NeedUpdateOutput(OutputValueFile, PcdValueInitExe, InputValueFile):
2312             Command = PcdValueInitExe + ' -i %s -o %s' % (InputValueFile, OutputValueFile)
2313             returncode, StdOut, StdErr = DscBuildData.ExecuteCommand (Command)
2314             if returncode != 0:
2315                 EdkLogger.warn('Build', COMMAND_FAILURE, 'Can not collect output from command: %s' % Command)
2316
2317         File = open (OutputValueFile, 'r')
2318         FileBuffer = File.readlines()
2319         File.close()
2320
2321         StructurePcdSet = []
2322         for Pcd in FileBuffer:
2323             PcdValue = Pcd.split ('|')
2324             PcdInfo = PcdValue[0].split ('.')
2325             StructurePcdSet.append((PcdInfo[0], PcdInfo[1], PcdInfo[2], PcdInfo[3], PcdValue[2].strip()))
2326         return StructurePcdSet
2327
2328     @staticmethod
2329     def NeedUpdateOutput(OutputFile, ValueCFile, StructureInput):
2330         if not os.path.exists(OutputFile):
2331             return True
2332         if os.stat(OutputFile).st_mtime <= os.stat(ValueCFile).st_mtime:
2333             return True
2334         if os.stat(OutputFile).st_mtime <= os.stat(StructureInput).st_mtime:
2335             return True
2336         return False
2337
2338     ## Retrieve dynamic PCD settings
2339     #
2340     #   @param  Type    PCD type
2341     #
2342     #   @retval a dict object contains settings of given PCD type
2343     #
2344     def _GetDynamicPcd(self, Type):
2345
2346
2347         Pcds = OrderedDict()
2348         #
2349         # tdict is a special dict kind of type, used for selecting correct
2350         # PCD settings for certain ARCH and SKU
2351         #
2352         PcdDict = tdict(True, 4)
2353         PcdList = []
2354         # Find out all possible PCD candidates for self._Arch
2355         RecordList = self._RawData[Type, self._Arch]
2356         AvailableSkuIdSet = copy.copy(self.SkuIds)
2357
2358
2359         for TokenSpaceGuid, PcdCName, Setting, Arch, SkuName, Dummy3, Dummy4, Dummy5 in RecordList:
2360             SkuName = SkuName.upper()
2361             SkuName = TAB_DEFAULT if SkuName == TAB_COMMON else SkuName
2362             if SkuName not in AvailableSkuIdSet:
2363                 EdkLogger.error('build', PARAMETER_INVALID, 'Sku %s is not defined in [SkuIds] section' % SkuName,
2364                                             File=self.MetaFile, Line=Dummy5)
2365             if "." not in TokenSpaceGuid:
2366                 PcdList.append((PcdCName, TokenSpaceGuid, SkuName, Dummy5))
2367             PcdDict[Arch, SkuName, PcdCName, TokenSpaceGuid] = Setting
2368
2369         # Remove redundant PCD candidates, per the ARCH and SKU
2370         for PcdCName, TokenSpaceGuid, SkuName, Dummy4 in PcdList:
2371
2372             Setting = PcdDict[self._Arch, SkuName, PcdCName, TokenSpaceGuid]
2373             if Setting is None:
2374                 continue
2375
2376             PcdValue, DatumType, MaxDatumSize = self._ValidatePcd(PcdCName, TokenSpaceGuid, Setting, Type, Dummy4)
2377             if MaxDatumSize:
2378                 if int(MaxDatumSize, 0) > 0xFFFF:
2379                     EdkLogger.error('build', FORMAT_INVALID, "The size value must not exceed the maximum value of 0xFFFF (UINT16) for %s." % ".".join((TokenSpaceGuid, PcdCName)),
2380                                     File=self.MetaFile, Line=Dummy4)
2381                 if int(MaxDatumSize, 0) < 0:
2382                     EdkLogger.error('build', FORMAT_INVALID, "The size value can't be set to negative value for %s." % ".".join((TokenSpaceGuid, PcdCName)),
2383                                     File=self.MetaFile, Line=Dummy4)
2384             SkuInfo = SkuInfoClass(SkuName, self.SkuIds[SkuName][0], '', '', '', '', '', PcdValue)
2385             if (PcdCName, TokenSpaceGuid) in Pcds:
2386                 pcdObject = Pcds[PcdCName, TokenSpaceGuid]
2387                 pcdObject.SkuInfoList[SkuName] = SkuInfo
2388                 if MaxDatumSize.strip():
2389                     CurrentMaxSize = int(MaxDatumSize.strip(), 0)
2390                 else:
2391                     CurrentMaxSize = 0
2392                 if pcdObject.MaxDatumSize:
2393                     PcdMaxSize = int(pcdObject.MaxDatumSize, 0)
2394                 else:
2395                     PcdMaxSize = 0
2396                 if CurrentMaxSize > PcdMaxSize:
2397                     pcdObject.MaxDatumSize = str(CurrentMaxSize)
2398             else:
2399                 Pcds[PcdCName, TokenSpaceGuid] = PcdClassObject(
2400                                                     PcdCName,
2401                                                     TokenSpaceGuid,
2402                                                     self._PCD_TYPE_STRING_[Type],
2403                                                     DatumType,
2404                                                     PcdValue,
2405                                                     '',
2406                                                     MaxDatumSize,
2407                                                     {SkuName : SkuInfo},
2408                                                     False,
2409                                                     None,
2410                                                     IsDsc=True)
2411
2412         for pcd in Pcds.values():
2413             pcdDecObject = self._DecPcds[pcd.TokenCName, pcd.TokenSpaceGuidCName]
2414             # Only fix the value while no value provided in DSC file.
2415             for sku in pcd.SkuInfoList.values():
2416                 if not sku.DefaultValue:
2417                     sku.DefaultValue = pcdDecObject.DefaultValue
2418             if TAB_DEFAULT not in pcd.SkuInfoList and TAB_COMMON not in pcd.SkuInfoList:
2419                 valuefromDec = pcdDecObject.DefaultValue
2420                 SkuInfo = SkuInfoClass(TAB_DEFAULT, '0', '', '', '', '', '', valuefromDec)
2421                 pcd.SkuInfoList[TAB_DEFAULT] = SkuInfo
2422             elif TAB_DEFAULT not in pcd.SkuInfoList and TAB_COMMON in pcd.SkuInfoList:
2423                 pcd.SkuInfoList[TAB_DEFAULT] = pcd.SkuInfoList[TAB_COMMON]
2424                 del pcd.SkuInfoList[TAB_COMMON]
2425             elif TAB_DEFAULT in pcd.SkuInfoList and TAB_COMMON in pcd.SkuInfoList:
2426                 del pcd.SkuInfoList[TAB_COMMON]
2427
2428         map(self.FilterSkuSettings, Pcds.values())
2429
2430         return Pcds
2431
2432     def FilterSkuSettings(self, PcdObj):
2433
2434         if self.SkuIdMgr.SkuUsageType == self.SkuIdMgr.SINGLE:
2435             if TAB_DEFAULT in PcdObj.SkuInfoList and self.SkuIdMgr.SystemSkuId not in PcdObj.SkuInfoList:
2436                 PcdObj.SkuInfoList[self.SkuIdMgr.SystemSkuId] = PcdObj.SkuInfoList[TAB_DEFAULT]
2437             PcdObj.SkuInfoList = {TAB_DEFAULT:PcdObj.SkuInfoList[self.SkuIdMgr.SystemSkuId]}
2438             PcdObj.SkuInfoList[TAB_DEFAULT].SkuIdName = TAB_DEFAULT
2439             PcdObj.SkuInfoList[TAB_DEFAULT].SkuId = '0'
2440
2441         elif self.SkuIdMgr.SkuUsageType == self.SkuIdMgr.DEFAULT:
2442             PcdObj.SkuInfoList = {TAB_DEFAULT:PcdObj.SkuInfoList[TAB_DEFAULT]}
2443
2444         return PcdObj
2445
2446     @staticmethod
2447     def CompareVarAttr(Attr1, Attr2):
2448         if not Attr1 or not Attr2:  # for empty string
2449             return True
2450         Attr1s = [attr.strip() for attr in Attr1.split(",")]
2451         Attr1Set = set(Attr1s)
2452         Attr2s = [attr.strip() for attr in Attr2.split(",")]
2453         Attr2Set = set(Attr2s)
2454         if Attr2Set == Attr1Set:
2455             return True
2456         else:
2457             return False
2458
2459     def CopyDscRawValue(self, Pcd):
2460         if Pcd.DscRawValue is None:
2461             Pcd.DscRawValue = dict()
2462         if Pcd.Type in [self._PCD_TYPE_STRING_[MODEL_PCD_FIXED_AT_BUILD], self._PCD_TYPE_STRING_[MODEL_PCD_PATCHABLE_IN_MODULE]]:
2463             if self.SkuIdMgr.SystemSkuId not in Pcd.DscRawValue:
2464                 Pcd.DscRawValue[self.SkuIdMgr.SystemSkuId] = {}
2465             Pcd.DscRawValue[self.SkuIdMgr.SystemSkuId][TAB_DEFAULT_STORES_DEFAULT] = Pcd.DefaultValue
2466         for skuname in Pcd.SkuInfoList:
2467             Pcd.DscRawValue[skuname] = {}
2468             if Pcd.Type in [self._PCD_TYPE_STRING_[MODEL_PCD_DYNAMIC_HII], self._PCD_TYPE_STRING_[MODEL_PCD_DYNAMIC_EX_HII]]:
2469                 for defaultstore in Pcd.SkuInfoList[skuname].DefaultStoreDict:
2470                     Pcd.DscRawValue[skuname][defaultstore] = Pcd.SkuInfoList[skuname].DefaultStoreDict[defaultstore]
2471             else:
2472                 Pcd.DscRawValue[skuname][TAB_DEFAULT_STORES_DEFAULT] = Pcd.SkuInfoList[skuname].DefaultValue
2473     def CompletePcdValues(self, PcdSet):
2474         Pcds = {}
2475         DefaultStoreObj = DefaultStore(self._GetDefaultStores())
2476         SkuIds = {skuname:skuid for skuname, skuid in self.SkuIdMgr.AvailableSkuIdSet.items() if skuname != TAB_COMMON}
2477         DefaultStores = set(storename for pcdobj in PcdSet.values() for skuobj in pcdobj.SkuInfoList.values() for storename in skuobj.DefaultStoreDict)
2478         for PcdCName, TokenSpaceGuid in PcdSet:
2479             PcdObj = PcdSet[(PcdCName, TokenSpaceGuid)]
2480             self.CopyDscRawValue(PcdObj)
2481             if PcdObj.Type not in [self._PCD_TYPE_STRING_[MODEL_PCD_DYNAMIC_DEFAULT],
2482                         self._PCD_TYPE_STRING_[MODEL_PCD_DYNAMIC_HII],
2483                         self._PCD_TYPE_STRING_[MODEL_PCD_DYNAMIC_VPD],
2484                         self._PCD_TYPE_STRING_[MODEL_PCD_DYNAMIC_EX_DEFAULT],
2485                         self._PCD_TYPE_STRING_[MODEL_PCD_DYNAMIC_EX_HII],
2486                         self._PCD_TYPE_STRING_[MODEL_PCD_DYNAMIC_EX_VPD]]:
2487                 Pcds[PcdCName, TokenSpaceGuid]= PcdObj
2488                 continue
2489             PcdType = PcdObj.Type
2490             if PcdType in [self._PCD_TYPE_STRING_[MODEL_PCD_DYNAMIC_HII], self._PCD_TYPE_STRING_[MODEL_PCD_DYNAMIC_EX_HII]]:
2491                 for skuid in PcdObj.SkuInfoList:
2492                     skuobj = PcdObj.SkuInfoList[skuid]
2493                     mindefaultstorename = DefaultStoreObj.GetMin(set(defaultstorename for defaultstorename in skuobj.DefaultStoreDict))
2494                     for defaultstorename in DefaultStores:
2495                         if defaultstorename not in skuobj.DefaultStoreDict:
2496                             skuobj.DefaultStoreDict[defaultstorename] = copy.deepcopy(skuobj.DefaultStoreDict[mindefaultstorename])
2497                     skuobj.HiiDefaultValue = skuobj.DefaultStoreDict[mindefaultstorename]
2498             for skuname, skuid in SkuIds.items():
2499                 if skuname not in PcdObj.SkuInfoList:
2500                     nextskuid = self.SkuIdMgr.GetNextSkuId(skuname)
2501                     while nextskuid not in PcdObj.SkuInfoList:
2502                         nextskuid = self.SkuIdMgr.GetNextSkuId(nextskuid)
2503                     PcdObj.SkuInfoList[skuname] = copy.deepcopy(PcdObj.SkuInfoList[nextskuid])
2504                     PcdObj.SkuInfoList[skuname].SkuId = skuid
2505                     PcdObj.SkuInfoList[skuname].SkuIdName = skuname
2506             if PcdType in [self._PCD_TYPE_STRING_[MODEL_PCD_DYNAMIC_HII], self._PCD_TYPE_STRING_[MODEL_PCD_DYNAMIC_EX_HII]]:
2507                 PcdObj.DefaultValue = PcdObj.SkuInfoList.values()[0].HiiDefaultValue if self.SkuIdMgr.SkuUsageType == self.SkuIdMgr.SINGLE else PcdObj.SkuInfoList[TAB_DEFAULT].HiiDefaultValue
2508             Pcds[PcdCName, TokenSpaceGuid]= PcdObj
2509         return Pcds
2510     ## Retrieve dynamic HII PCD settings
2511     #
2512     #   @param  Type    PCD type
2513     #
2514     #   @retval a dict object contains settings of given PCD type
2515     #
2516     def _GetDynamicHiiPcd(self, Type):
2517
2518         VariableAttrs = {}
2519
2520         Pcds = OrderedDict()
2521         #
2522         # tdict is a special dict kind of type, used for selecting correct
2523         # PCD settings for certain ARCH and SKU
2524         #
2525         PcdDict = tdict(True, 5)
2526         PcdSet = set()
2527         RecordList = self._RawData[Type, self._Arch]
2528         # Find out all possible PCD candidates for self._Arch
2529         AvailableSkuIdSet = copy.copy(self.SkuIds)
2530         DefaultStoresDefine = self._GetDefaultStores()
2531
2532         for TokenSpaceGuid, PcdCName, Setting, Arch, SkuName, DefaultStore, Dummy4, Dummy5 in RecordList:
2533             SkuName = SkuName.upper()
2534             SkuName = TAB_DEFAULT if SkuName == TAB_COMMON else SkuName
2535             DefaultStore = DefaultStore.upper()
2536             if DefaultStore == TAB_COMMON:
2537                 DefaultStore = TAB_DEFAULT_STORES_DEFAULT
2538             if SkuName not in AvailableSkuIdSet:
2539                 EdkLogger.error('build', PARAMETER_INVALID, 'Sku %s is not defined in [SkuIds] section' % SkuName,
2540                                             File=self.MetaFile, Line=Dummy5)
2541             if DefaultStore not in DefaultStoresDefine:
2542                 EdkLogger.error('build', PARAMETER_INVALID, 'DefaultStores %s is not defined in [DefaultStores] section' % DefaultStore,
2543                                             File=self.MetaFile, Line=Dummy5)
2544             if "." not in TokenSpaceGuid:
2545                 PcdSet.add((PcdCName, TokenSpaceGuid, SkuName, DefaultStore, Dummy5))
2546             PcdDict[Arch, SkuName, PcdCName, TokenSpaceGuid, DefaultStore] = Setting
2547
2548
2549         # Remove redundant PCD candidates, per the ARCH and SKU
2550         for PcdCName, TokenSpaceGuid, SkuName, DefaultStore, Dummy4 in PcdSet:
2551
2552             Setting = PcdDict[self._Arch, SkuName, PcdCName, TokenSpaceGuid, DefaultStore]
2553             if Setting is None:
2554                 continue
2555             VariableName, VariableGuid, VariableOffset, DefaultValue, VarAttribute = self._ValidatePcd(PcdCName, TokenSpaceGuid, Setting, Type, Dummy4)
2556
2557             rt, Msg = VariableAttributes.ValidateVarAttributes(VarAttribute)
2558             if not rt:
2559                 EdkLogger.error("build", PCD_VARIABLE_ATTRIBUTES_ERROR, "Variable attributes settings for %s is incorrect.\n %s" % (".".join((TokenSpaceGuid, PcdCName)), Msg),
2560                         ExtraData="[%s]" % VarAttribute)
2561             ExceedMax = False
2562             FormatCorrect = True
2563             if VariableOffset.isdigit():
2564                 if int(VariableOffset, 10) > 0xFFFF:
2565                     ExceedMax = True
2566             elif variablePattern.match(VariableOffset):
2567                 if int(VariableOffset, 16) > 0xFFFF:
2568                     ExceedMax = True
2569             # For Offset written in "A.B"
2570             elif VariableOffset.find('.') > -1:
2571                 VariableOffsetList = VariableOffset.split(".")
2572                 if not (len(VariableOffsetList) == 2
2573                         and IsValidWord(VariableOffsetList[0])
2574                         and IsValidWord(VariableOffsetList[1])):
2575                     FormatCorrect = False
2576             else:
2577                 FormatCorrect = False
2578             if not FormatCorrect:
2579                 EdkLogger.error('Build', FORMAT_INVALID, "Invalid syntax or format of the variable offset value is incorrect for %s." % ".".join((TokenSpaceGuid, PcdCName)))
2580
2581             if ExceedMax:
2582                 EdkLogger.error('Build', OPTION_VALUE_INVALID, "The variable offset value must not exceed the maximum value of 0xFFFF (UINT16) for %s." % ".".join((TokenSpaceGuid, PcdCName)))
2583             if (VariableName, VariableGuid) not in VariableAttrs:
2584                 VariableAttrs[(VariableName, VariableGuid)] = VarAttribute
2585             else:
2586                 if not DscBuildData.CompareVarAttr(VariableAttrs[(VariableName, VariableGuid)], VarAttribute):
2587                     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)]))
2588
2589             pcdDecObject = self._DecPcds[PcdCName, TokenSpaceGuid]
2590             if (PcdCName, TokenSpaceGuid) in Pcds:
2591                 pcdObject = Pcds[PcdCName, TokenSpaceGuid]
2592                 if SkuName in pcdObject.SkuInfoList:
2593                     Skuitem = pcdObject.SkuInfoList[SkuName]
2594                     Skuitem.DefaultStoreDict.update({DefaultStore:DefaultValue})
2595                 else:
2596                     SkuInfo = SkuInfoClass(SkuName, self.SkuIds[SkuName][0], VariableName, VariableGuid, VariableOffset, DefaultValue, VariableAttribute=VarAttribute, DefaultStore={DefaultStore:DefaultValue})
2597                     pcdObject.SkuInfoList[SkuName] = SkuInfo
2598             else:
2599                 SkuInfo = SkuInfoClass(SkuName, self.SkuIds[SkuName][0], VariableName, VariableGuid, VariableOffset, DefaultValue, VariableAttribute=VarAttribute, DefaultStore={DefaultStore:DefaultValue})
2600                 Pcds[PcdCName, TokenSpaceGuid] = PcdClassObject(
2601                                                 PcdCName,
2602                                                 TokenSpaceGuid,
2603                                                 self._PCD_TYPE_STRING_[Type],
2604                                                 '',
2605                                                 DefaultValue,
2606                                                 '',
2607                                                 '',
2608                                                 {SkuName : SkuInfo},
2609                                                 False,
2610                                                 None,
2611                                                 pcdDecObject.validateranges,
2612                                                 pcdDecObject.validlists,
2613                                                 pcdDecObject.expressions,
2614                                                 IsDsc=True)
2615
2616
2617         for pcd in Pcds.values():
2618             SkuInfoObj = pcd.SkuInfoList.values()[0]
2619             pcdDecObject = self._DecPcds[pcd.TokenCName, pcd.TokenSpaceGuidCName]
2620             pcd.DatumType = pcdDecObject.DatumType
2621             # Only fix the value while no value provided in DSC file.
2622             for sku in pcd.SkuInfoList.values():
2623                 if (sku.HiiDefaultValue == "" or sku.HiiDefaultValue is None):
2624                     sku.HiiDefaultValue = pcdDecObject.DefaultValue
2625                     for default_store in sku.DefaultStoreDict:
2626                         sku.DefaultStoreDict[default_store]=pcdDecObject.DefaultValue
2627                     pcd.DefaultValue = pcdDecObject.DefaultValue
2628             if TAB_DEFAULT not in pcd.SkuInfoList and TAB_COMMON not in pcd.SkuInfoList:
2629                 valuefromDec = pcdDecObject.DefaultValue
2630                 SkuInfo = SkuInfoClass(TAB_DEFAULT, '0', SkuInfoObj.VariableName, SkuInfoObj.VariableGuid, SkuInfoObj.VariableOffset, valuefromDec, VariableAttribute=SkuInfoObj.VariableAttribute, DefaultStore={DefaultStore:valuefromDec})
2631                 pcd.SkuInfoList[TAB_DEFAULT] = SkuInfo
2632             elif TAB_DEFAULT not in pcd.SkuInfoList and TAB_COMMON in pcd.SkuInfoList:
2633                 pcd.SkuInfoList[TAB_DEFAULT] = pcd.SkuInfoList[TAB_COMMON]
2634                 del pcd.SkuInfoList[TAB_COMMON]
2635             elif TAB_DEFAULT in pcd.SkuInfoList and TAB_COMMON in pcd.SkuInfoList:
2636                 del pcd.SkuInfoList[TAB_COMMON]
2637
2638             if pcd.MaxDatumSize.strip():
2639                 MaxSize = int(pcd.MaxDatumSize, 0)
2640             else:
2641                 MaxSize = 0
2642             if pcd.DatumType not in TAB_PCD_NUMERIC_TYPES:
2643                 for (_, skuobj) in pcd.SkuInfoList.items():
2644                     datalen = 0
2645                     skuobj.HiiDefaultValue = StringToArray(skuobj.HiiDefaultValue)
2646                     datalen = len(skuobj.HiiDefaultValue.split(","))
2647                     if datalen > MaxSize:
2648                         MaxSize = datalen
2649                     for defaultst in skuobj.DefaultStoreDict:
2650                         skuobj.DefaultStoreDict[defaultst] = StringToArray(skuobj.DefaultStoreDict[defaultst])
2651                 pcd.DefaultValue = StringToArray(pcd.DefaultValue)
2652                 pcd.MaxDatumSize = str(MaxSize)
2653         rt, invalidhii = DscBuildData.CheckVariableNameAssignment(Pcds)
2654         if not rt:
2655             invalidpcd = ",".join(invalidhii)
2656             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)
2657
2658         map(self.FilterSkuSettings, Pcds.values())
2659
2660         return Pcds
2661
2662     @staticmethod
2663     def CheckVariableNameAssignment(Pcds):
2664         invalidhii = []
2665         for pcdname in Pcds:
2666             pcd = Pcds[pcdname]
2667             varnameset = set(sku.VariableName for (skuid, sku) in pcd.SkuInfoList.items())
2668             if len(varnameset) > 1:
2669                 invalidhii.append(".".join((pcdname[1], pcdname[0])))
2670         if len(invalidhii):
2671             return False, invalidhii
2672         else:
2673             return True, []
2674     ## Retrieve dynamic VPD PCD settings
2675     #
2676     #   @param  Type    PCD type
2677     #
2678     #   @retval a dict object contains settings of given PCD type
2679     #
2680     def _GetDynamicVpdPcd(self, Type):
2681
2682
2683         Pcds = OrderedDict()
2684         #
2685         # tdict is a special dict kind of type, used for selecting correct
2686         # PCD settings for certain ARCH and SKU
2687         #
2688         PcdDict = tdict(True, 4)
2689         PcdList = []
2690
2691         # Find out all possible PCD candidates for self._Arch
2692         RecordList = self._RawData[Type, self._Arch]
2693         AvailableSkuIdSet = copy.copy(self.SkuIds)
2694
2695         for TokenSpaceGuid, PcdCName, Setting, Arch, SkuName, Dummy3, Dummy4, Dummy5 in RecordList:
2696             SkuName = SkuName.upper()
2697             SkuName = TAB_DEFAULT if SkuName == TAB_COMMON else SkuName
2698             if SkuName not in AvailableSkuIdSet:
2699                 EdkLogger.error('build', PARAMETER_INVALID, 'Sku %s is not defined in [SkuIds] section' % SkuName,
2700                                             File=self.MetaFile, Line=Dummy5)
2701             if "." not in TokenSpaceGuid:
2702                 PcdList.append((PcdCName, TokenSpaceGuid, SkuName, Dummy5))
2703             PcdDict[Arch, SkuName, PcdCName, TokenSpaceGuid] = Setting
2704
2705         # Remove redundant PCD candidates, per the ARCH and SKU
2706         for PcdCName, TokenSpaceGuid, SkuName, Dummy4 in PcdList:
2707             Setting = PcdDict[self._Arch, SkuName, PcdCName, TokenSpaceGuid]
2708             if Setting is None:
2709                 continue
2710             #
2711             # For the VOID* type, it can have optional data of MaxDatumSize and InitialValue
2712             # For the Integer & Boolean type, the optional data can only be InitialValue.
2713             # At this point, we put all the data into the PcdClssObject for we don't know the PCD's datumtype
2714             # until the DEC parser has been called.
2715             #
2716             VpdOffset, MaxDatumSize, InitialValue = self._ValidatePcd(PcdCName, TokenSpaceGuid, Setting, Type, Dummy4)
2717             if MaxDatumSize:
2718                 if int(MaxDatumSize, 0) > 0xFFFF:
2719                     EdkLogger.error('build', FORMAT_INVALID, "The size value must not exceed the maximum value of 0xFFFF (UINT16) for %s." % ".".join((TokenSpaceGuid, PcdCName)),
2720                                     File=self.MetaFile, Line=Dummy4)
2721                 if int(MaxDatumSize, 0) < 0:
2722                     EdkLogger.error('build', FORMAT_INVALID, "The size value can't be set to negative value for %s." % ".".join((TokenSpaceGuid, PcdCName)),
2723                                     File=self.MetaFile, Line=Dummy4)
2724             SkuInfo = SkuInfoClass(SkuName, self.SkuIds[SkuName][0], '', '', '', '', VpdOffset, InitialValue)
2725             if (PcdCName, TokenSpaceGuid) in Pcds:
2726                 pcdObject = Pcds[PcdCName, TokenSpaceGuid]
2727                 pcdObject.SkuInfoList[SkuName] = SkuInfo
2728                 if MaxDatumSize.strip():
2729                     CurrentMaxSize = int(MaxDatumSize.strip(), 0)
2730                 else:
2731                     CurrentMaxSize = 0
2732                 if pcdObject.MaxDatumSize:
2733                     PcdMaxSize = int(pcdObject.MaxDatumSize, 0)
2734                 else:
2735                     PcdMaxSize = 0
2736                 if CurrentMaxSize > PcdMaxSize:
2737                     pcdObject.MaxDatumSize = str(CurrentMaxSize)
2738             else:
2739                 Pcds[PcdCName, TokenSpaceGuid] = PcdClassObject(
2740                                                 PcdCName,
2741                                                 TokenSpaceGuid,
2742                                                 self._PCD_TYPE_STRING_[Type],
2743                                                 '',
2744                                                 InitialValue,
2745                                                 '',
2746                                                 MaxDatumSize,
2747                                                 {SkuName : SkuInfo},
2748                                                 False,
2749                                                 None,
2750                                                 IsDsc=True)
2751         for pcd in Pcds.values():
2752             SkuInfoObj = pcd.SkuInfoList.values()[0]
2753             pcdDecObject = self._DecPcds[pcd.TokenCName, pcd.TokenSpaceGuidCName]
2754             pcd.DatumType = pcdDecObject.DatumType
2755             # Only fix the value while no value provided in DSC file.
2756             for sku in pcd.SkuInfoList.values():
2757                 if not sku.DefaultValue:
2758                     sku.DefaultValue = pcdDecObject.DefaultValue
2759             if TAB_DEFAULT not in pcd.SkuInfoList and TAB_COMMON not in pcd.SkuInfoList:
2760                 valuefromDec = pcdDecObject.DefaultValue
2761                 SkuInfo = SkuInfoClass(TAB_DEFAULT, '0', '', '', '', '', SkuInfoObj.VpdOffset, valuefromDec)
2762                 pcd.SkuInfoList[TAB_DEFAULT] = SkuInfo
2763             elif TAB_DEFAULT not in pcd.SkuInfoList and TAB_COMMON in pcd.SkuInfoList:
2764                 pcd.SkuInfoList[TAB_DEFAULT] = pcd.SkuInfoList[TAB_COMMON]
2765                 del pcd.SkuInfoList[TAB_COMMON]
2766             elif TAB_DEFAULT in pcd.SkuInfoList and TAB_COMMON in pcd.SkuInfoList:
2767                 del pcd.SkuInfoList[TAB_COMMON]
2768
2769
2770         map(self.FilterSkuSettings, Pcds.values())
2771         return Pcds
2772
2773     ## Add external modules
2774     #
2775     #   The external modules are mostly those listed in FDF file, which don't
2776     # need "build".
2777     #
2778     #   @param  FilePath    The path of module description file
2779     #
2780     def AddModule(self, FilePath):
2781         FilePath = NormPath(FilePath)
2782         if FilePath not in self.Modules:
2783             Module = ModuleBuildClassObject()
2784             Module.MetaFile = FilePath
2785             self.Modules.append(Module)
2786
2787     def _GetToolChainFamily(self):
2788         self._ToolChainFamily = TAB_COMPILER_MSFT
2789         BuildConfigurationFile = os.path.normpath(os.path.join(GlobalData.gConfDirectory, "target.txt"))
2790         if os.path.isfile(BuildConfigurationFile) == True:
2791             TargetTxt      = TargetTxtClassObject()
2792             TargetTxt.LoadTargetTxtFile(BuildConfigurationFile)
2793             ToolDefinitionFile = TargetTxt.TargetTxtDictionary[DataType.TAB_TAT_DEFINES_TOOL_CHAIN_CONF]
2794             if ToolDefinitionFile == '':
2795                 ToolDefinitionFile = "tools_def.txt"
2796                 ToolDefinitionFile = os.path.normpath(mws.join(self.WorkspaceDir, 'Conf', ToolDefinitionFile))
2797             if os.path.isfile(ToolDefinitionFile) == True:
2798                 ToolDef        = ToolDefClassObject()
2799                 ToolDef.LoadToolDefFile(ToolDefinitionFile)
2800                 ToolDefinition = ToolDef.ToolsDefTxtDatabase
2801                 if TAB_TOD_DEFINES_FAMILY not in ToolDefinition \
2802                    or self._Toolchain not in ToolDefinition[TAB_TOD_DEFINES_FAMILY] \
2803                    or not ToolDefinition[TAB_TOD_DEFINES_FAMILY][self._Toolchain]:
2804                     self._ToolChainFamily = TAB_COMPILER_MSFT
2805                 else:
2806                     self._ToolChainFamily = ToolDefinition[TAB_TOD_DEFINES_FAMILY][self._Toolchain]
2807         return self._ToolChainFamily
2808
2809     ## Add external PCDs
2810     #
2811     #   The external PCDs are mostly those listed in FDF file to specify address
2812     # or offset information.
2813     #
2814     #   @param  Name    Name of the PCD
2815     #   @param  Guid    Token space guid of the PCD
2816     #   @param  Value   Value of the PCD
2817     #
2818     def AddPcd(self, Name, Guid, Value):
2819         if (Name, Guid) not in self.Pcds:
2820             self.Pcds[Name, Guid] = PcdClassObject(Name, Guid, '', '', '', '', '', {}, False, None)
2821         self.Pcds[Name, Guid].DefaultValue = Value
2822     @property
2823     def DecPcds(self):
2824         if self._DecPcds is None:
2825             FdfInfList = []
2826             if GlobalData.gFdfParser:
2827                 FdfInfList = GlobalData.gFdfParser.Profile.InfList
2828             PkgSet = set()
2829             for Inf in FdfInfList:
2830                 ModuleFile = PathClass(NormPath(Inf), GlobalData.gWorkspace, Arch=self._Arch)
2831                 if ModuleFile in self._Modules:
2832                     continue
2833                 ModuleData = self._Bdb[ModuleFile, self._Arch, self._Target, self._Toolchain]
2834                 PkgSet.update(ModuleData.Packages)
2835             self._DecPcds, self._GuidDict = GetDeclaredPcd(self, self._Bdb, self._Arch, self._Target, self._Toolchain, PkgSet)
2836         return self._DecPcds
2837     _Macros             = property(_GetMacros)
2838     Arch                = property(_GetArch)
2839     Platform            = property(_GetPlatformName)
2840     PlatformName        = property(_GetPlatformName)
2841     Guid                = property(_GetFileGuid)
2842     Version             = property(_GetVersion)
2843     DscSpecification    = property(_GetDscSpec)
2844     OutputDirectory     = property(_GetOutpuDir)
2845     SupArchList         = property(_GetSupArch)
2846     BuildTargets        = property(_GetBuildTarget)
2847     SkuName             = property(_GetSkuName, _SetSkuName)
2848     PcdInfoFlag         = property(_GetPcdInfoFlag)
2849     VarCheckFlag        = property(_GetVarCheckFlag)
2850     FlashDefinition     = property(_GetFdfFile)
2851     Prebuild            = property(_GetPrebuild)
2852     Postbuild           = property(_GetPostbuild)
2853     BuildNumber         = property(_GetBuildNumber)
2854     MakefileName        = property(_GetMakefileName)
2855     BsBaseAddress       = property(_GetBsBaseAddress)
2856     RtBaseAddress       = property(_GetRtBaseAddress)
2857     LoadFixAddress      = property(_GetLoadFixAddress)
2858     RFCLanguages        = property(_GetRFCLanguages)
2859     ISOLanguages        = property(_GetISOLanguages)
2860     VpdToolGuid         = property(_GetVpdToolGuid)
2861     SkuIds              = property(_GetSkuIds)
2862     Modules             = property(_GetModules)
2863     LibraryInstances    = property(_GetLibraryInstances)
2864     LibraryClasses      = property(_GetLibraryClasses)
2865     Pcds                = property(_GetPcds)
2866     BuildOptions        = property(_GetBuildOptions)
2867     ToolChainFamily     = property(_GetToolChainFamily)