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