import 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

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))

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)

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)

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)

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)

class ItemBuild(object):

def __init__(self, Arch, Platform = None, Package = None, Module = None):

self.Arch = Arch

self.PlatformDatabase = {}

self.PackageDatabase = {}

self.ModuleDatabase = {}

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

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()