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