text: ## @file
  # This file is used to define each component of the build database
  #
  # Copyright (c) 2007 - 2014, 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, string, copy, pdb, copy
  import EdkLogger
  import DataType
  from InfClassObject import *
  from DecClassObject import *
  from DscClassObject import *
  from String import *
  from BuildToolError import *
  from Misc import sdict
  import Database as Database
  import time as time
  
  ## PcdClassObject
  #
  # This Class is used for PcdObject
  #
  # @param object:             Inherited from object class
  # @param Name:               Input value for Name of Pcd, default is None
  # @param Guid:               Input value for Guid of Pcd, default is None
  # @param Type:               Input value for Type of Pcd, default is None
  # @param DatumType:          Input value for DatumType of Pcd, default is None
  # @param Value:              Input value for Value of Pcd, default is None
  # @param Token:              Input value for Token of Pcd, default is None
  # @param MaxDatumSize:       Input value for MaxDatumSize of Pcd, default is None
  # @param SkuInfoList:        Input value for SkuInfoList of Pcd, default is {}
  # @param IsOverrided:        Input value for IsOverrided of Pcd, default is False
  #
  # @var TokenCName:           To store value for TokenCName
  # @var TokenSpaceGuidCName:  To store value for TokenSpaceGuidCName
  # @var Type:                 To store value for Type
  # @var DatumType:            To store value for DatumType
  # @var TokenValue:           To store value for TokenValue
  # @var MaxDatumSize:         To store value for MaxDatumSize
  # @var SkuInfoList:          To store value for SkuInfoList
  # @var IsOverrided:          To store value for IsOverrided
  # @var Phase:                To store value for Phase, default is "DXE"
  #
  class PcdClassObject(object):
      def __init__(self, Name = None, Guid = None, Type = None, DatumType = None, Value = None, Token = None, MaxDatumSize = None, SkuInfoList = {}, IsOverrided = False):
          self.TokenCName = Name
          self.TokenSpaceGuidCName = Guid
          self.Type = Type
          self.DatumType = DatumType
          self.DefaultValue = Value
          self.TokenValue = Token
          self.MaxDatumSize = MaxDatumSize
          self.SkuInfoList = SkuInfoList
          self.IsOverrided = IsOverrided
          self.Phase = "DXE"
  
      ## Convert the class to a string
      #
      #  Convert each member of the class to string
      #  Organize to a signle line format string
      #
      #  @retval Rtn Formatted String
      #
      def __str__(self):
          Rtn = '\tTokenCName=' + str(self.TokenCName) + ', ' + \
                'TokenSpaceGuidCName=' + str(self.TokenSpaceGuidCName) + ', ' + \
                'Type=' + str(self.Type) + ', ' + \
                'DatumType=' + str(self.DatumType) + ', ' + \
                'DefaultValue=' + str(self.DefaultValue) + ', ' + \
                'TokenValue=' + str(self.TokenValue) + ', ' + \
                'MaxDatumSize=' + str(self.MaxDatumSize) + ', '
          for Item in self.SkuInfoList.values():
              Rtn = Rtn + 'SkuId=' + Item.SkuId + ', ' + 'SkuIdName=' + Item.SkuIdName
          Rtn = Rtn + str(self.IsOverrided)
  
          return Rtn
  
      ## Override __eq__ function
      #
      # Check whether pcds are the same
      #
      # @retval False The two pcds are different
      # @retval True  The two pcds are the same
      #
      def __eq__(self, Other):
          return Other != None and self.TokenCName == Other.TokenCName and self.TokenSpaceGuidCName == Other.TokenSpaceGuidCName
  
      ## Override __hash__ function
      #
      # Use (TokenCName, TokenSpaceGuidCName) as key in hash table
      #
      # @retval truple() Key for hash table
      #
      def __hash__(self):
          return hash((self.TokenCName, self.TokenSpaceGuidCName))
  
  ## LibraryClassObject
  #
  # This Class defines LibraryClassObject used in BuildDatabase
  #
  # @param object:      Inherited from object class
  # @param Name:        Input value for LibraryClassName, default is None
  # @param SupModList:  Input value for SupModList, default is []
  # @param Type:        Input value for Type, default is None
  #
  # @var LibraryClass:  To store value for LibraryClass
  # @var SupModList:    To store value for SupModList
  # @var Type:          To store value for Type
  #
  class LibraryClassObject(object):
      def __init__(self, Name = None, SupModList = [], Type = None):
          self.LibraryClass = Name
          self.SupModList = SupModList
          if Type != None:
              self.SupModList = CleanString(Type).split(DataType.TAB_SPACE_SPLIT)
  
  ## ModuleBuildClassObject
  #
  # This Class defines ModuleBuildClass
  #
  # @param object:               Inherited from object class
  #
  # @var DescFilePath:           To store value for DescFilePath
  # @var BaseName:               To store value for BaseName
  # @var ModuleType:             To store value for ModuleType
  # @var Guid:                   To store value for Guid
  # @var Version:                To store value for Version
  # @var PcdIsDriver:            To store value for PcdIsDriver
  # @var BinaryModule:           To store value for BinaryModule
  # @var CustomMakefile:         To store value for CustomMakefile
  # @var Specification:          To store value for Specification
  # @var Shadow                  To store value for Shadow
  # @var LibraryClass:           To store value for LibraryClass, it is a list structure as
  #                              [ LibraryClassObject, ...]
  # @var ModuleEntryPointList:   To store value for ModuleEntryPointList
  # @var ModuleUnloadImageList:  To store value for ModuleUnloadImageList
  # @var ConstructorList:        To store value for ConstructorList
  # @var DestructorList:         To store value for DestructorList
  # @var Binaries:               To store value for Binaries, it is a list structure as
  #                              [ ModuleBinaryClassObject, ...]
  # @var Sources:                To store value for Sources, it is a list structure as
  #                              [ ModuleSourceFilesClassObject, ... ]
  # @var LibraryClasses:         To store value for LibraryClasses, it is a set structure as
  #                              { [LibraryClassName, ModuleType] : LibraryClassInfFile }
  # @var Protocols:              To store value for Protocols, it is a list structure as
  #                              [ ProtocolName, ... ]
  # @var Ppis:                   To store value for Ppis, it is a list structure as
  #                              [ PpiName, ... ]
  # @var Guids:                  To store value for Guids, it is a list structure as
  #                              [ GuidName, ... ]
  # @var Includes:               To store value for Includes, it is a list structure as
  #                              [ IncludePath, ... ]
  # @var Packages:               To store value for Packages, it is a list structure as
  #                              [ DecFileName, ... ]
  # @var Pcds:                   To store value for Pcds, it is a set structure as
  #                              { [(PcdCName, PcdGuidCName)] : PcdClassObject}
  # @var BuildOptions:           To store value for BuildOptions, it is a set structure as
  #                              { [BuildOptionKey] : BuildOptionValue}
  # @var Depex:                  To store value for Depex
  #
  class ModuleBuildClassObject(object):
      def __init__(self):
          self.AutoGenVersion          = 0
          self.DescFilePath            = ''
          self.BaseName                = ''
          self.ModuleType              = ''
          self.Guid                    = ''
          self.Version                 = ''
          self.PcdIsDriver             = ''
          self.BinaryModule            = ''
          self.Shadow                  = ''
          self.CustomMakefile          = {}
          self.Specification           = {}
          self.LibraryClass            = []
          self.ModuleEntryPointList    = []
          self.ModuleUnloadImageList   = []
          self.ConstructorList         = []
          self.DestructorList          = []
  
          self.Binaries                = []
          self.Sources                 = []
          self.LibraryClasses          = sdict()
          self.Libraries               = []
          self.Protocols               = []
          self.Ppis                    = []
          self.Guids                   = []
          self.Includes                = []
          self.Packages                = []
          self.Pcds                    = {}
          self.BuildOptions            = {}
          self.Depex                   = ''
  
      ## Convert the class to a string
      #
      #  Convert member DescFilePath of the class to a string
      #
      #  @retval string Formatted String
      #
      def __str__(self):
          return self.DescFilePath
  
      ## Override __eq__ function
      #
      # Check whether ModuleBuildClassObjects are the same
      #
      # @retval False The two ModuleBuildClassObjects are different
      # @retval True  The two ModuleBuildClassObjects are the same
      #
      def __eq__(self, Other):
          return self.DescFilePath == str(Other)
  
      ## Override __hash__ function
      #
      # Use DescFilePath as key in hash table
      #
      # @retval string Key for hash table
      #
      def __hash__(self):
          return hash(self.DescFilePath)
  
  ## PackageBuildClassObject
  #
  # This Class defines PackageBuildClass
  #
  # @param object:        Inherited from object class
  #
  # @var DescFilePath:    To store value for DescFilePath
  # @var PackageName:     To store value for PackageName
  # @var Guid:            To store value for Guid
  # @var Version:         To store value for Version
  # @var Protocols:       To store value for Protocols, it is a set structure as
  #                       { [ProtocolName] : Protocol Guid, ... }
  # @var Ppis:            To store value for Ppis, it is a set structure as
  #                       { [PpiName] : Ppi Guid, ... }
  # @var Guids:           To store value for Guids, it is a set structure as
  #                       { [GuidName] : Guid, ... }
  # @var Includes:        To store value for Includes, it is a list structure as
  #                       [ IncludePath, ... ]
  # @var LibraryClasses:  To store value for LibraryClasses, it is a set structure as
  #                       { [LibraryClassName] : LibraryClassInfFile }
  # @var Pcds:            To store value for Pcds, it is a set structure as
  #                       { [(PcdCName, PcdGuidCName)] : PcdClassObject}
  #
  class PackageBuildClassObject(object):
      def __init__(self):
          self.DescFilePath            = ''
          self.PackageName             = ''
          self.Guid                    = ''
          self.Version                 = ''
  
          self.Protocols               = {}
          self.Ppis                    = {}
          self.Guids                   = {}
          self.Includes                = []
          self.LibraryClasses          = {}
          self.Pcds                    = {}
  
      ## Convert the class to a string
      #
      #  Convert member DescFilePath of the class to a string
      #
      #  @retval string Formatted String
      #
      def __str__(self):
          return self.DescFilePath
  
      ## Override __eq__ function
      #
      # Check whether PackageBuildClassObjects are the same
      #
      # @retval False The two PackageBuildClassObjects are different
      # @retval True  The two PackageBuildClassObjects are the same
      #
      def __eq__(self, Other):
          return self.DescFilePath == str(Other)
  
      ## Override __hash__ function
      #
      # Use DescFilePath as key in hash table
      #
      # @retval string Key for hash table
      #
      def __hash__(self):
          return hash(self.DescFilePath)
  
  ## PlatformBuildClassObject
  #
  # This Class defines PlatformBuildClass
  #
  # @param object:          Inherited from object class
  #
  # @var DescFilePath:      To store value for DescFilePath
  # @var PlatformName:      To store value for PlatformName
  # @var Guid:              To store value for Guid
  # @var Version:           To store value for Version
  # @var DscSpecification:  To store value for DscSpecification
  # @var OutputDirectory:   To store value for OutputDirectory
  # @var FlashDefinition:   To store value for FlashDefinition
  # @var BuildNumber:       To store value for BuildNumber
  # @var MakefileName:      To store value for MakefileName
  # @var SkuIds:            To store value for SkuIds, it is a set structure as
  #                         { 'SkuName' : SkuId, '!include' : includefilename, ...}
  # @var Modules:           To store value for Modules, it is a list structure as
  #                         [ InfFileName, ... ]
  # @var Libraries:         To store value for Libraries, it is a list structure as
  #                         [ InfFileName, ... ]
  # @var LibraryClasses:    To store value for LibraryClasses, it is a set structure as
  #                         { (LibraryClassName, ModuleType) : LibraryClassInfFile }
  # @var Pcds:              To store value for Pcds, it is a set structure as
  #                         { [(PcdCName, PcdGuidCName)] : PcdClassObject }
  # @var BuildOptions:      To store value for BuildOptions, it is a set structure as
  #                         { [BuildOptionKey] : BuildOptionValue }
  #
  class PlatformBuildClassObject(object):
      def __init__(self):
          self.DescFilePath            = ''
          self.PlatformName            = ''
          self.Guid                    = ''
          self.Version                 = ''
          self.DscSpecification        = ''
          self.OutputDirectory         = ''
          self.FlashDefinition         = ''
          self.BuildNumber             = ''
          self.MakefileName            = ''
  
          self.SkuIds                  = {}
          self.Modules                 = []
          self.LibraryInstances        = []
          self.LibraryClasses          = {}
          self.Libraries               = {}
          self.Pcds                    = {}
          self.BuildOptions            = {}
  
      ## Convert the class to a string
      #
      #  Convert member DescFilePath of the class to a string
      #
      #  @retval string Formatted String
      #
      def __str__(self):
          return self.DescFilePath
  
      ## Override __eq__ function
      #
      # Check whether PlatformBuildClassObjects are the same
      #
      # @retval False The two PlatformBuildClassObjects are different
      # @retval True  The two PlatformBuildClassObjects are the same
      #
      def __eq__(self, other):
          return self.DescFilePath == str(other)
  
      ## Override __hash__ function
      #
      # Use DescFilePath as key in hash table
      #
      # @retval string Key for hash table
      #
      def __hash__(self):
          return hash(self.DescFilePath)
  
  ## ItemBuild
  #
  # This Class defines Module/Platform/Package databases for build system
  #
  # @param object:          Inherited from object class
  # @param Arch:            Build arch
  # @param Platform:        Build Platform
  # @param Package:         Build Package
  # @param Module:          Build Module
  #
  # @var Arch:              To store value for Build Arch
  # @var PlatformDatabase:  To store value for PlatformDatabase, it is a set structure as
  #                         { [DscFileName] : PlatformBuildClassObject, ...}
  # @var PackageDatabase:   To store value for PackageDatabase, it is a set structure as
  #                         { [DecFileName] : PacakgeBuildClassObject, ...}
  # @var ModuleDatabase:    To store value for ModuleDatabase, it is a list structure as
  #                         { [InfFileName] : ModuleBuildClassObject, ...}
  #
  class ItemBuild(object):
      def __init__(self, Arch, Platform = None, Package = None, Module = None):
          self.Arch                    = Arch
          self.PlatformDatabase        = {}
          self.PackageDatabase         = {}
          self.ModuleDatabase          = {}
  
  ## WorkspaceBuild
  #
  # This class is used to parse active platform to init all inf/dec/dsc files
  # Generate module/package/platform databases for build
  #
  # @param object:          Inherited from object class
  # @param ActivePlatform:  Input value for current active platform
  # @param WorkspaceDir:    Input value for current WorkspaceDir
  #
  # @var WorkspaceDir:      To store value for WorkspaceDir
  # @var SupArchList:       To store value for SupArchList, selection scope is in below list
  #                         EBC | IA32 | X64 | IPF | ARM | PPC | AARCH64
  # @var BuildTarget:       To store value for WorkspaceDir, selection scope is in below list
  #                         RELEASE | DEBUG
  # @var SkuId:             To store value for SkuId
  # @var Fdf:               To store value for Fdf
  # @var FdTargetList:      To store value for FdTargetList
  # @var FvTargetList:      To store value for FvTargetList
  # @var TargetTxt:         To store value for TargetTxt, it is a set structure as
  #                         TargetTxtClassObject
  # @var ToolDef:           To store value for ToolDef, it is a set structure as
  #                         ToolDefClassObject
  # @var InfDatabase:       To store value for InfDatabase, it is a set structure as
  #                         { [InfFileName] : InfClassObject}
  # @var DecDatabase:       To store value for DecDatabase, it is a set structure as
  #                         { [DecFileName] : DecClassObject}
  # @var DscDatabase:       To store value for DscDatabase, it is a set structure as
  #                         { [DscFileName] : DscClassObject}
  # @var Build:             To store value for DscDatabase, it is a set structure as
  #                         ItemBuild
  # @var DscFileName:       To store value for Active Platform
  # @var UnFoundPcdInDsc:   To store values for the pcds defined in INF/DEC but not found in DSC, it is a set structure as
  #                         { (PcdGuid, PcdCName, Arch) : DecFileName }
  #
  class WorkspaceBuild(object):
      def __init__(self, ActivePlatform, WorkspaceDir):
          self.WorkspaceDir            = NormPath(WorkspaceDir)
          self.SupArchList             = []
          self.BuildTarget             = []
          self.SkuId                   = ''
          self.Fdf                     = ''
          self.FdTargetList            = []
          self.FvTargetList            = []
          self.TargetTxt               = None
          self.ToolDef                 = None
  
          self.InfDatabase             = {}
          self.DecDatabase             = {}
          self.DscDatabase             = {}
  
          self.UnFoundPcdInDsc         = {}
  
          #
          # Init build for all arches
          #
          self.Build                   = {}
          for Arch in DataType.ARCH_LIST:
              self.Build[Arch] = ItemBuild(Arch)
  
          #
          # Init build database
          #
          self.Db = Database.Database(DATABASE_PATH)
          self.Db.InitDatabase()
  
          #
          # Get active platform
          #
          self.DscFileName = NormPath(ActivePlatform)
          File = self.WorkspaceFile(self.DscFileName)
          if os.path.exists(File) and os.path.isfile(File):
              self.DscDatabase[self.DscFileName] = Dsc(File, False, True, self.WorkspaceDir, self.Db)
          else:
              EdkLogger.error("AutoGen", FILE_NOT_FOUND, ExtraData = File)
  
          #
          # Parse platform to get module
          #
          for DscFile in self.DscDatabase.keys():
              Platform = self.DscDatabase[DscFile].Platform
  
              #
              # Get global information
              #
              Tmp = set()
              for Arch in DataType.ARCH_LIST:
                  for Item in Platform.Header[Arch].SupArchList:
                      Tmp.add(Item)
              self.SupArchList = list(Tmp)
              Tmp = set()
              for Arch in DataType.ARCH_LIST:
                  for Item in Platform.Header[Arch].BuildTargets:
                      Tmp.add(Item)
              self.BuildTarget = list(Tmp)
              for Arch in self.SupArchList:
                  self.SkuId = Platform.Header[Arch].SkuIdName
              self.Fdf = Platform.FlashDefinitionFile.FilePath
  
              #
              # Get all inf files
              #
              for Item in Platform.LibraryClasses.LibraryList:
                  for Arch in Item.SupArchList:
                      self.AddToInfDatabase(Item.FilePath)
  
              for Item in Platform.Libraries.LibraryList:
                  for Arch in Item.SupArchList:
                      self.AddToInfDatabase(Item.FilePath)
  
              for Item in Platform.Modules.ModuleList:
                  for Arch in Item.SupArchList:
                      #
                      # Add modules
                      #
                      Module = Item.FilePath
                      self.AddToInfDatabase(Module)
                      #
                      # Add library used in modules
                      #
                      for Lib in Item.LibraryClasses.LibraryList:
                          self.AddToInfDatabase(Lib.FilePath)
                          self.UpdateLibraryClassOfModule(Module, Lib.Name, Arch, Lib.FilePath)
  
          #
          # Parse module to get package
          #
          for InfFile in self.InfDatabase.keys():
              Module = self.InfDatabase[InfFile].Module
              #
              # Get all dec
              #
              for Item in Module.PackageDependencies:
                  for Arch in Item.SupArchList:
                      self.AddToDecDatabase(Item.FilePath)
      # End of self.Init()
  
      ## Generate PlatformDatabase
      #
      # Go through each arch to get all items in DscDatabase to PlatformDatabase
      #
      def GenPlatformDatabase(self, PcdsSet={}):
          for Dsc in self.DscDatabase.keys():
              Platform = self.DscDatabase[Dsc].Platform
              for Arch in self.SupArchList:
                  Pb = PlatformBuildClassObject()
  
                  #
                  # Defines
                  #
                  Pb.DescFilePath = Dsc
                  Pb.PlatformName = Platform.Header[Arch].Name
                  if Pb.PlatformName == '':
                      EdkLogger.error("AutoGen", PARSER_ERROR, "The BaseName of platform %s is not defined for arch %s" % (Dsc, Arch))
                  Pb.Guid = Platform.Header[Arch].Guid
                  Pb.Version = Platform.Header[Arch].Version
                  Pb.DscSpecification = Platform.Header[Arch].DscSpecification
                  Pb.OutputDirectory = Platform.Header[Arch].OutputDirectory
                  Pb.FlashDefinition = Platform.FlashDefinitionFile.FilePath
                  Pb.BuildNumber = Platform.Header[Arch].BuildNumber
  
                  #
                  # SkuId
                  #
                  for Key in Platform.SkuInfos.SkuInfoList.keys():
                      Pb.SkuIds[Key] = Platform.SkuInfos.SkuInfoList[Key]
  
                  #
                  # Module
                  #
                  for Item in Platform.Modules.ModuleList:
                      if Arch in Item.SupArchList:
                          Pb.Modules.append(Item.FilePath)
  
                  #
                  # BuildOptions
                  #
                  for Item in Platform.BuildOptions.BuildOptionList:
                      if Arch in Item.SupArchList:
                          Pb.BuildOptions[(Item.ToolChainFamily, Item.ToolChain)] = Item.Option
  
                  #
                  # LibraryClass
                  #
                  for Item in Platform.LibraryClasses.LibraryList:
                      SupModuleList = self.FindSupModuleListOfLibraryClass(Item, Platform.LibraryClasses.LibraryList, Arch)
                      if Arch in Item.SupArchList:
                          for ModuleType in SupModuleList:
                              Pb.LibraryClasses[(Item.Name, ModuleType)] = Item.FilePath
  
                  #
                  # Libraries
                  #
                  for Item in Platform.Libraries.LibraryList:
                      for ItemArch in Item.SupArchList:
                          Library = self.InfDatabase[Item.FilePath]
                          if ItemArch not in Library.Module.Header:
                              continue
                          Pb.Libraries[Library.Module.Header[ItemArch].Name] = Item.FilePath
  
                  #
                  # Pcds
                  #
                  for Item in Platform.DynamicPcdBuildDefinitions:
                      if Arch in Item.SupArchList:
                          Name = Item.CName
                          Guid = Item.TokenSpaceGuidCName
                          Type = Item.ItemType
                          DatumType = Item.DatumType
                          Value = Item.DefaultValue
                          Token = Item.Token
                          MaxDatumSize = Item.MaxDatumSize
                          SkuInfoList = Item.SkuInfoList
                          Pb.Pcds[(Name, Guid)] = PcdClassObject(Name, Guid, Type, DatumType, Value, Token, MaxDatumSize, SkuInfoList, False)
  
                  for (Name, Guid) in PcdsSet:
                      Value = PcdsSet[Name, Guid]
                      for PcdType in ["FixedAtBuild", "PatchableInModule", "FeatureFlag", "Dynamic", "DynamicEx"]:
                          for Dec in self.Build[Arch].PackageDatabase:
                              Pcds = self.Build[Arch].PackageDatabase[Dec].Pcds
                              if (Name, Guid, PcdType) in Pcds:
                                  Pcd = Pcds[(Name, Guid, PcdType)]
                                  Type = PcdType
                                  DatumType = Pcd.DatumType
                                  Token = Pcd.TokenValue
                                  MaxDatumSize = Pcd.MaxDatumSize
                                  SkuInfoList = Pcd.SkuInfoList
                                  Pb.Pcds[(Name, Guid)] = PcdClassObject(Name, Guid, Type, DatumType, Value, Token, MaxDatumSize, SkuInfoList, False)
                                  break
                          else:
                              # nothing found
                              continue
                          # found in one package, find next PCD
                          break
                      else:
                          EdkLogger.error("AutoGen", PARSER_ERROR, "PCD is not found in any package", ExtraData="%s.%s" % (Guid, Name))
                  #
                  # Add to database
                  #
                  self.Build[Arch].PlatformDatabase[Dsc] = Pb
                  Pb = None
  
      ## Generate PackageDatabase
      #
      # Go through each arch to get all items in DecDatabase to PackageDatabase
      #
      def GenPackageDatabase(self):
          for Dec in self.DecDatabase.keys():
              Package = self.DecDatabase[Dec].Package
  
              for Arch in self.SupArchList:
                  Pb = PackageBuildClassObject()
  
                  #
                  # Defines
                  #
                  Pb.DescFilePath = Dec
                  Pb.PackageName = Package.Header[Arch].Name
                  if Pb.PackageName == '':
                      EdkLogger.error("AutoGen", PARSER_ERROR, "The BaseName of package %s is not defined for arch %s" % (Dec, Arch))
  
                  Pb.Guid = Package.Header[Arch].Guid
                  Pb.Version = Package.Header[Arch].Version
  
                  #
                  # Protocols
                  #
                  for Item in Package.ProtocolDeclarations:
                      if Arch in Item.SupArchList:
                          Pb.Protocols[Item.CName] = Item.Guid
  
                  #
                  # Ppis
                  #
                  for Item in Package.PpiDeclarations:
                      if Arch in Item.SupArchList:
                          Pb.Ppis[Item.CName] = Item.Guid
  
                  #
                  # Guids
                  #
                  for Item in Package.GuidDeclarations:
                      if Arch in Item.SupArchList:
                          Pb.Guids[Item.CName] = Item.Guid
  
                  #
                  # Includes
                  #
                  for Item in Package.Includes:
                      if Arch in Item.SupArchList:
                          Pb.Includes.append(Item.FilePath)
  
                  #
                  # LibraryClasses
                  #
                  for Item in Package.LibraryClassDeclarations:
                      if Arch in Item.SupArchList:
                          Pb.LibraryClasses[Item.LibraryClass] = Item.RecommendedInstance
  
                  #
                  # Pcds
                  #
                  for Item in Package.PcdDeclarations:
                      if Arch in Item.SupArchList:
                          Name = Item.CName
                          Guid = Item.TokenSpaceGuidCName
                          Type = Item.ItemType
                          DatumType = Item.DatumType
                          Value = Item.DefaultValue
                          Token = Item.Token
                          MaxDatumSize = Item.MaxDatumSize
                          SkuInfoList = Item.SkuInfoList
                          Pb.Pcds[(Name, Guid, Type)] = PcdClassObject(Name, Guid, Type, DatumType, Value, Token, MaxDatumSize, SkuInfoList, False)
  
                  #
                  # Add to database
                  #
                  self.Build[Arch].PackageDatabase[Dec] = Pb
                  Pb = None
  
      ## Generate ModuleDatabase
      #
      # Go through each arch to get all items in InfDatabase to ModuleDatabase
      #
      def GenModuleDatabase(self, InfList = []):
          for Inf in self.InfDatabase.keys():
              Module = self.InfDatabase[Inf].Module
  
              for Arch in self.SupArchList:
                  if not self.IsModuleDefinedInPlatform(Inf, Arch, InfList) or Arch not in Module.Header:
                      continue
  
                  ModuleHeader = Module.Header[Arch]
                  Pb = ModuleBuildClassObject()
  
                  #
                  # Defines
                  #
                  Pb.DescFilePath = Inf
                  Pb.BaseName = ModuleHeader.Name
                  if Pb.BaseName == '':
                      EdkLogger.error("AutoGen", PARSER_ERROR, "The BaseName of module %s is not defined for arch %s" % (Inf, Arch))
                  Pb.Guid = ModuleHeader.Guid
                  Pb.Version = ModuleHeader.Version
                  Pb.ModuleType = ModuleHeader.ModuleType
                  Pb.PcdIsDriver = ModuleHeader.PcdIsDriver
                  Pb.BinaryModule = ModuleHeader.BinaryModule
                  Pb.CustomMakefile = ModuleHeader.CustomMakefile
                  Pb.Shadow = ModuleHeader.Shadow
  
                  #
                  # Specs os Defines
                  #
                  Pb.Specification = ModuleHeader.Specification
                  Pb.Specification[TAB_INF_DEFINES_EDK_RELEASE_VERSION] = ModuleHeader.EdkReleaseVersion
                  Pb.Specification[TAB_INF_DEFINES_EFI_SPECIFICATION_VERSION] = ModuleHeader.UefiSpecificationVersion
                  Pb.Specification[TAB_INF_DEFINES_UEFI_SPECIFICATION_VERSION] = ModuleHeader.UefiSpecificationVersion
                  Pb.AutoGenVersion = int(ModuleHeader.InfVersion, 0)
  
                  #
                  # LibraryClass of Defines
                  #
                  for Item in ModuleHeader.LibraryClass:
                      Pb.LibraryClass.append(LibraryClassObject(Item.LibraryClass, Item.SupModuleList, None))
  
                  #
                  # Module image and library of Defines
                  #
                  for Item in Module.ExternImages:
                      if Item.ModuleEntryPoint != '' and Item.ModuleEntryPoint not in Pb.ModuleEntryPointList:
                          Pb.ModuleEntryPointList.append(Item.ModuleEntryPoint)
                      if Item.ModuleUnloadImage != '' and Item.ModuleUnloadImage not in Pb.ModuleUnloadImageList:
                          Pb.ModuleUnloadImageList.append(Item.ModuleUnloadImage)
                  for Item in Module.ExternLibraries:
                      if Item.Constructor != '' and Item.Constructor not in Pb.ConstructorList:
                          Pb.ConstructorList.append(Item.Constructor)
                      if Item.Destructor != '' and Item.Destructor not in Pb.DestructorList:
                          Pb.DestructorList.append(Item.Destructor)
  
                  #
                  # Binaries
                  #
                  for Item in Module.Binaries:
                      if Arch in Item.SupArchList:
                          FileName = Item.BinaryFile
                          FileType = Item.FileType
                          Target = Item.Target
                          FeatureFlag = Item.FeatureFlag
                          Pb.Binaries.append(ModuleBinaryFileClass(FileName, FileType, Target, FeatureFlag, Arch.split()))
  
                  #
                  # Sources
                  #
                  for Item in Module.Sources:
                      if Arch in Item.SupArchList:
                          SourceFile = Item.SourceFile
                          TagName = Item.TagName
                          ToolCode = Item.ToolCode
                          ToolChainFamily = Item.ToolChainFamily
                          FeatureFlag = Item.FeatureFlag
                          Pb.Sources.append(ModuleSourceFileClass(SourceFile, TagName, ToolCode, ToolChainFamily, FeatureFlag))
  
                  #
                  # Protocols
                  #
                  for Item in Module.Protocols:
                      if Arch in Item.SupArchList:
                          Pb.Protocols.append(Item.CName)
  
                  #
                  # Ppis
                  #
                  for Item in Module.Ppis:
                      if Arch in Item.SupArchList:
                          Pb.Ppis.append(Item.CName)
  
                  #
                  # Guids
                  #
                  for Item in Module.Guids:
                      if Arch in Item.SupArchList:
                          Pb.Ppis.append(Item.CName)
  
                  #
                  # Includes
                  #
                  for Item in Module.Includes:
                      if Arch in Item.SupArchList:
                          Pb.Includes.append(Item.FilePath)
  
                  #
                  # Packages
                  #
                  for Item in Module.PackageDependencies:
                      if Arch in Item.SupArchList:
                          Pb.Packages.append(Item.FilePath)
  
                  #
                  # BuildOptions
                  #
                  for Item in Module.BuildOptions:
                      if Arch in Item.SupArchList:
                          if (Item.ToolChainFamily, Item.ToolChain) not in Pb.BuildOptions:
                              Pb.BuildOptions[(Item.ToolChainFamily, Item.ToolChain)] = Item.Option
                          else:
                              OptionString = Pb.BuildOptions[(Item.ToolChainFamily, Item.ToolChain)]
                              Pb.BuildOptions[(Item.ToolChainFamily, Item.ToolChain)] = OptionString + " " + Item.Option
                  self.FindBuildOptions(Arch, Inf, Pb.BuildOptions)
  
                  #
                  # Depex
                  #
                  for Item in Module.Depex:
                      if Arch in Item.SupArchList:
                          Pb.Depex = Pb.Depex + Item.Depex + ' '
                  Pb.Depex = Pb.Depex.strip()
  
                  #
                  # LibraryClasses
                  #
                  for Item in Module.LibraryClasses:
                      if Arch in Item.SupArchList:
                          Lib = Item.LibraryClass
                          RecommendedInstance = Item.RecommendedInstance
                          if Pb.LibraryClass != []:
                              #
                              # For Library
                              #
                              for Libs in Pb.LibraryClass:
                                  for Type in Libs.SupModList:
                                      Instance = self.FindLibraryClassInstanceOfLibrary(Lib, Arch, Type)
                                      if Instance == None:
                                          Instance = RecommendedInstance
                                      Pb.LibraryClasses[(Lib, Type)] = Instance
                          else:
                              #
                              # For Module
                              #
                              Instance = self.FindLibraryClassInstanceOfModule(Lib, Arch, Pb.ModuleType, Inf)
                              if Instance == None:
                                  Instance = RecommendedInstance
                              Pb.LibraryClasses[(Lib, Pb.ModuleType)] = Instance
  
                  #
                  # Libraries
                  #
                  for Item in Module.Libraries:
                      if Arch in Item.SupArchList:
                          Pb.Libraries.append(Item.Library)
  
                  #
                  # Pcds
                  #
                  for Item in Module.PcdCodes:
                      if Arch in Item.SupArchList:
                          Name = Item.CName
                          Guid = Item.TokenSpaceGuidCName
                          Type = Item.ItemType
                          Pb.Pcds[(Name, Guid)] = self.FindPcd(Arch, Inf, Name, Guid, Type)
  
                  #
                  # Add to database
                  #
                  self.Build[Arch].ModuleDatabase[Inf] = Pb
                  Pb = None
  
      ## Update Libraries Of Platform Database
      #
      # @param InfList: A list for all inf files
      #
      def UpdateLibrariesOfPlatform(self, InfList = []):
          for Arch in self.SupArchList:
              PlatformDatabase = self.Build[Arch].PlatformDatabase
              for Dsc in PlatformDatabase:
                  Platform = PlatformDatabase[Dsc]
                  for Inf in Platform.Modules:
                      if not self.IsModuleDefinedInPlatform(Inf, Arch, InfList):
                          continue
                      Module = self.Build[Arch].ModuleDatabase[Inf]
                      if Module.LibraryClass == None or Module.LibraryClass == []:
                          self.UpdateLibrariesOfModule(Platform, Module, Arch)
                          for Key in Module.LibraryClasses:
                              Lib = Module.LibraryClasses[Key]
                              if Lib not in Platform.LibraryInstances:
                                  Platform.LibraryInstances.append(Lib)
  
  
      ## Update Libraries Of Module Database
      #
      # @param Module:  The module need to be updated libraries
      # @param Arch:    The supportted arch of the module
      #
      def UpdateLibrariesOfModule(self, Platform, Module, Arch):
          ModuleDatabase = self.Build[Arch].ModuleDatabase
          ModuleType = Module.ModuleType
  
          # check Edk module
          if Module.AutoGenVersion < 0x00010005:
              EdkLogger.verbose("")
              EdkLogger.verbose("Library instances of module [%s] [%s]:" % (str(Module), Arch))
              LibraryConsumerList = [Module]
  
              # "CompilerStub" is a must for Edk modules
              Module.Libraries.append("CompilerStub")
              while len(LibraryConsumerList) > 0:
                  M = LibraryConsumerList.pop()
                  for LibraryName in M.Libraries:
                      if LibraryName not in Platform.Libraries:
                          EdkLogger.warn("AutoGen", "Library [%s] is not found" % LibraryName,
                                          ExtraData="\t%s [%s]" % (str(Module), Arch))
                          continue
  
                      LibraryFile = Platform.Libraries[LibraryName]
                      if (LibraryName, ModuleType) not in Module.LibraryClasses:
                          Module.LibraryClasses[LibraryName, ModuleType] = LibraryFile
                          LibraryConsumerList.append(ModuleDatabase[LibraryFile])
                          EdkLogger.verbose("\t" + LibraryName + " : " + LibraryFile)
              return
  
          # EdkII module
          LibraryConsumerList = [Module]
          Constructor         = []
          ConsumedByList      = sdict()
          LibraryInstance     = sdict()
  
          EdkLogger.verbose("")
          EdkLogger.verbose("Library instances of module [%s] [%s]:" % (str(Module), Arch))
          while len(LibraryConsumerList) > 0:
              M = LibraryConsumerList.pop()
              for Key, LibraryPath in M.LibraryClasses.iteritems():
                  # The "Key" is in format of (library_class_name, supported_module_type)
                  if ModuleType != "USER_DEFINED" and ModuleType not in Key:
                      EdkLogger.debug(EdkLogger.DEBUG_3, "%s for module type %s is not supported (%s)" % (Key + (LibraryPath,)))
                      continue
  
                  LibraryClassName = Key[0]
                  if LibraryClassName not in LibraryInstance or LibraryInstance[LibraryClassName] == None:
                      if LibraryPath == None or LibraryPath == "":
                          LibraryInstance[LibraryClassName] = None
                          continue
                      LibraryModule = ModuleDatabase[LibraryPath]
                      LibraryInstance[LibraryClassName] = LibraryModule
                      LibraryConsumerList.append(LibraryModule)
                      EdkLogger.verbose("\t" + LibraryClassName + " : " + str(LibraryModule))
                  elif LibraryPath == None or LibraryPath == "":
                      continue
                  else:
                      LibraryModule = LibraryInstance[LibraryClassName]
  
                  if LibraryModule.ConstructorList != [] and LibraryModule not in Constructor:
                      Constructor.append(LibraryModule)
  
                  if LibraryModule not in ConsumedByList:
                      ConsumedByList[LibraryModule] = []
                  if M != Module:
                      if M in ConsumedByList[LibraryModule]:
                          continue
                      ConsumedByList[LibraryModule].append(M)
          #
          # Initialize the sorted output list to the empty set
          #
          SortedLibraryList = []
          #
          # Q <- Set of all nodes with no incoming edges
          #
          LibraryList = [] #LibraryInstance.values()
          Q = []
          for LibraryClassName in LibraryInstance:
              M = LibraryInstance[LibraryClassName]
              if M == None:
                  EdkLogger.error("AutoGen", AUTOGEN_ERROR,
                                  "Library instance for library class [%s] is not found" % LibraryClassName,
                                  ExtraData="\t%s [%s]" % (str(Module), Arch))
              LibraryList.append(M)
              #
              # check if there're duplicate library classes
              #
              for Lc in M.LibraryClass:
                  if Lc.SupModList != None and ModuleType not in Lc.SupModList:
                      EdkLogger.error("AutoGen", AUTOGEN_ERROR,
                                      "Module type [%s] is not supported by library instance [%s]" % (ModuleType, str(M)),
                                      ExtraData="\t%s" % str(Module))
  
                  if Lc.LibraryClass in LibraryInstance and str(M) != str(LibraryInstance[Lc.LibraryClass]):
                      EdkLogger.error("AutoGen", AUTOGEN_ERROR,
                                      "More than one library instance found for library class [%s] in module [%s]" % (Lc.LibraryClass, Module),
                                      ExtraData="\t%s\n\t%s" % (LibraryInstance[Lc.LibraryClass], str(M))
                                      )
              if ConsumedByList[M] == []:
                  Q.insert(0, M)
          #
          # while Q is not empty do
          #
          while Q != []:
              #
              # remove node from Q
              #
              Node = Q.pop()
              #
              # output Node
              #
              SortedLibraryList.append(Node)
              #
              # for each node Item with an edge e from Node to Item do
              #
              for Item in LibraryList:
                  if Node not in ConsumedByList[Item]:
                      continue
                  #
                  # remove edge e from the graph
                  #
                  ConsumedByList[Item].remove(Node)
                  #
                  # If Item has no other incoming edges then
                  #
                  if ConsumedByList[Item] == []:
                      #
                      # insert Item into Q
                      #
                      Q.insert(0, Item)
  
              EdgeRemoved = True
              while Q == [] and EdgeRemoved:
                  EdgeRemoved = False
                  #
                  # for each node Item with a Constructor
                  #
                  for Item in LibraryList:
                      if Item in Constructor:
                          #
                          # for each Node without a constructor with an edge e from Item to Node
                          #
                          for Node in ConsumedByList[Item]:
                              if Node not in Constructor:
                                  #
                                  # remove edge e from the graph
                                  #
                                  ConsumedByList[Item].remove(Node)
                                  EdgeRemoved = True
                                  if ConsumedByList[Item] == []:
                                      #
                                      # insert Item into Q
                                      #
                                      Q.insert(0, Item)
                                      break
                      if Q != []:
                          break
  
          #
          # if any remaining node Item in the graph has a constructor and an incoming edge, then the graph has a cycle
          #
          for Item in LibraryList:
              if ConsumedByList[Item] != [] and Item in Constructor and len(Constructor) > 1:
                  ErrorMessage = 'Library [%s] with constructors has a cycle' % str(Item)
                  EdkLogger.error("AutoGen", AUTOGEN_ERROR, ErrorMessage,
                                  "\tconsumed by " + "\n\tconsumed by ".join([str(L) for L in ConsumedByList[Item]]))
              if Item not in SortedLibraryList:
                  SortedLibraryList.append(Item)
  
          #
          # Build the list of constructor and destructir names
          # The DAG Topo sort produces the destructor order, so the list of constructors must generated in the reverse order
          #
          SortedLibraryList.reverse()
          Module.LibraryClasses = sdict()
          for L in SortedLibraryList:
              for Lc in L.LibraryClass:
                  Module.LibraryClasses[Lc.LibraryClass, ModuleType] = str(L)
              #
              # Merge PCDs from library instance
              #
              for Key in L.Pcds:
                  if Key not in Module.Pcds:
                      LibPcd = L.Pcds[Key]
                      Module.Pcds[Key] = self.FindPcd(Arch, str(Module), LibPcd.TokenCName, LibPcd.TokenSpaceGuidCName, LibPcd.Type)
              #
              # Merge GUIDs from library instance
              #
              for CName in L.Guids:
                  if CName not in Module.Guids:
                      Module.Guids.append(CName)
              #
              # Merge Protocols from library instance
              #
              for CName in L.Protocols:
                  if CName not in Module.Protocols:
                      Module.Protocols.append(CName)
              #
              # Merge Ppis from library instance
              #
              for CName in L.Ppis:
                  if CName not in Module.Ppis:
                      Module.Ppis.append(CName)
  
      ## GenBuildDatabase
      #
      # Generate build database for all arches
      #
      # @param PcdsSet: Pcd list for override from Fdf parse result
      # @param InfList: Inf list for override from Fdf parse result
      #
      def GenBuildDatabase(self, PcdsSet = {}, InfList = []):
          #
          # Add additional inf file defined in Fdf file
          #
          for InfFile in InfList:
              self.AddToInfDatabase(NormPath(InfFile))
  
          #
          # Generate PlatformDatabase, PackageDatabase and ModuleDatabase
          #
          self.GenPackageDatabase()
          self.GenPlatformDatabase(PcdsSet)
          self.GenModuleDatabase(InfList)
  
          self.Db.Close()
  
          #
          # Update Libraries Of Platform
          #
          self.UpdateLibrariesOfPlatform(InfList)
  
          #
          # Output used Pcds not found in DSC file
          #
          self.ShowUnFoundPcds()
  
      ## ShowUnFoundPcds()
      #
      # If there is any pcd used but not defined in DSC
      # Print warning message on screen and output a list of pcds
      #
      def ShowUnFoundPcds(self):
          if self.UnFoundPcdInDsc != {}:
              WrnMessage = '**** WARNING ****\n'
              WrnMessage += 'The following Pcds were not defined in the DSC file: %s\n' % self.DscFileName
              WrnMessage += 'The default values were obtained from the DEC file that declares the PCD and the PCD default value\n'
              for (Guid, Name, Type, Arch) in self.UnFoundPcdInDsc:
                  Dec = self.UnFoundPcdInDsc[(Guid, Name, Type, Arch)]
                  Pcds = self.Build[Arch].PackageDatabase[Dec].Pcds
                  if (Name, Guid, Type) in Pcds:
                      Pcd = Pcds[(Name, Guid, Type)]
                      PcdItemTypeUsed = Pcd.Type
                      DefaultValue = Pcd.DefaultValue
                      WrnMessage += '%s.%s: Defined in file %s, PcdItemType is Pcds%s, DefaultValue is %s\n' % (Guid, Name, Dec, PcdItemTypeUsed, DefaultValue)
              EdkLogger.verbose(WrnMessage)
  
      ## Create a full path with workspace dir
      #
      # Convert Filename with workspace dir to create a full path
      #
      # @param Filename: The filename need to be added workspace dir
      #
      # @retval string Full path
      #
      def WorkspaceFile(self, Filename):
          return WorkspaceFile(self.WorkspaceDir, Filename)
  
      ## Update LibraryClass of Module
      #
      # If a module of a platform has its own override libraryclass but the libraryclass not defined in the module
      # Add this libraryclass to the module
      #
      # @param InfFileName:       InfFileName specificed in platform
      # @param LibraryClass:      LibraryClass specificed in platform
      # @param Arch:              Supportted Arch
      # @param InstanceFilePath:  InstanceFilePath specificed in platform
      #
      def UpdateLibraryClassOfModule(self, InfFileName, LibraryClass, Arch, InstanceFilePath):
          #
          # Update the library instance itself to add this libraryclass name
          #
          LibraryModule = self.InfDatabase[InstanceFilePath].Module
          LibList = LibraryModule.Header[Arch].LibraryClass
          NotFound = True
          for Lib in LibList:
              #
              # Find this LibraryClass
              #
              if Lib.LibraryClass == LibraryClass:
                  NotFound = False;
                  break;
          if NotFound:
              NewLib = LibraryClassClass()
              NewLib.LibraryClass = LibraryClass
              NewLib.SupModuleList = DataType.SUP_MODULE_LIST # LibraryModule.Header[Arch].ModuleType.split()
              LibraryModule.Header[Arch].LibraryClass.append(NewLib)
  
          #
          # Add it to LibraryClasses Section for the module which is using the library
          #
          Module = self.InfDatabase[InfFileName].Module
          LibList = Module.LibraryClasses
          NotFound = True
          for Lib in LibList:
              #
              # Find this LibraryClass
              #
              if Lib.LibraryClass == LibraryClass:
                  if Arch in Lib.SupArchList:
                      return
                  else:
                      Lib.SupArchList.append(Arch)
                      return
          if NotFound:
              Lib = LibraryClassClass()
              Lib.LibraryClass = LibraryClass
              Lib.SupArchList = [Arch]
              Module.LibraryClasses.append(Lib)
  
      ## Add Inf file to InfDatabase
      #
      # Create a Inf instance for input inf file and add it to InfDatabase
      #
      # @param InfFileName: The InfFileName need to be added to database
      #
      def AddToInfDatabase(self, InfFileName):
          File = self.WorkspaceFile(InfFileName)
          if os.path.exists(File) and os.path.isfile(File):
              if InfFileName not in self.InfDatabase:
                  self.InfDatabase[InfFileName] = Inf(File, False, True, self.WorkspaceDir, self.Db, self.SupArchList)
          else:
              EdkLogger.error("AutoGen", FILE_NOT_FOUND, ExtraData=File)
  
      ## Add Dec file to DecDatabase
      #
      # Create a Dec instance for input dec file and add it to DecDatabase
      #
      # @param DecFileName: The DecFileName need to be added to database
      #
      def AddToDecDatabase(self, DecFileName):
          File = self.WorkspaceFile(DecFileName)
          if os.path.exists(File) and os.path.isfile(File):
              if DecFileName not in self.DecDatabase:
                  self.DecDatabase[DecFileName] = Dec(File, False, True, self.WorkspaceDir, self.Db, self.SupArchList)
          else:
              EdkLogger.error("AutoGen", FILE_NOT_FOUND, ExtraData=File)
  
      ## Search LibraryClass Instance for Module
      #
      # Search PlatformBuildDatabase to find LibraryClass Instance for Module
      # Return the instance if found
      #
      # @param Lib:         Input value for Library Class Name
      # @param Arch:        Supportted Arch
      # @param ModuleType:  Supportted ModuleType
      # @param ModuleName:  Input value for Module Name
      #
      # @retval string Found LibraryClass Instance file path
      #
      def FindLibraryClassInstanceOfModule(self, Lib, Arch, ModuleType, ModuleName):
          #
          # First find if exist in <LibraryClass> of <Components> from dsc file
          #
          for Dsc in self.DscDatabase.keys():
              Platform = self.DscDatabase[Dsc].Platform
              for Module in Platform.Modules.ModuleList:
                  if Arch in Module.SupArchList:
                      if Module.FilePath == ModuleName:
                          for LibraryClass in Module.LibraryClasses.LibraryList:
                              if LibraryClass.Name == Lib:
                                  return LibraryClass.FilePath
          #
          #Second find if exist in <LibraryClass> of <LibraryClasses> from dsc file
          #
          return self.FindLibraryClassInstanceOfLibrary(Lib, Arch, ModuleType)
  
      ## Search LibraryClass Instance for Library
      #
      # Search PlatformBuildDatabase to find LibraryClass Instance for Library
      # Return the instance if found
      #
      # @param Lib:   Input value for Library Class Name
      # @param Arch:  Supportted Arch
      # @param Type:  Supportted Library Usage Type
      #
      # @retval string Found LibraryClass Instance file path
      # @retval None   Not Found
      #
      def FindLibraryClassInstanceOfLibrary(self, Lib, Arch, Type):
          for Dsc in self.DscDatabase.keys():
              Platform  = self.DscDatabase[Dsc].Platform
              if (Lib, Type) in self.Build[Arch].PlatformDatabase[Dsc].LibraryClasses:
                  return self.Build[Arch].PlatformDatabase[Dsc].LibraryClasses[(Lib, Type)]
              elif (Lib, '') in self.Build[Arch].PlatformDatabase[Dsc].LibraryClasses:
                  return self.Build[Arch].PlatformDatabase[Dsc].LibraryClasses[(Lib, '')]
          return None
  
      ## Find BuildOptions
      #
      # Search DscDatabase to find component definition of ModuleName
      # Override BuildOption if it is defined in component
      #
      # @param Arch:          Supportted Arch
      # @param ModuleName:    The module which has buildoption definition in component of platform
      # @param BuildOptions:  The set of all buildopitons
      #
      def FindBuildOptions(self, Arch, ModuleName, BuildOptions):
          for Dsc in self.DscDatabase.keys():
              #
              # First find if exist in <BuildOptions> of <Components> from dsc file
              # if find, use that override the one defined in inf file
              #
              Platform = self.DscDatabase[Dsc].Platform
              for Module in Platform.Modules.ModuleList:
                  if Arch in Module.SupArchList:
                      if Module.FilePath == ModuleName:
                          for BuildOption in Module.ModuleSaBuildOption.BuildOptionList:
                              #
                              # Add to BuildOptions
                              #
                              BuildOptions[(BuildOption.ToolChainFamily, BuildOption.ToolChain)] = BuildOption.Option
  
      ## Find Pcd
      #
      # Search platform database, package database, module database and PcdsSet from Fdf
      # Return found Pcd
      #
      # @param Arch:        Supportted Arch
      # @param ModuleName:  The module which has pcd definition in component of platform
      # @param Name:        Name of Pcd
      # @param Guid:        Guid of Pcd
      # @param Type:        Type of Pcd
      #
      # @retval PcdClassObject An instance for PcdClassObject with all members filled
      #
      def FindPcd(self, Arch, ModuleName, Name, Guid, Type):
          NewType = ''
          DatumType = ''
          Value = ''
          Token = ''
          MaxDatumSize = ''
          SkuInfoList = {}
          IsOverrided = False
          IsFoundInDsc = False
          IsFoundInDec = False
          FoundInDecFile = ''
  
          #
          # Second get information from platform database
          #
          OwnerPlatform = ''
          for Dsc in self.Build[Arch].PlatformDatabase.keys():
              Pcds = self.Build[Arch].PlatformDatabase[Dsc].Pcds
              if (Name, Guid) in Pcds:
                  OwnerPlatform = Dsc
                  Pcd = Pcds[(Name, Guid)]
                  if Pcd.Type != '' and Pcd.Type != None:
                      NewType = Pcd.Type
                      if NewType in DataType.PCD_DYNAMIC_TYPE_LIST:
                          NewType = DataType.TAB_PCDS_DYNAMIC
                      elif NewType in DataType.PCD_DYNAMIC_EX_TYPE_LIST:
                          NewType = DataType.TAB_PCDS_DYNAMIC_EX
                  else:
                      NewType = Type
  
                  if Type != '' and Type != NewType:
                      ErrorMsg = "PCD %s.%s is declared as [%s] in module\n\t%s\n\n"\
                                 "    But it's used as [%s] in platform\n\t%s"\
                                 % (Guid, Name, Type, ModuleName, NewType, OwnerPlatform)
                      EdkLogger.error("AutoGen", PARSER_ERROR, ErrorMsg)
  
  
                  if Pcd.DatumType != '' and Pcd.DatumType != None:
                      DatumType = Pcd.DatumType
                  if Pcd.TokenValue != '' and Pcd.TokenValue != None:
                      Token = Pcd.TokenValue
                  if Pcd.DefaultValue != '' and Pcd.DefaultValue != None:
                      Value = Pcd.DefaultValue
                  if Pcd.MaxDatumSize != '' and Pcd.MaxDatumSize != None:
                      MaxDatumSize = Pcd.MaxDatumSize
                  SkuInfoList =  Pcd.SkuInfoList
  
                  IsOverrided = True
                  IsFoundInDsc = True
                  break
  
          #
          # Third get information from <Pcd> of <Compontents> from module database
          #
          for Dsc in self.DscDatabase.keys():
              for Module in self.DscDatabase[Dsc].Platform.Modules.ModuleList:
                  if Arch in Module.SupArchList:
                      if Module.FilePath == ModuleName:
                          for Pcd in Module.PcdBuildDefinitions:
                              if (Name, Guid) == (Pcd.CName, Pcd.TokenSpaceGuidCName):
                                  if Pcd.DefaultValue != '':
                                      Value = Pcd.DefaultValue
                                  if Pcd.MaxDatumSize != '':
                                      MaxDatumSize = Pcd.MaxDatumSize
  
                                  IsFoundInDsc = True
                                  IsOverrided = True
                                  break
  
          #
          # First get information from package database
          #
          Pcd = None
          if NewType == '':
              if Type != '':
                  PcdTypeList = [Type]
              else:
                  PcdTypeList = ["FixedAtBuild", "PatchableInModule", "FeatureFlag", "Dynamic", "DynamicEx"]
  
              for Dec in self.Build[Arch].PackageDatabase.keys():
                  Pcds = self.Build[Arch].PackageDatabase[Dec].Pcds
                  for PcdType in PcdTypeList:
                      if (Name, Guid, PcdType) in Pcds:
                          Pcd = Pcds[(Name, Guid, PcdType)]
                          NewType = PcdType
                          IsOverrided = True
                          IsFoundInDec = True
                          FoundInDecFile = Dec
                          break
                  else:
                      continue
                  break
          else:
              for Dec in self.Build[Arch].PackageDatabase.keys():
                  Pcds = self.Build[Arch].PackageDatabase[Dec].Pcds
                  if (Name, Guid, NewType) in Pcds:
                      Pcd = Pcds[(Name, Guid, NewType)]
                      IsOverrided = True
                      IsFoundInDec = True
                      FoundInDecFile = Dec
                      break
  
          if not IsFoundInDec:
              ErrorMsg = "Pcd '%s.%s [%s]' defined in module '%s' is not found in any package for Arch '%s'" % (Guid, Name, NewType, ModuleName, Arch)
              EdkLogger.error("AutoGen", PARSER_ERROR, ErrorMsg)
  
          #
          # Not found in any platform and fdf
          #
          if not IsFoundInDsc:
              Value = Pcd.DefaultValue
              if NewType.startswith("Dynamic") and SkuInfoList == {}:
                  SkuIds = self.Build[Arch].PlatformDatabase.values()[0].SkuIds
                  SkuInfoList['DEFAULT'] = SkuInfoClass(SkuIdName='DEFAULT', SkuId=SkuIds['DEFAULT'], DefaultValue=Value)
              self.UnFoundPcdInDsc[(Guid, Name, NewType, Arch)] = FoundInDecFile
          #elif Type != '' and NewType.startswith("Dynamic"):
          #    NewType = Pcd.Type
          DatumType = Pcd.DatumType
          if Token in [None, '']:
              Token = Pcd.TokenValue
          if DatumType == "VOID*" and MaxDatumSize in ['', None]:
              EdkLogger.verbose("No MaxDatumSize specified for PCD %s.%s in module [%s]" % (Guid, Name, ModuleName))
              if Value[0] == 'L':
                  MaxDatumSize = str(len(Value) * 2)
              elif Value[0] == '{':
                  MaxDatumSize = str(len(Value.split(',')))
              else:
                  MaxDatumSize = str(len(Value))
  
          return PcdClassObject(Name, Guid, NewType, DatumType, Value, Token, MaxDatumSize, SkuInfoList, IsOverrided)
  
      ## Find Supportted Module List Of LibraryClass
      #
      # Search in InfDatabase, find the supmodulelist of the libraryclass
      #
      # @param LibraryClass:               LibraryClass name for search
      # @param OverridedLibraryClassList:  A list of all LibraryClass
      # @param Arch:                       Supportted Arch
      #
      # @retval list SupModuleList
      #
      def FindSupModuleListOfLibraryClass(self, LibraryClass, OverridedLibraryClassList, Arch):
          Name = LibraryClass.Name
          FilePath = LibraryClass.FilePath
          SupModuleList = copy.copy(LibraryClass.SupModuleList)
  
          #
          # If the SupModuleList means all, remove overrided module types of platform
          #
          if SupModuleList == DataType.SUP_MODULE_LIST:
              EdkLogger.debug(EdkLogger.DEBUG_3, "\tLibraryClass %s supports all module types" % Name)
              for Item in OverridedLibraryClassList:
                  #
                  # Find a library class (Item) with the same name
                  #
                  if Item.Name == Name:
                      #
                      # Do nothing if it is itself
                      #
                      if Item.SupModuleList == DataType.SUP_MODULE_LIST:
                          continue
                      #
                      # If not itself, check arch first
                      #
                      if Arch in LibraryClass.SupArchList:
                          #
                          # If arch is supportted, remove all related module type
                          #
                          if Arch in Item.SupArchList:
                              for ModuleType in Item.SupModuleList:
                                  EdkLogger.debug(EdkLogger.DEBUG_3, "\tLibraryClass %s has specific defined module types" % Name)
                                  if ModuleType in SupModuleList:
                                      SupModuleList.remove(ModuleType)
  
          return SupModuleList
  
      ## Find Module inf Platform
      #
      # Check if the module is defined in <Compentent> of <Platform>
      #
      # @param Inf:      Inf file (Module) need to be searched
      # @param Arch:     Supportted Arch
      # @param InfList:  A list for all Inf file
      #
      # @retval True     Mudule Found
      # @retval Flase    Module Not Found
      #
      def IsModuleDefinedInPlatform(self, Inf, Arch, InfList):
          for Dsc in self.DscDatabase.values():
              for LibraryClass in Dsc.Platform.LibraryClasses.LibraryList:
                  if Inf == LibraryClass.FilePath and Arch in LibraryClass.SupArchList:
                      return True
              for Module in Dsc.Platform.Modules.ModuleList:
                  if Inf == Module.FilePath and Arch in Module.SupArchList:
                      return True
                  for Item in Module.LibraryClasses.LibraryList:
                      if Inf == Item.FilePath:
                          return True
              for Library in Dsc.Platform.Libraries.LibraryList:
                  if Inf == Library.FilePath and Arch in Library.SupArchList:
                      return True
  
          return False
  
      ## Show all content of the workspacebuild
      #
      # Print each item of the workspacebuild with (Key = Value) pair
      #
      def ShowWorkspaceBuild(self):
          print self.DscDatabase
          print self.InfDatabase
          print self.DecDatabase
          print 'SupArchList', self.SupArchList
          print 'BuildTarget', self.BuildTarget
          print 'SkuId', self.SkuId
  
          for Arch in self.SupArchList:
              print Arch
              print 'Platform'
              for Platform in self.Build[Arch].PlatformDatabase.keys():
                  P = self.Build[Arch].PlatformDatabase[Platform]
                  print 'DescFilePath = ', P.DescFilePath
                  print 'PlatformName = ', P.PlatformName
                  print 'Guid = ', P.Guid
                  print 'Version = ', P.Version
                  print 'OutputDirectory = ', P.OutputDirectory
                  print 'FlashDefinition = ', P.FlashDefinition
                  print 'SkuIds = ', P.SkuIds
                  print 'Modules = ', P.Modules
                  print 'LibraryClasses = ', P.LibraryClasses
                  print 'Pcds = ', P.Pcds
                  for item in P.Pcds.keys():
                      print P.Pcds[item]
                  print 'BuildOptions = ', P.BuildOptions
                  print ''
              # End of Platform
  
              print 'package'
              for Package in self.Build[Arch].PackageDatabase.keys():
                  P = self.Build[Arch].PackageDatabase[Package]
                  print 'DescFilePath = ', P.DescFilePath
                  print 'PackageName = ', P.PackageName
                  print 'Guid = ', P.Guid
                  print 'Version = ', P.Version
                  print 'Protocols = ', P.Protocols
                  print 'Ppis = ', P.Ppis
                  print 'Guids = ', P.Guids
                  print 'Includes = ', P.Includes
                  print 'LibraryClasses = ', P.LibraryClasses
                  print 'Pcds = ', P.Pcds
                  for item in P.Pcds.keys():
                      print P.Pcds[item]
                  print ''
              # End of Package
  
              print 'module'
              for Module in self.Build[Arch].ModuleDatabase.keys():
                  P = self.Build[Arch].ModuleDatabase[Module]
                  print 'DescFilePath = ', P.DescFilePath
                  print 'BaseName = ', P.BaseName
                  print 'ModuleType = ', P.ModuleType
                  print 'Guid = ', P.Guid
                  print 'Version = ', P.Version
                  print 'CustomMakefile = ', P.CustomMakefile
                  print 'Specification = ', P.Specification
                  print 'Shadow = ', P.Shadow
                  print 'PcdIsDriver = ', P.PcdIsDriver
                  for Lib in P.LibraryClass:
                      print 'LibraryClassDefinition = ', Lib.LibraryClass, 'SupModList = ', Lib.SupModList
                  print 'ModuleEntryPointList = ', P.ModuleEntryPointList
                  print 'ModuleUnloadImageList = ', P.ModuleUnloadImageList
                  print 'ConstructorList = ', P.ConstructorList
                  print 'DestructorList = ', P.DestructorList
  
                  print 'Binaries = '
                  for item in P.Binaries:
                      print item.BinaryFile, item.FeatureFlag, item.SupArchList
                  print 'Sources = '
                  for item in P.Sources:
                      print item.SourceFile
                  print 'LibraryClasses = ', P.LibraryClasses
                  print 'Protocols = ', P.Protocols
                  print 'Ppis = ', P.Ppis
                  print 'Guids = ', P.Guids
                  print 'Includes = ', P.Includes
                  print 'Packages = ', P.Packages
                  print 'Pcds = ', P.Pcds
                  for item in P.Pcds.keys():
                      print P.Pcds[item]
                  print 'BuildOptions = ', P.BuildOptions
                  print 'Depex = ', P.Depex
                  print ''
              # End of Module
  
  ##
  #
  # This acts like the main() function for the script, unless it is 'import'ed into another
  # script.
  #
  if __name__ == '__main__':
      print 'Start!', time.strftime('%H:%M:%S', time.localtime())
      EdkLogger.Initialize()
      EdkLogger.SetLevel(EdkLogger.QUIET)
  
      W = os.getenv('WORKSPACE')
      Ewb = WorkspaceBuild('Nt32Pkg/Nt32Pkg.dsc', W)
      Ewb.GenBuildDatabase({('PcdDevicePathSupportDevicePathFromText', 'gEfiMdeModulePkgTokenSpaceGuid') : 'KKKKKKKKKKKKKKKKKKKKK'}, ['Test.Inf'])
      print 'Done!', time.strftime('%H:%M:%S', time.localtime())
      Ewb.ShowWorkspaceBuild()
  