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