Enhance build tool to support "UEFI_SPECIFICATION_VERSION" in INF spec. It also suppo...
authorqhuang8 <qhuang8@c2973edb-eda0-4c78-bc6a-9341b269661f>
Tue, 9 Feb 2010 10:16:00 +0000 (10:16 +0000)
committerqhuang8 <qhuang8@c2973edb-eda0-4c78-bc6a-9341b269661f>
Tue, 9 Feb 2010 10:16:00 +0000 (10:16 +0000)
git-svn-id: https://edk2-buildtools.svn.sourceforge.net/svnroot/edk2-buildtools/trunk/BaseTools@1856 c2973edb-eda0-4c78-bc6a-9341b269661f

Source/Python/AutoGen/GenC.py
Source/Python/Common/EdkIIWorkspaceBuild.py
Source/Python/Common/InfClassObject.py
Source/Python/Common/InfClassObjectLight.py
Source/Python/CommonDataClass/ModuleClass.py
Source/Python/Workspace/WorkspaceDatabase.py
Source/Python/msa2inf/ConvertModule.py
Source/Python/msa2inf/StoreInf.py

index 44046ae..a5d268c 100644 (file)
@@ -453,7 +453,7 @@ ${END}
 
 gSmmCoreEntryPointString = TemplateString("""
 ${BEGIN}
-const UINT32 _gUefiDriverRevision = ${EfiSpecVersion};
+const UINT32 _gUefiDriverRevision = ${UefiSpecVersion};
 const UINT32 _gDxeRevision = ${PiSpecVersion};
 
 EFI_STATUS
@@ -482,7 +482,7 @@ ${END}
 
 gDxeSmmEntryPointString = [
 TemplateString("""
-const UINT32 _gUefiDriverRevision = ${EfiSpecVersion};
+const UINT32 _gUefiDriverRevision = ${UefiSpecVersion};
 const UINT32 _gDxeRevision = ${PiSpecVersion};
 
 EFI_STATUS
@@ -497,7 +497,7 @@ ProcessModuleEntryPointList (
 }
 """),
 TemplateString("""
-const UINT32 _gUefiDriverRevision = ${EfiSpecVersion};
+const UINT32 _gUefiDriverRevision = ${UefiSpecVersion};
 const UINT32 _gDxeRevision = ${PiSpecVersion};
 
 static BASE_LIBRARY_JUMP_BUFFER  mJumpContext;
@@ -550,7 +550,7 @@ ${END}
 
 gUefiDriverEntryPointString = [
 TemplateString("""
-const UINT32 _gUefiDriverRevision = ${EfiSpecVersion};
+const UINT32 _gUefiDriverRevision = ${UefiSpecVersion};
 const UINT32 _gDxeRevision = ${PiSpecVersion};
 
 EFI_STATUS
@@ -564,7 +564,7 @@ ProcessModuleEntryPointList (
 }
 """),
 TemplateString("""
-const UINT32 _gUefiDriverRevision = ${EfiSpecVersion};
+const UINT32 _gUefiDriverRevision = ${UefiSpecVersion};
 const UINT32 _gDxeRevision = ${PiSpecVersion};
 
 ${BEGIN}
@@ -592,7 +592,7 @@ ExitDriver (
 }
 """),
 TemplateString("""
-const UINT32 _gUefiDriverRevision = ${EfiSpecVersion};
+const UINT32 _gUefiDriverRevision = ${UefiSpecVersion};
 const UINT32 _gDxeRevision = ${PiSpecVersion};
 
 EFI_STATUS
@@ -645,7 +645,7 @@ ${END}
 
 gUefiApplicationEntryPointString = [
 TemplateString("""
-const UINT32 _gUefiDriverRevision = ${EfiSpecVersion};
+const UINT32 _gUefiDriverRevision = ${UefiSpecVersion};
 
 EFI_STATUS
 EFIAPI
@@ -658,7 +658,7 @@ ProcessModuleEntryPointList (
 }
 """),
 TemplateString("""
-const UINT32 _gUefiDriverRevision = ${EfiSpecVersion};
+const UINT32 _gUefiDriverRevision = ${UefiSpecVersion};
 
 ${BEGIN}
 EFI_STATUS
@@ -685,7 +685,7 @@ ExitDriver (
 }
 """),
 TemplateString("""
-const UINT32 _gUefiDriverRevision = ${EfiSpecVersion};
+const UINT32 _gUefiDriverRevision = ${UefiSpecVersion};
 
 EFI_STATUS
 EFIAPI
@@ -1653,14 +1653,14 @@ def CreateModuleEntryPointCode(Info, AutoGenC, AutoGenH):
         PiSpecVersion = Info.Module.Specification['PI_SPECIFICATION_VERSION']
     else:
         PiSpecVersion = 0
-    if 'EFI_SPECIFICATION_VERSION' in Info.Module.Specification:
-        EfiSpecVersion = Info.Module.Specification['EFI_SPECIFICATION_VERSION']
+    if 'UEFI_SPECIFICATION_VERSION' in Info.Module.Specification:
+        UefiSpecVersion = Info.Module.Specification['UEFI_SPECIFICATION_VERSION']
     else:
-        EfiSpecVersion = 0
+        UefiSpecVersion = 0
     Dict = {
-        'Function'      :   Info.Module.ModuleEntryPointList,
-        'PiSpecVersion' :   PiSpecVersion,
-        'EfiSpecVersion':   EfiSpecVersion
+        'Function'       :   Info.Module.ModuleEntryPointList,
+        'PiSpecVersion'  :   PiSpecVersion,
+        'UefiSpecVersion':   UefiSpecVersion
     }
 
     if Info.ModuleType in ['PEI_CORE', 'DXE_CORE', 'SMM_CORE']:
index 82ab179..c33b9bf 100755 (executable)
@@ -1,7 +1,7 @@
 ## @file\r
 # This file is used to define each component of the build database\r
 #\r
-# Copyright (c) 2007 ~ 2008, Intel Corporation\r
+# Copyright (c) 2007 - 2010, Intel Corporation\r
 # All rights reserved. This program and the accompanying materials\r
 # are licensed and made available under the terms and conditions of the BSD License\r
 # which accompanies this distribution.  The full text of the license may be found at\r
@@ -748,7 +748,8 @@ class WorkspaceBuild(object):
                 #\r
                 Pb.Specification = ModuleHeader.Specification\r
                 Pb.Specification[TAB_INF_DEFINES_EDK_RELEASE_VERSION] = ModuleHeader.EdkReleaseVersion\r
-                Pb.Specification[TAB_INF_DEFINES_EFI_SPECIFICATION_VERSION] = ModuleHeader.EfiSpecificationVersion\r
+                Pb.Specification[TAB_INF_DEFINES_EFI_SPECIFICATION_VERSION] = ModuleHeader.UefiSpecificationVersion\r
+                Pb.Specification[TAB_INF_DEFINES_UEFI_SPECIFICATION_VERSION] = ModuleHeader.UefiSpecificationVersion\r
                 Pb.AutoGenVersion = int(ModuleHeader.InfVersion, 0)\r
 \r
                 #\r
index 27e67f3..7127cc5 100755 (executable)
@@ -1,7 +1,7 @@
 ## @file\r
 # This file is used to define each component of INF file\r
 #\r
-# Copyright (c) 2007, Intel Corporation\r
+# Copyright (c) 2007 - 2010, Intel Corporation\r
 # All rights reserved. This program and the accompanying materials\r
 # are licensed and made available under the terms and conditions of the BSD License\r
 # which accompanies this distribution.  The full text of the license may be found at\r
@@ -85,7 +85,8 @@ class InfHeader(ModuleHeaderClass):
         TAB_INF_DEFINES_BASE_NAME                   : "Name",\r
         TAB_INF_DEFINES_FILE_GUID                   : "Guid",\r
         TAB_INF_DEFINES_MODULE_TYPE                 : "ModuleType",\r
-        TAB_INF_DEFINES_EFI_SPECIFICATION_VERSION   : "EfiSpecificationVersion",\r
+        TAB_INF_DEFINES_EFI_SPECIFICATION_VERSION   : "UefiSpecificationVersion",\r
+        TAB_INF_DEFINES_UEFI_SPECIFICATION_VERSION  : "UefiSpecificationVersion",\r
         TAB_INF_DEFINES_EDK_RELEASE_VERSION         : "EdkReleaseVersion",\r
         #\r
         # Optional Fields\r
@@ -452,7 +453,7 @@ class Inf(InfObject):
             print 'Guid =', M.Header[Arch].Guid\r
             print 'Version =', M.Header[Arch].Version\r
             print 'InfVersion =', M.Header[Arch].InfVersion\r
-            print 'EfiSpecificationVersion =', M.Header[Arch].EfiSpecificationVersion\r
+            print 'UefiSpecificationVersion =', M.Header[Arch].UefiSpecificationVersion\r
             print 'EdkReleaseVersion =', M.Header[Arch].EdkReleaseVersion\r
             print 'ModuleType =', M.Header[Arch].ModuleType\r
             print 'BinaryModule =', M.Header[Arch].BinaryModule\r
index a655828..179b75e 100644 (file)
@@ -1,7 +1,7 @@
 ## @file\r
 # This file is used to define each component of INF file\r
 #\r
-# Copyright (c) 2007, Intel Corporation\r
+# Copyright (c) 2007 - 2010, Intel Corporation\r
 # All rights reserved. This program and the accompanying materials\r
 # are licensed and made available under the terms and conditions of the BSD License\r
 # which accompanies this distribution.  The full text of the license may be found at\r
@@ -71,7 +71,8 @@ class InfHeader(ModuleHeaderClass):
         TAB_INF_DEFINES_BASE_NAME                   : "Name",\r
         TAB_INF_DEFINES_FILE_GUID                   : "Guid",\r
         TAB_INF_DEFINES_MODULE_TYPE                 : "ModuleType",\r
-        TAB_INF_DEFINES_EFI_SPECIFICATION_VERSION   : "EfiSpecificationVersion",\r
+        TAB_INF_DEFINES_EFI_SPECIFICATION_VERSION   : "UefiSpecificationVersion",\r
+        TAB_INF_DEFINES_UEFI_SPECIFICATION_VERSION  : "UefiSpecificationVersion",\r
         TAB_INF_DEFINES_EDK_RELEASE_VERSION         : "EdkReleaseVersion",        \r
 \r
         # Optional Fields\r
@@ -583,7 +584,7 @@ class Inf(InfObject):
                     ModuleHeader.PcdIsDriver = Value\r
                 elif Name == TAB_INF_DEFINES_MODULE_TYPE:\r
                     ModuleHeader.ModuleType = Value\r
-                elif Name == TAB_INF_DEFINES_UEFI_SPECIFICATION_VERSION:\r
+                elif Name in (TAB_INF_DEFINES_UEFI_SPECIFICATION_VERSION, TAB_INF_DEFINES_UEFI_SPECIFICATION_VERSION):\r
                     ModuleHeader.UefiSpecificationVersion = Value\r
                 elif Name == TAB_INF_DEFINES_PI_SPECIFICATION_VERSION:\r
                     ModuleHeader.PiSpecificationVersion = Value\r
index 49d052d..350350b 100755 (executable)
@@ -1,7 +1,7 @@
 ## @file\r
 # This file is used to define a class object to describe a module\r
 #\r
-# Copyright (c) 2007, Intel Corporation\r
+# Copyright (c) 2007 - 2010, Intel Corporation\r
 # All rights reserved. This program and the accompanying materials\r
 # are licensed and made available under the terms and conditions of the BSD License\r
 # which accompanies this distribution.    The full text of the license may be found at\r
@@ -34,7 +34,7 @@ from CommonClass import *
 #                                PEI_PCD_DRIVER | DXE_PCD_DRIVER\r
 # @var TianoR8FlashMap_h:        To store value for TianoR8FlashMap_h\r
 # @var InfVersion:               To store value for InfVersion\r
-# @var EfiSpecificationVersion:  To store value for EfiSpecificationVersion\r
+# @var UefiSpecificationVersion: To store value for UefiSpecificationVersion\r
 # @var EdkReleaseVersion:        To store value for EdkReleaseVersion\r
 # @var LibraryClass:             To store value for LibraryClass, it is a set structure as\r
 #                                [ LibraryClassClass, ...]\r
@@ -65,7 +65,6 @@ class ModuleHeaderClass(IdentificationClass, CommonHeaderClass, DefineClass):
         self.PcdIsDriver = ''\r
         self.TianoR8FlashMap_h = False\r
         self.InfVersion = ''\r
-        self.EfiSpecificationVersion = ''\r
         self.PiSpecificationVersion = ''\r
         self.UefiSpecificationVersion = ''\r
         self.EdkReleaseVersion = ''\r
index 9a22ab3..5b20c40 100644 (file)
-## @file
-# This file is used to create a database used by build tool
-#
-# Copyright (c) 2008 - 2009, Intel Corporation
-# All rights reserved. This program and the accompanying materials
-# are licensed and made available under the terms and conditions of the BSD License
-# which accompanies this distribution.  The full text of the license may be found at
-# http://opensource.org/licenses/bsd-license.php
-#
-# THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
-# WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
-#
-
-##
-# Import Modules
-#
-import sqlite3
-import os
-import os.path
-import pickle
-
-import Common.EdkLogger as EdkLogger
-import Common.GlobalData as GlobalData
-
-from Common.String import *
-from Common.DataType import *
-from Common.Misc import *
-from types import *
-
-from CommonDataClass.CommonClass import SkuInfoClass
-
-from MetaDataTable import *
-from MetaFileTable import *
-from MetaFileParser import *
-from BuildClassObject import *
-
-## Platform build information from DSC file
-#
-#  This class is used to retrieve information stored in database and convert them
-# into PlatformBuildClassObject form for easier use for AutoGen.
-#
-class DscBuildData(PlatformBuildClassObject):
-    # dict used to convert PCD type in database to string used by build tool
-    _PCD_TYPE_STRING_ = {
-        MODEL_PCD_FIXED_AT_BUILD        :   "FixedAtBuild",
-        MODEL_PCD_PATCHABLE_IN_MODULE   :   "PatchableInModule",
-        MODEL_PCD_FEATURE_FLAG          :   "FeatureFlag",
-        MODEL_PCD_DYNAMIC               :   "Dynamic",
-        MODEL_PCD_DYNAMIC_DEFAULT       :   "Dynamic",
-        MODEL_PCD_DYNAMIC_HII           :   "DynamicHii",
-        MODEL_PCD_DYNAMIC_VPD           :   "DynamicVpd",
-        MODEL_PCD_DYNAMIC_EX            :   "DynamicEx",
-        MODEL_PCD_DYNAMIC_EX_DEFAULT    :   "DynamicEx",
-        MODEL_PCD_DYNAMIC_EX_HII        :   "DynamicExHii",
-        MODEL_PCD_DYNAMIC_EX_VPD        :   "DynamicExVpd",
-    }
-
-    # dict used to convert part of [Defines] to members of DscBuildData directly
-    _PROPERTY_ = {
-        #
-        # Required Fields
-        #
-        TAB_DSC_DEFINES_PLATFORM_NAME           :   "_PlatformName",
-        TAB_DSC_DEFINES_PLATFORM_GUID           :   "_Guid",
-        TAB_DSC_DEFINES_PLATFORM_VERSION        :   "_Version",
-        TAB_DSC_DEFINES_DSC_SPECIFICATION       :   "_DscSpecification",
-        #TAB_DSC_DEFINES_OUTPUT_DIRECTORY        :   "_OutputDirectory",
-        #TAB_DSC_DEFINES_SUPPORTED_ARCHITECTURES :   "_SupArchList",
-        #TAB_DSC_DEFINES_BUILD_TARGETS           :   "_BuildTargets",
-        #TAB_DSC_DEFINES_SKUID_IDENTIFIER        :   "_SkuName",
-        #TAB_DSC_DEFINES_FLASH_DEFINITION        :   "_FlashDefinition",
-        TAB_DSC_DEFINES_BUILD_NUMBER            :   "_BuildNumber",
-        TAB_DSC_DEFINES_MAKEFILE_NAME           :   "_MakefileName",
-        TAB_DSC_DEFINES_BS_BASE_ADDRESS         :   "_BsBaseAddress",
-        TAB_DSC_DEFINES_RT_BASE_ADDRESS         :   "_RtBaseAddress",
-    }
-
-    # used to compose dummy library class name for those forced library instances
-    _NullLibraryNumber = 0
-
-    ## Constructor of DscBuildData
-    #
-    #  Initialize object of DscBuildData
-    #
-    #   @param      FilePath        The path of platform description file
-    #   @param      RawData         The raw data of DSC file
-    #   @param      BuildDataBase   Database used to retrieve module/package information
-    #   @param      Arch            The target architecture
-    #   @param      Platform        (not used for DscBuildData)
-    #   @param      Macros          Macros used for replacement in DSC file
-    #
-    def __init__(self, FilePath, RawData, BuildDataBase, Arch='COMMON', Platform='DUMMY', Macros={}):
-        self.MetaFile = FilePath
-        self._RawData = RawData
-        self._Bdb = BuildDataBase
-        self._Arch = Arch
-        self._Macros = Macros
-        self._Clear()
-        RecordList = self._RawData[MODEL_META_DATA_DEFINE, self._Arch]
-        for Record in RecordList:
-            GlobalData.gEdkGlobal[Record[0]] = Record[1]
-
-    ## XXX[key] = value
-    def __setitem__(self, key, value):
-        self.__dict__[self._PROPERTY_[key]] = value
-
-    ## value = XXX[key]
-    def __getitem__(self, key):
-        return self.__dict__[self._PROPERTY_[key]]
-
-    ## "in" test support
-    def __contains__(self, key):
-        return key in self._PROPERTY_
-
-    ## Set all internal used members of DscBuildData to None
-    def _Clear(self):
-        self._Header            = None
-        self._PlatformName      = None
-        self._Guid              = None
-        self._Version           = None
-        self._DscSpecification  = None
-        self._OutputDirectory   = None
-        self._SupArchList       = None
-        self._BuildTargets      = None
-        self._SkuName           = None
-        self._FlashDefinition   = None
-        self._BuildNumber       = None
-        self._MakefileName      = None
-        self._BsBaseAddress     = None
-        self._RtBaseAddress     = None
-        self._SkuIds            = None
-        self._Modules           = None
-        self._LibraryInstances  = None
-        self._LibraryClasses    = None
-        self._Pcds              = None
-        self._BuildOptions      = None
-        self._LoadFixAddress    = None
-
-    ## Get architecture
-    def _GetArch(self):
-        return self._Arch
-
-    ## Set architecture
-    #
-    #   Changing the default ARCH to another may affect all other information
-    # because all information in a platform may be ARCH-related. That's
-    # why we need to clear all internal used members, in order to cause all
-    # information to be re-retrieved.
-    #
-    #   @param  Value   The value of ARCH
-    #
-    def _SetArch(self, Value):
-        if self._Arch == Value:
-            return
-        self._Arch = Value
-        self._Clear()
-
-    ## Retrieve all information in [Defines] section
-    #
-    #   (Retriving all [Defines] information in one-shot is just to save time.)
-    #
-    def _GetHeaderInfo(self):
-        RecordList = self._RawData[MODEL_META_DATA_HEADER, self._Arch]
-        for Record in RecordList:
-            Name = Record[0]
-            # items defined _PROPERTY_ don't need additional processing
-            if Name in self:
-                self[Name] = Record[1]
-            # some special items in [Defines] section need special treatment
-            elif Name == TAB_DSC_DEFINES_OUTPUT_DIRECTORY:
-                self._OutputDirectory = NormPath(Record[1], self._Macros)
-                if ' ' in self._OutputDirectory:
-                    EdkLogger.error("build", FORMAT_NOT_SUPPORTED, "No space is allowed in OUTPUT_DIRECTORY",
-                                    File=self.MetaFile, Line=Record[-1],
-                                    ExtraData=self._OutputDirectory)
-            elif Name == TAB_DSC_DEFINES_FLASH_DEFINITION:
-                self._FlashDefinition = PathClass(NormPath(Record[1], self._Macros), GlobalData.gWorkspace)
-                ErrorCode, ErrorInfo = self._FlashDefinition.Validate('.fdf')
-                if ErrorCode != 0:
-                    EdkLogger.error('build', ErrorCode, File=self.MetaFile, Line=Record[-1],
-                                    ExtraData=ErrorInfo)
-            elif Name == TAB_DSC_DEFINES_SUPPORTED_ARCHITECTURES:
-                self._SupArchList = GetSplitValueList(Record[1], TAB_VALUE_SPLIT)
-            elif Name == TAB_DSC_DEFINES_BUILD_TARGETS:
-                self._BuildTargets = GetSplitValueList(Record[1])
-            elif Name == TAB_DSC_DEFINES_SKUID_IDENTIFIER:
-                if self._SkuName == None:
-                    self._SkuName = Record[1]
-            elif Name == TAB_FIX_LOAD_TOP_MEMORY_ADDRESS:
-                self._LoadFixAddress = Record[1]
-        # set _Header to non-None in order to avoid database re-querying
-        self._Header = 'DUMMY'
-
-    ## Retrieve platform name
-    def _GetPlatformName(self):
-        if self._PlatformName == None:
-            if self._Header == None:
-                self._GetHeaderInfo()
-            if self._PlatformName == None:
-                EdkLogger.error('build', ATTRIBUTE_NOT_AVAILABLE, "No PLATFORM_NAME", File=self.MetaFile)
-        return self._PlatformName
-
-    ## Retrieve file guid
-    def _GetFileGuid(self):
-        if self._Guid == None:
-            if self._Header == None:
-                self._GetHeaderInfo()
-            if self._Guid == None:
-                EdkLogger.error('build', ATTRIBUTE_NOT_AVAILABLE, "No FILE_GUID", File=self.MetaFile)
-        return self._Guid
-
-    ## Retrieve platform version
-    def _GetVersion(self):
-        if self._Version == None:
-            if self._Header == None:
-                self._GetHeaderInfo()
-            if self._Version == None:
-                self._Version = ''
-        return self._Version
-
-    ## Retrieve platform description file version
-    def _GetDscSpec(self):
-        if self._DscSpecification == None:
-            if self._Header == None:
-                self._GetHeaderInfo()
-            if self._DscSpecification == None:
-                self._DscSpecification = ''
-        return self._DscSpecification
-
-    ## Retrieve OUTPUT_DIRECTORY
-    def _GetOutpuDir(self):
-        if self._OutputDirectory == None:
-            if self._Header == None:
-                self._GetHeaderInfo()
-            if self._OutputDirectory == None:
-                self._OutputDirectory = os.path.join("Build", self._PlatformName)
-        return self._OutputDirectory
-
-    ## Retrieve SUPPORTED_ARCHITECTURES
-    def _GetSupArch(self):
-        if self._SupArchList == None:
-            if self._Header == None:
-                self._GetHeaderInfo()
-            if self._SupArchList == None:
-                self._SupArchList = ARCH_LIST
-        return self._SupArchList
-
-    ## Retrieve BUILD_TARGETS
-    def _GetBuildTarget(self):
-        if self._BuildTargets == None:
-            if self._Header == None:
-                self._GetHeaderInfo()
-            if self._BuildTargets == None:
-                self._BuildTargets = ['DEBUG', 'RELEASE']
-        return self._BuildTargets
-
-    ## Retrieve SKUID_IDENTIFIER
-    def _GetSkuName(self):
-        if self._SkuName == None:
-            if self._Header == None:
-                self._GetHeaderInfo()
-            if self._SkuName == None or self._SkuName not in self.SkuIds:
-                self._SkuName = 'DEFAULT'
-        return self._SkuName
-
-    ## Override SKUID_IDENTIFIER
-    def _SetSkuName(self, Value):
-        if Value in self.SkuIds:
-            self._SkuName = Value
-
-    def _GetFdfFile(self):
-        if self._FlashDefinition == None:
-            if self._Header == None:
-                self._GetHeaderInfo()
-            if self._FlashDefinition == None:
-                self._FlashDefinition = ''
-        return self._FlashDefinition
-
-    ## Retrieve FLASH_DEFINITION
-    def _GetBuildNumber(self):
-        if self._BuildNumber == None:
-            if self._Header == None:
-                self._GetHeaderInfo()
-            if self._BuildNumber == None:
-                self._BuildNumber = ''
-        return self._BuildNumber
-
-    ## Retrieve MAKEFILE_NAME
-    def _GetMakefileName(self):
-        if self._MakefileName == None:
-            if self._Header == None:
-                self._GetHeaderInfo()
-            if self._MakefileName == None:
-                self._MakefileName = ''
-        return self._MakefileName
-
-    ## Retrieve BsBaseAddress
-    def _GetBsBaseAddress(self):
-        if self._BsBaseAddress == None:
-            if self._Header == None:
-                self._GetHeaderInfo()
-            if self._BsBaseAddress == None:
-                self._BsBaseAddress = ''
-        return self._BsBaseAddress
-
-    ## Retrieve RtBaseAddress
-    def _GetRtBaseAddress(self):
-        if self._RtBaseAddress == None:
-            if self._Header == None:
-                self._GetHeaderInfo()
-            if self._RtBaseAddress == None:
-                self._RtBaseAddress = ''
-        return self._RtBaseAddress
-
-    ## Retrieve the top address for the load fix address
-    def _GetLoadFixAddress(self):
-        if self._LoadFixAddress == None:
-            if self._Header == None:
-                self._GetHeaderInfo()
-            if self._LoadFixAddress == None:
-                self._LoadFixAddress = ''
-        return self._LoadFixAddress
-
-    ## Retrieve [SkuIds] section information
-    def _GetSkuIds(self):
-        if self._SkuIds == None:
-            self._SkuIds = {}
-            RecordList = self._RawData[MODEL_EFI_SKU_ID]
-            for Record in RecordList:
-                if Record[0] in [None, '']:
-                    EdkLogger.error('build', FORMAT_INVALID, 'No Sku ID number',
-                                    File=self.MetaFile, Line=Record[-1])
-                if Record[1] in [None, '']:
-                    EdkLogger.error('build', FORMAT_INVALID, 'No Sku ID name',
-                                    File=self.MetaFile, Line=Record[-1])
-                self._SkuIds[Record[1]] = Record[0]
-            if 'DEFAULT' not in self._SkuIds:
-                self._SkuIds['DEFAULT'] = 0
-        return self._SkuIds
-
-    ## Retrieve [Components] section information
-    def _GetModules(self):
-        if self._Modules != None:
-            return self._Modules
-
-        self._Modules = sdict()
-        RecordList = self._RawData[MODEL_META_DATA_COMPONENT, self._Arch]
-        Macros = {"EDK_SOURCE":GlobalData.gEcpSource, "EFI_SOURCE":GlobalData.gEfiSource}
-        Macros.update(self._Macros)
-        for Record in RecordList:
-            ModuleFile = PathClass(NormPath(Record[0], Macros), GlobalData.gWorkspace, Arch=self._Arch)
-            ModuleId = Record[5]
-            LineNo = Record[6]
-
-            # check the file validation
-            ErrorCode, ErrorInfo = ModuleFile.Validate('.inf')
-            if ErrorCode != 0:
-                EdkLogger.error('build', ErrorCode, File=self.MetaFile, Line=LineNo,
-                                ExtraData=ErrorInfo)
-            # Check duplication
-            if ModuleFile in self._Modules:
-                EdkLogger.error('build', FILE_DUPLICATED, File=self.MetaFile, ExtraData=str(ModuleFile), Line=LineNo)
-
-            Module = ModuleBuildClassObject()
-            Module.MetaFile = ModuleFile
-
-            # get module override path
-            RecordList = self._RawData[MODEL_META_DATA_COMPONENT_SOURCE_OVERRIDE_PATH, self._Arch, None, ModuleId]
-            if RecordList != []:
-                Module.SourceOverridePath = os.path.join(GlobalData.gWorkspace, NormPath(RecordList[0][0], Macros))
-
-                # Check if the source override path exists
-                if not os.path.isdir(Module.SourceOverridePath):
-                    EdkLogger.error('build', FILE_NOT_FOUND, Message = 'Source override path does not exist:', File=self.MetaFile, ExtraData=Module.SourceOverridePath, Line=LineNo)
-                
-                #Add to GlobalData Variables
-                GlobalData.gOverrideDir[ModuleFile.Key] = Module.SourceOverridePath
-
-            # get module private library instance
-            RecordList = self._RawData[MODEL_EFI_LIBRARY_CLASS, self._Arch, None, ModuleId]
-            for Record in RecordList:
-                LibraryClass = Record[0]
-                LibraryPath = PathClass(NormPath(Record[1], Macros), GlobalData.gWorkspace, Arch=self._Arch)
-                LineNo = Record[-1]
-
-                # check the file validation
-                ErrorCode, ErrorInfo = LibraryPath.Validate('.inf')
-                if ErrorCode != 0:
-                    EdkLogger.error('build', ErrorCode, File=self.MetaFile, Line=LineNo,
-                                    ExtraData=ErrorInfo)
-
-                if LibraryClass == '' or LibraryClass == 'NULL':
-                    self._NullLibraryNumber += 1
-                    LibraryClass = 'NULL%d' % self._NullLibraryNumber
-                    EdkLogger.verbose("Found forced library for %s\n\t%s [%s]" % (ModuleFile, LibraryPath, LibraryClass))
-                Module.LibraryClasses[LibraryClass] = LibraryPath
-                if LibraryPath not in self.LibraryInstances:
-                    self.LibraryInstances.append(LibraryPath)
-
-            # get module private PCD setting
-            for Type in [MODEL_PCD_FIXED_AT_BUILD, MODEL_PCD_PATCHABLE_IN_MODULE, \
-                         MODEL_PCD_FEATURE_FLAG, MODEL_PCD_DYNAMIC, MODEL_PCD_DYNAMIC_EX]:
-                RecordList = self._RawData[Type, self._Arch, None, ModuleId]
-                for TokenSpaceGuid, PcdCName, Setting, Dummy1, Dummy2, Dummy3, Dummy4 in RecordList:
-                    TokenList = GetSplitValueList(Setting)
-                    DefaultValue = TokenList[0]
-                    if len(TokenList) > 1:
-                        MaxDatumSize = TokenList[1]
-                    else:
-                        MaxDatumSize = ''
-                    TypeString = self._PCD_TYPE_STRING_[Type]
-                    Pcd = PcdClassObject(
-                            PcdCName,
-                            TokenSpaceGuid,
-                            TypeString,
-                            '',
-                            DefaultValue,
-                            '',
-                            MaxDatumSize,
-                            {},
-                            None
-                            )
-                    Module.Pcds[PcdCName, TokenSpaceGuid] = Pcd
-
-            # get module private build options
-            RecordList = self._RawData[MODEL_META_DATA_BUILD_OPTION, self._Arch, None, ModuleId]
-            for ToolChainFamily, ToolChain, Option, Dummy1, Dummy2, Dummy3, Dummy4 in RecordList:
-                if (ToolChainFamily, ToolChain) not in Module.BuildOptions:
-                    Module.BuildOptions[ToolChainFamily, ToolChain] = Option
-                else:
-                    OptionString = Module.BuildOptions[ToolChainFamily, ToolChain]
-                    Module.BuildOptions[ToolChainFamily, ToolChain] = OptionString + " " + Option
-
-            self._Modules[ModuleFile] = Module
-        return self._Modules
-
-    ## Retrieve all possible library instances used in this platform
-    def _GetLibraryInstances(self):
-        if self._LibraryInstances == None:
-            self._GetLibraryClasses()
-        return self._LibraryInstances
-
-    ## Retrieve [LibraryClasses] information
-    def _GetLibraryClasses(self):
-        if self._LibraryClasses == None:
-            self._LibraryInstances = []
-            #
-            # tdict is a special dict kind of type, used for selecting correct
-            # library instance for given library class and module type
-            #
-            LibraryClassDict = tdict(True, 3)
-            # track all library class names
-            LibraryClassSet = set()
-            RecordList = self._RawData[MODEL_EFI_LIBRARY_CLASS, self._Arch]
-            Macros = {"EDK_SOURCE":GlobalData.gEcpSource, "EFI_SOURCE":GlobalData.gEfiSource}
-            Macros.update(self._Macros)
-            for Record in RecordList:
-                LibraryClass, LibraryInstance, Dummy, Arch, ModuleType, Dummy, LineNo = Record
-                if LibraryClass == '' or LibraryClass == 'NULL':
-                    self._NullLibraryNumber += 1
-                    LibraryClass = 'NULL%d' % self._NullLibraryNumber
-                    EdkLogger.verbose("Found forced library for arch=%s\n\t%s [%s]" % (Arch, LibraryInstance, LibraryClass))
-                LibraryClassSet.add(LibraryClass)
-                LibraryInstance = PathClass(NormPath(LibraryInstance, Macros), GlobalData.gWorkspace, Arch=self._Arch)
-                # check the file validation
-                ErrorCode, ErrorInfo = LibraryInstance.Validate('.inf')
-                if ErrorCode != 0:
-                    EdkLogger.error('build', ErrorCode, File=self.MetaFile, Line=LineNo,
-                                    ExtraData=ErrorInfo)
-
-                if ModuleType != 'COMMON' and ModuleType not in SUP_MODULE_LIST:
-                    EdkLogger.error('build', OPTION_UNKNOWN, "Unknown module type [%s]" % ModuleType,
-                                    File=self.MetaFile, ExtraData=LibraryInstance, Line=LineNo)
-                LibraryClassDict[Arch, ModuleType, LibraryClass] = LibraryInstance
-                if LibraryInstance not in self._LibraryInstances:
-                    self._LibraryInstances.append(LibraryInstance)
-
-            # resolve the specific library instance for each class and each module type
-            self._LibraryClasses = tdict(True)
-            for LibraryClass in LibraryClassSet:
-                # try all possible module types
-                for ModuleType in SUP_MODULE_LIST:
-                    LibraryInstance = LibraryClassDict[self._Arch, ModuleType, LibraryClass]
-                    if LibraryInstance == None:
-                        continue
-                    self._LibraryClasses[LibraryClass, ModuleType] = LibraryInstance
-
-            # for R8 style library instances, which are listed in different section
-            RecordList = self._RawData[MODEL_EFI_LIBRARY_INSTANCE, self._Arch]
-            for Record in RecordList:
-                File = PathClass(NormPath(Record[0], Macros), GlobalData.gWorkspace, Arch=self._Arch)
-                LineNo = Record[-1]
-                # check the file validation
-                ErrorCode, ErrorInfo = File.Validate('.inf')
-                if ErrorCode != 0:
-                    EdkLogger.error('build', ErrorCode, File=self.MetaFile, Line=LineNo,
-                                    ExtraData=ErrorInfo)
-                if File not in self._LibraryInstances:
-                    self._LibraryInstances.append(File)
-                #
-                # we need the module name as the library class name, so we have
-                # to parse it here. (self._Bdb[] will trigger a file parse if it
-                # hasn't been parsed)
-                #
-                Library = self._Bdb[File, self._Arch]
-                self._LibraryClasses[Library.BaseName, ':dummy:'] = Library
-        return self._LibraryClasses
-
-    ## Retrieve all PCD settings in platform
-    def _GetPcds(self):
-        if self._Pcds == None:
-            self._Pcds = {}
-            self._Pcds.update(self._GetPcd(MODEL_PCD_FIXED_AT_BUILD))
-            self._Pcds.update(self._GetPcd(MODEL_PCD_PATCHABLE_IN_MODULE))
-            self._Pcds.update(self._GetPcd(MODEL_PCD_FEATURE_FLAG))
-            self._Pcds.update(self._GetDynamicPcd(MODEL_PCD_DYNAMIC_DEFAULT))
-            self._Pcds.update(self._GetDynamicHiiPcd(MODEL_PCD_DYNAMIC_HII))
-            self._Pcds.update(self._GetDynamicVpdPcd(MODEL_PCD_DYNAMIC_VPD))
-            self._Pcds.update(self._GetDynamicPcd(MODEL_PCD_DYNAMIC_EX_DEFAULT))
-            self._Pcds.update(self._GetDynamicHiiPcd(MODEL_PCD_DYNAMIC_EX_HII))
-            self._Pcds.update(self._GetDynamicVpdPcd(MODEL_PCD_DYNAMIC_EX_VPD))
-        return self._Pcds
-
-    ## Retrieve [BuildOptions]
-    def _GetBuildOptions(self):
-        if self._BuildOptions == None:
-            self._BuildOptions = {}
-            #
-            # Retrieve build option for EDKII style module
-            #
-            RecordList = self._RawData[MODEL_META_DATA_BUILD_OPTION, 'COMMON', EDKII_NAME]
-            for ToolChainFamily, ToolChain, Option, Dummy1, Dummy2, Dummy3, Dummy4 in RecordList:
-                self._BuildOptions[ToolChainFamily, ToolChain, EDKII_NAME] = Option
-            #
-            # Retrieve build option for EDK style module
-            #
-            RecordList = self._RawData[MODEL_META_DATA_BUILD_OPTION, 'COMMON', EDK_NAME]     
-            for ToolChainFamily, ToolChain, Option, Dummy1, Dummy2, Dummy3, Dummy4 in RecordList:
-                self._BuildOptions[ToolChainFamily, ToolChain, EDK_NAME] = Option
-        return self._BuildOptions
-
-    ## Retrieve non-dynamic PCD settings
-    #
-    #   @param  Type    PCD type
-    #
-    #   @retval a dict object contains settings of given PCD type
-    #
-    def _GetPcd(self, Type):
-        Pcds = {}
-        #
-        # tdict is a special dict kind of type, used for selecting correct
-        # PCD settings for certain ARCH
-        #
-        PcdDict = tdict(True, 3)
-        PcdSet = set()
-        # Find out all possible PCD candidates for self._Arch
-        RecordList = self._RawData[Type, self._Arch]
-        for TokenSpaceGuid, PcdCName, Setting, Arch, SkuName, Dummy3, Dummy4 in RecordList:
-            PcdSet.add((PcdCName, TokenSpaceGuid))
-            PcdDict[Arch, PcdCName, TokenSpaceGuid] = Setting
-        # Remove redundant PCD candidates
-        for PcdCName, TokenSpaceGuid in PcdSet:
-            ValueList = ['', '', '']
-            Setting = PcdDict[self._Arch, PcdCName, TokenSpaceGuid]
-            if Setting == None:
-                continue
-            TokenList = Setting.split(TAB_VALUE_SPLIT)
-            ValueList[0:len(TokenList)] = TokenList
-            PcdValue, DatumType, MaxDatumSize = ValueList
-            Pcds[PcdCName, TokenSpaceGuid] = PcdClassObject(
-                                                PcdCName,
-                                                TokenSpaceGuid,
-                                                self._PCD_TYPE_STRING_[Type],
-                                                DatumType,
-                                                PcdValue,
-                                                '',
-                                                MaxDatumSize,
-                                                {},
-                                                None
-                                                )
-        return Pcds
-
-    ## Retrieve dynamic PCD settings
-    #
-    #   @param  Type    PCD type
-    #
-    #   @retval a dict object contains settings of given PCD type
-    #
-    def _GetDynamicPcd(self, Type):
-        Pcds = {}
-        #
-        # tdict is a special dict kind of type, used for selecting correct
-        # PCD settings for certain ARCH and SKU
-        #
-        PcdDict = tdict(True, 4)
-        PcdSet = set()
-        # Find out all possible PCD candidates for self._Arch
-        RecordList = self._RawData[Type, self._Arch]
-        for TokenSpaceGuid, PcdCName, Setting, Arch, SkuName, Dummy3, Dummy4 in RecordList:
-            PcdSet.add((PcdCName, TokenSpaceGuid))
-            PcdDict[Arch, SkuName, PcdCName, TokenSpaceGuid] = Setting
-        # Remove redundant PCD candidates, per the ARCH and SKU
-        for PcdCName, TokenSpaceGuid in PcdSet:
-            ValueList = ['', '', '']
-            Setting = PcdDict[self._Arch, self.SkuName, PcdCName, TokenSpaceGuid]
-            if Setting == None:
-                continue
-            TokenList = Setting.split(TAB_VALUE_SPLIT)
-            ValueList[0:len(TokenList)] = TokenList
-            PcdValue, DatumType, MaxDatumSize = ValueList
-
-            SkuInfo = SkuInfoClass(self.SkuName, self.SkuIds[self.SkuName], '', '', '', '', '', PcdValue)
-            Pcds[PcdCName, TokenSpaceGuid] = PcdClassObject(
-                                                PcdCName,
-                                                TokenSpaceGuid,
-                                                self._PCD_TYPE_STRING_[Type],
-                                                DatumType,
-                                                PcdValue,
-                                                '',
-                                                MaxDatumSize,
-                                                {self.SkuName : SkuInfo},
-                                                None
-                                                )
-        return Pcds
-
-    ## Retrieve dynamic HII PCD settings
-    #
-    #   @param  Type    PCD type
-    #
-    #   @retval a dict object contains settings of given PCD type
-    #
-    def _GetDynamicHiiPcd(self, Type):
-        Pcds = {}
-        #
-        # tdict is a special dict kind of type, used for selecting correct
-        # PCD settings for certain ARCH and SKU
-        #
-        PcdDict = tdict(True, 4)
-        PcdSet = set()
-        RecordList = self._RawData[Type, self._Arch]
-        # Find out all possible PCD candidates for self._Arch
-        for TokenSpaceGuid, PcdCName, Setting, Arch, SkuName, Dummy3, Dummy4 in RecordList:
-            PcdSet.add((PcdCName, TokenSpaceGuid))
-            PcdDict[Arch, SkuName, PcdCName, TokenSpaceGuid] = Setting
-        # Remove redundant PCD candidates, per the ARCH and SKU
-        for PcdCName, TokenSpaceGuid in PcdSet:
-            ValueList = ['', '', '', '']
-            Setting = PcdDict[self._Arch, self.SkuName, PcdCName, TokenSpaceGuid]
-            if Setting == None:
-                continue
-            TokenList = Setting.split(TAB_VALUE_SPLIT)
-            ValueList[0:len(TokenList)] = TokenList
-            VariableName, VariableGuid, VariableOffset, DefaultValue = ValueList
-            SkuInfo = SkuInfoClass(self.SkuName, self.SkuIds[self.SkuName], VariableName, VariableGuid, VariableOffset, DefaultValue)
-            Pcds[PcdCName, TokenSpaceGuid] = PcdClassObject(
-                                                PcdCName,
-                                                TokenSpaceGuid,
-                                                self._PCD_TYPE_STRING_[Type],
-                                                '',
-                                                DefaultValue,
-                                                '',
-                                                '',
-                                                {self.SkuName : SkuInfo},
-                                                None
-                                                )
-        return Pcds
-
-    ## Retrieve dynamic VPD PCD settings
-    #
-    #   @param  Type    PCD type
-    #
-    #   @retval a dict object contains settings of given PCD type
-    #
-    def _GetDynamicVpdPcd(self, Type):
-        Pcds = {}
-        #
-        # tdict is a special dict kind of type, used for selecting correct
-        # PCD settings for certain ARCH and SKU
-        #
-        PcdDict = tdict(True, 4)
-        PcdSet = set()
-        # Find out all possible PCD candidates for self._Arch
-        RecordList = self._RawData[Type, self._Arch]
-        for TokenSpaceGuid, PcdCName, Setting, Arch, SkuName, Dummy3, Dummy4 in RecordList:
-            PcdSet.add((PcdCName, TokenSpaceGuid))
-            PcdDict[Arch, SkuName, PcdCName, TokenSpaceGuid] = Setting
-        # Remove redundant PCD candidates, per the ARCH and SKU
-        for PcdCName, TokenSpaceGuid in PcdSet:
-            ValueList = ['', '']
-            Setting = PcdDict[self._Arch, self.SkuName, PcdCName, TokenSpaceGuid]
-            if Setting == None:
-                continue
-            TokenList = Setting.split(TAB_VALUE_SPLIT)
-            ValueList[0:len(TokenList)] = TokenList
-            VpdOffset, MaxDatumSize = ValueList
-
-            SkuInfo = SkuInfoClass(self.SkuName, self.SkuIds[self.SkuName], '', '', '', '', VpdOffset)
-            Pcds[PcdCName, TokenSpaceGuid] = PcdClassObject(
-                                                PcdCName,
-                                                TokenSpaceGuid,
-                                                self._PCD_TYPE_STRING_[Type],
-                                                '',
-                                                '',
-                                                '',
-                                                MaxDatumSize,
-                                                {self.SkuName : SkuInfo},
-                                                None
-                                                )
-        return Pcds
-
-    ## Add external modules
-    #
-    #   The external modules are mostly those listed in FDF file, which don't
-    # need "build".
-    #
-    #   @param  FilePath    The path of module description file
-    #
-    def AddModule(self, FilePath):
-        FilePath = NormPath(FilePath)
-        if FilePath not in self.Modules:
-            Module = ModuleBuildClassObject()
-            Module.MetaFile = FilePath
-            self.Modules.append(Module)
-
-    ## Add external PCDs
-    #
-    #   The external PCDs are mostly those listed in FDF file to specify address
-    # or offset information.
-    #
-    #   @param  Name    Name of the PCD
-    #   @param  Guid    Token space guid of the PCD
-    #   @param  Value   Value of the PCD
-    #
-    def AddPcd(self, Name, Guid, Value):
-        if (Name, Guid) not in self.Pcds:
-            self.Pcds[Name, Guid] = PcdClassObject(Name, Guid, '', '', '', '', '', {}, None)
-        self.Pcds[Name, Guid].DefaultValue = Value
-
-    Arch                = property(_GetArch, _SetArch)
-    Platform            = property(_GetPlatformName)
-    PlatformName        = property(_GetPlatformName)
-    Guid                = property(_GetFileGuid)
-    Version             = property(_GetVersion)
-    DscSpecification    = property(_GetDscSpec)
-    OutputDirectory     = property(_GetOutpuDir)
-    SupArchList         = property(_GetSupArch)
-    BuildTargets        = property(_GetBuildTarget)
-    SkuName             = property(_GetSkuName, _SetSkuName)
-    FlashDefinition     = property(_GetFdfFile)
-    BuildNumber         = property(_GetBuildNumber)
-    MakefileName        = property(_GetMakefileName)
-    BsBaseAddress       = property(_GetBsBaseAddress)
-    RtBaseAddress       = property(_GetRtBaseAddress)
-    LoadFixAddress      = property(_GetLoadFixAddress)
-
-    SkuIds              = property(_GetSkuIds)
-    Modules             = property(_GetModules)
-    LibraryInstances    = property(_GetLibraryInstances)
-    LibraryClasses      = property(_GetLibraryClasses)
-    Pcds                = property(_GetPcds)
-    BuildOptions        = property(_GetBuildOptions)
-
-## Platform build information from DSC file
-#
-#  This class is used to retrieve information stored in database and convert them
-# into PackageBuildClassObject form for easier use for AutoGen.
-#
-class DecBuildData(PackageBuildClassObject):
-    # dict used to convert PCD type in database to string used by build tool
-    _PCD_TYPE_STRING_ = {
-        MODEL_PCD_FIXED_AT_BUILD        :   "FixedAtBuild",
-        MODEL_PCD_PATCHABLE_IN_MODULE   :   "PatchableInModule",
-        MODEL_PCD_FEATURE_FLAG          :   "FeatureFlag",
-        MODEL_PCD_DYNAMIC               :   "Dynamic",
-        MODEL_PCD_DYNAMIC_DEFAULT       :   "Dynamic",
-        MODEL_PCD_DYNAMIC_HII           :   "DynamicHii",
-        MODEL_PCD_DYNAMIC_VPD           :   "DynamicVpd",
-        MODEL_PCD_DYNAMIC_EX            :   "DynamicEx",
-        MODEL_PCD_DYNAMIC_EX_DEFAULT    :   "DynamicEx",
-        MODEL_PCD_DYNAMIC_EX_HII        :   "DynamicExHii",
-        MODEL_PCD_DYNAMIC_EX_VPD        :   "DynamicExVpd",
-    }
-
-    # dict used to convert part of [Defines] to members of DecBuildData directly
-    _PROPERTY_ = {
-        #
-        # Required Fields
-        #
-        TAB_DEC_DEFINES_PACKAGE_NAME                : "_PackageName",
-        TAB_DEC_DEFINES_PACKAGE_GUID                : "_Guid",
-        TAB_DEC_DEFINES_PACKAGE_VERSION             : "_Version",
-    }
-
-
-    ## Constructor of DecBuildData
-    #
-    #  Initialize object of DecBuildData
-    #
-    #   @param      FilePath        The path of package description file
-    #   @param      RawData         The raw data of DEC file
-    #   @param      BuildDataBase   Database used to retrieve module information
-    #   @param      Arch            The target architecture
-    #   @param      Platform        (not used for DecBuildData)
-    #   @param      Macros          Macros used for replacement in DSC file
-    #
-    def __init__(self, File, RawData, BuildDataBase, Arch='COMMON', Platform='DUMMY', Macros={}):
-        self.MetaFile = File
-        self._PackageDir = File.Dir
-        self._RawData = RawData
-        self._Bdb = BuildDataBase
-        self._Arch = Arch
-        self._Macros = Macros
-        self._Clear()
-
-    ## XXX[key] = value
-    def __setitem__(self, key, value):
-        self.__dict__[self._PROPERTY_[key]] = value
-
-    ## value = XXX[key]
-    def __getitem__(self, key):
-        return self.__dict__[self._PROPERTY_[key]]
-
-    ## "in" test support
-    def __contains__(self, key):
-        return key in self._PROPERTY_
-
-    ## Set all internal used members of DecBuildData to None
-    def _Clear(self):
-        self._Header            = None
-        self._PackageName       = None
-        self._Guid              = None
-        self._Version           = None
-        self._Protocols         = None
-        self._Ppis              = None
-        self._Guids             = None
-        self._Includes          = None
-        self._LibraryClasses    = None
-        self._Pcds              = None
-
-    ## Get architecture
-    def _GetArch(self):
-        return self._Arch
-
-    ## Set architecture
-    #
-    #   Changing the default ARCH to another may affect all other information
-    # because all information in a platform may be ARCH-related. That's
-    # why we need to clear all internal used members, in order to cause all
-    # information to be re-retrieved.
-    #
-    #   @param  Value   The value of ARCH
-    #
-    def _SetArch(self, Value):
-        if self._Arch == Value:
-            return
-        self._Arch = Value
-        self._Clear()
-
-    ## Retrieve all information in [Defines] section
-    #
-    #   (Retriving all [Defines] information in one-shot is just to save time.)
-    #
-    def _GetHeaderInfo(self):
-        RecordList = self._RawData[MODEL_META_DATA_HEADER]
-        for Record in RecordList:
-            Name = Record[0]
-            if Name in self:
-                self[Name] = Record[1]
-        self._Header = 'DUMMY'
-
-    ## Retrieve package name
-    def _GetPackageName(self):
-        if self._PackageName == None:
-            if self._Header == None:
-                self._GetHeaderInfo()
-            if self._PackageName == None:
-                EdkLogger.error("build", ATTRIBUTE_NOT_AVAILABLE, "No PACKAGE_NAME", File=self.MetaFile)
-        return self._PackageName
-
-    ## Retrieve file guid
-    def _GetFileGuid(self):
-        if self._Guid == None:
-            if self._Header == None:
-                self._GetHeaderInfo()
-            if self._Guid == None:
-                EdkLogger.error("build", ATTRIBUTE_NOT_AVAILABLE, "No PACKAGE_GUID", File=self.MetaFile)
-        return self._Guid
-
-    ## Retrieve package version
-    def _GetVersion(self):
-        if self._Version == None:
-            if self._Header == None:
-                self._GetHeaderInfo()
-            if self._Version == None:
-                self._Version = ''
-        return self._Version
-
-    ## Retrieve protocol definitions (name/value pairs)
-    def _GetProtocol(self):
-        if self._Protocols == None:
-            #
-            # tdict is a special kind of dict, used for selecting correct
-            # protocol defition for given ARCH
-            #
-            ProtocolDict = tdict(True)
-            NameList = []
-            # find out all protocol definitions for specific and 'common' arch
-            RecordList = self._RawData[MODEL_EFI_PROTOCOL, self._Arch]
-            for Name, Guid, Dummy, Arch, ID, LineNo in RecordList:
-                if Name not in NameList:
-                    NameList.append(Name)
-                ProtocolDict[Arch, Name] = Guid
-            # use sdict to keep the order
-            self._Protocols = sdict()
-            for Name in NameList:
-                #
-                # limit the ARCH to self._Arch, if no self._Arch found, tdict
-                # will automatically turn to 'common' ARCH for trying
-                #
-                self._Protocols[Name] = ProtocolDict[self._Arch, Name]
-        return self._Protocols
-
-    ## Retrieve PPI definitions (name/value pairs)
-    def _GetPpi(self):
-        if self._Ppis == None:
-            #
-            # tdict is a special kind of dict, used for selecting correct
-            # PPI defition for given ARCH
-            #
-            PpiDict = tdict(True)
-            NameList = []
-            # find out all PPI definitions for specific arch and 'common' arch
-            RecordList = self._RawData[MODEL_EFI_PPI, self._Arch]
-            for Name, Guid, Dummy, Arch, ID, LineNo in RecordList:
-                if Name not in NameList:
-                    NameList.append(Name)
-                PpiDict[Arch, Name] = Guid
-            # use sdict to keep the order
-            self._Ppis = sdict()
-            for Name in NameList:
-                #
-                # limit the ARCH to self._Arch, if no self._Arch found, tdict
-                # will automatically turn to 'common' ARCH for trying
-                #
-                self._Ppis[Name] = PpiDict[self._Arch, Name]
-        return self._Ppis
-
-    ## Retrieve GUID definitions (name/value pairs)
-    def _GetGuid(self):
-        if self._Guids == None:
-            #
-            # tdict is a special kind of dict, used for selecting correct
-            # GUID defition for given ARCH
-            #
-            GuidDict = tdict(True)
-            NameList = []
-            # find out all protocol definitions for specific and 'common' arch
-            RecordList = self._RawData[MODEL_EFI_GUID, self._Arch]
-            for Name, Guid, Dummy, Arch, ID, LineNo in RecordList:
-                if Name not in NameList:
-                    NameList.append(Name)
-                GuidDict[Arch, Name] = Guid
-            # use sdict to keep the order
-            self._Guids = sdict()
-            for Name in NameList:
-                #
-                # limit the ARCH to self._Arch, if no self._Arch found, tdict
-                # will automatically turn to 'common' ARCH for trying
-                #
-                self._Guids[Name] = GuidDict[self._Arch, Name]
-        return self._Guids
-
-    ## Retrieve public include paths declared in this package
-    def _GetInclude(self):
-        if self._Includes == None:
-            self._Includes = []
-            RecordList = self._RawData[MODEL_EFI_INCLUDE, self._Arch]
-            Macros = {"EDK_SOURCE":GlobalData.gEcpSource, "EFI_SOURCE":GlobalData.gEfiSource}
-            Macros.update(self._Macros)
-            for Record in RecordList:
-                File = PathClass(NormPath(Record[0], Macros), self._PackageDir, Arch=self._Arch)
-                LineNo = Record[-1]
-                # validate the path
-                ErrorCode, ErrorInfo = File.Validate()
-                if ErrorCode != 0:
-                    EdkLogger.error('build', ErrorCode, ExtraData=ErrorInfo, File=self.MetaFile, Line=LineNo)
-
-                # avoid duplicate include path
-                if File not in self._Includes:
-                    self._Includes.append(File)
-        return self._Includes
-
-    ## Retrieve library class declarations (not used in build at present)
-    def _GetLibraryClass(self):
-        if self._LibraryClasses == None:
-            #
-            # tdict is a special kind of dict, used for selecting correct
-            # library class declaration for given ARCH
-            #
-            LibraryClassDict = tdict(True)
-            LibraryClassSet = set()
-            RecordList = self._RawData[MODEL_EFI_LIBRARY_CLASS, self._Arch]
-            Macros = {"EDK_SOURCE":GlobalData.gEcpSource, "EFI_SOURCE":GlobalData.gEfiSource}
-            Macros.update(self._Macros)
-            for LibraryClass, File, Dummy, Arch, ID, LineNo in RecordList:
-                File = PathClass(NormPath(File, Macros), self._PackageDir, Arch=self._Arch)
-                # check the file validation
-                ErrorCode, ErrorInfo = File.Validate()
-                if ErrorCode != 0:
-                    EdkLogger.error('build', ErrorCode, ExtraData=ErrorInfo, File=self.MetaFile, Line=LineNo)
-                LibraryClassSet.add(LibraryClass)
-                LibraryClassDict[Arch, LibraryClass] = File
-            self._LibraryClasses = sdict()
-            for LibraryClass in LibraryClassSet:
-                self._LibraryClasses[LibraryClass] = LibraryClassDict[self._Arch, LibraryClass]
-        return self._LibraryClasses
-
-    ## Retrieve PCD declarations
-    def _GetPcds(self):
-        if self._Pcds == None:
-            self._Pcds = {}
-            self._Pcds.update(self._GetPcd(MODEL_PCD_FIXED_AT_BUILD))
-            self._Pcds.update(self._GetPcd(MODEL_PCD_PATCHABLE_IN_MODULE))
-            self._Pcds.update(self._GetPcd(MODEL_PCD_FEATURE_FLAG))
-            self._Pcds.update(self._GetPcd(MODEL_PCD_DYNAMIC))
-            self._Pcds.update(self._GetPcd(MODEL_PCD_DYNAMIC_EX))
-        return self._Pcds
-
-    ## Retrieve PCD declarations for given type
-    def _GetPcd(self, Type):
-        Pcds = {}
-        #
-        # tdict is a special kind of dict, used for selecting correct
-        # PCD declaration for given ARCH
-        #
-        PcdDict = tdict(True, 3)
-        # for summarizing PCD
-        PcdSet = set()
-        # find out all PCDs of the 'type'
-        RecordList = self._RawData[Type, self._Arch]
-        for TokenSpaceGuid, PcdCName, Setting, Arch, Dummy1, Dummy2 in RecordList:
-            PcdDict[Arch, PcdCName, TokenSpaceGuid] = Setting
-            PcdSet.add((PcdCName, TokenSpaceGuid))
-
-        for PcdCName, TokenSpaceGuid in PcdSet:
-            ValueList = ['', '', '']
-            #
-            # limit the ARCH to self._Arch, if no self._Arch found, tdict
-            # will automatically turn to 'common' ARCH and try again
-            #
-            Setting = PcdDict[self._Arch, PcdCName, TokenSpaceGuid]
-            if Setting == None:
-                continue
-            TokenList = Setting.split(TAB_VALUE_SPLIT)
-            ValueList[0:len(TokenList)] = TokenList
-            DefaultValue, DatumType, TokenNumber = ValueList
-            Pcds[PcdCName, TokenSpaceGuid, self._PCD_TYPE_STRING_[Type]] = PcdClassObject(
-                                                                            PcdCName,
-                                                                            TokenSpaceGuid,
-                                                                            self._PCD_TYPE_STRING_[Type],
-                                                                            DatumType,
-                                                                            DefaultValue,
-                                                                            TokenNumber,
-                                                                            '',
-                                                                            {},
-                                                                            None
-                                                                            )
-        return Pcds
-
-
-    Arch            = property(_GetArch, _SetArch)
-    PackageName     = property(_GetPackageName)
-    Guid            = property(_GetFileGuid)
-    Version         = property(_GetVersion)
-
-    Protocols       = property(_GetProtocol)
-    Ppis            = property(_GetPpi)
-    Guids           = property(_GetGuid)
-    Includes        = property(_GetInclude)
-    LibraryClasses  = property(_GetLibraryClass)
-    Pcds            = property(_GetPcds)
-
-## Module build information from INF file
-#
-#  This class is used to retrieve information stored in database and convert them
-# into ModuleBuildClassObject form for easier use for AutoGen.
-#
-class InfBuildData(ModuleBuildClassObject):
-    # dict used to convert PCD type in database to string used by build tool
-    _PCD_TYPE_STRING_ = {
-        MODEL_PCD_FIXED_AT_BUILD        :   "FixedAtBuild",
-        MODEL_PCD_PATCHABLE_IN_MODULE   :   "PatchableInModule",
-        MODEL_PCD_FEATURE_FLAG          :   "FeatureFlag",
-        MODEL_PCD_DYNAMIC               :   "Dynamic",
-        MODEL_PCD_DYNAMIC_DEFAULT       :   "Dynamic",
-        MODEL_PCD_DYNAMIC_HII           :   "DynamicHii",
-        MODEL_PCD_DYNAMIC_VPD           :   "DynamicVpd",
-        MODEL_PCD_DYNAMIC_EX            :   "DynamicEx",
-        MODEL_PCD_DYNAMIC_EX_DEFAULT    :   "DynamicEx",
-        MODEL_PCD_DYNAMIC_EX_HII        :   "DynamicExHii",
-        MODEL_PCD_DYNAMIC_EX_VPD        :   "DynamicExVpd",
-    }
-
-    # dict used to convert part of [Defines] to members of InfBuildData directly
-    _PROPERTY_ = {
-        #
-        # Required Fields
-        #
-        TAB_INF_DEFINES_BASE_NAME                   : "_BaseName",
-        TAB_INF_DEFINES_FILE_GUID                   : "_Guid",
-        TAB_INF_DEFINES_MODULE_TYPE                 : "_ModuleType",
-        #
-        # Optional Fields
-        #
-        TAB_INF_DEFINES_INF_VERSION                 : "_AutoGenVersion",
-        TAB_INF_DEFINES_COMPONENT_TYPE              : "_ComponentType",
-        TAB_INF_DEFINES_MAKEFILE_NAME               : "_MakefileName",
-        #TAB_INF_DEFINES_CUSTOM_MAKEFILE             : "_CustomMakefile",
-        TAB_INF_DEFINES_VERSION_NUMBER              : "_Version",
-        TAB_INF_DEFINES_VERSION_STRING              : "_Version",
-        TAB_INF_DEFINES_VERSION                     : "_Version",
-        TAB_INF_DEFINES_PCD_IS_DRIVER               : "_PcdIsDriver",
-        TAB_INF_DEFINES_SHADOW                      : "_Shadow",
-
-        TAB_COMPONENTS_SOURCE_OVERRIDE_PATH         : "_SourceOverridePath",
-    }
-
-    # dict used to convert Component type to Module type
-    _MODULE_TYPE_ = {
-        "LIBRARY"               :   "BASE",
-        "SECURITY_CORE"         :   "SEC",
-        "PEI_CORE"              :   "PEI_CORE",
-        "COMBINED_PEIM_DRIVER"  :   "PEIM",
-        "PIC_PEIM"              :   "PEIM",
-        "RELOCATABLE_PEIM"      :   "PEIM",
-        "PE32_PEIM"             :   "PEIM",
-        "BS_DRIVER"             :   "DXE_DRIVER",
-        "RT_DRIVER"             :   "DXE_RUNTIME_DRIVER",
-        "SAL_RT_DRIVER"         :   "DXE_SAL_DRIVER",
-        "DXE_SMM_DRIVER"        :   "DXE_SMM_DRIVER",
-    #    "SMM_DRIVER"            :   "DXE_SMM_DRIVER",
-    #    "BS_DRIVER"             :   "DXE_SMM_DRIVER",
-    #    "BS_DRIVER"             :   "UEFI_DRIVER",
-        "APPLICATION"           :   "UEFI_APPLICATION",
-        "LOGO"                  :   "BASE",
-    }
-
-    # regular expression for converting XXX_FLAGS in [nmake] section to new type
-    _NMAKE_FLAG_PATTERN_ = re.compile("(?:EBC_)?([A-Z]+)_(?:STD_|PROJ_|ARCH_)?FLAGS(?:_DLL|_ASL|_EXE)?", re.UNICODE)
-    # dict used to convert old tool name used in [nmake] section to new ones
-    _TOOL_CODE_ = {
-        "C"         :   "CC",
-        "LIB"       :   "SLINK",
-        "LINK"      :   "DLINK",
-    }
-
-
-    ## Constructor of DscBuildData
-    #
-    #  Initialize object of DscBuildData
-    #
-    #   @param      FilePath        The path of platform description file
-    #   @param      RawData         The raw data of DSC file
-    #   @param      BuildDataBase   Database used to retrieve module/package information
-    #   @param      Arch            The target architecture
-    #   @param      Platform        The name of platform employing this module
-    #   @param      Macros          Macros used for replacement in DSC file
-    #
-    def __init__(self, FilePath, RawData, BuildDatabase, Arch='COMMON', Platform='COMMON', Macros={}):
-        self.MetaFile = FilePath
-        self._ModuleDir = FilePath.Dir
-        self._RawData = RawData
-        self._Bdb = BuildDatabase
-        self._Arch = Arch
-        self._Platform = 'COMMON'
-        self._Macros = Macros
-        self._SourceOverridePath = None
-        if FilePath.Key in GlobalData.gOverrideDir:
-            self._SourceOverridePath = GlobalData.gOverrideDir[FilePath.Key]
-        self._Clear()
-
-    ## XXX[key] = value
-    def __setitem__(self, key, value):
-        self.__dict__[self._PROPERTY_[key]] = value
-
-    ## value = XXX[key]
-    def __getitem__(self, key):
-        return self.__dict__[self._PROPERTY_[key]]
-
-    ## "in" test support
-    def __contains__(self, key):
-        return key in self._PROPERTY_
-
-    ## Set all internal used members of InfBuildData to None
-    def _Clear(self):
-        self._Header_               = None
-        self._AutoGenVersion        = None
-        self._BaseName              = None
-        self._ModuleType            = None
-        self._ComponentType         = None
-        self._BuildType             = None
-        self._Guid                  = None
-        self._Version               = None
-        self._PcdIsDriver           = None
-        self._BinaryModule          = None
-        self._Shadow                = None
-        self._MakefileName          = None
-        self._CustomMakefile        = None
-        self._Specification         = None
-        self._LibraryClass          = None
-        self._ModuleEntryPointList  = None
-        self._ModuleUnloadImageList = None
-        self._ConstructorList       = None
-        self._DestructorList        = None
-        self._Defs                  = None
-        self._Binaries              = None
-        self._Sources               = None
-        self._LibraryClasses        = None
-        self._Libraries             = None
-        self._Protocols             = None
-        self._Ppis                  = None
-        self._Guids                 = None
-        self._Includes              = None
-        self._Packages              = None
-        self._Pcds                  = None
-        self._BuildOptions          = None
-        self._Depex                 = None
-        self._DepexExpression       = None
-        #self._SourceOverridePath    = None
-
-    ## Get architecture
-    def _GetArch(self):
-        return self._Arch
-
-    ## Set architecture
-    #
-    #   Changing the default ARCH to another may affect all other information
-    # because all information in a platform may be ARCH-related. That's
-    # why we need to clear all internal used members, in order to cause all
-    # information to be re-retrieved.
-    #
-    #   @param  Value   The value of ARCH
-    #
-    def _SetArch(self, Value):
-        if self._Arch == Value:
-            return
-        self._Arch = Value
-        self._Clear()
-
-    ## Return the name of platform employing this module
-    def _GetPlatform(self):
-        return self._Platform
-
-    ## Change the name of platform employing this module
-    #
-    #   Changing the default name of platform to another may affect some information
-    # because they may be PLATFORM-related. That's why we need to clear all internal
-    # used members, in order to cause all information to be re-retrieved.
-    #
-    def _SetPlatform(self, Value):
-        if self._Platform == Value:
-            return
-        self._Platform = Value
-        self._Clear()
-
-    ## Retrieve all information in [Defines] section
-    #
-    #   (Retriving all [Defines] information in one-shot is just to save time.)
-    #
-    def _GetHeaderInfo(self):
-        RecordList = self._RawData[MODEL_META_DATA_HEADER, self._Arch, self._Platform]
-        for Record in RecordList:
-            Record = ReplaceMacros(Record, GlobalData.gEdkGlobal, False)
-            Name = Record[0]
-            # items defined _PROPERTY_ don't need additional processing
-            if Name in self:
-                self[Name] = Record[1]
-            # some special items in [Defines] section need special treatment
-            elif Name == 'EFI_SPECIFICATION_VERSION':
-                if self._Specification == None:
-                    self._Specification = sdict()
-                self._Specification[Name] = Record[1]
-            elif Name == 'EDK_RELEASE_VERSION':
-                if self._Specification == None:
-                    self._Specification = sdict()
-                self._Specification[Name] = Record[1]
-            elif Name == 'PI_SPECIFICATION_VERSION':
-                if self._Specification == None:
-                    self._Specification = sdict()
-                self._Specification[Name] = Record[1]
-            elif Name == 'LIBRARY_CLASS':
-                if self._LibraryClass == None:
-                    self._LibraryClass = []
-                ValueList = GetSplitValueList(Record[1])
-                LibraryClass = ValueList[0]
-                if len(ValueList) > 1:
-                    SupModuleList = GetSplitValueList(ValueList[1], ' ')
-                else:
-                    SupModuleList = SUP_MODULE_LIST
-                self._LibraryClass.append(LibraryClassObject(LibraryClass, SupModuleList))
-            elif Name == 'ENTRY_POINT':
-                if self._ModuleEntryPointList == None:
-                    self._ModuleEntryPointList = []
-                self._ModuleEntryPointList.append(Record[1])
-            elif Name == 'UNLOAD_IMAGE':
-                if self._ModuleUnloadImageList == None:
-                    self._ModuleUnloadImageList = []
-                if Record[1] == '':
-                    continue
-                self._ModuleUnloadImageList.append(Record[1])
-            elif Name == 'CONSTRUCTOR':
-                if self._ConstructorList == None:
-                    self._ConstructorList = []
-                if Record[1] == '':
-                    continue
-                self._ConstructorList.append(Record[1])
-            elif Name == 'DESTRUCTOR':
-                if self._DestructorList == None:
-                    self._DestructorList = []
-                if Record[1] == '':
-                    continue
-                self._DestructorList.append(Record[1])
-            elif Name == TAB_INF_DEFINES_CUSTOM_MAKEFILE:
-                TokenList = GetSplitValueList(Record[1])
-                if self._CustomMakefile == None:
-                    self._CustomMakefile = {}
-                if len(TokenList) < 2:
-                    self._CustomMakefile['MSFT'] = TokenList[0]
-                    self._CustomMakefile['GCC'] = TokenList[0]
-                else:
-                    if TokenList[0] not in ['MSFT', 'GCC']:
-                        EdkLogger.error("build", FORMAT_NOT_SUPPORTED,
-                                        "No supported family [%s]" % TokenList[0],
-                                        File=self.MetaFile, Line=Record[-1])
-                    self._CustomMakefile[TokenList[0]] = TokenList[1]
-            else:
-                if self._Defs == None:
-                    self._Defs = sdict()
-                self._Defs[Name] = Record[1]
-
-        #
-        # Retrieve information in sections specific to R8.x modules
-        #
-        if self._AutoGenVersion >= 0x00010005:   # _AutoGenVersion may be None, which is less than anything
-            if not self._ModuleType:
-                EdkLogger.error("build", ATTRIBUTE_NOT_AVAILABLE,
-                                "MODULE_TYPE is not given", File=self.MetaFile)
-            if (self._Specification == None) or (not 'PI_SPECIFICATION_VERSION' in self._Specification) or (self._Specification['PI_SPECIFICATION_VERSION'] < 0x0001000A):
-                if self._ModuleType == SUP_MODULE_SMM_CORE:
-                    EdkLogger.error("build", FORMAT_NOT_SUPPORTED, "SMM_CORE module type can't be used in the module with PI_SPECIFICATION_VERSION less than 0x0001000A", File=self.MetaFile)                
-            if self._Defs and 'PCI_DEVICE_ID' in self._Defs and 'PCI_VENDOR_ID' in self._Defs \
-               and 'PCI_CLASS_CODE' in self._Defs:
-                self._BuildType = 'UEFI_OPTIONROM'
-            elif self._Defs and 'UEFI_HII_RESOURCE_SECTION' in self._Defs \
-               and self._Defs['UEFI_HII_RESOURCE_SECTION'] == 'TRUE':
-                self._BuildType = 'UEFI_HII'
-            else:
-                self._BuildType = self._ModuleType.upper()
-        else:
-            self._BuildType = self._ComponentType.upper()
-            if not self._ComponentType:
-                EdkLogger.error("build", ATTRIBUTE_NOT_AVAILABLE,
-                                "COMPONENT_TYPE is not given", File=self.MetaFile)
-            if self._ComponentType in self._MODULE_TYPE_:
-                self._ModuleType = self._MODULE_TYPE_[self._ComponentType]
-            if self._ComponentType == 'LIBRARY':
-                self._LibraryClass = [LibraryClassObject(self._BaseName, SUP_MODULE_LIST)]
-            # make use some [nmake] section macros
-            RecordList = self._RawData[MODEL_META_DATA_NMAKE, self._Arch, self._Platform]
-            for Name,Value,Dummy,Arch,Platform,ID,LineNo in RecordList:
-                Value = Value.replace('$(PROCESSOR)', self._Arch)
-                Name = Name.replace('$(PROCESSOR)', self._Arch)
-                Name, Value = ReplaceMacros((Name, Value), GlobalData.gEdkGlobal, True)
-                if Name == "IMAGE_ENTRY_POINT":
-                    if self._ModuleEntryPointList == None:
-                        self._ModuleEntryPointList = []
-                    self._ModuleEntryPointList.append(Value)
-                elif Name == "DPX_SOURCE":
-                    Macros = {"EDK_SOURCE":GlobalData.gEcpSource, "EFI_SOURCE":GlobalData.gEfiSource}
-                    Macros.update(self._Macros)
-                    File = PathClass(NormPath(Value, Macros), self._ModuleDir, Arch=self._Arch)
-                    # check the file validation
-                    ErrorCode, ErrorInfo = File.Validate(".dxs", CaseSensitive=False)
-                    if ErrorCode != 0:
-                        EdkLogger.error('build', ErrorCode, ExtraData=ErrorInfo,
-                                        File=self.MetaFile, Line=LineNo)
-                    if self.Sources == None:
-                        self._Sources = []
-                    self._Sources.append(File)
-                else:
-                    ToolList = self._NMAKE_FLAG_PATTERN_.findall(Name)
-                    if len(ToolList) == 0 or len(ToolList) != 1:
-                        pass
-#                        EdkLogger.warn("build", "Don't know how to do with macro [%s]" % Name,
-#                                       File=self.MetaFile, Line=LineNo)
-                    else:
-                        if self._BuildOptions == None:
-                            self._BuildOptions = sdict()
-
-                        if ToolList[0] in self._TOOL_CODE_:
-                            Tool = self._TOOL_CODE_[ToolList[0]]
-                        else:
-                            Tool = ToolList[0]
-                        ToolChain = "*_*_*_%s_FLAGS" % Tool
-                        ToolChainFamily = 'MSFT'    # R8.x only support MSFT tool chain
-                        #ignore not replaced macros in value
-                        ValueList = GetSplitValueList(' ' + Value, '/D')
-                        Dummy = ValueList[0]
-                        for Index in range(1, len(ValueList)):
-                            if ValueList[Index][-1] == '=' or ValueList[Index] == '':
-                                continue
-                            Dummy = Dummy + ' /D ' + ValueList[Index]
-                        Value = Dummy.strip()
-                        if (ToolChainFamily, ToolChain) not in self._BuildOptions:
-                            self._BuildOptions[ToolChainFamily, ToolChain] = Value
-                        else:
-                            OptionString = self._BuildOptions[ToolChainFamily, ToolChain]
-                            self._BuildOptions[ToolChainFamily, ToolChain] = OptionString + " " + Value
-        # set _Header to non-None in order to avoid database re-querying
-        self._Header_ = 'DUMMY'
-
-    ## Retrieve file version
-    def _GetInfVersion(self):
-        if self._AutoGenVersion == None:
-            if self._Header_ == None:
-                self._GetHeaderInfo()
-            if self._AutoGenVersion == None:
-                self._AutoGenVersion = 0x00010000
-        return self._AutoGenVersion
-
-    ## Retrieve BASE_NAME
-    def _GetBaseName(self):
-        if self._BaseName == None:
-            if self._Header_ == None:
-                self._GetHeaderInfo()
-            if self._BaseName == None:
-                EdkLogger.error('build', ATTRIBUTE_NOT_AVAILABLE, "No BASE_NAME name", File=self.MetaFile)
-        return self._BaseName
-
-    ## Retrieve MODULE_TYPE
-    def _GetModuleType(self):
-        if self._ModuleType == None:
-            if self._Header_ == None:
-                self._GetHeaderInfo()
-            if self._ModuleType == None:
-                self._ModuleType = 'BASE'
-            if self._ModuleType not in SUP_MODULE_LIST:
-                self._ModuleType = "USER_DEFINED"
-        return self._ModuleType
-
-    ## Retrieve COMPONENT_TYPE
-    def _GetComponentType(self):
-        if self._ComponentType == None:
-            if self._Header_ == None:
-                self._GetHeaderInfo()
-            if self._ComponentType == None:
-                self._ComponentType = 'USER_DEFINED'
-        return self._ComponentType
-
-    ## Retrieve "BUILD_TYPE"
-    def _GetBuildType(self):
-        if self._BuildType == None:
-            if self._Header_ == None:
-                self._GetHeaderInfo()
-            if not self._BuildType:
-                self._BuildType = "BASE"
-        return self._BuildType
-
-    ## Retrieve file guid
-    def _GetFileGuid(self):
-        if self._Guid == None:
-            if self._Header_ == None:
-                self._GetHeaderInfo()
-            if self._Guid == None:
-                self._Guid = '00000000-0000-0000-000000000000'
-        return self._Guid
-
-    ## Retrieve module version
-    def _GetVersion(self):
-        if self._Version == None:
-            if self._Header_ == None:
-                self._GetHeaderInfo()
-            if self._Version == None:
-                self._Version = '0.0'
-        return self._Version
-
-    ## Retrieve PCD_IS_DRIVER
-    def _GetPcdIsDriver(self):
-        if self._PcdIsDriver == None:
-            if self._Header_ == None:
-                self._GetHeaderInfo()
-            if self._PcdIsDriver == None:
-                self._PcdIsDriver = ''
-        return self._PcdIsDriver
-
-    ## Retrieve SHADOW
-    def _GetShadow(self):
-        if self._Shadow == None:
-            if self._Header_ == None:
-                self._GetHeaderInfo()
-            if self._Shadow != None and self._Shadow.upper() == 'TRUE':
-                self._Shadow = True
-            else:
-                self._Shadow = False
-        return self._Shadow
-
-    ## Retrieve CUSTOM_MAKEFILE
-    def _GetMakefile(self):
-        if self._CustomMakefile == None:
-            if self._Header_ == None:
-                self._GetHeaderInfo()
-            if self._CustomMakefile == None:
-                self._CustomMakefile = {}
-        return self._CustomMakefile
-
-    ## Retrieve EFI_SPECIFICATION_VERSION
-    def _GetSpec(self):
-        if self._Specification == None:
-            if self._Header_ == None:
-                self._GetHeaderInfo()
-            if self._Specification == None:
-                self._Specification = {}
-        return self._Specification
-
-    ## Retrieve LIBRARY_CLASS
-    def _GetLibraryClass(self):
-        if self._LibraryClass == None:
-            if self._Header_ == None:
-                self._GetHeaderInfo()
-            if self._LibraryClass == None:
-                self._LibraryClass = []
-        return self._LibraryClass
-
-    ## Retrieve ENTRY_POINT
-    def _GetEntryPoint(self):
-        if self._ModuleEntryPointList == None:
-            if self._Header_ == None:
-                self._GetHeaderInfo()
-            if self._ModuleEntryPointList == None:
-                self._ModuleEntryPointList = []
-        return self._ModuleEntryPointList
-
-    ## Retrieve UNLOAD_IMAGE
-    def _GetUnloadImage(self):
-        if self._ModuleUnloadImageList == None:
-            if self._Header_ == None:
-                self._GetHeaderInfo()
-            if self._ModuleUnloadImageList == None:
-                self._ModuleUnloadImageList = []
-        return self._ModuleUnloadImageList
-
-    ## Retrieve CONSTRUCTOR
-    def _GetConstructor(self):
-        if self._ConstructorList == None:
-            if self._Header_ == None:
-                self._GetHeaderInfo()
-            if self._ConstructorList == None:
-                self._ConstructorList = []
-        return self._ConstructorList
-
-    ## Retrieve DESTRUCTOR
-    def _GetDestructor(self):
-        if self._DestructorList == None:
-            if self._Header_ == None:
-                self._GetHeaderInfo()
-            if self._DestructorList == None:
-                self._DestructorList = []
-        return self._DestructorList
-
-    ## Retrieve definies other than above ones
-    def _GetDefines(self):
-        if self._Defs == None:
-            if self._Header_ == None:
-                self._GetHeaderInfo()
-            if self._Defs == None:
-                self._Defs = sdict()
-        return self._Defs
-
-    ## Retrieve binary files
-    def _GetBinaryFiles(self):
-        if self._Binaries == None:
-            self._Binaries = []
-            RecordList = self._RawData[MODEL_EFI_BINARY_FILE, self._Arch, self._Platform]
-            Macros = {"EDK_SOURCE":GlobalData.gEcpSource, "EFI_SOURCE":GlobalData.gEfiSource, 'PROCESSOR':self._Arch}
-            Macros.update(self._Macros)
-            for Record in RecordList:
-                Record = ReplaceMacros(Record, GlobalData.gEdkGlobal, False)
-                FileType = Record[0]
-                LineNo = Record[-1]
-                Target = 'COMMON'
-                FeatureFlag = []
-                if Record[2]:
-                    TokenList = GetSplitValueList(Record[2], TAB_VALUE_SPLIT)
-                    if TokenList:
-                        Target = TokenList[0]
-                    if len(TokenList) > 1:
-                        FeatureFlag = Record[1:]
-
-                File = PathClass(NormPath(Record[1], Macros), self._ModuleDir, '', FileType, True, self._Arch, '', Target)
-                # check the file validation
-                ErrorCode, ErrorInfo = File.Validate()
-                if ErrorCode != 0:
-                    EdkLogger.error('build', ErrorCode, ExtraData=ErrorInfo, File=self.MetaFile, Line=LineNo)
-                self._Binaries.append(File)
-        return self._Binaries
-
-    ## Retrieve source files
-    def _GetSourceFiles(self):
-        if self._Sources == None:
-            self._Sources = []
-            RecordList = self._RawData[MODEL_EFI_SOURCE_FILE, self._Arch, self._Platform]
-            Macros = {"EDK_SOURCE":GlobalData.gEcpSource, "EFI_SOURCE":GlobalData.gEfiSource, 'PROCESSOR':self._Arch}
-            Macros.update(self._Macros)
-            for Record in RecordList:
-                Record = ReplaceMacros(Record, GlobalData.gEdkGlobal, False)
-                LineNo = Record[-1]
-                ToolChainFamily = Record[1]
-                TagName = Record[2]
-                ToolCode = Record[3]
-                FeatureFlag = Record[4]
-                if self._AutoGenVersion < 0x00010005:
-                    # old module source files (R8)
-                    File = PathClass(NormPath(Record[0], Macros), self._ModuleDir, self._SourceOverridePath,
-                                     '', False, self._Arch, ToolChainFamily, '', TagName, ToolCode)
-                    # check the file validation
-                    ErrorCode, ErrorInfo = File.Validate(CaseSensitive=False)
-                    if ErrorCode != 0:
-                        if File.Ext.lower() == '.h':
-                            EdkLogger.warn('build', 'Include file not found', ExtraData=ErrorInfo,
-                                           File=self.MetaFile, Line=LineNo)
-                            continue
-                        else:
-                            EdkLogger.error('build', ErrorCode, ExtraData=File, File=self.MetaFile, Line=LineNo)
-                else:
-                    File = PathClass(NormPath(Record[0], Macros), self._ModuleDir, '',
-                                     '', False, self._Arch, ToolChainFamily, '', TagName, ToolCode)
-                    # check the file validation
-                    ErrorCode, ErrorInfo = File.Validate()
-                    if ErrorCode != 0:
-                        EdkLogger.error('build', ErrorCode, ExtraData=ErrorInfo, File=self.MetaFile, Line=LineNo)
-
-                self._Sources.append(File)
-        return self._Sources
-
-    ## Retrieve library classes employed by this module
-    def _GetLibraryClassUses(self):
-        if self._LibraryClasses == None:
-            self._LibraryClasses = sdict()
-            RecordList = self._RawData[MODEL_EFI_LIBRARY_CLASS, self._Arch, self._Platform]
-            for Record in RecordList:
-                Record = ReplaceMacros(Record, GlobalData.gEdkGlobal, False)
-                Lib = Record[0]
-                Instance = Record[1]
-                if Instance != None and Instance != '':
-                    Instance = NormPath(Instance, self._Macros)
-                self._LibraryClasses[Lib] = Instance
-        return self._LibraryClasses
-
-    ## Retrieve library names (for R8.x style of modules)
-    def _GetLibraryNames(self):
-        if self._Libraries == None:
-            self._Libraries = []
-            RecordList = self._RawData[MODEL_EFI_LIBRARY_INSTANCE, self._Arch, self._Platform]
-            for Record in RecordList:
-                # in case of name with '.lib' extension, which is unusual in R8.x inf
-                Record = ReplaceMacros(Record, GlobalData.gEdkGlobal, False)
-                LibraryName = os.path.splitext(Record[0])[0]
-                if LibraryName not in self._Libraries:
-                    self._Libraries.append(LibraryName)
-        return self._Libraries
-
-    ## Retrieve protocols consumed/produced by this module
-    def _GetProtocols(self):
-        if self._Protocols == None:
-            self._Protocols = sdict()
-            RecordList = self._RawData[MODEL_EFI_PROTOCOL, self._Arch, self._Platform]
-            for Record in RecordList:
-                CName = Record[0]
-                Value = ProtocolValue(CName, self.Packages)
-                if Value == None:
-                    PackageList = "\n\t".join([str(P) for P in self.Packages])
-                    EdkLogger.error('build', RESOURCE_NOT_AVAILABLE,
-                                    "Value of Protocol [%s] is not found under [Protocols] section in" % CName,
-                                    ExtraData=PackageList, File=self.MetaFile, Line=Record[-1])
-                self._Protocols[CName] = Value
-        return self._Protocols
-
-    ## Retrieve PPIs consumed/produced by this module
-    def _GetPpis(self):
-        if self._Ppis == None:
-            self._Ppis = sdict()
-            RecordList = self._RawData[MODEL_EFI_PPI, self._Arch, self._Platform]
-            for Record in RecordList:
-                CName = Record[0]
-                Value = PpiValue(CName, self.Packages)
-                if Value == None:
-                    PackageList = "\n\t".join([str(P) for P in self.Packages])
-                    EdkLogger.error('build', RESOURCE_NOT_AVAILABLE,
-                                    "Value of PPI [%s] is not found under [Ppis] section in " % CName,
-                                    ExtraData=PackageList, File=self.MetaFile, Line=Record[-1])
-                self._Ppis[CName] = Value
-        return self._Ppis
-
-    ## Retrieve GUIDs consumed/produced by this module
-    def _GetGuids(self):
-        if self._Guids == None:
-            self._Guids = sdict()
-            RecordList = self._RawData[MODEL_EFI_GUID, self._Arch, self._Platform]
-            for Record in RecordList:
-                CName = Record[0]
-                Value = GuidValue(CName, self.Packages)
-                if Value == None:
-                    PackageList = "\n\t".join([str(P) for P in self.Packages])
-                    EdkLogger.error('build', RESOURCE_NOT_AVAILABLE,
-                                    "Value of Guid [%s] is not found under [Guids] section in" % CName,
-                                    ExtraData=PackageList, File=self.MetaFile, Line=Record[-1])
-                self._Guids[CName] = Value
-        return self._Guids
-
-    ## Retrieve include paths necessary for this module (for R8.x style of modules)
-    def _GetIncludes(self):
-        if self._Includes == None:
-            self._Includes = []
-            if self._SourceOverridePath:
-                self._Includes.append(self._SourceOverridePath)
-            RecordList = self._RawData[MODEL_EFI_INCLUDE, self._Arch, self._Platform]
-            # [includes] section must be used only in old (R8.x) inf file
-            if self.AutoGenVersion >= 0x00010005 and len(RecordList) > 0:
-                EdkLogger.error('build', FORMAT_NOT_SUPPORTED, "No [include] section allowed",
-                                File=self.MetaFile, Line=RecordList[0][-1]-1)
-            for Record in RecordList:
-                Record = ReplaceMacros(Record, GlobalData.gEdkGlobal, False)
-                Record[0] = Record[0].replace('$(PROCESSOR)', self._Arch)
-                Record[0] = ReplaceMacro(Record[0], {'EFI_SOURCE' : GlobalData.gEfiSource}, False)
-                if Record[0].find('EDK_SOURCE') > -1:
-                    File = NormPath(ReplaceMacro(Record[0], {'EDK_SOURCE' : GlobalData.gEcpSource}, False), self._Macros)
-                    if File[0] == '.':
-                        File = os.path.join(self._ModuleDir, File)
-                    else:
-                        File = os.path.join(GlobalData.gWorkspace, File)
-                    File = RealPath(os.path.normpath(File))
-                    if File:
-                        self._Includes.append(File)
-
-                    #TRICK: let compiler to choose correct header file
-                    File = NormPath(ReplaceMacro(Record[0], {'EDK_SOURCE' : GlobalData.gEdkSource}, False), self._Macros)
-                    if File[0] == '.':
-                        File = os.path.join(self._ModuleDir, File)
-                    else:
-                        File = os.path.join(GlobalData.gWorkspace, File)
-                    File = RealPath(os.path.normpath(File))
-                    if File:
-                        self._Includes.append(File)
-                else:
-                    File = NormPath(Record[0], self._Macros)
-                    if File[0] == '.':
-                        File = os.path.join(self._ModuleDir, File)
-                    else:
-                        File = os.path.join(GlobalData.gWorkspace, File)
-                    File = RealPath(os.path.normpath(File))
-                    if File:
-                        self._Includes.append(File)
-        return self._Includes
-
-    ## Retrieve packages this module depends on
-    def _GetPackages(self):
-        if self._Packages == None:
-            self._Packages = []
-            RecordList = self._RawData[MODEL_META_DATA_PACKAGE, self._Arch, self._Platform]
-            Macros = {"EDK_SOURCE":GlobalData.gEcpSource, "EFI_SOURCE":GlobalData.gEfiSource}
-            Macros.update(self._Macros)
-            for Record in RecordList:
-                File = PathClass(NormPath(Record[0], Macros), GlobalData.gWorkspace, Arch=self._Arch)
-                LineNo = Record[-1]
-                # check the file validation
-                ErrorCode, ErrorInfo = File.Validate('.dec')
-                if ErrorCode != 0:
-                    EdkLogger.error('build', ErrorCode, ExtraData=ErrorInfo, File=self.MetaFile, Line=LineNo)
-                # parse this package now. we need it to get protocol/ppi/guid value
-                Package = self._Bdb[File, self._Arch]
-                self._Packages.append(Package)
-        return self._Packages
-
-    ## Retrieve PCDs used in this module
-    def _GetPcds(self):
-        if self._Pcds == None:
-            self._Pcds = {}
-            self._Pcds.update(self._GetPcd(MODEL_PCD_FIXED_AT_BUILD))
-            self._Pcds.update(self._GetPcd(MODEL_PCD_PATCHABLE_IN_MODULE))
-            self._Pcds.update(self._GetPcd(MODEL_PCD_FEATURE_FLAG))
-            self._Pcds.update(self._GetPcd(MODEL_PCD_DYNAMIC))
-            self._Pcds.update(self._GetPcd(MODEL_PCD_DYNAMIC_EX))
-        return self._Pcds
-
-    ## Retrieve build options specific to this module
-    def _GetBuildOptions(self):
-        if self._BuildOptions == None:
-            self._BuildOptions = sdict()
-            RecordList = self._RawData[MODEL_META_DATA_BUILD_OPTION, self._Arch, self._Platform]
-            for Record in RecordList:
-                ToolChainFamily = Record[0]
-                ToolChain = Record[1]
-                Option = Record[2]
-                if (ToolChainFamily, ToolChain) not in self._BuildOptions:
-                    self._BuildOptions[ToolChainFamily, ToolChain] = Option
-                else:
-                    # concatenate the option string if they're for the same tool
-                    OptionString = self._BuildOptions[ToolChainFamily, ToolChain]
-                    self._BuildOptions[ToolChainFamily, ToolChain] = OptionString + " " + Option
-        return self._BuildOptions
-
-    ## Retrieve depedency expression
-    def _GetDepex(self):
-        if self._Depex == None:
-            self._Depex = tdict(False, 2)
-            RecordList = self._RawData[MODEL_EFI_DEPEX, self._Arch]
-
-            # PEIM and DXE drivers must have a valid [Depex] section
-            if len(self.LibraryClass) == 0 and len(RecordList) == 0:
-                if self.ModuleType == 'DXE_DRIVER' or self.ModuleType == 'PEIM' or self.ModuleType == 'DXE_SMM_DRIVER' or \
-                    self.ModuleType == 'DXE_SAL_DRIVER' or self.ModuleType == 'DXE_RUNTIME_DRIVER':
-                    EdkLogger.error('build', RESOURCE_NOT_AVAILABLE, "No [Depex] section or no valid expression in [Depex] section for [%s] module" \
-                                    % self.ModuleType, File=self.MetaFile)
-
-            Depex = {}
-            for Record in RecordList:
-                Record = ReplaceMacros(Record, GlobalData.gEdkGlobal, False)
-                Arch = Record[3]
-                ModuleType = Record[4]
-                TokenList = Record[0].split()
-                if (Arch, ModuleType) not in Depex:
-                    Depex[Arch, ModuleType] = []
-                DepexList = Depex[Arch, ModuleType]
-                for Token in TokenList:
-                    if Token in DEPEX_SUPPORTED_OPCODE:
-                        DepexList.append(Token)
-                    elif Token.endswith(".inf"):    # module file name
-                        ModuleFile = os.path.normpath(Token)
-                        Module = self.BuildDatabase[ModuleFile]
-                        if Module == None:
-                            EdkLogger.error('build', RESOURCE_NOT_AVAILABLE, "Module is not found in active platform",
-                                            ExtraData=Token, File=self.MetaFile, Line=Record[-1])
-                        DepexList.append(Module.Guid)
-                    else:
-                        # get the GUID value now
-                        Value = ProtocolValue(Token, self.Packages)
-                        if Value == None:
-                            Value = PpiValue(Token, self.Packages)
-                            if Value == None:
-                                Value = GuidValue(Token, self.Packages)
-                        if Value == None:
-                            PackageList = "\n\t".join([str(P) for P in self.Packages])
-                            EdkLogger.error('build', RESOURCE_NOT_AVAILABLE,
-                                            "Value of [%s] is not found in" % Token,
-                                            ExtraData=PackageList, File=self.MetaFile, Line=Record[-1])
-                        DepexList.append(Value)
-            for Arch, ModuleType in Depex:
-                self._Depex[Arch, ModuleType] = Depex[Arch, ModuleType]
-        return self._Depex
-
-    ## Retrieve depedency expression
-    def _GetDepexExpression(self):
-        if self._DepexExpression == None:
-            self._DepexExpression = tdict(False, 2)
-            RecordList = self._RawData[MODEL_EFI_DEPEX, self._Arch]
-            DepexExpression = {}
-            for Record in RecordList:
-                Record = ReplaceMacros(Record, GlobalData.gEdkGlobal, False)
-                Arch = Record[3]
-                ModuleType = Record[4]
-                TokenList = Record[0].split()
-                if (Arch, ModuleType) not in DepexExpression:
-                    DepexExpression[Arch, ModuleType] = ''
-                for Token in TokenList:
-                    DepexExpression[Arch, ModuleType] = DepexExpression[Arch, ModuleType] + Token.strip() + ' '
-            for Arch, ModuleType in DepexExpression:
-                self._DepexExpression[Arch, ModuleType] = DepexExpression[Arch, ModuleType]
-        return self._DepexExpression
-
-    ## Retrieve PCD for given type
-    def _GetPcd(self, Type):
-        Pcds = {}
-        PcdDict = tdict(True, 4)
-        PcdSet = set()
-        RecordList = self._RawData[Type, self._Arch, self._Platform]
-        for TokenSpaceGuid, PcdCName, Setting, Arch, Platform, Dummy1, LineNo in RecordList:
-            PcdDict[Arch, Platform, PcdCName, TokenSpaceGuid] = (Setting, LineNo)
-            PcdSet.add((PcdCName, TokenSpaceGuid))
-            # get the guid value
-            if TokenSpaceGuid not in self.Guids:
-                Value = GuidValue(TokenSpaceGuid, self.Packages)
-                if Value == None:
-                    PackageList = "\n\t".join([str(P) for P in self.Packages])
-                    EdkLogger.error('build', RESOURCE_NOT_AVAILABLE,
-                                    "Value of Guid [%s] is not found under [Guids] section in" % TokenSpaceGuid,
-                                    ExtraData=PackageList, File=self.MetaFile, Line=LineNo)
-                self.Guids[TokenSpaceGuid] = Value
-
-        # resolve PCD type, value, datum info, etc. by getting its definition from package
-        for PcdCName, TokenSpaceGuid in PcdSet:
-            ValueList = ['', '']
-            Setting, LineNo = PcdDict[self._Arch, self.Platform, PcdCName, TokenSpaceGuid]
-            if Setting == None:
-                continue
-            TokenList = Setting.split(TAB_VALUE_SPLIT)
-            ValueList[0:len(TokenList)] = TokenList
-            DefaultValue = ValueList[0]
-            Pcd = PcdClassObject(
-                    PcdCName,
-                    TokenSpaceGuid,
-                    '',
-                    '',
-                    DefaultValue,
-                    '',
-                    '',
-                    {},
-                    self.Guids[TokenSpaceGuid]
-                    )
-
-            # get necessary info from package declaring this PCD
-            for Package in self.Packages:
-                #
-                # 'dynamic' in INF means its type is determined by platform;
-                # if platform doesn't give its type, use 'lowest' one in the
-                # following order, if any
-                #
-                #   "FixedAtBuild", "PatchableInModule", "FeatureFlag", "Dynamic", "DynamicEx"
-                #
-                PcdType = self._PCD_TYPE_STRING_[Type]
-                if Type in [MODEL_PCD_DYNAMIC, MODEL_PCD_DYNAMIC_EX]:
-                    Pcd.Pending = True
-                    for T in ["FixedAtBuild", "PatchableInModule", "FeatureFlag", "Dynamic", "DynamicEx"]:
-                        if (PcdCName, TokenSpaceGuid, T) in Package.Pcds:
-                            PcdType = T
-                            break
-                else:
-                    Pcd.Pending = False
-
-                if (PcdCName, TokenSpaceGuid, PcdType) in Package.Pcds:
-                    PcdInPackage = Package.Pcds[PcdCName, TokenSpaceGuid, PcdType]
-                    Pcd.Type = PcdType
-                    Pcd.TokenValue = PcdInPackage.TokenValue
-                    Pcd.DatumType = PcdInPackage.DatumType
-                    Pcd.MaxDatumSize = PcdInPackage.MaxDatumSize
-                    Pcd.InfDefaultValue = Pcd.DefaultValue
-                    if Pcd.DefaultValue in [None, '']:
-                        Pcd.DefaultValue = PcdInPackage.DefaultValue
-                    break
-            else:
-                EdkLogger.error(
-                            'build',
-                            PARSER_ERROR,
-                            "PCD [%s.%s] in [%s] is not found in dependent packages:" % (TokenSpaceGuid, PcdCName, self.MetaFile),
-                            File =self.MetaFile, Line=LineNo,
-                            ExtraData="\t%s" % '\n\t'.join([str(P) for P in self.Packages])
-                            )
-            Pcds[PcdCName, TokenSpaceGuid] = Pcd
-        return Pcds
-
-    Arch                    = property(_GetArch, _SetArch)
-    Platform                = property(_GetPlatform, _SetPlatform)
-
-    AutoGenVersion          = property(_GetInfVersion)
-    BaseName                = property(_GetBaseName)
-    ModuleType              = property(_GetModuleType)
-    ComponentType           = property(_GetComponentType)
-    BuildType               = property(_GetBuildType)
-    Guid                    = property(_GetFileGuid)
-    Version                 = property(_GetVersion)
-    PcdIsDriver             = property(_GetPcdIsDriver)
-    Shadow                  = property(_GetShadow)
-    CustomMakefile          = property(_GetMakefile)
-    Specification           = property(_GetSpec)
-    LibraryClass            = property(_GetLibraryClass)
-    ModuleEntryPointList    = property(_GetEntryPoint)
-    ModuleUnloadImageList   = property(_GetUnloadImage)
-    ConstructorList         = property(_GetConstructor)
-    DestructorList          = property(_GetDestructor)
-    Defines                 = property(_GetDefines)
-
-    Binaries                = property(_GetBinaryFiles)
-    Sources                 = property(_GetSourceFiles)
-    LibraryClasses          = property(_GetLibraryClassUses)
-    Libraries               = property(_GetLibraryNames)
-    Protocols               = property(_GetProtocols)
-    Ppis                    = property(_GetPpis)
-    Guids                   = property(_GetGuids)
-    Includes                = property(_GetIncludes)
-    Packages                = property(_GetPackages)
-    Pcds                    = property(_GetPcds)
-    BuildOptions            = property(_GetBuildOptions)
-    Depex                   = property(_GetDepex)
-    DepexExpression         = property(_GetDepexExpression)
-
-## Database
-#
-#   This class defined the build databse for all modules, packages and platform.
-# It will call corresponding parser for the given file if it cannot find it in
-# the database.
-#
-# @param DbPath             Path of database file
-# @param GlobalMacros       Global macros used for replacement during file parsing
-# @prarm RenewDb=False      Create new database file if it's already there
-#
-class WorkspaceDatabase(object):
-    # file parser
-    _FILE_PARSER_ = {
-        MODEL_FILE_INF  :   InfParser,
-        MODEL_FILE_DEC  :   DecParser,
-        MODEL_FILE_DSC  :   DscParser,
-        MODEL_FILE_FDF  :   None, #FdfParser,
-        MODEL_FILE_CIF  :   None
-    }
-
-    # file table
-    _FILE_TABLE_ = {
-        MODEL_FILE_INF  :   ModuleTable,
-        MODEL_FILE_DEC  :   PackageTable,
-        MODEL_FILE_DSC  :   PlatformTable,
-    }
-
-    # default database file path
-    _DB_PATH_ = "Conf/.cache/build.db"
-
-    #
-    # internal class used for call corresponding file parser and caching the result
-    # to avoid unnecessary re-parsing
-    #
-    class BuildObjectFactory(object):
-        _FILE_TYPE_ = {
-            ".inf"  : MODEL_FILE_INF,
-            ".dec"  : MODEL_FILE_DEC,
-            ".dsc"  : MODEL_FILE_DSC,
-            ".fdf"  : MODEL_FILE_FDF,
-        }
-
-        # convert to xxxBuildData object
-        _GENERATOR_ = {
-            MODEL_FILE_INF  :   InfBuildData,
-            MODEL_FILE_DEC  :   DecBuildData,
-            MODEL_FILE_DSC  :   DscBuildData,
-            MODEL_FILE_FDF  :   None #FlashDefTable,
-        }
-
-        _CACHE_ = {}    # (FilePath, Arch)  : <object>
-
-        # constructor
-        def __init__(self, WorkspaceDb):
-            self.WorkspaceDb = WorkspaceDb
-
-        # key = (FilePath, Arch='COMMON')
-        def __contains__(self, Key):
-            FilePath = Key[0]
-            Arch = 'COMMON'
-            if len(Key) > 1:
-                Arch = Key[1]
-            return (FilePath, Arch) in self._CACHE_
-
-        # key = (FilePath, Arch='COMMON')
-        def __getitem__(self, Key):
-            FilePath = Key[0]
-            Arch = 'COMMON'
-            Platform = 'COMMON'
-            if len(Key) > 1:
-                Arch = Key[1]
-            if len(Key) > 2:
-                Platform = Key[2]
-
-            # if it's generated before, just return the cached one
-            Key = (FilePath, Arch)
-            if Key in self._CACHE_:
-                return self._CACHE_[Key]
-
-            # check file type
-            Ext = FilePath.Ext.lower()
-            if Ext not in self._FILE_TYPE_:
-                return None
-            FileType = self._FILE_TYPE_[Ext]
-            if FileType not in self._GENERATOR_:
-                return None
-
-            # get table for current file
-            MetaFile = self.WorkspaceDb[FilePath, FileType, self.WorkspaceDb._GlobalMacros]
-            BuildObject = self._GENERATOR_[FileType](
-                                    FilePath,
-                                    MetaFile,
-                                    self,
-                                    Arch,
-                                    Platform,
-                                    self.WorkspaceDb._GlobalMacros,
-                                    )
-            self._CACHE_[Key] = BuildObject
-            return BuildObject
-
-    # placeholder for file format conversion
-    class TransformObjectFactory:
-        def __init__(self, WorkspaceDb):
-            self.WorkspaceDb = WorkspaceDb
-
-        # key = FilePath, Arch
-        def __getitem__(self, Key):
-            pass
-
-    ## Constructor of WorkspaceDatabase
-    #
-    # @param DbPath             Path of database file
-    # @param GlobalMacros       Global macros used for replacement during file parsing
-    # @prarm RenewDb=False      Create new database file if it's already there
-    #
-    def __init__(self, DbPath, GlobalMacros={}, RenewDb=False):
-        self._GlobalMacros = GlobalMacros
-
-        if DbPath == None or DbPath == '':
-            DbPath = os.path.normpath(os.path.join(GlobalData.gWorkspace, self._DB_PATH_))
-
-        # don't create necessary path for db in memory
-        if DbPath != ':memory:':
-            DbDir = os.path.split(DbPath)[0]
-            if not os.path.exists(DbDir):
-                os.makedirs(DbDir)
-
-            # remove db file in case inconsistency between db and file in file system
-            if self._CheckWhetherDbNeedRenew(RenewDb, DbPath):
-                os.remove(DbPath)
-        
-        # create db with optimized parameters
-        self.Conn = sqlite3.connect(DbPath, isolation_level='DEFERRED')
-        self.Conn.execute("PRAGMA synchronous=OFF")
-        self.Conn.execute("PRAGMA temp_store=MEMORY")
-        self.Conn.execute("PRAGMA count_changes=OFF")
-        self.Conn.execute("PRAGMA cache_size=8192")
-        #self.Conn.execute("PRAGMA page_size=8192")
-
-        # to avoid non-ascii character conversion issue
-        self.Conn.text_factory = str
-        self.Cur = self.Conn.cursor()
-
-        # create table for internal uses
-        self.TblDataModel = TableDataModel(self.Cur)
-        self.TblFile = TableFile(self.Cur)
-
-        # conversion object for build or file format conversion purpose
-        self.BuildObject = WorkspaceDatabase.BuildObjectFactory(self)
-        self.TransformObject = WorkspaceDatabase.TransformObjectFactory(self)
-
-    ## Check whether workspace database need to be renew.
-    #  The renew reason maybe:
-    #  1) If user force to renew;
-    #  2) If user do not force renew, and
-    #     a) If the time of last modified python source is newer than database file;
-    #     b) If the time of last modified frozen executable file is newer than database file;
-    #
-    #  @param force     User force renew database
-    #  @param DbPath    The absolute path of workspace database file
-    #
-    #  @return Bool value for whether need renew workspace databse
-    #
-    def _CheckWhetherDbNeedRenew (self, force, DbPath):
-        DbDir = os.path.split(DbPath)[0]
-        MacroFilePath = os.path.normpath(os.path.join(DbDir, "build.mac"))
-        MacroMatch = False
-        if os.path.exists(MacroFilePath) and os.path.isfile(MacroFilePath):
-            LastMacros = None
-            try:
-                f = open(MacroFilePath,'r')
-                LastMacros = pickle.load(f)
-                f.close()
-            except IOError:
-                pass
-            except:
-                f.close()
-
-            if LastMacros != None and type(LastMacros) is DictType:
-                if LastMacros == self._GlobalMacros:
-                    MacroMatch = True
-                    for Macro in LastMacros.keys():
-                        if not (Macro in self._GlobalMacros and LastMacros[Macro] == self._GlobalMacros[Macro]):
-                            MacroMatch = False;
-                            break;
-
-        if not MacroMatch:
-            # save command line macros to file
-            try:
-                f = open(MacroFilePath,'w')
-                pickle.dump(self._GlobalMacros, f, 2)
-                f.close()
-            except IOError:
-                pass
-            except:
-                f.close()
-
-            force = True
-
-        # if database does not exist, we need do nothing
-        if not os.path.exists(DbPath): return False
-            
-        # if user force to renew database, then not check whether database is out of date
-        if force: return True
-        
-        #    
-        # Check the time of last modified source file or build.exe
-        # if is newer than time of database, then database need to be re-created.
-        #
-        timeOfToolModified = 0
-        if hasattr(sys, "frozen"):
-            exePath             = os.path.abspath(sys.executable)
-            timeOfToolModified  = os.stat(exePath).st_mtime
-        else:
-            curPath  = os.path.dirname(__file__) # curPath is the path of WorkspaceDatabase.py
-            rootPath = os.path.split(curPath)[0] # rootPath is root path of python source, such as /BaseTools/Source/Python
-            if rootPath == "" or rootPath == None:
-                EdkLogger.verbose("\nFail to find the root path of build.exe or python sources, so can not \
-determine whether database file is out of date!\n")
-        
-            # walk the root path of source or build's binary to get the time last modified.
-        
-            for root, dirs, files in os.walk (rootPath):
-                for dir in dirs:
-                    # bypass source control folder 
-                    if dir.lower() in [".svn", "_svn", "cvs"]:
-                        dirs.remove(dir)
-                        
-                for file in files:
-                    ext = os.path.splitext(file)[1]
-                    if ext.lower() == ".py":            # only check .py files
-                        fd = os.stat(os.path.join(root, file))
-                        if timeOfToolModified < fd.st_mtime:
-                            timeOfToolModified = fd.st_mtime
-        if timeOfToolModified > os.stat(DbPath).st_mtime:
-            EdkLogger.verbose("\nWorkspace database is out of data!")
-            return True
-            
-        return False
-            
-    ## Initialize build database
-    def InitDatabase(self):
-        EdkLogger.verbose("\nInitialize build database started ...")
-
-        #
-        # Create new tables
-        #
-        self.TblDataModel.Create(False)
-        self.TblFile.Create(False)
-
-        #
-        # Initialize table DataModel
-        #
-        self.TblDataModel.InitTable()
-        EdkLogger.verbose("Initialize build database ... DONE!")
-
-    ## Query a table
-    #
-    # @param Table:  The instance of the table to be queried
-    #
-    def QueryTable(self, Table):
-        Table.Query()
-
-    ## Close entire database
-    #
-    # Commit all first
-    # Close the connection and cursor
-    #
-    def Close(self):
-        self.Conn.commit()
-        self.Cur.close()
-        self.Conn.close()
-
-    ## Get unique file ID for the gvien file
-    def GetFileId(self, FilePath):
-        return self.TblFile.GetFileId(FilePath)
-
-    ## Get file type value for the gvien file ID
-    def GetFileType(self, FileId):
-        return self.TblFile.GetFileType(FileId)
-
-    ## Get time stamp stored in file table
-    def GetTimeStamp(self, FileId):
-        return self.TblFile.GetFileTimeStamp(FileId)
-
-    ## Update time stamp in file table
-    def SetTimeStamp(self, FileId, TimeStamp):
-        return self.TblFile.SetFileTimeStamp(FileId, TimeStamp)
-
-    ## Check if a table integrity flag exists or not
-    def CheckIntegrity(self, TableName):
-        try:
-            Result = self.Cur.execute("select min(ID) from %s" % (TableName)).fetchall()
-            if Result[0][0] != -1:
-                return False
-        except:
-            return False
-        return True
-
-    ## Compose table name for given file type and file ID
-    def GetTableName(self, FileType, FileId):
-        return "_%s_%s" % (FileType, FileId)
-
-    ## Return a temp table containing all content of the given file
-    #
-    #   @param  FileInfo    The tuple containing path and type of a file
-    #
-    def __getitem__(self, FileInfo):
-        FilePath, FileType, Macros = FileInfo
-        if FileType not in self._FILE_TABLE_:
-            return None
-
-        # flag used to indicate if it's parsed or not
-        FilePath = str(FilePath)
-        Parsed = False
-        FileId = self.GetFileId(FilePath)
-        if FileId != None:
-            TimeStamp = os.stat(FilePath)[8]
-            TableName = self.GetTableName(FileType, FileId)
-            if TimeStamp != self.GetTimeStamp(FileId):
-                # update the timestamp in database
-                self.SetTimeStamp(FileId, TimeStamp)
-            else:
-                # if the table exists and is integrity, don't parse it
-                Parsed = self.CheckIntegrity(TableName)
-        else:
-            FileId = self.TblFile.InsertFile(FilePath, FileType)
-            TableName = self.GetTableName(FileType, FileId)
-
-        FileTable = self._FILE_TABLE_[FileType](self.Cur, TableName, FileId)
-        FileTable.Create(not Parsed)
-        Parser = self._FILE_PARSER_[FileType](FilePath, FileType, FileTable, Macros)
-        # set the "Finished" flag in parser in order to avoid re-parsing (if parsed)
-        Parser.Finished = Parsed
-        return Parser
-
-    ## Summarize all packages in the database
-    def _GetPackageList(self):
-        PackageList = []
-        for Module in self.ModuleList:
-            for Package in Module.Packages:
-                if Package not in PackageList:
-                    PackageList.append(Package)
-        return PackageList
-
-    ## Summarize all platforms in the database
-    def _GetPlatformList(self):
-        PlatformList = []
-        for PlatformFile in self.TblFile.GetFileList(MODEL_FILE_DSC):
-            try:
-                Platform = self.BuildObject[PathClass(PlatformFile), 'COMMON']
-            except:
-                Platform = None
-            if Platform != None:
-                PlatformList.append(Platform)
-        return PlatformList
-
-    ## Summarize all modules in the database
-    def _GetModuleList(self):
-        ModuleList = []
-        for ModuleFile in self.TblFile.GetFileList(MODEL_FILE_INF):
-            try:
-                Module = self.BuildObject[PathClass(ModuleFile), 'COMMON']
-            except:
-                Module = None
-            if Module != None:
-                ModuleList.append(Module)
-        return ModuleList
-
-    PlatformList = property(_GetPlatformList)
-    PackageList = property(_GetPackageList)
-    ModuleList = property(_GetModuleList)
-
-##
-#
-# This acts like the main() function for the script, unless it is 'import'ed into another
-# script.
-#
-if __name__ == '__main__':
-    pass
-
+## @file\r
+# This file is used to create a database used by build tool\r
+#\r
+# Copyright (c) 2008 - 2010, Intel Corporation\r
+# All rights reserved. This program and the accompanying materials\r
+# are licensed and made available under the terms and conditions of the BSD License\r
+# which accompanies this distribution.  The full text of the license may be found at\r
+# http://opensource.org/licenses/bsd-license.php\r
+#\r
+# THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,\r
+# WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.\r
+#\r
+\r
+##\r
+# Import Modules\r
+#\r
+import sqlite3\r
+import os\r
+import os.path\r
+import pickle\r
+\r
+import Common.EdkLogger as EdkLogger\r
+import Common.GlobalData as GlobalData\r
+\r
+from Common.String import *\r
+from Common.DataType import *\r
+from Common.Misc import *\r
+from types import *\r
+\r
+from CommonDataClass.CommonClass import SkuInfoClass\r
+\r
+from MetaDataTable import *\r
+from MetaFileTable import *\r
+from MetaFileParser import *\r
+from BuildClassObject import *\r
+\r
+## Platform build information from DSC file\r
+#\r
+#  This class is used to retrieve information stored in database and convert them\r
+# into PlatformBuildClassObject form for easier use for AutoGen.\r
+#\r
+class DscBuildData(PlatformBuildClassObject):\r
+    # dict used to convert PCD type in database to string used by build tool\r
+    _PCD_TYPE_STRING_ = {\r
+        MODEL_PCD_FIXED_AT_BUILD        :   "FixedAtBuild",\r
+        MODEL_PCD_PATCHABLE_IN_MODULE   :   "PatchableInModule",\r
+        MODEL_PCD_FEATURE_FLAG          :   "FeatureFlag",\r
+        MODEL_PCD_DYNAMIC               :   "Dynamic",\r
+        MODEL_PCD_DYNAMIC_DEFAULT       :   "Dynamic",\r
+        MODEL_PCD_DYNAMIC_HII           :   "DynamicHii",\r
+        MODEL_PCD_DYNAMIC_VPD           :   "DynamicVpd",\r
+        MODEL_PCD_DYNAMIC_EX            :   "DynamicEx",\r
+        MODEL_PCD_DYNAMIC_EX_DEFAULT    :   "DynamicEx",\r
+        MODEL_PCD_DYNAMIC_EX_HII        :   "DynamicExHii",\r
+        MODEL_PCD_DYNAMIC_EX_VPD        :   "DynamicExVpd",\r
+    }\r
+\r
+    # dict used to convert part of [Defines] to members of DscBuildData directly\r
+    _PROPERTY_ = {\r
+        #\r
+        # Required Fields\r
+        #\r
+        TAB_DSC_DEFINES_PLATFORM_NAME           :   "_PlatformName",\r
+        TAB_DSC_DEFINES_PLATFORM_GUID           :   "_Guid",\r
+        TAB_DSC_DEFINES_PLATFORM_VERSION        :   "_Version",\r
+        TAB_DSC_DEFINES_DSC_SPECIFICATION       :   "_DscSpecification",\r
+        #TAB_DSC_DEFINES_OUTPUT_DIRECTORY        :   "_OutputDirectory",\r
+        #TAB_DSC_DEFINES_SUPPORTED_ARCHITECTURES :   "_SupArchList",\r
+        #TAB_DSC_DEFINES_BUILD_TARGETS           :   "_BuildTargets",\r
+        #TAB_DSC_DEFINES_SKUID_IDENTIFIER        :   "_SkuName",\r
+        #TAB_DSC_DEFINES_FLASH_DEFINITION        :   "_FlashDefinition",\r
+        TAB_DSC_DEFINES_BUILD_NUMBER            :   "_BuildNumber",\r
+        TAB_DSC_DEFINES_MAKEFILE_NAME           :   "_MakefileName",\r
+        TAB_DSC_DEFINES_BS_BASE_ADDRESS         :   "_BsBaseAddress",\r
+        TAB_DSC_DEFINES_RT_BASE_ADDRESS         :   "_RtBaseAddress",\r
+    }\r
+\r
+    # used to compose dummy library class name for those forced library instances\r
+    _NullLibraryNumber = 0\r
+\r
+    ## Constructor of DscBuildData\r
+    #\r
+    #  Initialize object of DscBuildData\r
+    #\r
+    #   @param      FilePath        The path of platform description file\r
+    #   @param      RawData         The raw data of DSC file\r
+    #   @param      BuildDataBase   Database used to retrieve module/package information\r
+    #   @param      Arch            The target architecture\r
+    #   @param      Platform        (not used for DscBuildData)\r
+    #   @param      Macros          Macros used for replacement in DSC file\r
+    #\r
+    def __init__(self, FilePath, RawData, BuildDataBase, Arch='COMMON', Platform='DUMMY', Macros={}):\r
+        self.MetaFile = FilePath\r
+        self._RawData = RawData\r
+        self._Bdb = BuildDataBase\r
+        self._Arch = Arch\r
+        self._Macros = Macros\r
+        self._Clear()\r
+        RecordList = self._RawData[MODEL_META_DATA_DEFINE, self._Arch]\r
+        for Record in RecordList:\r
+            GlobalData.gEdkGlobal[Record[0]] = Record[1]\r
+\r
+    ## XXX[key] = value\r
+    def __setitem__(self, key, value):\r
+        self.__dict__[self._PROPERTY_[key]] = value\r
+\r
+    ## value = XXX[key]\r
+    def __getitem__(self, key):\r
+        return self.__dict__[self._PROPERTY_[key]]\r
+\r
+    ## "in" test support\r
+    def __contains__(self, key):\r
+        return key in self._PROPERTY_\r
+\r
+    ## Set all internal used members of DscBuildData to None\r
+    def _Clear(self):\r
+        self._Header            = None\r
+        self._PlatformName      = None\r
+        self._Guid              = None\r
+        self._Version           = None\r
+        self._DscSpecification  = None\r
+        self._OutputDirectory   = None\r
+        self._SupArchList       = None\r
+        self._BuildTargets      = None\r
+        self._SkuName           = None\r
+        self._FlashDefinition   = None\r
+        self._BuildNumber       = None\r
+        self._MakefileName      = None\r
+        self._BsBaseAddress     = None\r
+        self._RtBaseAddress     = None\r
+        self._SkuIds            = None\r
+        self._Modules           = None\r
+        self._LibraryInstances  = None\r
+        self._LibraryClasses    = None\r
+        self._Pcds              = None\r
+        self._BuildOptions      = None\r
+        self._LoadFixAddress    = None\r
+\r
+    ## Get architecture\r
+    def _GetArch(self):\r
+        return self._Arch\r
+\r
+    ## Set architecture\r
+    #\r
+    #   Changing the default ARCH to another may affect all other information\r
+    # because all information in a platform may be ARCH-related. That's\r
+    # why we need to clear all internal used members, in order to cause all\r
+    # information to be re-retrieved.\r
+    #\r
+    #   @param  Value   The value of ARCH\r
+    #\r
+    def _SetArch(self, Value):\r
+        if self._Arch == Value:\r
+            return\r
+        self._Arch = Value\r
+        self._Clear()\r
+\r
+    ## Retrieve all information in [Defines] section\r
+    #\r
+    #   (Retriving all [Defines] information in one-shot is just to save time.)\r
+    #\r
+    def _GetHeaderInfo(self):\r
+        RecordList = self._RawData[MODEL_META_DATA_HEADER, self._Arch]\r
+        for Record in RecordList:\r
+            Name = Record[0]\r
+            # items defined _PROPERTY_ don't need additional processing\r
+            if Name in self:\r
+                self[Name] = Record[1]\r
+            # some special items in [Defines] section need special treatment\r
+            elif Name == TAB_DSC_DEFINES_OUTPUT_DIRECTORY:\r
+                self._OutputDirectory = NormPath(Record[1], self._Macros)\r
+                if ' ' in self._OutputDirectory:\r
+                    EdkLogger.error("build", FORMAT_NOT_SUPPORTED, "No space is allowed in OUTPUT_DIRECTORY",\r
+                                    File=self.MetaFile, Line=Record[-1],\r
+                                    ExtraData=self._OutputDirectory)\r
+            elif Name == TAB_DSC_DEFINES_FLASH_DEFINITION:\r
+                self._FlashDefinition = PathClass(NormPath(Record[1], self._Macros), GlobalData.gWorkspace)\r
+                ErrorCode, ErrorInfo = self._FlashDefinition.Validate('.fdf')\r
+                if ErrorCode != 0:\r
+                    EdkLogger.error('build', ErrorCode, File=self.MetaFile, Line=Record[-1],\r
+                                    ExtraData=ErrorInfo)\r
+            elif Name == TAB_DSC_DEFINES_SUPPORTED_ARCHITECTURES:\r
+                self._SupArchList = GetSplitValueList(Record[1], TAB_VALUE_SPLIT)\r
+            elif Name == TAB_DSC_DEFINES_BUILD_TARGETS:\r
+                self._BuildTargets = GetSplitValueList(Record[1])\r
+            elif Name == TAB_DSC_DEFINES_SKUID_IDENTIFIER:\r
+                if self._SkuName == None:\r
+                    self._SkuName = Record[1]\r
+            elif Name == TAB_FIX_LOAD_TOP_MEMORY_ADDRESS:\r
+                self._LoadFixAddress = Record[1]\r
+        # set _Header to non-None in order to avoid database re-querying\r
+        self._Header = 'DUMMY'\r
+\r
+    ## Retrieve platform name\r
+    def _GetPlatformName(self):\r
+        if self._PlatformName == None:\r
+            if self._Header == None:\r
+                self._GetHeaderInfo()\r
+            if self._PlatformName == None:\r
+                EdkLogger.error('build', ATTRIBUTE_NOT_AVAILABLE, "No PLATFORM_NAME", File=self.MetaFile)\r
+        return self._PlatformName\r
+\r
+    ## Retrieve file guid\r
+    def _GetFileGuid(self):\r
+        if self._Guid == None:\r
+            if self._Header == None:\r
+                self._GetHeaderInfo()\r
+            if self._Guid == None:\r
+                EdkLogger.error('build', ATTRIBUTE_NOT_AVAILABLE, "No FILE_GUID", File=self.MetaFile)\r
+        return self._Guid\r
+\r
+    ## Retrieve platform version\r
+    def _GetVersion(self):\r
+        if self._Version == None:\r
+            if self._Header == None:\r
+                self._GetHeaderInfo()\r
+            if self._Version == None:\r
+                self._Version = ''\r
+        return self._Version\r
+\r
+    ## Retrieve platform description file version\r
+    def _GetDscSpec(self):\r
+        if self._DscSpecification == None:\r
+            if self._Header == None:\r
+                self._GetHeaderInfo()\r
+            if self._DscSpecification == None:\r
+                self._DscSpecification = ''\r
+        return self._DscSpecification\r
+\r
+    ## Retrieve OUTPUT_DIRECTORY\r
+    def _GetOutpuDir(self):\r
+        if self._OutputDirectory == None:\r
+            if self._Header == None:\r
+                self._GetHeaderInfo()\r
+            if self._OutputDirectory == None:\r
+                self._OutputDirectory = os.path.join("Build", self._PlatformName)\r
+        return self._OutputDirectory\r
+\r
+    ## Retrieve SUPPORTED_ARCHITECTURES\r
+    def _GetSupArch(self):\r
+        if self._SupArchList == None:\r
+            if self._Header == None:\r
+                self._GetHeaderInfo()\r
+            if self._SupArchList == None:\r
+                self._SupArchList = ARCH_LIST\r
+        return self._SupArchList\r
+\r
+    ## Retrieve BUILD_TARGETS\r
+    def _GetBuildTarget(self):\r
+        if self._BuildTargets == None:\r
+            if self._Header == None:\r
+                self._GetHeaderInfo()\r
+            if self._BuildTargets == None:\r
+                self._BuildTargets = ['DEBUG', 'RELEASE']\r
+        return self._BuildTargets\r
+\r
+    ## Retrieve SKUID_IDENTIFIER\r
+    def _GetSkuName(self):\r
+        if self._SkuName == None:\r
+            if self._Header == None:\r
+                self._GetHeaderInfo()\r
+            if self._SkuName == None or self._SkuName not in self.SkuIds:\r
+                self._SkuName = 'DEFAULT'\r
+        return self._SkuName\r
+\r
+    ## Override SKUID_IDENTIFIER\r
+    def _SetSkuName(self, Value):\r
+        if Value in self.SkuIds:\r
+            self._SkuName = Value\r
+\r
+    def _GetFdfFile(self):\r
+        if self._FlashDefinition == None:\r
+            if self._Header == None:\r
+                self._GetHeaderInfo()\r
+            if self._FlashDefinition == None:\r
+                self._FlashDefinition = ''\r
+        return self._FlashDefinition\r
+\r
+    ## Retrieve FLASH_DEFINITION\r
+    def _GetBuildNumber(self):\r
+        if self._BuildNumber == None:\r
+            if self._Header == None:\r
+                self._GetHeaderInfo()\r
+            if self._BuildNumber == None:\r
+                self._BuildNumber = ''\r
+        return self._BuildNumber\r
+\r
+    ## Retrieve MAKEFILE_NAME\r
+    def _GetMakefileName(self):\r
+        if self._MakefileName == None:\r
+            if self._Header == None:\r
+                self._GetHeaderInfo()\r
+            if self._MakefileName == None:\r
+                self._MakefileName = ''\r
+        return self._MakefileName\r
+\r
+    ## Retrieve BsBaseAddress\r
+    def _GetBsBaseAddress(self):\r
+        if self._BsBaseAddress == None:\r
+            if self._Header == None:\r
+                self._GetHeaderInfo()\r
+            if self._BsBaseAddress == None:\r
+                self._BsBaseAddress = ''\r
+        return self._BsBaseAddress\r
+\r
+    ## Retrieve RtBaseAddress\r
+    def _GetRtBaseAddress(self):\r
+        if self._RtBaseAddress == None:\r
+            if self._Header == None:\r
+                self._GetHeaderInfo()\r
+            if self._RtBaseAddress == None:\r
+                self._RtBaseAddress = ''\r
+        return self._RtBaseAddress\r
+\r
+    ## Retrieve the top address for the load fix address\r
+    def _GetLoadFixAddress(self):\r
+        if self._LoadFixAddress == None:\r
+            if self._Header == None:\r
+                self._GetHeaderInfo()\r
+            if self._LoadFixAddress == None:\r
+                self._LoadFixAddress = ''\r
+        return self._LoadFixAddress\r
+\r
+    ## Retrieve [SkuIds] section information\r
+    def _GetSkuIds(self):\r
+        if self._SkuIds == None:\r
+            self._SkuIds = {}\r
+            RecordList = self._RawData[MODEL_EFI_SKU_ID]\r
+            for Record in RecordList:\r
+                if Record[0] in [None, '']:\r
+                    EdkLogger.error('build', FORMAT_INVALID, 'No Sku ID number',\r
+                                    File=self.MetaFile, Line=Record[-1])\r
+                if Record[1] in [None, '']:\r
+                    EdkLogger.error('build', FORMAT_INVALID, 'No Sku ID name',\r
+                                    File=self.MetaFile, Line=Record[-1])\r
+                self._SkuIds[Record[1]] = Record[0]\r
+            if 'DEFAULT' not in self._SkuIds:\r
+                self._SkuIds['DEFAULT'] = 0\r
+        return self._SkuIds\r
+\r
+    ## Retrieve [Components] section information\r
+    def _GetModules(self):\r
+        if self._Modules != None:\r
+            return self._Modules\r
+\r
+        self._Modules = sdict()\r
+        RecordList = self._RawData[MODEL_META_DATA_COMPONENT, self._Arch]\r
+        Macros = {"EDK_SOURCE":GlobalData.gEcpSource, "EFI_SOURCE":GlobalData.gEfiSource}\r
+        Macros.update(self._Macros)\r
+        for Record in RecordList:\r
+            ModuleFile = PathClass(NormPath(Record[0], Macros), GlobalData.gWorkspace, Arch=self._Arch)\r
+            ModuleId = Record[5]\r
+            LineNo = Record[6]\r
+\r
+            # check the file validation\r
+            ErrorCode, ErrorInfo = ModuleFile.Validate('.inf')\r
+            if ErrorCode != 0:\r
+                EdkLogger.error('build', ErrorCode, File=self.MetaFile, Line=LineNo,\r
+                                ExtraData=ErrorInfo)\r
+            # Check duplication\r
+            if ModuleFile in self._Modules:\r
+                EdkLogger.error('build', FILE_DUPLICATED, File=self.MetaFile, ExtraData=str(ModuleFile), Line=LineNo)\r
+\r
+            Module = ModuleBuildClassObject()\r
+            Module.MetaFile = ModuleFile\r
+\r
+            # get module override path\r
+            RecordList = self._RawData[MODEL_META_DATA_COMPONENT_SOURCE_OVERRIDE_PATH, self._Arch, None, ModuleId]\r
+            if RecordList != []:\r
+                Module.SourceOverridePath = os.path.join(GlobalData.gWorkspace, NormPath(RecordList[0][0], Macros))\r
+\r
+                # Check if the source override path exists\r
+                if not os.path.isdir(Module.SourceOverridePath):\r
+                    EdkLogger.error('build', FILE_NOT_FOUND, Message = 'Source override path does not exist:', File=self.MetaFile, ExtraData=Module.SourceOverridePath, Line=LineNo)\r
+                \r
+                #Add to GlobalData Variables\r
+                GlobalData.gOverrideDir[ModuleFile.Key] = Module.SourceOverridePath\r
+\r
+            # get module private library instance\r
+            RecordList = self._RawData[MODEL_EFI_LIBRARY_CLASS, self._Arch, None, ModuleId]\r
+            for Record in RecordList:\r
+                LibraryClass = Record[0]\r
+                LibraryPath = PathClass(NormPath(Record[1], Macros), GlobalData.gWorkspace, Arch=self._Arch)\r
+                LineNo = Record[-1]\r
+\r
+                # check the file validation\r
+                ErrorCode, ErrorInfo = LibraryPath.Validate('.inf')\r
+                if ErrorCode != 0:\r
+                    EdkLogger.error('build', ErrorCode, File=self.MetaFile, Line=LineNo,\r
+                                    ExtraData=ErrorInfo)\r
+\r
+                if LibraryClass == '' or LibraryClass == 'NULL':\r
+                    self._NullLibraryNumber += 1\r
+                    LibraryClass = 'NULL%d' % self._NullLibraryNumber\r
+                    EdkLogger.verbose("Found forced library for %s\n\t%s [%s]" % (ModuleFile, LibraryPath, LibraryClass))\r
+                Module.LibraryClasses[LibraryClass] = LibraryPath\r
+                if LibraryPath not in self.LibraryInstances:\r
+                    self.LibraryInstances.append(LibraryPath)\r
+\r
+            # get module private PCD setting\r
+            for Type in [MODEL_PCD_FIXED_AT_BUILD, MODEL_PCD_PATCHABLE_IN_MODULE, \\r
+                         MODEL_PCD_FEATURE_FLAG, MODEL_PCD_DYNAMIC, MODEL_PCD_DYNAMIC_EX]:\r
+                RecordList = self._RawData[Type, self._Arch, None, ModuleId]\r
+                for TokenSpaceGuid, PcdCName, Setting, Dummy1, Dummy2, Dummy3, Dummy4 in RecordList:\r
+                    TokenList = GetSplitValueList(Setting)\r
+                    DefaultValue = TokenList[0]\r
+                    if len(TokenList) > 1:\r
+                        MaxDatumSize = TokenList[1]\r
+                    else:\r
+                        MaxDatumSize = ''\r
+                    TypeString = self._PCD_TYPE_STRING_[Type]\r
+                    Pcd = PcdClassObject(\r
+                            PcdCName,\r
+                            TokenSpaceGuid,\r
+                            TypeString,\r
+                            '',\r
+                            DefaultValue,\r
+                            '',\r
+                            MaxDatumSize,\r
+                            {},\r
+                            None\r
+                            )\r
+                    Module.Pcds[PcdCName, TokenSpaceGuid] = Pcd\r
+\r
+            # get module private build options\r
+            RecordList = self._RawData[MODEL_META_DATA_BUILD_OPTION, self._Arch, None, ModuleId]\r
+            for ToolChainFamily, ToolChain, Option, Dummy1, Dummy2, Dummy3, Dummy4 in RecordList:\r
+                if (ToolChainFamily, ToolChain) not in Module.BuildOptions:\r
+                    Module.BuildOptions[ToolChainFamily, ToolChain] = Option\r
+                else:\r
+                    OptionString = Module.BuildOptions[ToolChainFamily, ToolChain]\r
+                    Module.BuildOptions[ToolChainFamily, ToolChain] = OptionString + " " + Option\r
+\r
+            self._Modules[ModuleFile] = Module\r
+        return self._Modules\r
+\r
+    ## Retrieve all possible library instances used in this platform\r
+    def _GetLibraryInstances(self):\r
+        if self._LibraryInstances == None:\r
+            self._GetLibraryClasses()\r
+        return self._LibraryInstances\r
+\r
+    ## Retrieve [LibraryClasses] information\r
+    def _GetLibraryClasses(self):\r
+        if self._LibraryClasses == None:\r
+            self._LibraryInstances = []\r
+            #\r
+            # tdict is a special dict kind of type, used for selecting correct\r
+            # library instance for given library class and module type\r
+            #\r
+            LibraryClassDict = tdict(True, 3)\r
+            # track all library class names\r
+            LibraryClassSet = set()\r
+            RecordList = self._RawData[MODEL_EFI_LIBRARY_CLASS, self._Arch]\r
+            Macros = {"EDK_SOURCE":GlobalData.gEcpSource, "EFI_SOURCE":GlobalData.gEfiSource}\r
+            Macros.update(self._Macros)\r
+            for Record in RecordList:\r
+                LibraryClass, LibraryInstance, Dummy, Arch, ModuleType, Dummy, LineNo = Record\r
+                if LibraryClass == '' or LibraryClass == 'NULL':\r
+                    self._NullLibraryNumber += 1\r
+                    LibraryClass = 'NULL%d' % self._NullLibraryNumber\r
+                    EdkLogger.verbose("Found forced library for arch=%s\n\t%s [%s]" % (Arch, LibraryInstance, LibraryClass))\r
+                LibraryClassSet.add(LibraryClass)\r
+                LibraryInstance = PathClass(NormPath(LibraryInstance, Macros), GlobalData.gWorkspace, Arch=self._Arch)\r
+                # check the file validation\r
+                ErrorCode, ErrorInfo = LibraryInstance.Validate('.inf')\r
+                if ErrorCode != 0:\r
+                    EdkLogger.error('build', ErrorCode, File=self.MetaFile, Line=LineNo,\r
+                                    ExtraData=ErrorInfo)\r
+\r
+                if ModuleType != 'COMMON' and ModuleType not in SUP_MODULE_LIST:\r
+                    EdkLogger.error('build', OPTION_UNKNOWN, "Unknown module type [%s]" % ModuleType,\r
+                                    File=self.MetaFile, ExtraData=LibraryInstance, Line=LineNo)\r
+                LibraryClassDict[Arch, ModuleType, LibraryClass] = LibraryInstance\r
+                if LibraryInstance not in self._LibraryInstances:\r
+                    self._LibraryInstances.append(LibraryInstance)\r
+\r
+            # resolve the specific library instance for each class and each module type\r
+            self._LibraryClasses = tdict(True)\r
+            for LibraryClass in LibraryClassSet:\r
+                # try all possible module types\r
+                for ModuleType in SUP_MODULE_LIST:\r
+                    LibraryInstance = LibraryClassDict[self._Arch, ModuleType, LibraryClass]\r
+                    if LibraryInstance == None:\r
+                        continue\r
+                    self._LibraryClasses[LibraryClass, ModuleType] = LibraryInstance\r
+\r
+            # for R8 style library instances, which are listed in different section\r
+            RecordList = self._RawData[MODEL_EFI_LIBRARY_INSTANCE, self._Arch]\r
+            for Record in RecordList:\r
+                File = PathClass(NormPath(Record[0], Macros), GlobalData.gWorkspace, Arch=self._Arch)\r
+                LineNo = Record[-1]\r
+                # check the file validation\r
+                ErrorCode, ErrorInfo = File.Validate('.inf')\r
+                if ErrorCode != 0:\r
+                    EdkLogger.error('build', ErrorCode, File=self.MetaFile, Line=LineNo,\r
+                                    ExtraData=ErrorInfo)\r
+                if File not in self._LibraryInstances:\r
+                    self._LibraryInstances.append(File)\r
+                #\r
+                # we need the module name as the library class name, so we have\r
+                # to parse it here. (self._Bdb[] will trigger a file parse if it\r
+                # hasn't been parsed)\r
+                #\r
+                Library = self._Bdb[File, self._Arch]\r
+                self._LibraryClasses[Library.BaseName, ':dummy:'] = Library\r
+        return self._LibraryClasses\r
+\r
+    ## Retrieve all PCD settings in platform\r
+    def _GetPcds(self):\r
+        if self._Pcds == None:\r
+            self._Pcds = {}\r
+            self._Pcds.update(self._GetPcd(MODEL_PCD_FIXED_AT_BUILD))\r
+            self._Pcds.update(self._GetPcd(MODEL_PCD_PATCHABLE_IN_MODULE))\r
+            self._Pcds.update(self._GetPcd(MODEL_PCD_FEATURE_FLAG))\r
+            self._Pcds.update(self._GetDynamicPcd(MODEL_PCD_DYNAMIC_DEFAULT))\r
+            self._Pcds.update(self._GetDynamicHiiPcd(MODEL_PCD_DYNAMIC_HII))\r
+            self._Pcds.update(self._GetDynamicVpdPcd(MODEL_PCD_DYNAMIC_VPD))\r
+            self._Pcds.update(self._GetDynamicPcd(MODEL_PCD_DYNAMIC_EX_DEFAULT))\r
+            self._Pcds.update(self._GetDynamicHiiPcd(MODEL_PCD_DYNAMIC_EX_HII))\r
+            self._Pcds.update(self._GetDynamicVpdPcd(MODEL_PCD_DYNAMIC_EX_VPD))\r
+        return self._Pcds\r
+\r
+    ## Retrieve [BuildOptions]\r
+    def _GetBuildOptions(self):\r
+        if self._BuildOptions == None:\r
+            self._BuildOptions = {}\r
+            #\r
+            # Retrieve build option for EDKII style module\r
+            #\r
+            RecordList = self._RawData[MODEL_META_DATA_BUILD_OPTION, 'COMMON', EDKII_NAME]\r
+            for ToolChainFamily, ToolChain, Option, Dummy1, Dummy2, Dummy3, Dummy4 in RecordList:\r
+                self._BuildOptions[ToolChainFamily, ToolChain, EDKII_NAME] = Option\r
+            #\r
+            # Retrieve build option for EDK style module\r
+            #\r
+            RecordList = self._RawData[MODEL_META_DATA_BUILD_OPTION, 'COMMON', EDK_NAME]     \r
+            for ToolChainFamily, ToolChain, Option, Dummy1, Dummy2, Dummy3, Dummy4 in RecordList:\r
+                self._BuildOptions[ToolChainFamily, ToolChain, EDK_NAME] = Option\r
+        return self._BuildOptions\r
+\r
+    ## Retrieve non-dynamic PCD settings\r
+    #\r
+    #   @param  Type    PCD type\r
+    #\r
+    #   @retval a dict object contains settings of given PCD type\r
+    #\r
+    def _GetPcd(self, Type):\r
+        Pcds = {}\r
+        #\r
+        # tdict is a special dict kind of type, used for selecting correct\r
+        # PCD settings for certain ARCH\r
+        #\r
+        PcdDict = tdict(True, 3)\r
+        PcdSet = set()\r
+        # Find out all possible PCD candidates for self._Arch\r
+        RecordList = self._RawData[Type, self._Arch]\r
+        for TokenSpaceGuid, PcdCName, Setting, Arch, SkuName, Dummy3, Dummy4 in RecordList:\r
+            PcdSet.add((PcdCName, TokenSpaceGuid))\r
+            PcdDict[Arch, PcdCName, TokenSpaceGuid] = Setting\r
+        # Remove redundant PCD candidates\r
+        for PcdCName, TokenSpaceGuid in PcdSet:\r
+            ValueList = ['', '', '']\r
+            Setting = PcdDict[self._Arch, PcdCName, TokenSpaceGuid]\r
+            if Setting == None:\r
+                continue\r
+            TokenList = Setting.split(TAB_VALUE_SPLIT)\r
+            ValueList[0:len(TokenList)] = TokenList\r
+            PcdValue, DatumType, MaxDatumSize = ValueList\r
+            Pcds[PcdCName, TokenSpaceGuid] = PcdClassObject(\r
+                                                PcdCName,\r
+                                                TokenSpaceGuid,\r
+                                                self._PCD_TYPE_STRING_[Type],\r
+                                                DatumType,\r
+                                                PcdValue,\r
+                                                '',\r
+                                                MaxDatumSize,\r
+                                                {},\r
+                                                None\r
+                                                )\r
+        return Pcds\r
+\r
+    ## Retrieve dynamic PCD settings\r
+    #\r
+    #   @param  Type    PCD type\r
+    #\r
+    #   @retval a dict object contains settings of given PCD type\r
+    #\r
+    def _GetDynamicPcd(self, Type):\r
+        Pcds = {}\r
+        #\r
+        # tdict is a special dict kind of type, used for selecting correct\r
+        # PCD settings for certain ARCH and SKU\r
+        #\r
+        PcdDict = tdict(True, 4)\r
+        PcdSet = set()\r
+        # Find out all possible PCD candidates for self._Arch\r
+        RecordList = self._RawData[Type, self._Arch]\r
+        for TokenSpaceGuid, PcdCName, Setting, Arch, SkuName, Dummy3, Dummy4 in RecordList:\r
+            PcdSet.add((PcdCName, TokenSpaceGuid))\r
+            PcdDict[Arch, SkuName, PcdCName, TokenSpaceGuid] = Setting\r
+        # Remove redundant PCD candidates, per the ARCH and SKU\r
+        for PcdCName, TokenSpaceGuid in PcdSet:\r
+            ValueList = ['', '', '']\r
+            Setting = PcdDict[self._Arch, self.SkuName, PcdCName, TokenSpaceGuid]\r
+            if Setting == None:\r
+                continue\r
+            TokenList = Setting.split(TAB_VALUE_SPLIT)\r
+            ValueList[0:len(TokenList)] = TokenList\r
+            PcdValue, DatumType, MaxDatumSize = ValueList\r
+\r
+            SkuInfo = SkuInfoClass(self.SkuName, self.SkuIds[self.SkuName], '', '', '', '', '', PcdValue)\r
+            Pcds[PcdCName, TokenSpaceGuid] = PcdClassObject(\r
+                                                PcdCName,\r
+                                                TokenSpaceGuid,\r
+                                                self._PCD_TYPE_STRING_[Type],\r
+                                                DatumType,\r
+                                                PcdValue,\r
+                                                '',\r
+                                                MaxDatumSize,\r
+                                                {self.SkuName : SkuInfo},\r
+                                                None\r
+                                                )\r
+        return Pcds\r
+\r
+    ## Retrieve dynamic HII PCD settings\r
+    #\r
+    #   @param  Type    PCD type\r
+    #\r
+    #   @retval a dict object contains settings of given PCD type\r
+    #\r
+    def _GetDynamicHiiPcd(self, Type):\r
+        Pcds = {}\r
+        #\r
+        # tdict is a special dict kind of type, used for selecting correct\r
+        # PCD settings for certain ARCH and SKU\r
+        #\r
+        PcdDict = tdict(True, 4)\r
+        PcdSet = set()\r
+        RecordList = self._RawData[Type, self._Arch]\r
+        # Find out all possible PCD candidates for self._Arch\r
+        for TokenSpaceGuid, PcdCName, Setting, Arch, SkuName, Dummy3, Dummy4 in RecordList:\r
+            PcdSet.add((PcdCName, TokenSpaceGuid))\r
+            PcdDict[Arch, SkuName, PcdCName, TokenSpaceGuid] = Setting\r
+        # Remove redundant PCD candidates, per the ARCH and SKU\r
+        for PcdCName, TokenSpaceGuid in PcdSet:\r
+            ValueList = ['', '', '', '']\r
+            Setting = PcdDict[self._Arch, self.SkuName, PcdCName, TokenSpaceGuid]\r
+            if Setting == None:\r
+                continue\r
+            TokenList = Setting.split(TAB_VALUE_SPLIT)\r
+            ValueList[0:len(TokenList)] = TokenList\r
+            VariableName, VariableGuid, VariableOffset, DefaultValue = ValueList\r
+            SkuInfo = SkuInfoClass(self.SkuName, self.SkuIds[self.SkuName], VariableName, VariableGuid, VariableOffset, DefaultValue)\r
+            Pcds[PcdCName, TokenSpaceGuid] = PcdClassObject(\r
+                                                PcdCName,\r
+                                                TokenSpaceGuid,\r
+                                                self._PCD_TYPE_STRING_[Type],\r
+                                                '',\r
+                                                DefaultValue,\r
+                                                '',\r
+                                                '',\r
+                                                {self.SkuName : SkuInfo},\r
+                                                None\r
+                                                )\r
+        return Pcds\r
+\r
+    ## Retrieve dynamic VPD PCD settings\r
+    #\r
+    #   @param  Type    PCD type\r
+    #\r
+    #   @retval a dict object contains settings of given PCD type\r
+    #\r
+    def _GetDynamicVpdPcd(self, Type):\r
+        Pcds = {}\r
+        #\r
+        # tdict is a special dict kind of type, used for selecting correct\r
+        # PCD settings for certain ARCH and SKU\r
+        #\r
+        PcdDict = tdict(True, 4)\r
+        PcdSet = set()\r
+        # Find out all possible PCD candidates for self._Arch\r
+        RecordList = self._RawData[Type, self._Arch]\r
+        for TokenSpaceGuid, PcdCName, Setting, Arch, SkuName, Dummy3, Dummy4 in RecordList:\r
+            PcdSet.add((PcdCName, TokenSpaceGuid))\r
+            PcdDict[Arch, SkuName, PcdCName, TokenSpaceGuid] = Setting\r
+        # Remove redundant PCD candidates, per the ARCH and SKU\r
+        for PcdCName, TokenSpaceGuid in PcdSet:\r
+            ValueList = ['', '']\r
+            Setting = PcdDict[self._Arch, self.SkuName, PcdCName, TokenSpaceGuid]\r
+            if Setting == None:\r
+                continue\r
+            TokenList = Setting.split(TAB_VALUE_SPLIT)\r
+            ValueList[0:len(TokenList)] = TokenList\r
+            VpdOffset, MaxDatumSize = ValueList\r
+\r
+            SkuInfo = SkuInfoClass(self.SkuName, self.SkuIds[self.SkuName], '', '', '', '', VpdOffset)\r
+            Pcds[PcdCName, TokenSpaceGuid] = PcdClassObject(\r
+                                                PcdCName,\r
+                                                TokenSpaceGuid,\r
+                                                self._PCD_TYPE_STRING_[Type],\r
+                                                '',\r
+                                                '',\r
+                                                '',\r
+                                                MaxDatumSize,\r
+                                                {self.SkuName : SkuInfo},\r
+                                                None\r
+                                                )\r
+        return Pcds\r
+\r
+    ## Add external modules\r
+    #\r
+    #   The external modules are mostly those listed in FDF file, which don't\r
+    # need "build".\r
+    #\r
+    #   @param  FilePath    The path of module description file\r
+    #\r
+    def AddModule(self, FilePath):\r
+        FilePath = NormPath(FilePath)\r
+        if FilePath not in self.Modules:\r
+            Module = ModuleBuildClassObject()\r
+            Module.MetaFile = FilePath\r
+            self.Modules.append(Module)\r
+\r
+    ## Add external PCDs\r
+    #\r
+    #   The external PCDs are mostly those listed in FDF file to specify address\r
+    # or offset information.\r
+    #\r
+    #   @param  Name    Name of the PCD\r
+    #   @param  Guid    Token space guid of the PCD\r
+    #   @param  Value   Value of the PCD\r
+    #\r
+    def AddPcd(self, Name, Guid, Value):\r
+        if (Name, Guid) not in self.Pcds:\r
+            self.Pcds[Name, Guid] = PcdClassObject(Name, Guid, '', '', '', '', '', {}, None)\r
+        self.Pcds[Name, Guid].DefaultValue = Value\r
+\r
+    Arch                = property(_GetArch, _SetArch)\r
+    Platform            = property(_GetPlatformName)\r
+    PlatformName        = property(_GetPlatformName)\r
+    Guid                = property(_GetFileGuid)\r
+    Version             = property(_GetVersion)\r
+    DscSpecification    = property(_GetDscSpec)\r
+    OutputDirectory     = property(_GetOutpuDir)\r
+    SupArchList         = property(_GetSupArch)\r
+    BuildTargets        = property(_GetBuildTarget)\r
+    SkuName             = property(_GetSkuName, _SetSkuName)\r
+    FlashDefinition     = property(_GetFdfFile)\r
+    BuildNumber         = property(_GetBuildNumber)\r
+    MakefileName        = property(_GetMakefileName)\r
+    BsBaseAddress       = property(_GetBsBaseAddress)\r
+    RtBaseAddress       = property(_GetRtBaseAddress)\r
+    LoadFixAddress      = property(_GetLoadFixAddress)\r
+\r
+    SkuIds              = property(_GetSkuIds)\r
+    Modules             = property(_GetModules)\r
+    LibraryInstances    = property(_GetLibraryInstances)\r
+    LibraryClasses      = property(_GetLibraryClasses)\r
+    Pcds                = property(_GetPcds)\r
+    BuildOptions        = property(_GetBuildOptions)\r
+\r
+## Platform build information from DSC file\r
+#\r
+#  This class is used to retrieve information stored in database and convert them\r
+# into PackageBuildClassObject form for easier use for AutoGen.\r
+#\r
+class DecBuildData(PackageBuildClassObject):\r
+    # dict used to convert PCD type in database to string used by build tool\r
+    _PCD_TYPE_STRING_ = {\r
+        MODEL_PCD_FIXED_AT_BUILD        :   "FixedAtBuild",\r
+        MODEL_PCD_PATCHABLE_IN_MODULE   :   "PatchableInModule",\r
+        MODEL_PCD_FEATURE_FLAG          :   "FeatureFlag",\r
+        MODEL_PCD_DYNAMIC               :   "Dynamic",\r
+        MODEL_PCD_DYNAMIC_DEFAULT       :   "Dynamic",\r
+        MODEL_PCD_DYNAMIC_HII           :   "DynamicHii",\r
+        MODEL_PCD_DYNAMIC_VPD           :   "DynamicVpd",\r
+        MODEL_PCD_DYNAMIC_EX            :   "DynamicEx",\r
+        MODEL_PCD_DYNAMIC_EX_DEFAULT    :   "DynamicEx",\r
+        MODEL_PCD_DYNAMIC_EX_HII        :   "DynamicExHii",\r
+        MODEL_PCD_DYNAMIC_EX_VPD        :   "DynamicExVpd",\r
+    }\r
+\r
+    # dict used to convert part of [Defines] to members of DecBuildData directly\r
+    _PROPERTY_ = {\r
+        #\r
+        # Required Fields\r
+        #\r
+        TAB_DEC_DEFINES_PACKAGE_NAME                : "_PackageName",\r
+        TAB_DEC_DEFINES_PACKAGE_GUID                : "_Guid",\r
+        TAB_DEC_DEFINES_PACKAGE_VERSION             : "_Version",\r
+    }\r
+\r
+\r
+    ## Constructor of DecBuildData\r
+    #\r
+    #  Initialize object of DecBuildData\r
+    #\r
+    #   @param      FilePath        The path of package description file\r
+    #   @param      RawData         The raw data of DEC file\r
+    #   @param      BuildDataBase   Database used to retrieve module information\r
+    #   @param      Arch            The target architecture\r
+    #   @param      Platform        (not used for DecBuildData)\r
+    #   @param      Macros          Macros used for replacement in DSC file\r
+    #\r
+    def __init__(self, File, RawData, BuildDataBase, Arch='COMMON', Platform='DUMMY', Macros={}):\r
+        self.MetaFile = File\r
+        self._PackageDir = File.Dir\r
+        self._RawData = RawData\r
+        self._Bdb = BuildDataBase\r
+        self._Arch = Arch\r
+        self._Macros = Macros\r
+        self._Clear()\r
+\r
+    ## XXX[key] = value\r
+    def __setitem__(self, key, value):\r
+        self.__dict__[self._PROPERTY_[key]] = value\r
+\r
+    ## value = XXX[key]\r
+    def __getitem__(self, key):\r
+        return self.__dict__[self._PROPERTY_[key]]\r
+\r
+    ## "in" test support\r
+    def __contains__(self, key):\r
+        return key in self._PROPERTY_\r
+\r
+    ## Set all internal used members of DecBuildData to None\r
+    def _Clear(self):\r
+        self._Header            = None\r
+        self._PackageName       = None\r
+        self._Guid              = None\r
+        self._Version           = None\r
+        self._Protocols         = None\r
+        self._Ppis              = None\r
+        self._Guids             = None\r
+        self._Includes          = None\r
+        self._LibraryClasses    = None\r
+        self._Pcds              = None\r
+\r
+    ## Get architecture\r
+    def _GetArch(self):\r
+        return self._Arch\r
+\r
+    ## Set architecture\r
+    #\r
+    #   Changing the default ARCH to another may affect all other information\r
+    # because all information in a platform may be ARCH-related. That's\r
+    # why we need to clear all internal used members, in order to cause all\r
+    # information to be re-retrieved.\r
+    #\r
+    #   @param  Value   The value of ARCH\r
+    #\r
+    def _SetArch(self, Value):\r
+        if self._Arch == Value:\r
+            return\r
+        self._Arch = Value\r
+        self._Clear()\r
+\r
+    ## Retrieve all information in [Defines] section\r
+    #\r
+    #   (Retriving all [Defines] information in one-shot is just to save time.)\r
+    #\r
+    def _GetHeaderInfo(self):\r
+        RecordList = self._RawData[MODEL_META_DATA_HEADER]\r
+        for Record in RecordList:\r
+            Name = Record[0]\r
+            if Name in self:\r
+                self[Name] = Record[1]\r
+        self._Header = 'DUMMY'\r
+\r
+    ## Retrieve package name\r
+    def _GetPackageName(self):\r
+        if self._PackageName == None:\r
+            if self._Header == None:\r
+                self._GetHeaderInfo()\r
+            if self._PackageName == None:\r
+                EdkLogger.error("build", ATTRIBUTE_NOT_AVAILABLE, "No PACKAGE_NAME", File=self.MetaFile)\r
+        return self._PackageName\r
+\r
+    ## Retrieve file guid\r
+    def _GetFileGuid(self):\r
+        if self._Guid == None:\r
+            if self._Header == None:\r
+                self._GetHeaderInfo()\r
+            if self._Guid == None:\r
+                EdkLogger.error("build", ATTRIBUTE_NOT_AVAILABLE, "No PACKAGE_GUID", File=self.MetaFile)\r
+        return self._Guid\r
+\r
+    ## Retrieve package version\r
+    def _GetVersion(self):\r
+        if self._Version == None:\r
+            if self._Header == None:\r
+                self._GetHeaderInfo()\r
+            if self._Version == None:\r
+                self._Version = ''\r
+        return self._Version\r
+\r
+    ## Retrieve protocol definitions (name/value pairs)\r
+    def _GetProtocol(self):\r
+        if self._Protocols == None:\r
+            #\r
+            # tdict is a special kind of dict, used for selecting correct\r
+            # protocol defition for given ARCH\r
+            #\r
+            ProtocolDict = tdict(True)\r
+            NameList = []\r
+            # find out all protocol definitions for specific and 'common' arch\r
+            RecordList = self._RawData[MODEL_EFI_PROTOCOL, self._Arch]\r
+            for Name, Guid, Dummy, Arch, ID, LineNo in RecordList:\r
+                if Name not in NameList:\r
+                    NameList.append(Name)\r
+                ProtocolDict[Arch, Name] = Guid\r
+            # use sdict to keep the order\r
+            self._Protocols = sdict()\r
+            for Name in NameList:\r
+                #\r
+                # limit the ARCH to self._Arch, if no self._Arch found, tdict\r
+                # will automatically turn to 'common' ARCH for trying\r
+                #\r
+                self._Protocols[Name] = ProtocolDict[self._Arch, Name]\r
+        return self._Protocols\r
+\r
+    ## Retrieve PPI definitions (name/value pairs)\r
+    def _GetPpi(self):\r
+        if self._Ppis == None:\r
+            #\r
+            # tdict is a special kind of dict, used for selecting correct\r
+            # PPI defition for given ARCH\r
+            #\r
+            PpiDict = tdict(True)\r
+            NameList = []\r
+            # find out all PPI definitions for specific arch and 'common' arch\r
+            RecordList = self._RawData[MODEL_EFI_PPI, self._Arch]\r
+            for Name, Guid, Dummy, Arch, ID, LineNo in RecordList:\r
+                if Name not in NameList:\r
+                    NameList.append(Name)\r
+                PpiDict[Arch, Name] = Guid\r
+            # use sdict to keep the order\r
+            self._Ppis = sdict()\r
+            for Name in NameList:\r
+                #\r
+                # limit the ARCH to self._Arch, if no self._Arch found, tdict\r
+                # will automatically turn to 'common' ARCH for trying\r
+                #\r
+                self._Ppis[Name] = PpiDict[self._Arch, Name]\r
+        return self._Ppis\r
+\r
+    ## Retrieve GUID definitions (name/value pairs)\r
+    def _GetGuid(self):\r
+        if self._Guids == None:\r
+            #\r
+            # tdict is a special kind of dict, used for selecting correct\r
+            # GUID defition for given ARCH\r
+            #\r
+            GuidDict = tdict(True)\r
+            NameList = []\r
+            # find out all protocol definitions for specific and 'common' arch\r
+            RecordList = self._RawData[MODEL_EFI_GUID, self._Arch]\r
+            for Name, Guid, Dummy, Arch, ID, LineNo in RecordList:\r
+                if Name not in NameList:\r
+                    NameList.append(Name)\r
+                GuidDict[Arch, Name] = Guid\r
+            # use sdict to keep the order\r
+            self._Guids = sdict()\r
+            for Name in NameList:\r
+                #\r
+                # limit the ARCH to self._Arch, if no self._Arch found, tdict\r
+                # will automatically turn to 'common' ARCH for trying\r
+                #\r
+                self._Guids[Name] = GuidDict[self._Arch, Name]\r
+        return self._Guids\r
+\r
+    ## Retrieve public include paths declared in this package\r
+    def _GetInclude(self):\r
+        if self._Includes == None:\r
+            self._Includes = []\r
+            RecordList = self._RawData[MODEL_EFI_INCLUDE, self._Arch]\r
+            Macros = {"EDK_SOURCE":GlobalData.gEcpSource, "EFI_SOURCE":GlobalData.gEfiSource}\r
+            Macros.update(self._Macros)\r
+            for Record in RecordList:\r
+                File = PathClass(NormPath(Record[0], Macros), self._PackageDir, Arch=self._Arch)\r
+                LineNo = Record[-1]\r
+                # validate the path\r
+                ErrorCode, ErrorInfo = File.Validate()\r
+                if ErrorCode != 0:\r
+                    EdkLogger.error('build', ErrorCode, ExtraData=ErrorInfo, File=self.MetaFile, Line=LineNo)\r
+\r
+                # avoid duplicate include path\r
+                if File not in self._Includes:\r
+                    self._Includes.append(File)\r
+        return self._Includes\r
+\r
+    ## Retrieve library class declarations (not used in build at present)\r
+    def _GetLibraryClass(self):\r
+        if self._LibraryClasses == None:\r
+            #\r
+            # tdict is a special kind of dict, used for selecting correct\r
+            # library class declaration for given ARCH\r
+            #\r
+            LibraryClassDict = tdict(True)\r
+            LibraryClassSet = set()\r
+            RecordList = self._RawData[MODEL_EFI_LIBRARY_CLASS, self._Arch]\r
+            Macros = {"EDK_SOURCE":GlobalData.gEcpSource, "EFI_SOURCE":GlobalData.gEfiSource}\r
+            Macros.update(self._Macros)\r
+            for LibraryClass, File, Dummy, Arch, ID, LineNo in RecordList:\r
+                File = PathClass(NormPath(File, Macros), self._PackageDir, Arch=self._Arch)\r
+                # check the file validation\r
+                ErrorCode, ErrorInfo = File.Validate()\r
+                if ErrorCode != 0:\r
+                    EdkLogger.error('build', ErrorCode, ExtraData=ErrorInfo, File=self.MetaFile, Line=LineNo)\r
+                LibraryClassSet.add(LibraryClass)\r
+                LibraryClassDict[Arch, LibraryClass] = File\r
+            self._LibraryClasses = sdict()\r
+            for LibraryClass in LibraryClassSet:\r
+                self._LibraryClasses[LibraryClass] = LibraryClassDict[self._Arch, LibraryClass]\r
+        return self._LibraryClasses\r
+\r
+    ## Retrieve PCD declarations\r
+    def _GetPcds(self):\r
+        if self._Pcds == None:\r
+            self._Pcds = {}\r
+            self._Pcds.update(self._GetPcd(MODEL_PCD_FIXED_AT_BUILD))\r
+            self._Pcds.update(self._GetPcd(MODEL_PCD_PATCHABLE_IN_MODULE))\r
+            self._Pcds.update(self._GetPcd(MODEL_PCD_FEATURE_FLAG))\r
+            self._Pcds.update(self._GetPcd(MODEL_PCD_DYNAMIC))\r
+            self._Pcds.update(self._GetPcd(MODEL_PCD_DYNAMIC_EX))\r
+        return self._Pcds\r
+\r
+    ## Retrieve PCD declarations for given type\r
+    def _GetPcd(self, Type):\r
+        Pcds = {}\r
+        #\r
+        # tdict is a special kind of dict, used for selecting correct\r
+        # PCD declaration for given ARCH\r
+        #\r
+        PcdDict = tdict(True, 3)\r
+        # for summarizing PCD\r
+        PcdSet = set()\r
+        # find out all PCDs of the 'type'\r
+        RecordList = self._RawData[Type, self._Arch]\r
+        for TokenSpaceGuid, PcdCName, Setting, Arch, Dummy1, Dummy2 in RecordList:\r
+            PcdDict[Arch, PcdCName, TokenSpaceGuid] = Setting\r
+            PcdSet.add((PcdCName, TokenSpaceGuid))\r
+\r
+        for PcdCName, TokenSpaceGuid in PcdSet:\r
+            ValueList = ['', '', '']\r
+            #\r
+            # limit the ARCH to self._Arch, if no self._Arch found, tdict\r
+            # will automatically turn to 'common' ARCH and try again\r
+            #\r
+            Setting = PcdDict[self._Arch, PcdCName, TokenSpaceGuid]\r
+            if Setting == None:\r
+                continue\r
+            TokenList = Setting.split(TAB_VALUE_SPLIT)\r
+            ValueList[0:len(TokenList)] = TokenList\r
+            DefaultValue, DatumType, TokenNumber = ValueList\r
+            Pcds[PcdCName, TokenSpaceGuid, self._PCD_TYPE_STRING_[Type]] = PcdClassObject(\r
+                                                                            PcdCName,\r
+                                                                            TokenSpaceGuid,\r
+                                                                            self._PCD_TYPE_STRING_[Type],\r
+                                                                            DatumType,\r
+                                                                            DefaultValue,\r
+                                                                            TokenNumber,\r
+                                                                            '',\r
+                                                                            {},\r
+                                                                            None\r
+                                                                            )\r
+        return Pcds\r
+\r
+\r
+    Arch            = property(_GetArch, _SetArch)\r
+    PackageName     = property(_GetPackageName)\r
+    Guid            = property(_GetFileGuid)\r
+    Version         = property(_GetVersion)\r
+\r
+    Protocols       = property(_GetProtocol)\r
+    Ppis            = property(_GetPpi)\r
+    Guids           = property(_GetGuid)\r
+    Includes        = property(_GetInclude)\r
+    LibraryClasses  = property(_GetLibraryClass)\r
+    Pcds            = property(_GetPcds)\r
+\r
+## Module build information from INF file\r
+#\r
+#  This class is used to retrieve information stored in database and convert them\r
+# into ModuleBuildClassObject form for easier use for AutoGen.\r
+#\r
+class InfBuildData(ModuleBuildClassObject):\r
+    # dict used to convert PCD type in database to string used by build tool\r
+    _PCD_TYPE_STRING_ = {\r
+        MODEL_PCD_FIXED_AT_BUILD        :   "FixedAtBuild",\r
+        MODEL_PCD_PATCHABLE_IN_MODULE   :   "PatchableInModule",\r
+        MODEL_PCD_FEATURE_FLAG          :   "FeatureFlag",\r
+        MODEL_PCD_DYNAMIC               :   "Dynamic",\r
+        MODEL_PCD_DYNAMIC_DEFAULT       :   "Dynamic",\r
+        MODEL_PCD_DYNAMIC_HII           :   "DynamicHii",\r
+        MODEL_PCD_DYNAMIC_VPD           :   "DynamicVpd",\r
+        MODEL_PCD_DYNAMIC_EX            :   "DynamicEx",\r
+        MODEL_PCD_DYNAMIC_EX_DEFAULT    :   "DynamicEx",\r
+        MODEL_PCD_DYNAMIC_EX_HII        :   "DynamicExHii",\r
+        MODEL_PCD_DYNAMIC_EX_VPD        :   "DynamicExVpd",\r
+    }\r
+\r
+    # dict used to convert part of [Defines] to members of InfBuildData directly\r
+    _PROPERTY_ = {\r
+        #\r
+        # Required Fields\r
+        #\r
+        TAB_INF_DEFINES_BASE_NAME                   : "_BaseName",\r
+        TAB_INF_DEFINES_FILE_GUID                   : "_Guid",\r
+        TAB_INF_DEFINES_MODULE_TYPE                 : "_ModuleType",\r
+        #\r
+        # Optional Fields\r
+        #\r
+        TAB_INF_DEFINES_INF_VERSION                 : "_AutoGenVersion",\r
+        TAB_INF_DEFINES_COMPONENT_TYPE              : "_ComponentType",\r
+        TAB_INF_DEFINES_MAKEFILE_NAME               : "_MakefileName",\r
+        #TAB_INF_DEFINES_CUSTOM_MAKEFILE             : "_CustomMakefile",\r
+        TAB_INF_DEFINES_VERSION_NUMBER              : "_Version",\r
+        TAB_INF_DEFINES_VERSION_STRING              : "_Version",\r
+        TAB_INF_DEFINES_VERSION                     : "_Version",\r
+        TAB_INF_DEFINES_PCD_IS_DRIVER               : "_PcdIsDriver",\r
+        TAB_INF_DEFINES_SHADOW                      : "_Shadow",\r
+\r
+        TAB_COMPONENTS_SOURCE_OVERRIDE_PATH         : "_SourceOverridePath",\r
+    }\r
+\r
+    # dict used to convert Component type to Module type\r
+    _MODULE_TYPE_ = {\r
+        "LIBRARY"               :   "BASE",\r
+        "SECURITY_CORE"         :   "SEC",\r
+        "PEI_CORE"              :   "PEI_CORE",\r
+        "COMBINED_PEIM_DRIVER"  :   "PEIM",\r
+        "PIC_PEIM"              :   "PEIM",\r
+        "RELOCATABLE_PEIM"      :   "PEIM",\r
+        "PE32_PEIM"             :   "PEIM",\r
+        "BS_DRIVER"             :   "DXE_DRIVER",\r
+        "RT_DRIVER"             :   "DXE_RUNTIME_DRIVER",\r
+        "SAL_RT_DRIVER"         :   "DXE_SAL_DRIVER",\r
+        "DXE_SMM_DRIVER"        :   "DXE_SMM_DRIVER",\r
+    #    "SMM_DRIVER"            :   "DXE_SMM_DRIVER",\r
+    #    "BS_DRIVER"             :   "DXE_SMM_DRIVER",\r
+    #    "BS_DRIVER"             :   "UEFI_DRIVER",\r
+        "APPLICATION"           :   "UEFI_APPLICATION",\r
+        "LOGO"                  :   "BASE",\r
+    }\r
+\r
+    # regular expression for converting XXX_FLAGS in [nmake] section to new type\r
+    _NMAKE_FLAG_PATTERN_ = re.compile("(?:EBC_)?([A-Z]+)_(?:STD_|PROJ_|ARCH_)?FLAGS(?:_DLL|_ASL|_EXE)?", re.UNICODE)\r
+    # dict used to convert old tool name used in [nmake] section to new ones\r
+    _TOOL_CODE_ = {\r
+        "C"         :   "CC",\r
+        "LIB"       :   "SLINK",\r
+        "LINK"      :   "DLINK",\r
+    }\r
+\r
+\r
+    ## Constructor of DscBuildData\r
+    #\r
+    #  Initialize object of DscBuildData\r
+    #\r
+    #   @param      FilePath        The path of platform description file\r
+    #   @param      RawData         The raw data of DSC file\r
+    #   @param      BuildDataBase   Database used to retrieve module/package information\r
+    #   @param      Arch            The target architecture\r
+    #   @param      Platform        The name of platform employing this module\r
+    #   @param      Macros          Macros used for replacement in DSC file\r
+    #\r
+    def __init__(self, FilePath, RawData, BuildDatabase, Arch='COMMON', Platform='COMMON', Macros={}):\r
+        self.MetaFile = FilePath\r
+        self._ModuleDir = FilePath.Dir\r
+        self._RawData = RawData\r
+        self._Bdb = BuildDatabase\r
+        self._Arch = Arch\r
+        self._Platform = 'COMMON'\r
+        self._Macros = Macros\r
+        self._SourceOverridePath = None\r
+        if FilePath.Key in GlobalData.gOverrideDir:\r
+            self._SourceOverridePath = GlobalData.gOverrideDir[FilePath.Key]\r
+        self._Clear()\r
+\r
+    ## XXX[key] = value\r
+    def __setitem__(self, key, value):\r
+        self.__dict__[self._PROPERTY_[key]] = value\r
+\r
+    ## value = XXX[key]\r
+    def __getitem__(self, key):\r
+        return self.__dict__[self._PROPERTY_[key]]\r
+\r
+    ## "in" test support\r
+    def __contains__(self, key):\r
+        return key in self._PROPERTY_\r
+\r
+    ## Set all internal used members of InfBuildData to None\r
+    def _Clear(self):\r
+        self._Header_               = None\r
+        self._AutoGenVersion        = None\r
+        self._BaseName              = None\r
+        self._ModuleType            = None\r
+        self._ComponentType         = None\r
+        self._BuildType             = None\r
+        self._Guid                  = None\r
+        self._Version               = None\r
+        self._PcdIsDriver           = None\r
+        self._BinaryModule          = None\r
+        self._Shadow                = None\r
+        self._MakefileName          = None\r
+        self._CustomMakefile        = None\r
+        self._Specification         = None\r
+        self._LibraryClass          = None\r
+        self._ModuleEntryPointList  = None\r
+        self._ModuleUnloadImageList = None\r
+        self._ConstructorList       = None\r
+        self._DestructorList        = None\r
+        self._Defs                  = None\r
+        self._Binaries              = None\r
+        self._Sources               = None\r
+        self._LibraryClasses        = None\r
+        self._Libraries             = None\r
+        self._Protocols             = None\r
+        self._Ppis                  = None\r
+        self._Guids                 = None\r
+        self._Includes              = None\r
+        self._Packages              = None\r
+        self._Pcds                  = None\r
+        self._BuildOptions          = None\r
+        self._Depex                 = None\r
+        self._DepexExpression       = None\r
+        #self._SourceOverridePath    = None\r
+\r
+    ## Get architecture\r
+    def _GetArch(self):\r
+        return self._Arch\r
+\r
+    ## Set architecture\r
+    #\r
+    #   Changing the default ARCH to another may affect all other information\r
+    # because all information in a platform may be ARCH-related. That's\r
+    # why we need to clear all internal used members, in order to cause all\r
+    # information to be re-retrieved.\r
+    #\r
+    #   @param  Value   The value of ARCH\r
+    #\r
+    def _SetArch(self, Value):\r
+        if self._Arch == Value:\r
+            return\r
+        self._Arch = Value\r
+        self._Clear()\r
+\r
+    ## Return the name of platform employing this module\r
+    def _GetPlatform(self):\r
+        return self._Platform\r
+\r
+    ## Change the name of platform employing this module\r
+    #\r
+    #   Changing the default name of platform to another may affect some information\r
+    # because they may be PLATFORM-related. That's why we need to clear all internal\r
+    # used members, in order to cause all information to be re-retrieved.\r
+    #\r
+    def _SetPlatform(self, Value):\r
+        if self._Platform == Value:\r
+            return\r
+        self._Platform = Value\r
+        self._Clear()\r
+\r
+    ## Retrieve all information in [Defines] section\r
+    #\r
+    #   (Retriving all [Defines] information in one-shot is just to save time.)\r
+    #\r
+    def _GetHeaderInfo(self):\r
+        RecordList = self._RawData[MODEL_META_DATA_HEADER, self._Arch, self._Platform]\r
+        for Record in RecordList:\r
+            Record = ReplaceMacros(Record, GlobalData.gEdkGlobal, False)\r
+            Name = Record[0]\r
+            # items defined _PROPERTY_ don't need additional processing\r
+            if Name in self:\r
+                self[Name] = Record[1]\r
+            # some special items in [Defines] section need special treatment\r
+            elif Name in ('EFI_SPECIFICATION_VERSION', 'UEFI_SPECIFICATION_VERSION'):\r
+                if self._Specification == None:\r
+                    self._Specification = sdict()\r
+                self._Specification['UEFI_SPECIFICATION_VERSION'] = Record[1]\r
+            elif Name == 'EDK_RELEASE_VERSION':\r
+                if self._Specification == None:\r
+                    self._Specification = sdict()\r
+                self._Specification[Name] = Record[1]\r
+            elif Name == 'PI_SPECIFICATION_VERSION':\r
+                if self._Specification == None:\r
+                    self._Specification = sdict()\r
+                self._Specification[Name] = Record[1]\r
+            elif Name == 'LIBRARY_CLASS':\r
+                if self._LibraryClass == None:\r
+                    self._LibraryClass = []\r
+                ValueList = GetSplitValueList(Record[1])\r
+                LibraryClass = ValueList[0]\r
+                if len(ValueList) > 1:\r
+                    SupModuleList = GetSplitValueList(ValueList[1], ' ')\r
+                else:\r
+                    SupModuleList = SUP_MODULE_LIST\r
+                self._LibraryClass.append(LibraryClassObject(LibraryClass, SupModuleList))\r
+            elif Name == 'ENTRY_POINT':\r
+                if self._ModuleEntryPointList == None:\r
+                    self._ModuleEntryPointList = []\r
+                self._ModuleEntryPointList.append(Record[1])\r
+            elif Name == 'UNLOAD_IMAGE':\r
+                if self._ModuleUnloadImageList == None:\r
+                    self._ModuleUnloadImageList = []\r
+                if Record[1] == '':\r
+                    continue\r
+                self._ModuleUnloadImageList.append(Record[1])\r
+            elif Name == 'CONSTRUCTOR':\r
+                if self._ConstructorList == None:\r
+                    self._ConstructorList = []\r
+                if Record[1] == '':\r
+                    continue\r
+                self._ConstructorList.append(Record[1])\r
+            elif Name == 'DESTRUCTOR':\r
+                if self._DestructorList == None:\r
+                    self._DestructorList = []\r
+                if Record[1] == '':\r
+                    continue\r
+                self._DestructorList.append(Record[1])\r
+            elif Name == TAB_INF_DEFINES_CUSTOM_MAKEFILE:\r
+                TokenList = GetSplitValueList(Record[1])\r
+                if self._CustomMakefile == None:\r
+                    self._CustomMakefile = {}\r
+                if len(TokenList) < 2:\r
+                    self._CustomMakefile['MSFT'] = TokenList[0]\r
+                    self._CustomMakefile['GCC'] = TokenList[0]\r
+                else:\r
+                    if TokenList[0] not in ['MSFT', 'GCC']:\r
+                        EdkLogger.error("build", FORMAT_NOT_SUPPORTED,\r
+                                        "No supported family [%s]" % TokenList[0],\r
+                                        File=self.MetaFile, Line=Record[-1])\r
+                    self._CustomMakefile[TokenList[0]] = TokenList[1]\r
+            else:\r
+                if self._Defs == None:\r
+                    self._Defs = sdict()\r
+                self._Defs[Name] = Record[1]\r
+\r
+        #\r
+        # Retrieve information in sections specific to R8.x modules\r
+        #\r
+        if self._AutoGenVersion >= 0x00010005:   # _AutoGenVersion may be None, which is less than anything\r
+            if not self._ModuleType:\r
+                EdkLogger.error("build", ATTRIBUTE_NOT_AVAILABLE,\r
+                                "MODULE_TYPE is not given", File=self.MetaFile)\r
+            if (self._Specification == None) or (not 'PI_SPECIFICATION_VERSION' in self._Specification) or (self._Specification['PI_SPECIFICATION_VERSION'] < 0x0001000A):\r
+                if self._ModuleType == SUP_MODULE_SMM_CORE:\r
+                    EdkLogger.error("build", FORMAT_NOT_SUPPORTED, "SMM_CORE module type can't be used in the module with PI_SPECIFICATION_VERSION less than 0x0001000A", File=self.MetaFile)                \r
+            if self._Defs and 'PCI_DEVICE_ID' in self._Defs and 'PCI_VENDOR_ID' in self._Defs \\r
+               and 'PCI_CLASS_CODE' in self._Defs:\r
+                self._BuildType = 'UEFI_OPTIONROM'\r
+            elif self._Defs and 'UEFI_HII_RESOURCE_SECTION' in self._Defs \\r
+               and self._Defs['UEFI_HII_RESOURCE_SECTION'] == 'TRUE':\r
+                self._BuildType = 'UEFI_HII'\r
+            else:\r
+                self._BuildType = self._ModuleType.upper()\r
+        else:\r
+            self._BuildType = self._ComponentType.upper()\r
+            if not self._ComponentType:\r
+                EdkLogger.error("build", ATTRIBUTE_NOT_AVAILABLE,\r
+                                "COMPONENT_TYPE is not given", File=self.MetaFile)\r
+            if self._ComponentType in self._MODULE_TYPE_:\r
+                self._ModuleType = self._MODULE_TYPE_[self._ComponentType]\r
+            if self._ComponentType == 'LIBRARY':\r
+                self._LibraryClass = [LibraryClassObject(self._BaseName, SUP_MODULE_LIST)]\r
+            # make use some [nmake] section macros\r
+            RecordList = self._RawData[MODEL_META_DATA_NMAKE, self._Arch, self._Platform]\r
+            for Name,Value,Dummy,Arch,Platform,ID,LineNo in RecordList:\r
+                Value = Value.replace('$(PROCESSOR)', self._Arch)\r
+                Name = Name.replace('$(PROCESSOR)', self._Arch)\r
+                Name, Value = ReplaceMacros((Name, Value), GlobalData.gEdkGlobal, True)\r
+                if Name == "IMAGE_ENTRY_POINT":\r
+                    if self._ModuleEntryPointList == None:\r
+                        self._ModuleEntryPointList = []\r
+                    self._ModuleEntryPointList.append(Value)\r
+                elif Name == "DPX_SOURCE":\r
+                    Macros = {"EDK_SOURCE":GlobalData.gEcpSource, "EFI_SOURCE":GlobalData.gEfiSource}\r
+                    Macros.update(self._Macros)\r
+                    File = PathClass(NormPath(Value, Macros), self._ModuleDir, Arch=self._Arch)\r
+                    # check the file validation\r
+                    ErrorCode, ErrorInfo = File.Validate(".dxs", CaseSensitive=False)\r
+                    if ErrorCode != 0:\r
+                        EdkLogger.error('build', ErrorCode, ExtraData=ErrorInfo,\r
+                                        File=self.MetaFile, Line=LineNo)\r
+                    if self.Sources == None:\r
+                        self._Sources = []\r
+                    self._Sources.append(File)\r
+                else:\r
+                    ToolList = self._NMAKE_FLAG_PATTERN_.findall(Name)\r
+                    if len(ToolList) == 0 or len(ToolList) != 1:\r
+                        pass\r
+#                        EdkLogger.warn("build", "Don't know how to do with macro [%s]" % Name,\r
+#                                       File=self.MetaFile, Line=LineNo)\r
+                    else:\r
+                        if self._BuildOptions == None:\r
+                            self._BuildOptions = sdict()\r
+\r
+                        if ToolList[0] in self._TOOL_CODE_:\r
+                            Tool = self._TOOL_CODE_[ToolList[0]]\r
+                        else:\r
+                            Tool = ToolList[0]\r
+                        ToolChain = "*_*_*_%s_FLAGS" % Tool\r
+                        ToolChainFamily = 'MSFT'    # R8.x only support MSFT tool chain\r
+                        #ignore not replaced macros in value\r
+                        ValueList = GetSplitValueList(' ' + Value, '/D')\r
+                        Dummy = ValueList[0]\r
+                        for Index in range(1, len(ValueList)):\r
+                            if ValueList[Index][-1] == '=' or ValueList[Index] == '':\r
+                                continue\r
+                            Dummy = Dummy + ' /D ' + ValueList[Index]\r
+                        Value = Dummy.strip()\r
+                        if (ToolChainFamily, ToolChain) not in self._BuildOptions:\r
+                            self._BuildOptions[ToolChainFamily, ToolChain] = Value\r
+                        else:\r
+                            OptionString = self._BuildOptions[ToolChainFamily, ToolChain]\r
+                            self._BuildOptions[ToolChainFamily, ToolChain] = OptionString + " " + Value\r
+        # set _Header to non-None in order to avoid database re-querying\r
+        self._Header_ = 'DUMMY'\r
+\r
+    ## Retrieve file version\r
+    def _GetInfVersion(self):\r
+        if self._AutoGenVersion == None:\r
+            if self._Header_ == None:\r
+                self._GetHeaderInfo()\r
+            if self._AutoGenVersion == None:\r
+                self._AutoGenVersion = 0x00010000\r
+        return self._AutoGenVersion\r
+\r
+    ## Retrieve BASE_NAME\r
+    def _GetBaseName(self):\r
+        if self._BaseName == None:\r
+            if self._Header_ == None:\r
+                self._GetHeaderInfo()\r
+            if self._BaseName == None:\r
+                EdkLogger.error('build', ATTRIBUTE_NOT_AVAILABLE, "No BASE_NAME name", File=self.MetaFile)\r
+        return self._BaseName\r
+\r
+    ## Retrieve MODULE_TYPE\r
+    def _GetModuleType(self):\r
+        if self._ModuleType == None:\r
+            if self._Header_ == None:\r
+                self._GetHeaderInfo()\r
+            if self._ModuleType == None:\r
+                self._ModuleType = 'BASE'\r
+            if self._ModuleType not in SUP_MODULE_LIST:\r
+                self._ModuleType = "USER_DEFINED"\r
+        return self._ModuleType\r
+\r
+    ## Retrieve COMPONENT_TYPE\r
+    def _GetComponentType(self):\r
+        if self._ComponentType == None:\r
+            if self._Header_ == None:\r
+                self._GetHeaderInfo()\r
+            if self._ComponentType == None:\r
+                self._ComponentType = 'USER_DEFINED'\r
+        return self._ComponentType\r
+\r
+    ## Retrieve "BUILD_TYPE"\r
+    def _GetBuildType(self):\r
+        if self._BuildType == None:\r
+            if self._Header_ == None:\r
+                self._GetHeaderInfo()\r
+            if not self._BuildType:\r
+                self._BuildType = "BASE"\r
+        return self._BuildType\r
+\r
+    ## Retrieve file guid\r
+    def _GetFileGuid(self):\r
+        if self._Guid == None:\r
+            if self._Header_ == None:\r
+                self._GetHeaderInfo()\r
+            if self._Guid == None:\r
+                self._Guid = '00000000-0000-0000-000000000000'\r
+        return self._Guid\r
+\r
+    ## Retrieve module version\r
+    def _GetVersion(self):\r
+        if self._Version == None:\r
+            if self._Header_ == None:\r
+                self._GetHeaderInfo()\r
+            if self._Version == None:\r
+                self._Version = '0.0'\r
+        return self._Version\r
+\r
+    ## Retrieve PCD_IS_DRIVER\r
+    def _GetPcdIsDriver(self):\r
+        if self._PcdIsDriver == None:\r
+            if self._Header_ == None:\r
+                self._GetHeaderInfo()\r
+            if self._PcdIsDriver == None:\r
+                self._PcdIsDriver = ''\r
+        return self._PcdIsDriver\r
+\r
+    ## Retrieve SHADOW\r
+    def _GetShadow(self):\r
+        if self._Shadow == None:\r
+            if self._Header_ == None:\r
+                self._GetHeaderInfo()\r
+            if self._Shadow != None and self._Shadow.upper() == 'TRUE':\r
+                self._Shadow = True\r
+            else:\r
+                self._Shadow = False\r
+        return self._Shadow\r
+\r
+    ## Retrieve CUSTOM_MAKEFILE\r
+    def _GetMakefile(self):\r
+        if self._CustomMakefile == None:\r
+            if self._Header_ == None:\r
+                self._GetHeaderInfo()\r
+            if self._CustomMakefile == None:\r
+                self._CustomMakefile = {}\r
+        return self._CustomMakefile\r
+\r
+    ## Retrieve EFI_SPECIFICATION_VERSION\r
+    def _GetSpec(self):\r
+        if self._Specification == None:\r
+            if self._Header_ == None:\r
+                self._GetHeaderInfo()\r
+            if self._Specification == None:\r
+                self._Specification = {}\r
+        return self._Specification\r
+\r
+    ## Retrieve LIBRARY_CLASS\r
+    def _GetLibraryClass(self):\r
+        if self._LibraryClass == None:\r
+            if self._Header_ == None:\r
+                self._GetHeaderInfo()\r
+            if self._LibraryClass == None:\r
+                self._LibraryClass = []\r
+        return self._LibraryClass\r
+\r
+    ## Retrieve ENTRY_POINT\r
+    def _GetEntryPoint(self):\r
+        if self._ModuleEntryPointList == None:\r
+            if self._Header_ == None:\r
+                self._GetHeaderInfo()\r
+            if self._ModuleEntryPointList == None:\r
+                self._ModuleEntryPointList = []\r
+        return self._ModuleEntryPointList\r
+\r
+    ## Retrieve UNLOAD_IMAGE\r
+    def _GetUnloadImage(self):\r
+        if self._ModuleUnloadImageList == None:\r
+            if self._Header_ == None:\r
+                self._GetHeaderInfo()\r
+            if self._ModuleUnloadImageList == None:\r
+                self._ModuleUnloadImageList = []\r
+        return self._ModuleUnloadImageList\r
+\r
+    ## Retrieve CONSTRUCTOR\r
+    def _GetConstructor(self):\r
+        if self._ConstructorList == None:\r
+            if self._Header_ == None:\r
+                self._GetHeaderInfo()\r
+            if self._ConstructorList == None:\r
+                self._ConstructorList = []\r
+        return self._ConstructorList\r
+\r
+    ## Retrieve DESTRUCTOR\r
+    def _GetDestructor(self):\r
+        if self._DestructorList == None:\r
+            if self._Header_ == None:\r
+                self._GetHeaderInfo()\r
+            if self._DestructorList == None:\r
+                self._DestructorList = []\r
+        return self._DestructorList\r
+\r
+    ## Retrieve definies other than above ones\r
+    def _GetDefines(self):\r
+        if self._Defs == None:\r
+            if self._Header_ == None:\r
+                self._GetHeaderInfo()\r
+            if self._Defs == None:\r
+                self._Defs = sdict()\r
+        return self._Defs\r
+\r
+    ## Retrieve binary files\r
+    def _GetBinaryFiles(self):\r
+        if self._Binaries == None:\r
+            self._Binaries = []\r
+            RecordList = self._RawData[MODEL_EFI_BINARY_FILE, self._Arch, self._Platform]\r
+            Macros = {"EDK_SOURCE":GlobalData.gEcpSource, "EFI_SOURCE":GlobalData.gEfiSource, 'PROCESSOR':self._Arch}\r
+            Macros.update(self._Macros)\r
+            for Record in RecordList:\r
+                Record = ReplaceMacros(Record, GlobalData.gEdkGlobal, False)\r
+                FileType = Record[0]\r
+                LineNo = Record[-1]\r
+                Target = 'COMMON'\r
+                FeatureFlag = []\r
+                if Record[2]:\r
+                    TokenList = GetSplitValueList(Record[2], TAB_VALUE_SPLIT)\r
+                    if TokenList:\r
+                        Target = TokenList[0]\r
+                    if len(TokenList) > 1:\r
+                        FeatureFlag = Record[1:]\r
+\r
+                File = PathClass(NormPath(Record[1], Macros), self._ModuleDir, '', FileType, True, self._Arch, '', Target)\r
+                # check the file validation\r
+                ErrorCode, ErrorInfo = File.Validate()\r
+                if ErrorCode != 0:\r
+                    EdkLogger.error('build', ErrorCode, ExtraData=ErrorInfo, File=self.MetaFile, Line=LineNo)\r
+                self._Binaries.append(File)\r
+        return self._Binaries\r
+\r
+    ## Retrieve source files\r
+    def _GetSourceFiles(self):\r
+        if self._Sources == None:\r
+            self._Sources = []\r
+            RecordList = self._RawData[MODEL_EFI_SOURCE_FILE, self._Arch, self._Platform]\r
+            Macros = {"EDK_SOURCE":GlobalData.gEcpSource, "EFI_SOURCE":GlobalData.gEfiSource, 'PROCESSOR':self._Arch}\r
+            Macros.update(self._Macros)\r
+            for Record in RecordList:\r
+                Record = ReplaceMacros(Record, GlobalData.gEdkGlobal, False)\r
+                LineNo = Record[-1]\r
+                ToolChainFamily = Record[1]\r
+                TagName = Record[2]\r
+                ToolCode = Record[3]\r
+                FeatureFlag = Record[4]\r
+                if self._AutoGenVersion < 0x00010005:\r
+                    # old module source files (R8)\r
+                    File = PathClass(NormPath(Record[0], Macros), self._ModuleDir, self._SourceOverridePath,\r
+                                     '', False, self._Arch, ToolChainFamily, '', TagName, ToolCode)\r
+                    # check the file validation\r
+                    ErrorCode, ErrorInfo = File.Validate(CaseSensitive=False)\r
+                    if ErrorCode != 0:\r
+                        if File.Ext.lower() == '.h':\r
+                            EdkLogger.warn('build', 'Include file not found', ExtraData=ErrorInfo,\r
+                                           File=self.MetaFile, Line=LineNo)\r
+                            continue\r
+                        else:\r
+                            EdkLogger.error('build', ErrorCode, ExtraData=File, File=self.MetaFile, Line=LineNo)\r
+                else:\r
+                    File = PathClass(NormPath(Record[0], Macros), self._ModuleDir, '',\r
+                                     '', False, self._Arch, ToolChainFamily, '', TagName, ToolCode)\r
+                    # check the file validation\r
+                    ErrorCode, ErrorInfo = File.Validate()\r
+                    if ErrorCode != 0:\r
+                        EdkLogger.error('build', ErrorCode, ExtraData=ErrorInfo, File=self.MetaFile, Line=LineNo)\r
+\r
+                self._Sources.append(File)\r
+        return self._Sources\r
+\r
+    ## Retrieve library classes employed by this module\r
+    def _GetLibraryClassUses(self):\r
+        if self._LibraryClasses == None:\r
+            self._LibraryClasses = sdict()\r
+            RecordList = self._RawData[MODEL_EFI_LIBRARY_CLASS, self._Arch, self._Platform]\r
+            for Record in RecordList:\r
+                Record = ReplaceMacros(Record, GlobalData.gEdkGlobal, False)\r
+                Lib = Record[0]\r
+                Instance = Record[1]\r
+                if Instance != None and Instance != '':\r
+                    Instance = NormPath(Instance, self._Macros)\r
+                self._LibraryClasses[Lib] = Instance\r
+        return self._LibraryClasses\r
+\r
+    ## Retrieve library names (for R8.x style of modules)\r
+    def _GetLibraryNames(self):\r
+        if self._Libraries == None:\r
+            self._Libraries = []\r
+            RecordList = self._RawData[MODEL_EFI_LIBRARY_INSTANCE, self._Arch, self._Platform]\r
+            for Record in RecordList:\r
+                # in case of name with '.lib' extension, which is unusual in R8.x inf\r
+                Record = ReplaceMacros(Record, GlobalData.gEdkGlobal, False)\r
+                LibraryName = os.path.splitext(Record[0])[0]\r
+                if LibraryName not in self._Libraries:\r
+                    self._Libraries.append(LibraryName)\r
+        return self._Libraries\r
+\r
+    ## Retrieve protocols consumed/produced by this module\r
+    def _GetProtocols(self):\r
+        if self._Protocols == None:\r
+            self._Protocols = sdict()\r
+            RecordList = self._RawData[MODEL_EFI_PROTOCOL, self._Arch, self._Platform]\r
+            for Record in RecordList:\r
+                CName = Record[0]\r
+                Value = ProtocolValue(CName, self.Packages)\r
+                if Value == None:\r
+                    PackageList = "\n\t".join([str(P) for P in self.Packages])\r
+                    EdkLogger.error('build', RESOURCE_NOT_AVAILABLE,\r
+                                    "Value of Protocol [%s] is not found under [Protocols] section in" % CName,\r
+                                    ExtraData=PackageList, File=self.MetaFile, Line=Record[-1])\r
+                self._Protocols[CName] = Value\r
+        return self._Protocols\r
+\r
+    ## Retrieve PPIs consumed/produced by this module\r
+    def _GetPpis(self):\r
+        if self._Ppis == None:\r
+            self._Ppis = sdict()\r
+            RecordList = self._RawData[MODEL_EFI_PPI, self._Arch, self._Platform]\r
+            for Record in RecordList:\r
+                CName = Record[0]\r
+                Value = PpiValue(CName, self.Packages)\r
+                if Value == None:\r
+                    PackageList = "\n\t".join([str(P) for P in self.Packages])\r
+                    EdkLogger.error('build', RESOURCE_NOT_AVAILABLE,\r
+                                    "Value of PPI [%s] is not found under [Ppis] section in " % CName,\r
+                                    ExtraData=PackageList, File=self.MetaFile, Line=Record[-1])\r
+                self._Ppis[CName] = Value\r
+        return self._Ppis\r
+\r
+    ## Retrieve GUIDs consumed/produced by this module\r
+    def _GetGuids(self):\r
+        if self._Guids == None:\r
+            self._Guids = sdict()\r
+            RecordList = self._RawData[MODEL_EFI_GUID, self._Arch, self._Platform]\r
+            for Record in RecordList:\r
+                CName = Record[0]\r
+                Value = GuidValue(CName, self.Packages)\r
+                if Value == None:\r
+                    PackageList = "\n\t".join([str(P) for P in self.Packages])\r
+                    EdkLogger.error('build', RESOURCE_NOT_AVAILABLE,\r
+                                    "Value of Guid [%s] is not found under [Guids] section in" % CName,\r
+                                    ExtraData=PackageList, File=self.MetaFile, Line=Record[-1])\r
+                self._Guids[CName] = Value\r
+        return self._Guids\r
+\r
+    ## Retrieve include paths necessary for this module (for R8.x style of modules)\r
+    def _GetIncludes(self):\r
+        if self._Includes == None:\r
+            self._Includes = []\r
+            if self._SourceOverridePath:\r
+                self._Includes.append(self._SourceOverridePath)\r
+            RecordList = self._RawData[MODEL_EFI_INCLUDE, self._Arch, self._Platform]\r
+            # [includes] section must be used only in old (R8.x) inf file\r
+            if self.AutoGenVersion >= 0x00010005 and len(RecordList) > 0:\r
+                EdkLogger.error('build', FORMAT_NOT_SUPPORTED, "No [include] section allowed",\r
+                                File=self.MetaFile, Line=RecordList[0][-1]-1)\r
+            for Record in RecordList:\r
+                Record = ReplaceMacros(Record, GlobalData.gEdkGlobal, False)\r
+                Record[0] = Record[0].replace('$(PROCESSOR)', self._Arch)\r
+                Record[0] = ReplaceMacro(Record[0], {'EFI_SOURCE' : GlobalData.gEfiSource}, False)\r
+                if Record[0].find('EDK_SOURCE') > -1:\r
+                    File = NormPath(ReplaceMacro(Record[0], {'EDK_SOURCE' : GlobalData.gEcpSource}, False), self._Macros)\r
+                    if File[0] == '.':\r
+                        File = os.path.join(self._ModuleDir, File)\r
+                    else:\r
+                        File = os.path.join(GlobalData.gWorkspace, File)\r
+                    File = RealPath(os.path.normpath(File))\r
+                    if File:\r
+                        self._Includes.append(File)\r
+\r
+                    #TRICK: let compiler to choose correct header file\r
+                    File = NormPath(ReplaceMacro(Record[0], {'EDK_SOURCE' : GlobalData.gEdkSource}, False), self._Macros)\r
+                    if File[0] == '.':\r
+                        File = os.path.join(self._ModuleDir, File)\r
+                    else:\r
+                        File = os.path.join(GlobalData.gWorkspace, File)\r
+                    File = RealPath(os.path.normpath(File))\r
+                    if File:\r
+                        self._Includes.append(File)\r
+                else:\r
+                    File = NormPath(Record[0], self._Macros)\r
+                    if File[0] == '.':\r
+                        File = os.path.join(self._ModuleDir, File)\r
+                    else:\r
+                        File = os.path.join(GlobalData.gWorkspace, File)\r
+                    File = RealPath(os.path.normpath(File))\r
+                    if File:\r
+                        self._Includes.append(File)\r
+        return self._Includes\r
+\r
+    ## Retrieve packages this module depends on\r
+    def _GetPackages(self):\r
+        if self._Packages == None:\r
+            self._Packages = []\r
+            RecordList = self._RawData[MODEL_META_DATA_PACKAGE, self._Arch, self._Platform]\r
+            Macros = {"EDK_SOURCE":GlobalData.gEcpSource, "EFI_SOURCE":GlobalData.gEfiSource}\r
+            Macros.update(self._Macros)\r
+            for Record in RecordList:\r
+                File = PathClass(NormPath(Record[0], Macros), GlobalData.gWorkspace, Arch=self._Arch)\r
+                LineNo = Record[-1]\r
+                # check the file validation\r
+                ErrorCode, ErrorInfo = File.Validate('.dec')\r
+                if ErrorCode != 0:\r
+                    EdkLogger.error('build', ErrorCode, ExtraData=ErrorInfo, File=self.MetaFile, Line=LineNo)\r
+                # parse this package now. we need it to get protocol/ppi/guid value\r
+                Package = self._Bdb[File, self._Arch]\r
+                self._Packages.append(Package)\r
+        return self._Packages\r
+\r
+    ## Retrieve PCDs used in this module\r
+    def _GetPcds(self):\r
+        if self._Pcds == None:\r
+            self._Pcds = {}\r
+            self._Pcds.update(self._GetPcd(MODEL_PCD_FIXED_AT_BUILD))\r
+            self._Pcds.update(self._GetPcd(MODEL_PCD_PATCHABLE_IN_MODULE))\r
+            self._Pcds.update(self._GetPcd(MODEL_PCD_FEATURE_FLAG))\r
+            self._Pcds.update(self._GetPcd(MODEL_PCD_DYNAMIC))\r
+            self._Pcds.update(self._GetPcd(MODEL_PCD_DYNAMIC_EX))\r
+        return self._Pcds\r
+\r
+    ## Retrieve build options specific to this module\r
+    def _GetBuildOptions(self):\r
+        if self._BuildOptions == None:\r
+            self._BuildOptions = sdict()\r
+            RecordList = self._RawData[MODEL_META_DATA_BUILD_OPTION, self._Arch, self._Platform]\r
+            for Record in RecordList:\r
+                ToolChainFamily = Record[0]\r
+                ToolChain = Record[1]\r
+                Option = Record[2]\r
+                if (ToolChainFamily, ToolChain) not in self._BuildOptions:\r
+                    self._BuildOptions[ToolChainFamily, ToolChain] = Option\r
+                else:\r
+                    # concatenate the option string if they're for the same tool\r
+                    OptionString = self._BuildOptions[ToolChainFamily, ToolChain]\r
+                    self._BuildOptions[ToolChainFamily, ToolChain] = OptionString + " " + Option\r
+        return self._BuildOptions\r
+\r
+    ## Retrieve depedency expression\r
+    def _GetDepex(self):\r
+        if self._Depex == None:\r
+            self._Depex = tdict(False, 2)\r
+            RecordList = self._RawData[MODEL_EFI_DEPEX, self._Arch]\r
+\r
+            # PEIM and DXE drivers must have a valid [Depex] section\r
+            if len(self.LibraryClass) == 0 and len(RecordList) == 0:\r
+                if self.ModuleType == 'DXE_DRIVER' or self.ModuleType == 'PEIM' or self.ModuleType == 'DXE_SMM_DRIVER' or \\r
+                    self.ModuleType == 'DXE_SAL_DRIVER' or self.ModuleType == 'DXE_RUNTIME_DRIVER':\r
+                    EdkLogger.error('build', RESOURCE_NOT_AVAILABLE, "No [Depex] section or no valid expression in [Depex] section for [%s] module" \\r
+                                    % self.ModuleType, File=self.MetaFile)\r
+\r
+            Depex = {}\r
+            for Record in RecordList:\r
+                Record = ReplaceMacros(Record, GlobalData.gEdkGlobal, False)\r
+                Arch = Record[3]\r
+                ModuleType = Record[4]\r
+                TokenList = Record[0].split()\r
+                if (Arch, ModuleType) not in Depex:\r
+                    Depex[Arch, ModuleType] = []\r
+                DepexList = Depex[Arch, ModuleType]\r
+                for Token in TokenList:\r
+                    if Token in DEPEX_SUPPORTED_OPCODE:\r
+                        DepexList.append(Token)\r
+                    elif Token.endswith(".inf"):    # module file name\r
+                        ModuleFile = os.path.normpath(Token)\r
+                        Module = self.BuildDatabase[ModuleFile]\r
+                        if Module == None:\r
+                            EdkLogger.error('build', RESOURCE_NOT_AVAILABLE, "Module is not found in active platform",\r
+                                            ExtraData=Token, File=self.MetaFile, Line=Record[-1])\r
+                        DepexList.append(Module.Guid)\r
+                    else:\r
+                        # get the GUID value now\r
+                        Value = ProtocolValue(Token, self.Packages)\r
+                        if Value == None:\r
+                            Value = PpiValue(Token, self.Packages)\r
+                            if Value == None:\r
+                                Value = GuidValue(Token, self.Packages)\r
+                        if Value == None:\r
+                            PackageList = "\n\t".join([str(P) for P in self.Packages])\r
+                            EdkLogger.error('build', RESOURCE_NOT_AVAILABLE,\r
+                                            "Value of [%s] is not found in" % Token,\r
+                                            ExtraData=PackageList, File=self.MetaFile, Line=Record[-1])\r
+                        DepexList.append(Value)\r
+            for Arch, ModuleType in Depex:\r
+                self._Depex[Arch, ModuleType] = Depex[Arch, ModuleType]\r
+        return self._Depex\r
+\r
+    ## Retrieve depedency expression\r
+    def _GetDepexExpression(self):\r
+        if self._DepexExpression == None:\r
+            self._DepexExpression = tdict(False, 2)\r
+            RecordList = self._RawData[MODEL_EFI_DEPEX, self._Arch]\r
+            DepexExpression = {}\r
+            for Record in RecordList:\r
+                Record = ReplaceMacros(Record, GlobalData.gEdkGlobal, False)\r
+                Arch = Record[3]\r
+                ModuleType = Record[4]\r
+                TokenList = Record[0].split()\r
+                if (Arch, ModuleType) not in DepexExpression:\r
+                    DepexExpression[Arch, ModuleType] = ''\r
+                for Token in TokenList:\r
+                    DepexExpression[Arch, ModuleType] = DepexExpression[Arch, ModuleType] + Token.strip() + ' '\r
+            for Arch, ModuleType in DepexExpression:\r
+                self._DepexExpression[Arch, ModuleType] = DepexExpression[Arch, ModuleType]\r
+        return self._DepexExpression\r
+\r
+    ## Retrieve PCD for given type\r
+    def _GetPcd(self, Type):\r
+        Pcds = {}\r
+        PcdDict = tdict(True, 4)\r
+        PcdSet = set()\r
+        RecordList = self._RawData[Type, self._Arch, self._Platform]\r
+        for TokenSpaceGuid, PcdCName, Setting, Arch, Platform, Dummy1, LineNo in RecordList:\r
+            PcdDict[Arch, Platform, PcdCName, TokenSpaceGuid] = (Setting, LineNo)\r
+            PcdSet.add((PcdCName, TokenSpaceGuid))\r
+            # get the guid value\r
+            if TokenSpaceGuid not in self.Guids:\r
+                Value = GuidValue(TokenSpaceGuid, self.Packages)\r
+                if Value == None:\r
+                    PackageList = "\n\t".join([str(P) for P in self.Packages])\r
+                    EdkLogger.error('build', RESOURCE_NOT_AVAILABLE,\r
+                                    "Value of Guid [%s] is not found under [Guids] section in" % TokenSpaceGuid,\r
+                                    ExtraData=PackageList, File=self.MetaFile, Line=LineNo)\r
+                self.Guids[TokenSpaceGuid] = Value\r
+\r
+        # resolve PCD type, value, datum info, etc. by getting its definition from package\r
+        for PcdCName, TokenSpaceGuid in PcdSet:\r
+            ValueList = ['', '']\r
+            Setting, LineNo = PcdDict[self._Arch, self.Platform, PcdCName, TokenSpaceGuid]\r
+            if Setting == None:\r
+                continue\r
+            TokenList = Setting.split(TAB_VALUE_SPLIT)\r
+            ValueList[0:len(TokenList)] = TokenList\r
+            DefaultValue = ValueList[0]\r
+            Pcd = PcdClassObject(\r
+                    PcdCName,\r
+                    TokenSpaceGuid,\r
+                    '',\r
+                    '',\r
+                    DefaultValue,\r
+                    '',\r
+                    '',\r
+                    {},\r
+                    self.Guids[TokenSpaceGuid]\r
+                    )\r
+\r
+            # get necessary info from package declaring this PCD\r
+            for Package in self.Packages:\r
+                #\r
+                # 'dynamic' in INF means its type is determined by platform;\r
+                # if platform doesn't give its type, use 'lowest' one in the\r
+                # following order, if any\r
+                #\r
+                #   "FixedAtBuild", "PatchableInModule", "FeatureFlag", "Dynamic", "DynamicEx"\r
+                #\r
+                PcdType = self._PCD_TYPE_STRING_[Type]\r
+                if Type in [MODEL_PCD_DYNAMIC, MODEL_PCD_DYNAMIC_EX]:\r
+                    Pcd.Pending = True\r
+                    for T in ["FixedAtBuild", "PatchableInModule", "FeatureFlag", "Dynamic", "DynamicEx"]:\r
+                        if (PcdCName, TokenSpaceGuid, T) in Package.Pcds:\r
+                            PcdType = T\r
+                            break\r
+                else:\r
+                    Pcd.Pending = False\r
+\r
+                if (PcdCName, TokenSpaceGuid, PcdType) in Package.Pcds:\r
+                    PcdInPackage = Package.Pcds[PcdCName, TokenSpaceGuid, PcdType]\r
+                    Pcd.Type = PcdType\r
+                    Pcd.TokenValue = PcdInPackage.TokenValue\r
+                    Pcd.DatumType = PcdInPackage.DatumType\r
+                    Pcd.MaxDatumSize = PcdInPackage.MaxDatumSize\r
+                    Pcd.InfDefaultValue = Pcd.DefaultValue\r
+                    if Pcd.DefaultValue in [None, '']:\r
+                        Pcd.DefaultValue = PcdInPackage.DefaultValue\r
+                    break\r
+            else:\r
+                EdkLogger.error(\r
+                            'build',\r
+                            PARSER_ERROR,\r
+                            "PCD [%s.%s] in [%s] is not found in dependent packages:" % (TokenSpaceGuid, PcdCName, self.MetaFile),\r
+                            File =self.MetaFile, Line=LineNo,\r
+                            ExtraData="\t%s" % '\n\t'.join([str(P) for P in self.Packages])\r
+                            )\r
+            Pcds[PcdCName, TokenSpaceGuid] = Pcd\r
+        return Pcds\r
+\r
+    Arch                    = property(_GetArch, _SetArch)\r
+    Platform                = property(_GetPlatform, _SetPlatform)\r
+\r
+    AutoGenVersion          = property(_GetInfVersion)\r
+    BaseName                = property(_GetBaseName)\r
+    ModuleType              = property(_GetModuleType)\r
+    ComponentType           = property(_GetComponentType)\r
+    BuildType               = property(_GetBuildType)\r
+    Guid                    = property(_GetFileGuid)\r
+    Version                 = property(_GetVersion)\r
+    PcdIsDriver             = property(_GetPcdIsDriver)\r
+    Shadow                  = property(_GetShadow)\r
+    CustomMakefile          = property(_GetMakefile)\r
+    Specification           = property(_GetSpec)\r
+    LibraryClass            = property(_GetLibraryClass)\r
+    ModuleEntryPointList    = property(_GetEntryPoint)\r
+    ModuleUnloadImageList   = property(_GetUnloadImage)\r
+    ConstructorList         = property(_GetConstructor)\r
+    DestructorList          = property(_GetDestructor)\r
+    Defines                 = property(_GetDefines)\r
+\r
+    Binaries                = property(_GetBinaryFiles)\r
+    Sources                 = property(_GetSourceFiles)\r
+    LibraryClasses          = property(_GetLibraryClassUses)\r
+    Libraries               = property(_GetLibraryNames)\r
+    Protocols               = property(_GetProtocols)\r
+    Ppis                    = property(_GetPpis)\r
+    Guids                   = property(_GetGuids)\r
+    Includes                = property(_GetIncludes)\r
+    Packages                = property(_GetPackages)\r
+    Pcds                    = property(_GetPcds)\r
+    BuildOptions            = property(_GetBuildOptions)\r
+    Depex                   = property(_GetDepex)\r
+    DepexExpression         = property(_GetDepexExpression)\r
+\r
+## Database\r
+#\r
+#   This class defined the build databse for all modules, packages and platform.\r
+# It will call corresponding parser for the given file if it cannot find it in\r
+# the database.\r
+#\r
+# @param DbPath             Path of database file\r
+# @param GlobalMacros       Global macros used for replacement during file parsing\r
+# @prarm RenewDb=False      Create new database file if it's already there\r
+#\r
+class WorkspaceDatabase(object):\r
+    # file parser\r
+    _FILE_PARSER_ = {\r
+        MODEL_FILE_INF  :   InfParser,\r
+        MODEL_FILE_DEC  :   DecParser,\r
+        MODEL_FILE_DSC  :   DscParser,\r
+        MODEL_FILE_FDF  :   None, #FdfParser,\r
+        MODEL_FILE_CIF  :   None\r
+    }\r
+\r
+    # file table\r
+    _FILE_TABLE_ = {\r
+        MODEL_FILE_INF  :   ModuleTable,\r
+        MODEL_FILE_DEC  :   PackageTable,\r
+        MODEL_FILE_DSC  :   PlatformTable,\r
+    }\r
+\r
+    # default database file path\r
+    _DB_PATH_ = "Conf/.cache/build.db"\r
+\r
+    #\r
+    # internal class used for call corresponding file parser and caching the result\r
+    # to avoid unnecessary re-parsing\r
+    #\r
+    class BuildObjectFactory(object):\r
+        _FILE_TYPE_ = {\r
+            ".inf"  : MODEL_FILE_INF,\r
+            ".dec"  : MODEL_FILE_DEC,\r
+            ".dsc"  : MODEL_FILE_DSC,\r
+            ".fdf"  : MODEL_FILE_FDF,\r
+        }\r
+\r
+        # convert to xxxBuildData object\r
+        _GENERATOR_ = {\r
+            MODEL_FILE_INF  :   InfBuildData,\r
+            MODEL_FILE_DEC  :   DecBuildData,\r
+            MODEL_FILE_DSC  :   DscBuildData,\r
+            MODEL_FILE_FDF  :   None #FlashDefTable,\r
+        }\r
+\r
+        _CACHE_ = {}    # (FilePath, Arch)  : <object>\r
+\r
+        # constructor\r
+        def __init__(self, WorkspaceDb):\r
+            self.WorkspaceDb = WorkspaceDb\r
+\r
+        # key = (FilePath, Arch='COMMON')\r
+        def __contains__(self, Key):\r
+            FilePath = Key[0]\r
+            Arch = 'COMMON'\r
+            if len(Key) > 1:\r
+                Arch = Key[1]\r
+            return (FilePath, Arch) in self._CACHE_\r
+\r
+        # key = (FilePath, Arch='COMMON')\r
+        def __getitem__(self, Key):\r
+            FilePath = Key[0]\r
+            Arch = 'COMMON'\r
+            Platform = 'COMMON'\r
+            if len(Key) > 1:\r
+                Arch = Key[1]\r
+            if len(Key) > 2:\r
+                Platform = Key[2]\r
+\r
+            # if it's generated before, just return the cached one\r
+            Key = (FilePath, Arch)\r
+            if Key in self._CACHE_:\r
+                return self._CACHE_[Key]\r
+\r
+            # check file type\r
+            Ext = FilePath.Ext.lower()\r
+            if Ext not in self._FILE_TYPE_:\r
+                return None\r
+            FileType = self._FILE_TYPE_[Ext]\r
+            if FileType not in self._GENERATOR_:\r
+                return None\r
+\r
+            # get table for current file\r
+            MetaFile = self.WorkspaceDb[FilePath, FileType, self.WorkspaceDb._GlobalMacros]\r
+            BuildObject = self._GENERATOR_[FileType](\r
+                                    FilePath,\r
+                                    MetaFile,\r
+                                    self,\r
+                                    Arch,\r
+                                    Platform,\r
+                                    self.WorkspaceDb._GlobalMacros,\r
+                                    )\r
+            self._CACHE_[Key] = BuildObject\r
+            return BuildObject\r
+\r
+    # placeholder for file format conversion\r
+    class TransformObjectFactory:\r
+        def __init__(self, WorkspaceDb):\r
+            self.WorkspaceDb = WorkspaceDb\r
+\r
+        # key = FilePath, Arch\r
+        def __getitem__(self, Key):\r
+            pass\r
+\r
+    ## Constructor of WorkspaceDatabase\r
+    #\r
+    # @param DbPath             Path of database file\r
+    # @param GlobalMacros       Global macros used for replacement during file parsing\r
+    # @prarm RenewDb=False      Create new database file if it's already there\r
+    #\r
+    def __init__(self, DbPath, GlobalMacros={}, RenewDb=False):\r
+        self._GlobalMacros = GlobalMacros\r
+\r
+        if DbPath == None or DbPath == '':\r
+            DbPath = os.path.normpath(os.path.join(GlobalData.gWorkspace, self._DB_PATH_))\r
+\r
+        # don't create necessary path for db in memory\r
+        if DbPath != ':memory:':\r
+            DbDir = os.path.split(DbPath)[0]\r
+            if not os.path.exists(DbDir):\r
+                os.makedirs(DbDir)\r
+\r
+            # remove db file in case inconsistency between db and file in file system\r
+            if self._CheckWhetherDbNeedRenew(RenewDb, DbPath):\r
+                os.remove(DbPath)\r
+        \r
+        # create db with optimized parameters\r
+        self.Conn = sqlite3.connect(DbPath, isolation_level='DEFERRED')\r
+        self.Conn.execute("PRAGMA synchronous=OFF")\r
+        self.Conn.execute("PRAGMA temp_store=MEMORY")\r
+        self.Conn.execute("PRAGMA count_changes=OFF")\r
+        self.Conn.execute("PRAGMA cache_size=8192")\r
+        #self.Conn.execute("PRAGMA page_size=8192")\r
+\r
+        # to avoid non-ascii character conversion issue\r
+        self.Conn.text_factory = str\r
+        self.Cur = self.Conn.cursor()\r
+\r
+        # create table for internal uses\r
+        self.TblDataModel = TableDataModel(self.Cur)\r
+        self.TblFile = TableFile(self.Cur)\r
+\r
+        # conversion object for build or file format conversion purpose\r
+        self.BuildObject = WorkspaceDatabase.BuildObjectFactory(self)\r
+        self.TransformObject = WorkspaceDatabase.TransformObjectFactory(self)\r
+\r
+    ## Check whether workspace database need to be renew.\r
+    #  The renew reason maybe:\r
+    #  1) If user force to renew;\r
+    #  2) If user do not force renew, and\r
+    #     a) If the time of last modified python source is newer than database file;\r
+    #     b) If the time of last modified frozen executable file is newer than database file;\r
+    #\r
+    #  @param force     User force renew database\r
+    #  @param DbPath    The absolute path of workspace database file\r
+    #\r
+    #  @return Bool value for whether need renew workspace databse\r
+    #\r
+    def _CheckWhetherDbNeedRenew (self, force, DbPath):\r
+        DbDir = os.path.split(DbPath)[0]\r
+        MacroFilePath = os.path.normpath(os.path.join(DbDir, "build.mac"))\r
+        MacroMatch = False\r
+        if os.path.exists(MacroFilePath) and os.path.isfile(MacroFilePath):\r
+            LastMacros = None\r
+            try:\r
+                f = open(MacroFilePath,'r')\r
+                LastMacros = pickle.load(f)\r
+                f.close()\r
+            except IOError:\r
+                pass\r
+            except:\r
+                f.close()\r
+\r
+            if LastMacros != None and type(LastMacros) is DictType:\r
+                if LastMacros == self._GlobalMacros:\r
+                    MacroMatch = True\r
+                    for Macro in LastMacros.keys():\r
+                        if not (Macro in self._GlobalMacros and LastMacros[Macro] == self._GlobalMacros[Macro]):\r
+                            MacroMatch = False;\r
+                            break;\r
+\r
+        if not MacroMatch:\r
+            # save command line macros to file\r
+            try:\r
+                f = open(MacroFilePath,'w')\r
+                pickle.dump(self._GlobalMacros, f, 2)\r
+                f.close()\r
+            except IOError:\r
+                pass\r
+            except:\r
+                f.close()\r
+\r
+            force = True\r
+\r
+        # if database does not exist, we need do nothing\r
+        if not os.path.exists(DbPath): return False\r
+            \r
+        # if user force to renew database, then not check whether database is out of date\r
+        if force: return True\r
+        \r
+        #    \r
+        # Check the time of last modified source file or build.exe\r
+        # if is newer than time of database, then database need to be re-created.\r
+        #\r
+        timeOfToolModified = 0\r
+        if hasattr(sys, "frozen"):\r
+            exePath             = os.path.abspath(sys.executable)\r
+            timeOfToolModified  = os.stat(exePath).st_mtime\r
+        else:\r
+            curPath  = os.path.dirname(__file__) # curPath is the path of WorkspaceDatabase.py\r
+            rootPath = os.path.split(curPath)[0] # rootPath is root path of python source, such as /BaseTools/Source/Python\r
+            if rootPath == "" or rootPath == None:\r
+                EdkLogger.verbose("\nFail to find the root path of build.exe or python sources, so can not \\r
+determine whether database file is out of date!\n")\r
+        \r
+            # walk the root path of source or build's binary to get the time last modified.\r
+        \r
+            for root, dirs, files in os.walk (rootPath):\r
+                for dir in dirs:\r
+                    # bypass source control folder \r
+                    if dir.lower() in [".svn", "_svn", "cvs"]:\r
+                        dirs.remove(dir)\r
+                        \r
+                for file in files:\r
+                    ext = os.path.splitext(file)[1]\r
+                    if ext.lower() == ".py":            # only check .py files\r
+                        fd = os.stat(os.path.join(root, file))\r
+                        if timeOfToolModified < fd.st_mtime:\r
+                            timeOfToolModified = fd.st_mtime\r
+        if timeOfToolModified > os.stat(DbPath).st_mtime:\r
+            EdkLogger.verbose("\nWorkspace database is out of data!")\r
+            return True\r
+            \r
+        return False\r
+            \r
+    ## Initialize build database\r
+    def InitDatabase(self):\r
+        EdkLogger.verbose("\nInitialize build database started ...")\r
+\r
+        #\r
+        # Create new tables\r
+        #\r
+        self.TblDataModel.Create(False)\r
+        self.TblFile.Create(False)\r
+\r
+        #\r
+        # Initialize table DataModel\r
+        #\r
+        self.TblDataModel.InitTable()\r
+        EdkLogger.verbose("Initialize build database ... DONE!")\r
+\r
+    ## Query a table\r
+    #\r
+    # @param Table:  The instance of the table to be queried\r
+    #\r
+    def QueryTable(self, Table):\r
+        Table.Query()\r
+\r
+    ## Close entire database\r
+    #\r
+    # Commit all first\r
+    # Close the connection and cursor\r
+    #\r
+    def Close(self):\r
+        self.Conn.commit()\r
+        self.Cur.close()\r
+        self.Conn.close()\r
+\r
+    ## Get unique file ID for the gvien file\r
+    def GetFileId(self, FilePath):\r
+        return self.TblFile.GetFileId(FilePath)\r
+\r
+    ## Get file type value for the gvien file ID\r
+    def GetFileType(self, FileId):\r
+        return self.TblFile.GetFileType(FileId)\r
+\r
+    ## Get time stamp stored in file table\r
+    def GetTimeStamp(self, FileId):\r
+        return self.TblFile.GetFileTimeStamp(FileId)\r
+\r
+    ## Update time stamp in file table\r
+    def SetTimeStamp(self, FileId, TimeStamp):\r
+        return self.TblFile.SetFileTimeStamp(FileId, TimeStamp)\r
+\r
+    ## Check if a table integrity flag exists or not\r
+    def CheckIntegrity(self, TableName):\r
+        try:\r
+            Result = self.Cur.execute("select min(ID) from %s" % (TableName)).fetchall()\r
+            if Result[0][0] != -1:\r
+                return False\r
+        except:\r
+            return False\r
+        return True\r
+\r
+    ## Compose table name for given file type and file ID\r
+    def GetTableName(self, FileType, FileId):\r
+        return "_%s_%s" % (FileType, FileId)\r
+\r
+    ## Return a temp table containing all content of the given file\r
+    #\r
+    #   @param  FileInfo    The tuple containing path and type of a file\r
+    #\r
+    def __getitem__(self, FileInfo):\r
+        FilePath, FileType, Macros = FileInfo\r
+        if FileType not in self._FILE_TABLE_:\r
+            return None\r
+\r
+        # flag used to indicate if it's parsed or not\r
+        FilePath = str(FilePath)\r
+        Parsed = False\r
+        FileId = self.GetFileId(FilePath)\r
+        if FileId != None:\r
+            TimeStamp = os.stat(FilePath)[8]\r
+            TableName = self.GetTableName(FileType, FileId)\r
+            if TimeStamp != self.GetTimeStamp(FileId):\r
+                # update the timestamp in database\r
+                self.SetTimeStamp(FileId, TimeStamp)\r
+            else:\r
+                # if the table exists and is integrity, don't parse it\r
+                Parsed = self.CheckIntegrity(TableName)\r
+        else:\r
+            FileId = self.TblFile.InsertFile(FilePath, FileType)\r
+            TableName = self.GetTableName(FileType, FileId)\r
+\r
+        FileTable = self._FILE_TABLE_[FileType](self.Cur, TableName, FileId)\r
+        FileTable.Create(not Parsed)\r
+        Parser = self._FILE_PARSER_[FileType](FilePath, FileType, FileTable, Macros)\r
+        # set the "Finished" flag in parser in order to avoid re-parsing (if parsed)\r
+        Parser.Finished = Parsed\r
+        return Parser\r
+\r
+    ## Summarize all packages in the database\r
+    def _GetPackageList(self):\r
+        PackageList = []\r
+        for Module in self.ModuleList:\r
+            for Package in Module.Packages:\r
+                if Package not in PackageList:\r
+                    PackageList.append(Package)\r
+        return PackageList\r
+\r
+    ## Summarize all platforms in the database\r
+    def _GetPlatformList(self):\r
+        PlatformList = []\r
+        for PlatformFile in self.TblFile.GetFileList(MODEL_FILE_DSC):\r
+            try:\r
+                Platform = self.BuildObject[PathClass(PlatformFile), 'COMMON']\r
+            except:\r
+                Platform = None\r
+            if Platform != None:\r
+                PlatformList.append(Platform)\r
+        return PlatformList\r
+\r
+    ## Summarize all modules in the database\r
+    def _GetModuleList(self):\r
+        ModuleList = []\r
+        for ModuleFile in self.TblFile.GetFileList(MODEL_FILE_INF):\r
+            try:\r
+                Module = self.BuildObject[PathClass(ModuleFile), 'COMMON']\r
+            except:\r
+                Module = None\r
+            if Module != None:\r
+                ModuleList.append(Module)\r
+        return ModuleList\r
+\r
+    PlatformList = property(_GetPlatformList)\r
+    PackageList = property(_GetPackageList)\r
+    ModuleList = property(_GetModuleList)\r
+\r
+##\r
+#\r
+# This acts like the main() function for the script, unless it is 'import'ed into another\r
+# script.\r
+#\r
+if __name__ == '__main__':\r
+    pass\r
+\r
index e0d7b88..af9aa1d 100644 (file)
@@ -2,7 +2,7 @@
 # Convert an MSA Module class object ot an INF Module class object by filling\r
 # several info required by INF file.\r
 #\r
-# Copyright (c) 2007, Intel Corporation\r
+# Copyright (c) 2007 - 2010, Intel Corporation\r
 # All rights reserved. This program and the accompanying materials\r
 # are licensed and made available under the terms and conditions of the BSD License\r
 # which accompanies this distribution.  The full text of the license may be found at\r
@@ -35,7 +35,7 @@ def AddModuleMiscVersion(Module):
     Module.Header.InfVersion = Version\r
 \r
     Version = Module.Header.Specification.get("EFI_SPECIFICATION_VERSION", "")\r
-    Module.Header.EfiSpecificationVersion = Version\r
+    Module.Header.UefiSpecificationVersion = Version\r
     \r
     Version = Module.Header.Specification.get("EDK_RELEASE_VERSION", "")\r
     Module.Header.EdkReleaseVersion = Version\r
index bb58dc2..6bf46cf 100644 (file)
@@ -64,8 +64,8 @@ def StoreModuleDefinesSection(InfFile, Module):
     if ModuleHeader.ModuleType != "":\r
         DefinesTupleList.append(("MODULE_TYPE", ModuleHeader.ModuleType))\r
 \r
-    if ModuleHeader.EfiSpecificationVersion != "":\r
-        DefinesTupleList.append(("EFI_SPECIFICATION_VERSION", ModuleHeader.EfiSpecificationVersion))\r
+    if ModuleHeader.UefiSpecificationVersion != "":\r
+        DefinesTupleList.append(("UEFI_SPECIFICATION_VERSION", ModuleHeader.UefiSpecificationVersion))\r
     \r
     if ModuleHeader.EdkReleaseVersion != "":\r
         DefinesTupleList.append(("EDK_RELEASE_VERSION", ModuleHeader.EdkReleaseVersion))\r