## @file
# This file is used to define each component of DSC file
#
# Copyright (c) 2007 - 2016, Intel Corporation. All rights reserved.<BR>
# 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 Common.LongFilePathOs as os
import EdkLogger as EdkLogger
import Database
from String import *
from Parsing import *
from DataType import *
from Identification import *
from Dictionary import *
from CommonDataClass.PlatformClass import *
from CommonDataClass.CommonClass import SkuInfoClass
from BuildToolError import *
from Misc import sdict
import GlobalData
from Table.TableDsc import TableDsc
from Common.LongFilePathSupport import OpenLongFilePath as open

#
# Global variable
#
Section = {TAB_UNKNOWN.upper() : MODEL_UNKNOWN,
           TAB_DSC_DEFINES.upper() : MODEL_META_DATA_HEADER,
           TAB_BUILD_OPTIONS.upper() : MODEL_META_DATA_BUILD_OPTION,
           TAB_SKUIDS.upper() : MODEL_EFI_SKU_ID,
           TAB_LIBRARIES.upper() : MODEL_EFI_LIBRARY_INSTANCE,
           TAB_LIBRARY_CLASSES.upper() : MODEL_EFI_LIBRARY_CLASS,
           TAB_PCDS_FIXED_AT_BUILD_NULL.upper() : MODEL_PCD_FIXED_AT_BUILD,
           TAB_PCDS_PATCHABLE_IN_MODULE_NULL.upper() : MODEL_PCD_PATCHABLE_IN_MODULE,
           TAB_PCDS_FEATURE_FLAG_NULL.upper() : MODEL_PCD_FEATURE_FLAG,
           TAB_PCDS_DYNAMIC_EX_NULL.upper() : MODEL_PCD_DYNAMIC_EX,
           TAB_PCDS_DYNAMIC_EX_DEFAULT_NULL.upper() :  MODEL_PCD_DYNAMIC_EX_DEFAULT,
           TAB_PCDS_DYNAMIC_EX_VPD_NULL.upper() : MODEL_PCD_DYNAMIC_EX_VPD,
           TAB_PCDS_DYNAMIC_EX_HII_NULL.upper() : MODEL_PCD_DYNAMIC_EX_HII,
           TAB_PCDS_DYNAMIC_NULL.upper() : MODEL_PCD_DYNAMIC,
           TAB_PCDS_DYNAMIC_DEFAULT_NULL.upper() : MODEL_PCD_DYNAMIC_DEFAULT,
           TAB_PCDS_DYNAMIC_VPD_NULL.upper() : MODEL_PCD_DYNAMIC_VPD,
           TAB_PCDS_DYNAMIC_HII_NULL.upper() : MODEL_PCD_DYNAMIC_HII,
           TAB_COMPONENTS.upper() : MODEL_META_DATA_COMPONENT,
           TAB_USER_EXTENSIONS.upper() : MODEL_META_DATA_USER_EXTENSION
           }

## DscObject
#
# This class defined basic Dsc object which is used by inheriting
#
# @param object:       Inherited from object class
#
class DscObject(object):
    def __init__(self):
        object.__init__()

## Dsc
#
# This class defined the structure used in Dsc object
#
# @param DscObject:         Inherited from InfObject class
# @param Ffilename:         Input value for Ffilename of Inf file, default is None
# @param IsMergeAllArches:  Input value for IsMergeAllArches
#                           True is to merge all arches
#                           Fales is not to merge all arches
#                           default is False
# @param IsToPlatform:      Input value for IsToPlatform
#                           True is to transfer to ModuleObject automatically
#                           False is not to transfer to ModuleObject automatically
#                           default is False
# @param WorkspaceDir:      Input value for current workspace directory, default is None
#
# @var _NullClassIndex:     To store value for _NullClassIndex, default is 0
# @var Identification:      To store value for Identification, it is a structure as Identification
# @var Defines:             To store value for Defines, it is a structure as DscDefines
# @var Contents:            To store value for Contents, it is a structure as DscContents
# @var UserExtensions:      To store value for UserExtensions
# @var Platform:            To store value for Platform, it is a structure as PlatformClass
# @var WorkspaceDir:        To store value for WorkspaceDir
# @var KeyList:             To store value for KeyList, a list for all Keys used in Dec
#
class Dsc(DscObject):
    _NullClassIndex = 0

    def __init__(self, Filename=None, IsToDatabase=False, IsToPlatform=False, WorkspaceDir=None, Database=None):
        self.Identification = Identification()
        self.Platform = PlatformClass()
        self.UserExtensions = ''
        self.WorkspaceDir = WorkspaceDir
        self.IsToDatabase = IsToDatabase
        if Database:
            self.Cur = Database.Cur
            self.TblFile = Database.TblFile
            self.TblDsc = Database.TblDsc

        self.KeyList = [
            TAB_SKUIDS, TAB_LIBRARIES, TAB_LIBRARY_CLASSES, TAB_BUILD_OPTIONS, TAB_PCDS_FIXED_AT_BUILD_NULL, \
            TAB_PCDS_PATCHABLE_IN_MODULE_NULL, TAB_PCDS_FEATURE_FLAG_NULL, \
            TAB_PCDS_DYNAMIC_DEFAULT_NULL, TAB_PCDS_DYNAMIC_HII_NULL, TAB_PCDS_DYNAMIC_VPD_NULL, \
            TAB_PCDS_DYNAMIC_EX_DEFAULT_NULL, TAB_PCDS_DYNAMIC_EX_HII_NULL, TAB_PCDS_DYNAMIC_EX_VPD_NULL, \
            TAB_COMPONENTS, TAB_DSC_DEFINES
        ]

        self.PcdToken = {}

        #
        # Upper all KEYs to ignore case sensitive when parsing
        #
        self.KeyList = map(lambda c: c.upper(), self.KeyList)

        #
        # Init RecordSet
        #
#        self.RecordSet = {}
#        for Key in self.KeyList:
#            self.RecordSet[Section[Key]] = []

        #
        # Load Dsc file if filename is not None
        #
        if Filename != None:
            self.LoadDscFile(Filename)

        #
        # Transfer to Platform Object if IsToPlatform is True
        #
        if IsToPlatform:
            self.DscToPlatform()

    ## Transfer to Platform Object
    #
    # Transfer all contents of an Inf file to a standard Module Object
    #
    def DscToPlatform(self):
        #
        # Init global information for the file
        #
        ContainerFile = self.Identification.FileFullPath

        #
        # Generate Platform Header
        #
        self.GenPlatformHeader(ContainerFile)

        #
        # Generate BuildOptions
        #
        self.GenBuildOptions(ContainerFile)

        #
        # Generate SkuInfos
        #
        self.GenSkuInfos(ContainerFile)

        #
        # Generate Libraries
        #
        self.GenLibraries(ContainerFile)

        #
        # Generate LibraryClasses
        #
        self.GenLibraryClasses(ContainerFile)

        #
        # Generate Pcds
        #
        self.GenPcds(DataType.TAB_PCDS_FIXED_AT_BUILD, ContainerFile)
        self.GenPcds(DataType.TAB_PCDS_PATCHABLE_IN_MODULE, ContainerFile)
        self.GenFeatureFlagPcds(DataType.TAB_PCDS_FEATURE_FLAG, ContainerFile)
        self.GenDynamicDefaultPcds(DataType.TAB_PCDS_DYNAMIC_DEFAULT, ContainerFile)
        self.GenDynamicDefaultPcds(DataType.TAB_PCDS_DYNAMIC_EX_DEFAULT, ContainerFile)
        self.GenDynamicHiiPcds(DataType.TAB_PCDS_DYNAMIC_HII, ContainerFile)
        self.GenDynamicHiiPcds(DataType.TAB_PCDS_DYNAMIC_EX_HII, ContainerFile)
        self.GenDynamicVpdPcds(DataType.TAB_PCDS_DYNAMIC_VPD, ContainerFile)
        self.GenDynamicVpdPcds(DataType.TAB_PCDS_DYNAMIC_EX_VPD, ContainerFile)

        #
        # Generate Components
        #
        self.GenComponents(ContainerFile)

        #
        # Update to database
        #
        if self.IsToDatabase:
            for Key in self.PcdToken.keys():
                SqlCommand = """update %s set Value2 = '%s' where ID = %s""" % (self.TblDsc.Table, ".".join((self.PcdToken[Key][0], self.PcdToken[Key][1])), Key)
                self.TblDsc.Exec(SqlCommand)
    #End of DscToPlatform

    ## Get Platform Header
    #
    # Gen Platform Header of Dsc as <Key> = <Value>
    #
    # @param ContainerFile: The Dsc file full path
    #
    def GenPlatformHeader(self, ContainerFile):
        EdkLogger.debug(2, "Generate PlatformHeader ...")
        #
        # Update all defines item in database
        #
        SqlCommand = """select ID, Value1, Arch, StartLine from %s
                        where Model = %s
                        and BelongsToFile = %s
                        and Enabled > -1""" % (self.TblDsc.Table, MODEL_META_DATA_HEADER, self.FileID)
        RecordSet = self.TblDsc.Exec(SqlCommand)
        for Record in RecordSet:
            ValueList = GetSplitValueList(Record[1], TAB_EQUAL_SPLIT)
            if len(ValueList) != 2:
                RaiseParserError(Record[1], 'Defines', ContainerFile, '<Key> = <Value>', Record[3])
            ID, Value1, Value2, Arch = Record[0], ValueList[0], ValueList[1], Record[2]
            SqlCommand = """update %s set Value1 = '%s', Value2 = '%s'
                            where ID = %s""" % (self.TblDsc.Table, ConvertToSqlString2(Value1), ConvertToSqlString2(Value2), ID)
            self.TblDsc.Exec(SqlCommand)

        #
        # Get detailed information
        #
        for Arch in DataType.ARCH_LIST:
            PlatformHeader = PlatformHeaderClass()

            PlatformHeader.Name = QueryDefinesItem(self.TblDsc, TAB_DSC_DEFINES_PLATFORM_NAME, Arch, self.FileID)[0]
            PlatformHeader.Guid = QueryDefinesItem(self.TblDsc, TAB_DSC_DEFINES_PLATFORM_GUID, Arch, self.FileID)[0]
            PlatformHeader.Version = QueryDefinesItem(self.TblDsc, TAB_DSC_DEFINES_PLATFORM_VERSION, Arch, self.FileID)[0]
            PlatformHeader.FileName = self.Identification.FileName
            PlatformHeader.FullPath = self.Identification.FileFullPath
            PlatformHeader.DscSpecification = QueryDefinesItem(self.TblDsc, TAB_DSC_DEFINES_DSC_SPECIFICATION, Arch, self.FileID)[0]

            PlatformHeader.SkuIdName = QueryDefinesItem(self.TblDsc, TAB_DSC_DEFINES_SKUID_IDENTIFIER, Arch, self.FileID)
            PlatformHeader.SupArchList = QueryDefinesItem(self.TblDsc, TAB_DSC_DEFINES_SUPPORTED_ARCHITECTURES, Arch, self.FileID)
            PlatformHeader.BuildTargets = QueryDefinesItem(self.TblDsc, TAB_DSC_DEFINES_BUILD_TARGETS, Arch, self.FileID)
            PlatformHeader.OutputDirectory = NormPath(QueryDefinesItem(self.TblDsc, TAB_DSC_DEFINES_OUTPUT_DIRECTORY, Arch, self.FileID)[0])
            PlatformHeader.BuildNumber = QueryDefinesItem(self.TblDsc, TAB_DSC_DEFINES_BUILD_NUMBER, Arch, self.FileID)[0]
            PlatformHeader.MakefileName = QueryDefinesItem(self.TblDsc, TAB_DSC_DEFINES_MAKEFILE_NAME, Arch, self.FileID)[0]

            PlatformHeader.BsBaseAddress = QueryDefinesItem(self.TblDsc, TAB_DSC_DEFINES_BS_BASE_ADDRESS, Arch, self.FileID)[0]
            PlatformHeader.RtBaseAddress = QueryDefinesItem(self.TblDsc, TAB_DSC_DEFINES_RT_BASE_ADDRESS, Arch, self.FileID)[0]

            self.Platform.Header[Arch] = PlatformHeader
            Fdf = PlatformFlashDefinitionFileClass()
            Fdf.FilePath = NormPath(QueryDefinesItem(self.TblDsc, TAB_DSC_DEFINES_FLASH_DEFINITION, Arch, self.FileID)[0])
            self.Platform.FlashDefinitionFile = Fdf
            Prebuild = BuildScriptClass()
            Prebuild.FilePath = NormPath(QueryDefinesItem(self.TblDsc, TAB_DSC_PREBUILD, Arch, self.FileID)[0])
            self.Platform.Prebuild = Prebuild
            Postbuild = BuildScriptClass()
            Postbuild.FilePath = NormPath(QueryDefinesItem(self.TblDsc, TAB_DSC_POSTBUILD, Arch, self.FileID)[0])
            self.Platform.Postbuild = Postbuild

    ## GenBuildOptions
    #
    # Gen BuildOptions of Dsc
    # [<Family>:]<ToolFlag>=Flag
    #
    # @param ContainerFile: The Dsc file full path
    #
    def GenBuildOptions(self, ContainerFile):
        EdkLogger.debug(2, "Generate %s ..." % TAB_BUILD_OPTIONS)
        BuildOptions = {}
        #
        # Get all include files
        #
        IncludeFiles = QueryDscItem(self.TblDsc, MODEL_META_DATA_INCLUDE, MODEL_META_DATA_BUILD_OPTION, self.FileID)

        #
        # Get all BuildOptions
        #
        RecordSet = QueryDscItem(self.TblDsc, MODEL_META_DATA_BUILD_OPTION, -1, self.FileID)

        #
        # Go through each arch
        #
        for Arch in DataType.ARCH_LIST:
            for IncludeFile in IncludeFiles:
                if IncludeFile[1] == Arch or IncludeFile[1] == TAB_ARCH_COMMON.upper():
                    Filename = CheckFileExist(self.WorkspaceDir, IncludeFile[0], ContainerFile, TAB_BUILD_OPTIONS, '', IncludeFile[2])
                    for NewItem in open(Filename, 'r').readlines():
                        if CleanString(NewItem) == '':
                            continue
                        (Family, ToolChain, Flag) = GetBuildOption(NewItem, Filename, -1)
                        MergeArches(BuildOptions, (Family, ToolChain, Flag), Arch)

            for Record in RecordSet:
                if Record[1] == Arch or Record[1] == TAB_ARCH_COMMON.upper():
                    (Family, ToolChain, Flag) = GetBuildOption(Record[0], ContainerFile, Record[2])
                    MergeArches(BuildOptions, (Family, ToolChain, Flag), Arch)
                    #
                    # Update to Database
                    #
                    if self.IsToDatabase:
                        SqlCommand = """update %s set Value1 = '%s', Value2 = '%s', Value3 = '%s'
                                        where ID = %s""" % (self.TblDsc.Table, ConvertToSqlString2(Family), ConvertToSqlString2(ToolChain), ConvertToSqlString2(Flag), Record[3])
                        self.TblDsc.Exec(SqlCommand)

        for Key in BuildOptions.keys():
            BuildOption = BuildOptionClass(Key[0], Key[1], Key[2])
            BuildOption.SupArchList = BuildOptions[Key]
            self.Platform.BuildOptions.BuildOptionList.append(BuildOption)

    ## GenSkuInfos
    #
    # Gen SkuInfos of Dsc
    # <Integer>|<UiName>
    #
    # @param ContainerFile: The Dsc file full path
    #
    def GenSkuInfos(self, ContainerFile):
        EdkLogger.debug(2, "Generate %s ..." % TAB_SKUIDS)
        #
        # SkuIds
        # <Integer>|<UiName>
        #
        self.Platform.SkuInfos.SkuInfoList['DEFAULT'] = '0'

        #
        # Get all include files
        #
        IncludeFiles = QueryDscItem(self.TblDsc, MODEL_META_DATA_INCLUDE, MODEL_EFI_SKU_ID, self.FileID)

        #
        # Get all SkuInfos
        #
        RecordSet = QueryDscItem(self.TblDsc, MODEL_EFI_SKU_ID, -1, self.FileID)

        #
        # Go through each arch
        #
        for Arch in DataType.ARCH_LIST:
            for IncludeFile in IncludeFiles:
                if IncludeFile[1] == Arch or IncludeFile[1] == TAB_ARCH_COMMON.upper():
                    Filename = CheckFileExist(self.WorkspaceDir, IncludeFile[0], ContainerFile, TAB_SKUIDS, '', IncludeFile[2])
                    for NewItem in open(Filename, 'r').readlines():
                        if CleanString(NewItem) == '':
                            continue
                        List = GetSplitValueList(NewItem)
                        if len(List) != 2:
                            RaiseParserError(NewItem, TAB_SKUIDS, Filename, '<Integer>|<UiName>')
                        else:
                            self.Platform.SkuInfos.SkuInfoList[List[1]] = List[0]

            for Record in RecordSet:
                if Record[1] == Arch or Record[1] == TAB_ARCH_COMMON.upper():
                    List = GetSplitValueList(Record[0])
                    if len(List) != 2:
                        RaiseParserError(Record[0], TAB_SKUIDS, ContainerFile, '<Integer>|<UiName>')
                    else:
                        self.Platform.SkuInfos.SkuInfoList[List[1]] = List[0]
                        #
                        # Update to Database
                        #
                        if self.IsToDatabase:
                            SqlCommand = """update %s set Value1 = '%s', Value2 = '%s'
                                            where ID = %s""" % (self.TblDsc.Table, ConvertToSqlString2(List[0]), ConvertToSqlString2(List[1]), Record[3])
                            self.TblDsc.Exec(SqlCommand)

    ## GenLibraries
    #
    # Gen Libraries of Dsc
    # <PathAndFilename>
    #
    # @param ContainerFile: The Dsc file full path
    #
    def GenLibraries(self, ContainerFile):
        EdkLogger.debug(2, "Generate %s ..." % TAB_LIBRARIES)
        Libraries = {}
        #
        # Get all include files
        #
        IncludeFiles = QueryDscItem(self.TblDsc, MODEL_META_DATA_INCLUDE, MODEL_EFI_LIBRARY_INSTANCE, self.FileID)

        #
        # Get all Libraries
        #
        RecordSet = QueryDscItem(self.TblDsc, MODEL_EFI_LIBRARY_INSTANCE, -1, self.FileID)

        #
        # Go through each arch
        #
        for Arch in DataType.ARCH_LIST:
            for IncludeFile in IncludeFiles:
                if IncludeFile[1] == Arch or IncludeFile[1] == TAB_ARCH_COMMON.upper():
                    Filename = CheckFileExist(self.WorkspaceDir, IncludeFile[0], ContainerFile, TAB_LIBRARIES, '', IncludeFile[2])
                    if os.path.exists(Filename):
                        for NewItem in open(Filename, 'r').readlines():
                            if CleanString(NewItem) == '':
                                continue
                            MergeArches(Libraries, NewItem, Arch)

            for Record in RecordSet:
                if Record[1] == Arch or Record[1] == TAB_ARCH_COMMON.upper():
                    MergeArches(Libraries, Record[0], Arch)

        for Key in Libraries.keys():
            Library = PlatformLibraryClass()
            Library.FilePath = NormPath(Key)
            Library.SupArchList = Libraries[Key]
            self.Platform.Libraries.LibraryList.append(Library)

    ## GenLibraryClasses
    #
    # Get LibraryClasses of Dsc
    # <LibraryClassKeyWord>|<LibraryInstance>
    #
    # @param ContainerFile: The Dsc file full path
    #
    def GenLibraryClasses(self, ContainerFile):
        EdkLogger.debug(2, "Generate %s ..." % TAB_LIBRARY_CLASSES)
        LibraryClasses = {}
        #
        # Get all include files
        #
        IncludeFiles = QueryDscItem(self.TblDsc, MODEL_META_DATA_INCLUDE, MODEL_EFI_LIBRARY_CLASS, self.FileID)

        #
        # Get all LibraryClasses
        #
        RecordSet = QueryDscItem(self.TblDsc, MODEL_EFI_LIBRARY_CLASS, -1, self.FileID)

        #
        # Go through each arch
        #
        for Arch in DataType.ARCH_LIST:
            for IncludeFile in IncludeFiles:
                if IncludeFile[1] == Arch or IncludeFile[1] == TAB_ARCH_COMMON.upper():
                    Filename = CheckFileExist(self.WorkspaceDir, IncludeFile[0], ContainerFile, TAB_LIBRARY_CLASSES, '', IncludeFile[2])
                    for NewItem in open(Filename, 'r').readlines():
                        if CleanString(NewItem) == '':
                            continue
                        MergeArches(LibraryClasses, GetLibraryClass([NewItem, IncludeFile[4]], Filename, self.WorkspaceDir, -1), Arch)

            for Record in RecordSet:
                if Record[1] == Arch or Record[1] == TAB_ARCH_COMMON.upper():
                    (LibClassName, LibClassIns, SupModelList) = GetLibraryClass([Record[0], Record[4]], ContainerFile, self.WorkspaceDir, Record[2])
                    MergeArches(LibraryClasses, (LibClassName, LibClassIns, SupModelList), Arch)
                    #
                    # Update to Database
                    #
                    if self.IsToDatabase:
                        SqlCommand = """update %s set Value1 = '%s', Value2 = '%s', Value3 = '%s'
                                        where ID = %s""" % (self.TblDsc.Table, ConvertToSqlString2(LibClassName), ConvertToSqlString2(LibClassIns), ConvertToSqlString2(SupModelList), Record[3])
                        self.TblDsc.Exec(SqlCommand)

        for Key in LibraryClasses.keys():
            Library = PlatformLibraryClass()
            Library.Name = Key[0]
            Library.FilePath = NormPath(Key[1])
            Library.SupModuleList = GetSplitValueList(Key[2])
            Library.SupArchList = LibraryClasses[Key]
            self.Platform.LibraryClasses.LibraryList.append(Library)

    ## Gen Pcds
    #
    # Gen Pcd of Dsc as <PcdTokenSpaceGuidCName>.<TokenCName>|<Value>[|<Type>|<MaximumDatumSize>]
    #
    # @param Type:           The type of Pcd
    # @param ContainerFile:  The file which describes the pcd, used for error report
    #
    def GenPcds(self, Type='', ContainerFile=''):
        Pcds = {}
        if Type == DataType.TAB_PCDS_PATCHABLE_IN_MODULE:
            Model = MODEL_PCD_PATCHABLE_IN_MODULE
        elif Type == DataType.TAB_PCDS_FIXED_AT_BUILD:
            Model = MODEL_PCD_FIXED_AT_BUILD
        else:
            pass
        EdkLogger.debug(2, "Generate %s ..." % Type)

        #
        # Get all include files
        #
        IncludeFiles = QueryDscItem(self.TblDsc, MODEL_META_DATA_INCLUDE, Model, self.FileID)

        #
        # Get all Pcds
        #
        RecordSet = QueryDscItem(self.TblDsc, Model, -1, self.FileID)

        #
        # Go through each arch
        #
        for Arch in DataType.ARCH_LIST:
            for IncludeFile in IncludeFiles:
                if IncludeFile[1] == Arch or IncludeFile[1] == TAB_ARCH_COMMON.upper():
                    Filename = CheckFileExist(self.WorkspaceDir, IncludeFile[0], ContainerFile, Type, '', IncludeFile[2])
                    for NewItem in open(Filename, 'r').readlines():
                        if CleanString(NewItem) == '':
                            continue
                        (TokenName, TokenGuidCName, Value, DatumType, MaxDatumSize, Type) = GetPcd(NewItem, Type, Filename, -1)
                        MergeArches(Pcds, (TokenName, TokenGuidCName, Value, DatumType, MaxDatumSize, Type), Arch)
                        self.PcdToken[Record[3]] = (TokenGuidCName, TokenName)

            for Record in RecordSet:
                if Record[1] == Arch or Record[1] == TAB_ARCH_COMMON.upper():
                    (TokenName, TokenGuidCName, Value, DatumType, MaxDatumSize, Type) = GetPcd(Record[0], Type, ContainerFile, Record[2])
                    MergeArches(Pcds, (TokenName, TokenGuidCName, Value, DatumType, MaxDatumSize, Type), Arch)
                    self.PcdToken[Record[3]] = (TokenGuidCName, TokenName)

        for Key in Pcds:
            Pcd = PcdClass(Key[0], '', Key[1], Key[3], Key[4], Key[2], Key[5], [], {}, [])
            Pcd.SupArchList = Pcds[Key]
            self.Platform.DynamicPcdBuildDefinitions.append(Pcd)

    ## Gen FeatureFlagPcds
    #
    # Gen FeatureFlagPcds of Dsc file as <PcdTokenSpaceGuidCName>.<TokenCName>|TRUE/FALSE
    #
    # @param Type:           The type of Pcd
    # @param ContainerFile:  The file which describes the pcd, used for error report
    #
    def GenFeatureFlagPcds(self, Type='', ContainerFile=''):
        Pcds = {}
        if Type == DataType.TAB_PCDS_FEATURE_FLAG:
            Model = MODEL_PCD_FEATURE_FLAG
        else:
            pass
        EdkLogger.debug(2, "Generate %s ..." % Type)

        #
        # Get all include files
        #
        IncludeFiles = QueryDscItem(self.TblDsc, MODEL_META_DATA_INCLUDE, Model, self.FileID)

        #
        # Get all FeatureFlagPcds
        #
        RecordSet = QueryDscItem(self.TblDsc, Model, -1, self.FileID)

        #
        # Go through each arch
        #
        for Arch in DataType.ARCH_LIST:
            for IncludeFile in IncludeFiles:
                if IncludeFile[1] == Arch or IncludeFile[1] == TAB_ARCH_COMMON.upper():
                    Filename = CheckFileExist(self.WorkspaceDir, IncludeFile[0], ContainerFile, Type, '', IncludeFile[2])
                    for NewItem in open(Filename, 'r').readlines():
                        if CleanString(NewItem) == '':
                            continue
                        (TokenName, TokenGuidCName, Value, Type) = GetFeatureFlagPcd(NewItem, Type, Filename, -1)
                        MergeArches(Pcds, (TokenName, TokenGuidCName, Value, Type), Arch)
                        self.PcdToken[Record[3]] = (TokenGuidCName, TokenName)

            for Record in RecordSet:
                if Record[1] == Arch or Record[1] == TAB_ARCH_COMMON.upper():
                    (TokenName, TokenGuidCName, Value, Type) = GetFeatureFlagPcd(Record[0], Type, ContainerFile, Record[2])
                    MergeArches(Pcds, (TokenName, TokenGuidCName, Value, Type), Arch)
                    self.PcdToken[Record[3]] = (TokenGuidCName, TokenName)

        for Key in Pcds:
            Pcd = PcdClass(Key[0], '', Key[1], '', '', Key[2], Key[3], [], {}, [])
            Pcd.SupArchList = Pcds[Key]
            self.Platform.DynamicPcdBuildDefinitions.append(Pcd)

    ## Gen DynamicDefaultPcds
    #
    # Gen DynamicDefaultPcds of Dsc as <PcdTokenSpaceGuidCName>.<TokenCName>|<Value>[|<DatumTyp>[|<MaxDatumSize>]]
    #
    # @param Type:           The type of Pcd
    # @param ContainerFile:  The file which describes the pcd, used for error report
    #
    def GenDynamicDefaultPcds(self, Type='', ContainerFile=''):
        Pcds = {}
        SkuInfoList = {}
        if Type == DataType.TAB_PCDS_DYNAMIC_DEFAULT:
            Model = MODEL_PCD_DYNAMIC_DEFAULT
        elif Type == DataType.TAB_PCDS_DYNAMIC_EX_DEFAULT:
            Model = MODEL_PCD_DYNAMIC_EX_DEFAULT
        else:
            pass
        EdkLogger.debug(2, "Generate %s ..." % Type)

        #
        # Get all include files
        #
        IncludeFiles = QueryDscItem(self.TblDsc, MODEL_META_DATA_INCLUDE, Model, self.FileID)

        #
        # Get all DynamicDefaultPcds
        #
        RecordSet = QueryDscItem(self.TblDsc, Model, -1, self.FileID)

        #
        # Go through each arch
        #
        for Arch in DataType.ARCH_LIST:
            for IncludeFile in IncludeFiles:
                if IncludeFile[1] == Arch or IncludeFile[1] == TAB_ARCH_COMMON.upper():
                    Filename = CheckFileExist(self.WorkspaceDir, IncludeFile[0], ContainerFile, Type, '', IncludeFile[2])
                    for NewItem in open(Filename, 'r').readlines():
                        if CleanString(NewItem) == '':
                            continue
                        (K1, K2, K3, K4, K5, K6) = GetDynamicDefaultPcd(NewItem, Type, Filename, -1)
                        MergeArches(Pcds, (K1, K2, K3, K4, K5, K6, IncludeFile[4]), Arch)
                        self.PcdToken[Record[3]] = (K2, K1)

            for Record in RecordSet:
                if Record[1] == Arch or Record[1] == TAB_ARCH_COMMON.upper():
                    (K1, K2, K3, K4, K5, K6) = GetDynamicDefaultPcd(Record[0], Type, ContainerFile, Record[2])
                    MergeArches(Pcds, (K1, K2, K3, K4, K5, K6, Record[4]), Arch)
                    self.PcdToken[Record[3]] = (K2, K1)

        for Key in Pcds:
            (Status, SkuInfoList) = self.GenSkuInfoList(Key[6], self.Platform.SkuInfos.SkuInfoList, '', '', '', '', '', Key[2])
            if Status == False:
                ErrorMsg = "The SKUID '%s' used in section '%s' is not defined in section [SkuIds]" % (SkuInfoList, Type)
                EdkLogger.error("DSC File Parser", PARSER_ERROR, ErrorMsg, ContainerFile, RaiseError=EdkLogger.IsRaiseError)
            Pcd = PcdClass(Key[0], '', Key[1], Key[3], Key[4], Key[2], Key[5], [], SkuInfoList, [])
            Pcd.SupArchList = Pcds[Key]
            self.Platform.DynamicPcdBuildDefinitions.append(Pcd)

    ## Gen DynamicHiiPcds
    #
    # Gen DynamicHiiPcds of Dsc as <PcdTokenSpaceGuidCName>.<TokenCName>|<String>|<VariableGuidCName>|<VariableOffset>[|<DefaultValue>[|<MaximumDatumSize>]]
    #
    # @param Type:           The type of Pcd
    # @param ContainerFile:  The file which describes the pcd, used for error report
    #
    def GenDynamicHiiPcds(self, Type='', ContainerFile=''):
        Pcds = {}
        SkuInfoList = {}
        if Type == DataType.TAB_PCDS_DYNAMIC_HII:
            Model = MODEL_PCD_DYNAMIC_HII
        elif Type == DataType.TAB_PCDS_DYNAMIC_EX_HII:
            Model = MODEL_PCD_DYNAMIC_EX_HII
        else:
            pass
        EdkLogger.debug(2, "Generate %s ..." % Type)

        #
        # Get all include files
        #
        IncludeFiles = QueryDscItem(self.TblDsc, MODEL_META_DATA_INCLUDE, Model, self.FileID)

        #
        # Get all DynamicHiiPcds
        #
        RecordSet = QueryDscItem(self.TblDsc, Model, -1, self.FileID)

        #
        # Go through each arch
        #
        for Arch in DataType.ARCH_LIST:
            for IncludeFile in IncludeFiles:
                if IncludeFile[1] == Arch or IncludeFile[1] == TAB_ARCH_COMMON.upper():
                    Filename = CheckFileExist(self.WorkspaceDir, IncludeFile[0], ContainerFile, Type, '', IncludeFile[2])
                    for NewItem in open(Filename, 'r').readlines():
                        if CleanString(NewItem) == '':
                            continue
                        (K1, K2, K3, K4, K5, K6, K7, K8) = GetDynamicHiiPcd(NewItem, Type, Filename, -1)
                        MergeArches(Pcds, (K1, K2, K3, K4, K5, K6, K7, K8, IncludeFile[4]), Arch)
                        self.PcdToken[Record[3]] = (K2, K1)

            for Record in RecordSet:
                if Record[1] == Arch or Record[1] == TAB_ARCH_COMMON.upper():
                    (K1, K2, K3, K4, K5, K6, K7, K8) = GetDynamicHiiPcd(Record[0], Type, ContainerFile, Record[2])
                    MergeArches(Pcds, (K1, K2, K3, K4, K5, K6, K7, K8, Record[4]), Arch)
                    self.PcdToken[Record[3]] = (K2, K1)

        for Key in Pcds:
            (Status, SkuInfoList) = self.GenSkuInfoList(Key[8], self.Platform.SkuInfos.SkuInfoList, Key[2], Key[3], Key[4], Key[5], '', '')
            if Status == False:
                ErrorMsg = "The SKUID '%s' used in section '%s' is not defined in section [SkuIds]" % (SkuInfoList, Type)
                EdkLogger.error("DSC File Parser", PARSER_ERROR, ErrorMsg, ContainerFile, RaiseError=EdkLogger.IsRaiseError)
            Pcd = PcdClass(Key[0], '', Key[1], '', Key[6], Key[5], Key[7], [], SkuInfoList, [])
            Pcd.SupArchList = Pcds[Key]
            self.Platform.DynamicPcdBuildDefinitions.append(Pcd)

    ## Gen DynamicVpdPcds
    #
    # Gen DynamicVpdPcds of Dsc as <PcdTokenSpaceGuidCName>.<TokenCName>|<VpdOffset>[|<MaximumDatumSize>]
    #
    # @param Type:           The type of Pcd
    # @param ContainerFile:  The file which describes the pcd, used for error report
    #
    def GenDynamicVpdPcds(self, Type='', ContainerFile=''):
        Pcds = {}
        SkuInfoList = {}
        if Type == DataType.TAB_PCDS_DYNAMIC_VPD:
            Model = MODEL_PCD_DYNAMIC_VPD
        elif Type == DataType.TAB_PCDS_DYNAMIC_EX_VPD:
            Model = MODEL_PCD_DYNAMIC_EX_VPD
        else:
            pass
        EdkLogger.debug(2, "Generate %s ..." % Type)

        #
        # Get all include files
        #
        IncludeFiles = QueryDscItem(self.TblDsc, MODEL_META_DATA_INCLUDE, Model, self.FileID)

        #
        # Get all DynamicVpdPcds
        #
        RecordSet = QueryDscItem(self.TblDsc, Model, -1, self.FileID)

        #
        # Go through each arch
        #
        for Arch in DataType.ARCH_LIST:
            for IncludeFile in IncludeFiles:
                if IncludeFile[1] == Arch or IncludeFile[1] == TAB_ARCH_COMMON.upper():
                    Filename = CheckFileExist(self.WorkspaceDir, IncludeFile[0], ContainerFile, Type, '', IncludeFile[2])
                    for NewItem in open(Filename, 'r').readlines():
                        if CleanString(NewItem) == '':
                            continue
                        (K1, K2, K3, K4, K5) = GetDynamicVpdPcd(NewItem, Type, Filename, -1)
                        MergeArches(Pcds, (K1, K2, K3, K4, K5, IncludeFile[4]), Arch)
                        self.PcdToken[Record[3]] = (K2, K1)

            for Record in RecordSet:
                if Record[1] == Arch or Record[1] == TAB_ARCH_COMMON.upper():
                    (K1, K2, K3, K4, K5) = GetDynamicVpdPcd(Record[0], Type, ContainerFile, Record[2])
                    MergeArches(Pcds, (K1, K2, K3, K4, K5, Record[4]), Arch)
                    self.PcdToken[Record[3]] = (K2, K1)

        for Key in Pcds:
            (Status, SkuInfoList) = self.GenSkuInfoList(Key[5], self.Platform.SkuInfos.SkuInfoList, '', '', '', '', Key[2], '')
            if Status == False:
                ErrorMsg = "The SKUID '%s' used in section '%s' is not defined in section [SkuIds]" % (SkuInfoList, Type)
                EdkLogger.error("DSC File Parser", PARSER_ERROR, ErrorMsg, ContainerFile, RaiseError=EdkLogger.IsRaiseError)
            Pcd = PcdClass(Key[0], '', Key[1], '', Key[3], '', Key[4], [], SkuInfoList, [])
            Pcd.SupArchList = Pcds[Key]
            self.Platform.DynamicPcdBuildDefinitions.append(Pcd)


    ## Get Component
    #
    # Get Component section defined in Dsc file
    #
    # @param ContainerFile:  The file which describes the Components, used for error report
    #
    # @retval PlatformModuleClass() A instance for PlatformModuleClass
    #
    def GenComponents(self, ContainerFile):
        EdkLogger.debug(2, "Generate %s ..." % TAB_COMPONENTS)
        Components = sdict()
        #
        # Get all include files
        #
        IncludeFiles = QueryDscItem(self.TblDsc, MODEL_META_DATA_INCLUDE, MODEL_META_DATA_COMPONENT, self.FileID)

        #
        # Get all Components
        #
        RecordSet = QueryDscItem(self.TblDsc, MODEL_META_DATA_COMPONENT, -1, self.FileID)

        #
        # Go through each arch
        #
        for Arch in DataType.ARCH_LIST:
            for IncludeFile in IncludeFiles:
                if IncludeFile[1] == Arch or IncludeFile[1] == TAB_ARCH_COMMON.upper():
                    Filename = CheckFileExist(self.WorkspaceDir, IncludeFile[0], ContainerFile, TAB_COMPONENTS, '', IncludeFile[2])
                    for NewItem in open(Filename, 'r').readlines():
                        if CleanString(NewItem) == '':
                            continue
                        NewItems = []
                        GetComponents(open(Filename, 'r').read(), TAB_COMPONENTS, NewItems, TAB_COMMENT_SPLIT)
                        for NewComponent in NewItems:
                            MergeArches(Components, self.GenComponent(NewComponent, Filename), Arch)

            for Record in RecordSet:
                if Record[1] == Arch or Record[1] == TAB_ARCH_COMMON.upper():
                    Lib, Bo, Pcd = [], [], []

                    SubLibSet = QueryDscItem(self.TblDsc, MODEL_EFI_LIBRARY_CLASS, Record[3], self.FileID)
                    for SubLib in SubLibSet:
                        Lib.append(TAB_VALUE_SPLIT.join([SubLib[0], SubLib[4]]))

                    SubBoSet = QueryDscItem(self.TblDsc, MODEL_META_DATA_BUILD_OPTION, Record[3], self.FileID)
                    for SubBo in SubBoSet:
                        Bo.append(SubBo[0])

                    SubPcdSet1 = QueryDscItem(self.TblDsc, MODEL_PCD_FIXED_AT_BUILD, Record[3], self.FileID)
                    SubPcdSet2 = QueryDscItem(self.TblDsc, MODEL_PCD_PATCHABLE_IN_MODULE, Record[3], self.FileID)
                    SubPcdSet3 = QueryDscItem(self.TblDsc, MODEL_PCD_FEATURE_FLAG, Record[3], self.FileID)
                    SubPcdSet4 = QueryDscItem(self.TblDsc, MODEL_PCD_DYNAMIC_EX_DEFAULT, Record[3], self.FileID)
                    SubPcdSet5 = QueryDscItem(self.TblDsc, MODEL_PCD_DYNAMIC_DEFAULT, Record[3], self.FileID)
                    for SubPcd in SubPcdSet1:
                        Pcd.append([DataType.TAB_PCDS_FIXED_AT_BUILD, SubPcd[0], SubPcd[3]])
                    for SubPcd in SubPcdSet2:
                        Pcd.append([DataType.TAB_PCDS_PATCHABLE_IN_MODULE, SubPcd[0], SubPcd[3]])
                    for SubPcd in SubPcdSet3:
                        Pcd.append([DataType.TAB_PCDS_FEATURE_FLAG, SubPcd[0], SubPcd[3]])
                    for SubPcd in SubPcdSet4:
                        Pcd.append([DataType.TAB_PCDS_DYNAMIC_EX, SubPcd[0], SubPcd[3]])
                    for SubPcd in SubPcdSet5:
                        Pcd.append([DataType.TAB_PCDS_DYNAMIC, SubPcd[0], SubPcd[3]])
                    Item = [Record[0], Lib, Bo, Pcd]
                    MergeArches(Components, self.GenComponent(Item, ContainerFile), Arch)

        for Key in Components.keys():
            Key.SupArchList = Components[Key]
            self.Platform.Modules.ModuleList.append(Key)

    ## Get Component
    #
    # Get Component section defined in Dsc file
    #
    # @param Item:           Contents includes a component block
    # @param ContainerFile:  The file which describes the library class, used for error report
    #
    # @retval PlatformModuleClass() A instance for PlatformModuleClass
    #
    def GenComponent(self, Item, ContainerFile, LineNo= -1):
        (InfFilename, ExecFilename) = GetExec(Item[0])
        LibraryClasses = Item[1]
        BuildOptions = Item[2]
        Pcds = Item[3]
        Component = PlatformModuleClass()
        Component.FilePath = NormPath(InfFilename)
        Component.ExecFilePath = NormPath(ExecFilename)
        CheckFileType(Component.FilePath, '.Inf', ContainerFile, 'component name', Item[0], LineNo)
        CheckFileExist(self.WorkspaceDir, Component.FilePath, ContainerFile, 'component', Item[0], LineNo)
        for Lib in LibraryClasses:
            List = GetSplitValueList(Lib)
            if len(List) != 2:
                RaiseParserError(Lib, 'LibraryClasses', ContainerFile, '<ClassName>|<InfFilename>')
            LibName = List[0]
            LibFile = NormPath(List[1])
            if LibName == "" or LibName == "NULL":
                LibName = "NULL%d" % self._NullClassIndex
                self._NullClassIndex += 1
            CheckFileType(List[1], '.Inf', ContainerFile, 'library instance of component ', Lib, LineNo)
            CheckFileExist(self.WorkspaceDir, LibFile, ContainerFile, 'library instance of component', Lib, LineNo)
            Component.LibraryClasses.LibraryList.append(PlatformLibraryClass(LibName, LibFile))
        for BuildOption in BuildOptions:
            Key = GetBuildOption(BuildOption, ContainerFile)
            Component.ModuleSaBuildOption.BuildOptionList.append(BuildOptionClass(Key[0], Key[1], Key[2]))
        for Pcd in Pcds:
            Type = Pcd[0]
            List = GetSplitValueList(Pcd[1])
            PcdId = Pcd[2]

            TokenInfo = None
            #
            # For FeatureFlag
            #
            if Type == DataType.TAB_PCDS_FEATURE_FLAG:
                if len(List) != 2:
                    RaiseParserError(Pcd[1], 'Components', ContainerFile, '<PcdTokenSpaceGuidCName>.<PcdTokenName>|TRUE/FALSE')

                CheckPcdTokenInfo(List[0], 'Components', ContainerFile)
                TokenInfo = GetSplitValueList(List[0], DataType.TAB_SPLIT)
                Component.PcdBuildDefinitions.append(PcdClass(TokenInfo[1], '', TokenInfo[0], '', '', List[1], Type, [], {}, []))
            #
            # For FixedAtBuild or PatchableInModule
            #
            if Type == DataType.TAB_PCDS_FIXED_AT_BUILD or Type == DataType.TAB_PCDS_PATCHABLE_IN_MODULE:
                List.append('')
                if len(List) != 3 and len(List) != 4:
                    RaiseParserError(Pcd[1], 'Components', ContainerFile, '<PcdTokenSpaceGuidCName>.<PcdTokenName>|<Value>[|<MaxDatumSize>]')

                CheckPcdTokenInfo(List[0], 'Components', ContainerFile)
                TokenInfo = GetSplitValueList(List[0], DataType.TAB_SPLIT)
                Component.PcdBuildDefinitions.append(PcdClass(TokenInfo[1], '', TokenInfo[0], '', List[2], List[1], Type, [], {}, []))

            #
            # For Dynamic or DynamicEx
            #
            if Type == DataType.TAB_PCDS_DYNAMIC or Type == DataType.TAB_PCDS_DYNAMIC_EX:
                if len(List) != 1:
                    RaiseParserError(Pcd[1], 'Components', ContainerFile, '<PcdTokenSpaceGuidCName>.<PcdTokenName>')

                CheckPcdTokenInfo(List[0], 'Components', ContainerFile)
                TokenInfo = GetSplitValueList(List[0], DataType.TAB_SPLIT)
                Component.PcdBuildDefinitions.append(PcdClass(TokenInfo[1], '', TokenInfo[0], '', '', '', Type, [], {}, []))

            #
            # Add to PcdToken
            #
            self.PcdToken[PcdId] = (TokenInfo[0], TokenInfo[1])

        return Component
    #End of GenComponent

    ## Gen SkuInfoList
    #
    # Gen SkuInfoList section defined in Dsc file
    #
    # @param SkuNameList:      Input value for SkuNameList
    # @param SkuInfo:          Input value for SkuInfo
    # @param VariableName:     Input value for VariableName
    # @param VariableGuid:     Input value for VariableGuid
    # @param VariableOffset:   Input value for VariableOffset
    # @param HiiDefaultValue:  Input value for HiiDefaultValue
    # @param VpdOffset:        Input value for VpdOffset
    # @param DefaultValue:     Input value for DefaultValue
    #
    # @retval (False, SkuName)     Not found in section SkuId Dsc file
    # @retval (True, SkuInfoList)  Found in section SkuId of Dsc file
    #
    def GenSkuInfoList(self, SkuNameList, SkuInfo, VariableName='', VariableGuid='', VariableOffset='', HiiDefaultValue='', VpdOffset='', DefaultValue=''):
        SkuNameList = GetSplitValueList(SkuNameList)
        if SkuNameList == None or SkuNameList == [] or SkuNameList == ['']:
            SkuNameList = ['DEFAULT']
        SkuInfoList = {}
        for Item in SkuNameList:
            if Item not in SkuInfo:
                return False, Item
            Sku = SkuInfoClass(Item, SkuInfo[Item], VariableName, VariableGuid, VariableOffset, HiiDefaultValue, VpdOffset, DefaultValue)
            SkuInfoList[Item] = Sku

        return True, SkuInfoList

    ## Parse Include statement
    #
    # Get include file path
    #
    # 1. Insert a record into TblFile ???
    # 2. Insert a record into TblDsc
    # Value1: IncludeFilePath
    #
    # @param LineValue:  The line of incude statement
    def ParseInclude(self, LineValue, StartLine, Table, FileID, Filename, SectionName, Model, Arch):
        EdkLogger.debug(EdkLogger.DEBUG_2, "!include statement '%s' found in section %s" % (LineValue, SectionName))
        SectionModel = Section[SectionName.upper()]
        IncludeFile = CleanString(LineValue[LineValue.upper().find(DataType.TAB_INCLUDE.upper() + ' ') + len(DataType.TAB_INCLUDE + ' ') : ])
        Table.Insert(Model, IncludeFile, '', '', Arch, SectionModel, FileID, StartLine, -1, StartLine, -1, 0)

    ## Parse DEFINE statement
    #
    # Get DEFINE macros
    #
    # 1. Insert a record into TblDsc
    # Value1: Macro Name
    # Value2: Macro Value
    #
    def ParseDefine(self, LineValue, StartLine, Table, FileID, Filename, SectionName, Model, Arch):
        EdkLogger.debug(EdkLogger.DEBUG_2, "DEFINE statement '%s' found in section %s" % (LineValue, SectionName))
        SectionModel = Section[SectionName.upper()]
        Define = GetSplitValueList(CleanString(LineValue[LineValue.upper().find(DataType.TAB_DEFINE.upper() + ' ') + len(DataType.TAB_DEFINE + ' ') : ]), TAB_EQUAL_SPLIT, 1)
        Table.Insert(Model, Define[0], Define[1], '', Arch, SectionModel, FileID, StartLine, -1, StartLine, -1, 0)

    ## Parse Defines section
    #
    # Get one item in defines section
    #
    # Value1: Item Name
    # Value2: Item Value
    #
    def ParseDefinesSection(self, LineValue, StartLine, Table, FileID, Filename, SectionName, Model, Arch):
        EdkLogger.debug(EdkLogger.DEBUG_2, "Parse '%s' found in section %s" % (LineValue, SectionName))
        Defines = GetSplitValueList(LineValue, TAB_EQUAL_SPLIT, 1)
        if len(Defines) != 2:
            RaiseParserError(LineValue, SectionName, Filename, '', StartLine)
        self.TblDsc.Insert(Model, Defines[0], Defines[1], '', Arch, -1, FileID, StartLine, -1, StartLine, -1, 0)

    ## Insert conditional statements
    #
    # Pop an item from IfDefList
    # Insert conditional statements to database
    #
    # @param Filename:   Path of parsing file
    # @param IfDefList:  A list stored current conditional statements
    # @param EndLine:    The end line no
    # @param ArchList:   Support arch list
    #
    def InsertConditionalStatement(self, Filename, FileID, BelongsToItem, IfDefList, EndLine, ArchList):
        (Value1, Value2, Value3, Model, StartColumn, EndColumn, Enabled) = ('', '', '', -1, -1, -1, 0)
        if IfDefList == []:
            ErrorMsg = 'Not suited conditional statement in file %s' % Filename
            EdkLogger.error("DSC File Parser", PARSER_ERROR, ErrorMsg, Filename, RaiseError=EdkLogger.IsRaiseError)
        else:
            #
            # Get New Dsc item ID
            #
            DscID = self.TblDsc.GetCount() + 1

            #
            # Pop the conditional statements which is closed
            #
            PreviousIf = IfDefList.pop()
            EdkLogger.debug(EdkLogger.DEBUG_5, 'Previous IfDef: ' + str(PreviousIf))

            #
            # !ifdef and !ifndef
            #
            if PreviousIf[2] in (MODEL_META_DATA_CONDITIONAL_STATEMENT_IFDEF, MODEL_META_DATA_CONDITIONAL_STATEMENT_IFNDEF):
                Value1 = PreviousIf[0]
                Model = PreviousIf[2]
                self.TblDsc.Insert(Model, Value1, Value2, Value3, ArchList, BelongsToItem, self.FileID, PreviousIf[1], StartColumn, EndLine, EndColumn, Enabled)
            #
            # !if and !elseif
            #
            elif PreviousIf[2] in (MODEL_META_DATA_CONDITIONAL_STATEMENT_IF, Model):
                List = PreviousIf[0].split(' ')
                Value1, Value2, Value3 = '', '==', '0'
                if len(List) == 3:
                    Value1 = List[0]
                    Value2 = List[1]
                    Value3 = List[2]
                    Value3 = SplitString(Value3)
                if len(List) == 1:
                    Value1 = List[0]
                Model = PreviousIf[2]
                self.TblDsc.Insert(Model, Value1, Value2, Value3, ArchList, BelongsToItem, self.FileID, PreviousIf[1], StartColumn, EndLine, EndColumn, Enabled)
            #
            # !else
            #
            elif PreviousIf[2] in (MODEL_META_DATA_CONDITIONAL_STATEMENT_ELSE, Model):
                Value1 = PreviousIf[0].strip()
                Model = PreviousIf[2]
                self.TblDsc.Insert(Model, Value1, Value2, Value3, ArchList, BelongsToItem, self.FileID, PreviousIf[1], StartColumn, EndLine, EndColumn, Enabled)

    ## Load Dsc file
    #
    # Load the file if it exists
    #
    # @param Filename:  Input value for filename of Dsc file
    #
    def LoadDscFile(self, Filename):
        #
        # Insert a record for file
        #
        Filename = NormPath(Filename)
        self.Identification.FileFullPath = Filename
        (self.Identification.FileRelativePath, self.Identification.FileName) = os.path.split(Filename)
        self.FileID = self.TblFile.InsertFile(Filename, MODEL_FILE_DSC)

        #
        # Init DscTable
        #
        #self.TblDsc.Table = "Dsc%s" % FileID
        #self.TblDsc.Create()

        #
        # Init common datas
        #
        IfDefList, SectionItemList, CurrentSection, ArchList, ThirdList, IncludeFiles = \
        [], [], TAB_UNKNOWN, [], [], []
        LineNo = 0

        #
        # Parse file content
        #
        IsFindBlockComment = False
        ReservedLine = ''
        for Line in open(Filename, 'r'):
            LineNo = LineNo + 1
            #
            # Remove comment block
            #
            if Line.find(TAB_COMMENT_EDK_START) > -1:
                ReservedLine = GetSplitList(Line, TAB_COMMENT_EDK_START, 1)[0]
                IsFindBlockComment = True
            if Line.find(TAB_COMMENT_EDK_END) > -1:
                Line = ReservedLine + GetSplitList(Line, TAB_COMMENT_EDK_END, 1)[1]
                ReservedLine = ''
                IsFindBlockComment = False
            if IsFindBlockComment:
                continue

            #
            # Remove comments at tail and remove spaces again
            #
            Line = CleanString(Line)
            if Line == '':
                continue

            #
            # Find a new section tab
            # First insert previous section items
            # And then parse the content of the new section
            #
            if Line.startswith(TAB_SECTION_START) and Line.endswith(TAB_SECTION_END):
                #
                # Insert items data of previous section
                #
                self.InsertSectionItemsIntoDatabase(self.FileID, Filename, CurrentSection, SectionItemList, ArchList, ThirdList, IfDefList)
                #
                # Parse the new section
                #
                SectionItemList = []
                ArchList = []
                ThirdList = []

                CurrentSection = ''
                LineList = GetSplitValueList(Line[len(TAB_SECTION_START):len(Line) - len(TAB_SECTION_END)], TAB_COMMA_SPLIT)
                for Item in LineList:
                    ItemList = GetSplitValueList(Item, TAB_SPLIT)
                    if CurrentSection == '':
                        CurrentSection = ItemList[0]
                    else:
                        if CurrentSection != ItemList[0]:
                            EdkLogger.error("Parser", PARSER_ERROR, "Different section names '%s' and '%s' are found in one section definition, this is not allowed." % (CurrentSection, ItemList[0]), File=Filename, Line=LineNo, RaiseError=EdkLogger.IsRaiseError)
                    if CurrentSection.upper() not in self.KeyList:
                        RaiseParserError(Line, CurrentSection, Filename, '', LineNo)
                        CurrentSection = TAB_UNKNOWN
                        continue
                    ItemList.append('')
                    ItemList.append('')
                    if len(ItemList) > 5:
                        RaiseParserError(Line, CurrentSection, Filename, '', LineNo)
                    else:
                        if ItemList[1] != '' and ItemList[1].upper() not in ARCH_LIST_FULL:
                            EdkLogger.error("Parser", PARSER_ERROR, "Invalid Arch definition '%s' found" % ItemList[1], File=Filename, Line=LineNo, RaiseError=EdkLogger.IsRaiseError)
                        ArchList.append(ItemList[1].upper())
                        ThirdList.append(ItemList[2])

                continue

            #
            # Not in any defined section
            #
            if CurrentSection == TAB_UNKNOWN:
                ErrorMsg = "%s is not in any defined section" % Line
                EdkLogger.error("Parser", PARSER_ERROR, ErrorMsg, File=Filename, Line=LineNo, RaiseError=EdkLogger.IsRaiseError)

            #
            # Add a section item
            #
            SectionItemList.append([Line, LineNo])
            # End of parse
        #End of For

        #
        # Insert items data of last section
        #
        self.InsertSectionItemsIntoDatabase(self.FileID, Filename, CurrentSection, SectionItemList, ArchList, ThirdList, IfDefList)

        #
        # Parse conditional statements
        #
        self.ParseConditionalStatement()

        #
        # Replace all DEFINE macros with its actual values
        #
        #ParseDefineMacro2(self.TblDsc, self.RecordSet, GlobalData.gGlobalDefines)
        ParseDefineMacro(self.TblDsc, GlobalData.gGlobalDefines)


    ## ParseConditionalStatement
    #
    # Search all conditional statement and disable no match records
    #
    def ParseConditionalStatement(self):
        #
        # Disabled all !if/!elif/!ifdef statements without DEFINE
        #
        SqlCommand = """select A.StartLine, A.EndLine from %s as A
                        where A.Model in (%s, %s, %s)
                        and A.Enabled = 0
                        and A.BelongsToFile = %s
                        and A.Value1 not in (select B.Value1 from %s as B
                                             where B.Model = %s
                                             and B.Enabled = 0
                                             and A.StartLine > B.StartLine
                                             and A.Arch = B.Arch
                                             and A.BelongsToItem = B.BelongsToItem
                                             and A.BelongsToFile = B.BelongsToFile) """ % \
                        (self.TblDsc.Table, \
                         MODEL_META_DATA_CONDITIONAL_STATEMENT_IF, MODEL_META_DATA_CONDITIONAL_STATEMENT_ELSE, MODEL_META_DATA_CONDITIONAL_STATEMENT_IFDEF, \
                         self.FileID, \
                         self.TblDsc.Table, \
                         MODEL_META_DATA_DEFINE)
        RecordSet = self.TblDsc.Exec(SqlCommand)
        for Record in RecordSet:
            SqlCommand = """Update %s set Enabled = -1 where StartLine >= %s and EndLine <= %s""" % (self.TblDsc.Table, Record[0], Record[1])
            self.TblDsc.Exec(SqlCommand)

        #
        # Disabled !ifndef with DEFINE
        #
        SqlCommand = """select A.StartLine, A.EndLine from %s as A
                        where A.Model = %s
                        and A.Enabled = 0
                        and A.BelongsToFile = %s
                        and A.Value1 in (select B.Value1 from %s as B
                                         where B.Model = %s
                                         and B.Enabled = 0
                                         and A.StartLine > B.StartLine
                                         and A.Arch = B.Arch
                                         and A.BelongsToItem = B.BelongsToItem
                                         and A.BelongsToFile = B.BelongsToFile)""" % \
                        (self.TblDsc.Table, \
                         MODEL_META_DATA_CONDITIONAL_STATEMENT_IFNDEF, \
                         self.FileID, \
                         self.TblDsc.Table, \
                         MODEL_META_DATA_DEFINE)
        RecordSet = self.TblDsc.Exec(SqlCommand)
        for Record in RecordSet:
            SqlCommand = """Update %s set Enabled = -1 where StartLine >= %s and EndLine <= %s""" % (self.TblDsc.Table, Record[0], Record[1])
            EdkLogger.debug(4, "SqlCommand: %s" % SqlCommand)
            self.Cur.execute(SqlCommand)

        #
        # Disabled !if, !elif and !else with un-match value
        #
        SqlCommand = """select A.Model, A.Value1, A.Value2, A.Value3, A.StartLine, A.EndLine, B.Value2 from %s as A join %s as B
                        where A.Model in (%s, %s)
                        and A.Enabled = 0
                        and A.BelongsToFile = %s
                        and B.Enabled = 0
                        and B.Model = %s
                        and A.Value1 = B.Value1
                        and A.StartLine > B.StartLine
                        and A.BelongsToItem = B.BelongsToItem
                        and A.BelongsToFile = B.BelongsToFile""" % \
                        (self.TblDsc.Table, self.TblDsc.Table, \
                         MODEL_META_DATA_CONDITIONAL_STATEMENT_IF, MODEL_META_DATA_CONDITIONAL_STATEMENT_ELSE, \
                         self.FileID, MODEL_META_DATA_DEFINE)
        RecordSet = self.TblDsc.Exec(SqlCommand)
        DisabledList = []
        for Record in RecordSet:
            if Record[0] == MODEL_META_DATA_CONDITIONAL_STATEMENT_IF:
                if not self.Compare(Record[6], Record[2], Record[3]):
                    SqlCommand = """Update %s set Enabled = -1 where StartLine >= %s and EndLine <= %s""" % (self.TblDsc.Table, Record[4], Record[5])
                    self.TblDsc.Exec(SqlCommand)
                else:
                    DisabledList.append(Record[1])
                continue
            if Record[0] == MODEL_META_DATA_CONDITIONAL_STATEMENT_ELSE and Record[1] in DisabledList:
                SqlCommand = """Update %s set Enabled = -1 where StartLine >= %s and EndLine <= %s""" % (self.TblDsc.Table, Record[4], Record[5])
                self.TblDsc.Exec(SqlCommand)

    ## Compare
    #
    # Compare two values
    # @param Value1:
    # @param CompareType:
    # @param Value2:
    #
    def Compare(self, Value1, CompareType, Value2):
        Command = """Value1 %s Value2""" % CompareType
        return eval(Command)

    ## First time to insert records to database
    #
    # Insert item data of a section to database
    # @param FileID:           The ID of belonging file
    # @param Filename:         The name of belonging file
    # @param CurrentSection:   The name of currect section
    # @param SectionItemList:  A list of items of the section
    # @param ArchList:         A list of arches
    # @param ThirdList:        A list of third parameters, ModuleType for LibraryClass and SkuId for Dynamic Pcds
    # @param IfDefList:        A list of all conditional statements
    #
    def InsertSectionItemsIntoDatabase(self, FileID, Filename, CurrentSection, SectionItemList, ArchList, ThirdList, IfDefList):
        #
        # Insert each item data of a section
        #
        for Index in range(0, len(ArchList)):
            Arch = ArchList[Index]
            Third = ThirdList[Index]
            if Arch == '':
                Arch = TAB_ARCH_COMMON.upper()

            Model = Section[CurrentSection.upper()]
            #Records = self.RecordSet[Model]

            for SectionItem in SectionItemList:
                BelongsToItem, EndLine, EndColumn = -1, -1, -1
                LineValue, StartLine, EndLine = SectionItem[0], SectionItem[1], SectionItem[1]


                EdkLogger.debug(4, "Parsing %s ..." % LineValue)
                #
                # Parse '!ifdef'
                #
                if LineValue.upper().find(TAB_IF_DEF.upper()) > -1:
                    IfDefList.append((LineValue[len(TAB_IF_N_DEF):].strip(), StartLine, MODEL_META_DATA_CONDITIONAL_STATEMENT_IFDEF))
                    continue

                #
                # Parse '!ifndef'
                #
                if LineValue.upper().find(TAB_IF_N_DEF.upper()) > -1:
                    IfDefList.append((LineValue[len(TAB_IF_N_DEF):].strip(), StartLine, MODEL_META_DATA_CONDITIONAL_STATEMENT_IFNDEF))
                    continue

                #
                # Parse '!endif'
                #
                if LineValue.upper().find(TAB_END_IF.upper()) > -1:
                    self.InsertConditionalStatement(Filename, FileID, Model, IfDefList, StartLine, Arch)
                    continue
                #
                # Parse '!if'
                #
                if LineValue.upper().find(TAB_IF.upper()) > -1:
                    IfDefList.append((LineValue[len(TAB_IF):].strip(), StartLine, MODEL_META_DATA_CONDITIONAL_STATEMENT_IF))
                    continue

                #
                # Parse '!elseif'
                #
                if LineValue.upper().find(TAB_ELSE_IF.upper()) > -1:
                    self.InsertConditionalStatement(Filename, FileID, Model, IfDefList, StartLine - 1, Arch)
                    IfDefList.append((LineValue[len(TAB_ELSE_IF):].strip(), StartLine, MODEL_META_DATA_CONDITIONAL_STATEMENT_IF))
                    continue

                #
                # Parse '!else'
                #
                if LineValue.upper().find(TAB_ELSE.upper()) > -1:
                    Key = IfDefList[-1][0].split(' ' , 1)[0].strip()
                    self.InsertConditionalStatement(Filename, FileID, Model, IfDefList, StartLine, Arch)
                    IfDefList.append((Key, StartLine, MODEL_META_DATA_CONDITIONAL_STATEMENT_ELSE))
                    continue

                #
                # Parse !include statement first
                #
                if LineValue.upper().find(DataType.TAB_INCLUDE.upper() + ' ') > -1:
                    self.ParseInclude(LineValue, StartLine, self.TblDsc, FileID, Filename, CurrentSection, MODEL_META_DATA_INCLUDE, Arch)
                    continue

                #
                # And then parse DEFINE statement
                #
                if LineValue.upper().find(DataType.TAB_DEFINE.upper() + ' ') > -1:
                    self.ParseDefine(LineValue, StartLine, self.TblDsc, FileID, Filename, CurrentSection, MODEL_META_DATA_DEFINE, Arch)
                    continue

                #
                # At last parse other sections
                #
                if CurrentSection == TAB_LIBRARY_CLASSES or CurrentSection in TAB_PCD_DYNAMIC_TYPE_LIST or CurrentSection in TAB_PCD_DYNAMIC_EX_TYPE_LIST:
                    ID = self.TblDsc.Insert(Model, LineValue, Third, '', Arch, -1, FileID, StartLine, -1, StartLine, -1, 0)
                    #Records.append([LineValue, Arch, StartLine, ID, Third])
                    continue
                elif CurrentSection != TAB_COMPONENTS:
                    ID = self.TblDsc.Insert(Model, LineValue, '', '', Arch, -1, FileID, StartLine, -1, StartLine, -1, 0)
                    #Records.append([LineValue, Arch, StartLine, ID, Third])
                    continue

            #
            # Parse COMPONENT section
            #
            if CurrentSection == TAB_COMPONENTS:
                Components = []
                GetComponent(SectionItemList, Components)
                for Component in Components:
                    EdkLogger.debug(4, "Parsing component %s ..." % Component)
                    DscItmeID = self.TblDsc.Insert(MODEL_META_DATA_COMPONENT, Component[0], '', '', Arch, -1, FileID, StartLine, -1, StartLine, -1, 0)
                    for Item in Component[1]:
                        List = GetSplitValueList(Item, MaxSplit=2)
                        LibName, LibIns = '', ''
                        if len(List) == 2:
                            LibName = List[0]
                            LibIns = List[1]
                        else:
                            LibName = List[0]
                        self.TblDsc.Insert(MODEL_EFI_LIBRARY_CLASS, LibName, LibIns, '', Arch, DscItmeID, FileID, StartLine, -1, StartLine, -1, 0)
                    for Item in Component[2]:
                        self.TblDsc.Insert(MODEL_META_DATA_BUILD_OPTION, Item, '', '', Arch, DscItmeID, FileID, StartLine, -1, StartLine, -1, 0)
                    for Item in Component[3]:
                        Model = Section[Item[0].upper()]
                        self.TblDsc.Insert(Model, Item[1], '', '', Arch, DscItmeID, FileID, StartLine, -1, StartLine, -1, 0)

    ## Show detailed information of Dsc
    #
    # Print all members and their values of Dsc class
    #
    def ShowDsc(self):
        print TAB_SECTION_START + TAB_INF_DEFINES + TAB_SECTION_END
        printDict(self.Defines.DefinesDictionary)

        for Key in self.KeyList:
            for Arch in DataType.ARCH_LIST_FULL:
                Command = "printList(TAB_SECTION_START + '" + \
                                    Key + DataType.TAB_SPLIT + Arch + \
                                    "' + TAB_SECTION_END, self.Contents[arch]." + Key + ')'
                eval(Command)

    ## Show detailed information of Platform
    #
    # Print all members and their values of Platform class
    #
    def ShowPlatform(self):
        M = self.Platform
        for Arch in M.Header.keys():
            print '\nArch =', Arch
            print 'Filename =', M.Header[Arch].FileName
            print 'FullPath =', M.Header[Arch].FullPath
            print 'BaseName =', M.Header[Arch].Name
            print 'Guid =', M.Header[Arch].Guid
            print 'Version =', M.Header[Arch].Version
            print 'DscSpecification =', M.Header[Arch].DscSpecification
            print 'SkuId =', M.Header[Arch].SkuIdName
            print 'SupArchList =', M.Header[Arch].SupArchList
            print 'BuildTargets =', M.Header[Arch].BuildTargets
            print 'OutputDirectory =', M.Header[Arch].OutputDirectory
            print 'BuildNumber =', M.Header[Arch].BuildNumber
            print 'MakefileName =', M.Header[Arch].MakefileName
            print 'BsBaseAddress =', M.Header[Arch].BsBaseAddress
            print 'RtBaseAddress =', M.Header[Arch].RtBaseAddress
            print 'Define =', M.Header[Arch].Define
        print 'Fdf =', M.FlashDefinitionFile.FilePath
        print '\nBuildOptions =', M.BuildOptions, M.BuildOptions.IncludeFiles
        for Item in M.BuildOptions.BuildOptionList:
            print '\t', 'ToolChainFamily =', Item.ToolChainFamily, 'ToolChain =', Item.ToolChain, 'Option =', Item.Option, 'Arch =', Item.SupArchList
        print '\nSkuIds =', M.SkuInfos.SkuInfoList, M.SkuInfos.IncludeFiles
        print '\nLibraries =', M.Libraries, M.Libraries.IncludeFiles
        for Item in M.Libraries.LibraryList:
            print '\t', Item.FilePath, Item.SupArchList, Item.Define
        print '\nLibraryClasses =', M.LibraryClasses, M.LibraryClasses.IncludeFiles
        for Item in M.LibraryClasses.LibraryList:
            print '\t', Item.Name, Item.FilePath, Item.SupModuleList, Item.SupArchList, Item.Define
        print '\nPcds =', M.DynamicPcdBuildDefinitions
        for Item in M.DynamicPcdBuildDefinitions:
            print '\tCname=', Item.CName, 'TSG=', Item.TokenSpaceGuidCName, 'Value=', Item.DefaultValue, 'Token=', Item.Token, 'Type=', Item.ItemType, 'Datum=', Item.DatumType, 'Size=', Item.MaxDatumSize, 'Arch=', Item.SupArchList, Item.SkuInfoList
            for Sku in Item.SkuInfoList.values():
                print '\t\t', str(Sku)
        print '\nComponents =', M.Modules.ModuleList, M.Modules.IncludeFiles
        for Item in M.Modules.ModuleList:
            print '\t', Item.FilePath, Item.ExecFilePath, Item.SupArchList
            for Lib in Item.LibraryClasses.LibraryList:
                print '\t\tLib:', Lib.Name, Lib.FilePath
            for Bo in Item.ModuleSaBuildOption.BuildOptionList:
                print '\t\tBuildOption:', Bo.ToolChainFamily, Bo.ToolChain, Bo.Option
            for Pcd in Item.PcdBuildDefinitions:
                print '\t\tPcd:', Pcd.CName, Pcd.TokenSpaceGuidCName, Pcd.MaxDatumSize, Pcd.DefaultValue, Pcd.ItemType

##
#
# This acts like the main() function for the script, unless it is 'import'ed into another
# script.
#
if __name__ == '__main__':
    EdkLogger.Initialize()
    EdkLogger.SetLevel(EdkLogger.DEBUG_0)

    W = os.getenv('WORKSPACE')
    F = os.path.join(W, 'Nt32Pkg/Nt32Pkg.dsc')

    Db = Database.Database('Dsc.db')
    Db.InitDatabase()

    P = Dsc(os.path.normpath(F), True, True, W, Db)
    P.ShowPlatform()

    Db.Close()