import os

import re

import EdkLogger

from CommonDataClass.CommonClass import LibraryClassClass

from CommonDataClass.ModuleClass import *

from String import *

from DataType import *

from Identification import *

from Dictionary import *

from BuildToolError import *

from Misc import sdict

import GlobalData

from Table.TableInf import TableInf

import Database

from Parsing import *

Section = {TAB_UNKNOWN.upper() : MODEL_UNKNOWN,

TAB_INF_DEFINES.upper() : MODEL_META_DATA_HEADER,

TAB_BUILD_OPTIONS.upper() : MODEL_META_DATA_BUILD_OPTION,

TAB_INCLUDES.upper() : MODEL_EFI_INCLUDE,

TAB_LIBRARIES.upper() : MODEL_EFI_LIBRARY_INSTANCE,

TAB_LIBRARY_CLASSES.upper() : MODEL_EFI_LIBRARY_CLASS,

TAB_PACKAGES.upper() : MODEL_META_DATA_PACKAGE,

TAB_NMAKE.upper() : MODEL_META_DATA_NMAKE,

TAB_INF_FIXED_PCD.upper() : MODEL_PCD_FIXED_AT_BUILD,

TAB_INF_PATCH_PCD.upper() : MODEL_PCD_PATCHABLE_IN_MODULE,

TAB_INF_FEATURE_PCD.upper() : MODEL_PCD_FEATURE_FLAG,

TAB_INF_PCD_EX.upper() : MODEL_PCD_DYNAMIC_EX,

TAB_INF_PCD.upper() : MODEL_PCD_DYNAMIC,

TAB_SOURCES.upper() : MODEL_EFI_SOURCE_FILE,

TAB_GUIDS.upper() : MODEL_EFI_GUID,

TAB_PROTOCOLS.upper() : MODEL_EFI_PROTOCOL,

TAB_PPIS.upper() : MODEL_EFI_PPI,

TAB_DEPEX.upper() : MODEL_EFI_DEPEX,

TAB_BINARIES.upper() : MODEL_EFI_BINARY_FILE,

TAB_USER_EXTENSIONS.upper() : MODEL_META_DATA_USER_EXTENSION

}

gComponentType2ModuleType = {

"LIBRARY" : "BASE",

"SECURITY_CORE" : "SEC",

"PEI_CORE" : "PEI_CORE",

"COMBINED_PEIM_DRIVER" : "PEIM",

"PIC_PEIM" : "PEIM",

"RELOCATABLE_PEIM" : "PEIM",

"PE32_PEIM" : "PEIM",

"BS_DRIVER" : "DXE_DRIVER",

"RT_DRIVER" : "DXE_RUNTIME_DRIVER",

"SAL_RT_DRIVER" : "DXE_SAL_DRIVER",

"APPLICATION" : "UEFI_APPLICATION",

"LOGO" : "BASE",

}

gNmakeFlagPattern = re.compile("(?:EBC_)?([A-Z]+)_(?:STD_|PROJ_|ARCH_)?FLAGS(?:_DLL|_ASL|_EXE)?", re.UNICODE)

gNmakeFlagName2ToolCode = {

"C" : "CC",

"LIB" : "SLINK",

"LINK" : "DLINK",

}

class InfHeader(ModuleHeaderClass):

_Mapping_ = {

#

# Required Fields

#

TAB_INF_DEFINES_BASE_NAME : "Name",

TAB_INF_DEFINES_FILE_GUID : "Guid",

TAB_INF_DEFINES_MODULE_TYPE : "ModuleType",

TAB_INF_DEFINES_EFI_SPECIFICATION_VERSION : "UefiSpecificationVersion",

TAB_INF_DEFINES_UEFI_SPECIFICATION_VERSION : "UefiSpecificationVersion",

TAB_INF_DEFINES_EDK_RELEASE_VERSION : "EdkReleaseVersion",

#

# Optional Fields

#

TAB_INF_DEFINES_INF_VERSION : "InfVersion",

TAB_INF_DEFINES_BINARY_MODULE : "BinaryModule",

TAB_INF_DEFINES_COMPONENT_TYPE : "ComponentType",

TAB_INF_DEFINES_MAKEFILE_NAME : "MakefileName",

TAB_INF_DEFINES_BUILD_NUMBER : "BuildNumber",

TAB_INF_DEFINES_BUILD_TYPE : "BuildType",

TAB_INF_DEFINES_FFS_EXT : "FfsExt",

TAB_INF_DEFINES_FV_EXT : "FvExt",

TAB_INF_DEFINES_SOURCE_FV : "SourceFv",

TAB_INF_DEFINES_VERSION_NUMBER : "VersionNumber",

TAB_INF_DEFINES_VERSION_STRING : "VersionString",

TAB_INF_DEFINES_VERSION : "Version",

TAB_INF_DEFINES_PCD_IS_DRIVER : "PcdIsDriver",

TAB_INF_DEFINES_TIANO_EDK_FLASHMAP_H : "TianoEdkFlashMap_h",

TAB_INF_DEFINES_SHADOW : "Shadow",

}

def __init__(self):

ModuleHeaderClass.__init__(self)

self.VersionNumber = ''

self.VersionString = ''

#print self.__dict__

def __setitem__(self, key, value):

self.__dict__[self._Mapping_[key]] = value

def __getitem__(self, key):

return self.__dict__[self._Mapping_[key]]

## "in" test support

def __contains__(self, key):

return key in self._Mapping_

class InfObject(object):

def __init__(self):

object.__init__()

class Inf(InfObject):

def __init__(self, Filename=None, IsToDatabase=False, IsToModule=False, WorkspaceDir=None, Database=None, SupArchList=DataType.ARCH_LIST):

self.Identification = Identification()

self.Module = ModuleClass()

self.UserExtensions = ''

self.WorkspaceDir = WorkspaceDir

self.SupArchList = SupArchList

self.IsToDatabase = IsToDatabase

self.Cur = Database.Cur

self.TblFile = Database.TblFile

self.TblInf = Database.TblInf

self.FileID = -1

#self.TblInf = TableInf(Database.Cur)

self.KeyList = [

TAB_SOURCES, TAB_BUILD_OPTIONS, TAB_BINARIES, TAB_INCLUDES, TAB_GUIDS,

TAB_PROTOCOLS, TAB_PPIS, TAB_LIBRARY_CLASSES, TAB_PACKAGES, TAB_LIBRARIES,

TAB_INF_FIXED_PCD, TAB_INF_PATCH_PCD, TAB_INF_FEATURE_PCD, TAB_INF_PCD,

TAB_INF_PCD_EX, TAB_DEPEX, TAB_NMAKE, TAB_INF_DEFINES

]

#

# Upper all KEYs to ignore case sensitive when parsing

#

self.KeyList = map(lambda c: c.upper(), self.KeyList)

#

# Init RecordSet

#

self.RecordSet = {}

for Key in self.KeyList:

self.RecordSet[Section[Key]] = []

#

# Load Inf file if filename is not None

#

if Filename != None:

self.LoadInfFile(Filename)

#

# Transfer to Module Object if IsToModule is True

#

if IsToModule:

self.InfToModule()

## Transfer to Module Object

#

# Transfer all contents of an Inf file to a standard Module Object

#

def InfToModule(self):

#

# Init global information for the file

#

ContainerFile = self.Identification.FileFullPath

#

# Generate Package Header

#

self.GenModuleHeader(ContainerFile)

#

# Generate BuildOptions

#

self.GenBuildOptions(ContainerFile)

#

# Generate Includes

#

self.GenIncludes(ContainerFile)

#

# Generate Libraries

#

self.GenLibraries(ContainerFile)

#

# Generate LibraryClasses

#

self.GenLibraryClasses(ContainerFile)

#

# Generate Packages

#

self.GenPackages(ContainerFile)

#

# Generate Nmakes

#

self.GenNmakes(ContainerFile)

#

# Generate Pcds

#

self.GenPcds(ContainerFile)

#

# Generate Sources

#

self.GenSources(ContainerFile)

#

# Generate UserExtensions

#

self.GenUserExtensions(ContainerFile)

#

# Generate Guids

#

self.GenGuidProtocolPpis(DataType.TAB_GUIDS, ContainerFile)

#

# Generate Protocols

#

self.GenGuidProtocolPpis(DataType.TAB_PROTOCOLS, ContainerFile)

#

# Generate Ppis

#

self.GenGuidProtocolPpis(DataType.TAB_PPIS, ContainerFile)

#

# Generate Depexes

#

self.GenDepexes(ContainerFile)

#

# Generate Binaries

#

self.GenBinaries(ContainerFile)

## Parse [Defines] section

#

# Parse [Defines] section into InfDefines object

#

# @param InfFile The path of the INF file

# @param Section The title of "Defines" section

# @param Lines The content of "Defines" section

#

def ParseDefines(self, InfFile, Section, Lines):

TokenList = Section.split(TAB_SPLIT)

if len(TokenList) == 3:

RaiseParserError(Section, "Defines", InfFile, "[xx.yy.%s] format (with platform) is not supported")

if len(TokenList) == 2:

Arch = TokenList[1].upper()

else:

Arch = TAB_ARCH_COMMON

if Arch not in self.Defines:

self.Defines[Arch] = InfDefines()

GetSingleValueOfKeyFromLines(Lines, self.Defines[Arch].DefinesDictionary,

TAB_COMMENT_SPLIT, TAB_EQUAL_SPLIT, False, None)

## Load Inf file

#

# Load the file if it exists

#

# @param Filename: Input value for filename of Inf file

#

def LoadInfFile(self, Filename):

#

# Insert a record for file

#

Filename = NormPath(Filename)

self.Identification.FileFullPath = Filename

(self.Identification.FileRelativePath, self.Identification.FileName) = os.path.split(Filename)

self.FileID = self.TblFile.InsertFile(Filename, MODEL_FILE_INF)

#

# Init InfTable

#

#self.TblInf.Table = "Inf%s" % self.FileID

#self.TblInf.Create()

#

# Init common datas

#

IfDefList, SectionItemList, CurrentSection, ArchList, ThirdList, IncludeFiles = \

[], [], TAB_UNKNOWN, [], [], []

LineNo = 0

#

# Parse file content

#

IsFindBlockComment = False

ReservedLine = ''

for Line in open(Filename, 'r'):

LineNo = LineNo + 1

#

# Remove comment block

#

if Line.find(TAB_COMMENT_EDK_START) > -1:

ReservedLine = GetSplitList(Line, TAB_COMMENT_EDK_START, 1)[0]

IsFindBlockComment = True

if Line.find(TAB_COMMENT_EDK_END) > -1:

Line = ReservedLine + GetSplitList(Line, TAB_COMMENT_EDK_END, 1)[1]

ReservedLine = ''

IsFindBlockComment = False

if IsFindBlockComment:

continue

#

# Remove comments at tail and remove spaces again

#

Line = CleanString(Line)

if Line == '':

continue

#

# Find a new section tab

# First insert previous section items

# And then parse the content of the new section

#

if Line.startswith(TAB_SECTION_START) and Line.endswith(TAB_SECTION_END):

if Line[1:3] == "--":

continue

Model = Section[CurrentSection.upper()]

#

# Insert items data of previous section

#

InsertSectionItemsIntoDatabase(self.TblInf, self.FileID, Filename, Model, CurrentSection, SectionItemList, ArchList, ThirdList, IfDefList, self.RecordSet)

#

# Parse the new section

#

SectionItemList = []

ArchList = []

ThirdList = []

CurrentSection = ''

LineList = GetSplitValueList(Line[len(TAB_SECTION_START):len(Line) - len(TAB_SECTION_END)], TAB_COMMA_SPLIT)

for Item in LineList:

ItemList = GetSplitValueList(Item, TAB_SPLIT)

if CurrentSection == '':

CurrentSection = ItemList[0]

else:

if CurrentSection != ItemList[0]:

EdkLogger.error("Parser", PARSER_ERROR, "Different section names '%s' and '%s' are found in one section definition, this is not allowed." % (CurrentSection, ItemList[0]), File=Filename, Line=LineNo, RaiseError=EdkLogger.IsRaiseError)

if CurrentSection.upper() not in self.KeyList:

RaiseParserError(Line, CurrentSection, Filename, '', LineNo)

CurrentSection = TAB_UNKNOWN

continue

ItemList.append('')

ItemList.append('')

if len(ItemList) > 5:

RaiseParserError(Line, CurrentSection, Filename, '', LineNo)

else:

if ItemList[1] != '' and ItemList[1].upper() not in ARCH_LIST_FULL:

EdkLogger.error("Parser", PARSER_ERROR, "Invalid Arch definition '%s' found" % ItemList[1], File=Filename, Line=LineNo, RaiseError=EdkLogger.IsRaiseError)

ArchList.append(ItemList[1].upper())

ThirdList.append(ItemList[2])

continue

#

# Not in any defined section

#

if CurrentSection == TAB_UNKNOWN:

ErrorMsg = "%s is not in any defined section" % Line

EdkLogger.error("Parser", PARSER_ERROR, ErrorMsg, File=Filename, Line=LineNo, RaiseError=EdkLogger.IsRaiseError)

#

# Add a section item

#

SectionItemList.append([Line, LineNo])

# End of parse

#End of For

#

# Insert items data of last section

#

Model = Section[CurrentSection.upper()]

InsertSectionItemsIntoDatabase(self.TblInf, self.FileID, Filename, Model, CurrentSection, SectionItemList, ArchList, ThirdList, IfDefList, self.RecordSet)

#

# Replace all DEFINE macros with its actual values

#

ParseDefineMacro2(self.TblInf, self.RecordSet, GlobalData.gGlobalDefines)

## Show detailed information of Module

#

# Print all members and their values of Module class

#

def ShowModule(self):

M = self.Module

for Arch in M.Header.keys():

print '\nArch =', Arch

print 'Filename =', M.Header[Arch].FileName

print 'FullPath =', M.Header[Arch].FullPath

print 'BaseName =', M.Header[Arch].Name

print 'Guid =', M.Header[Arch].Guid

print 'Version =', M.Header[Arch].Version

print 'InfVersion =', M.Header[Arch].InfVersion

print 'UefiSpecificationVersion =', M.Header[Arch].UefiSpecificationVersion

print 'EdkReleaseVersion =', M.Header[Arch].EdkReleaseVersion

print 'ModuleType =', M.Header[Arch].ModuleType

print 'BinaryModule =', M.Header[Arch].BinaryModule

print 'ComponentType =', M.Header[Arch].ComponentType

print 'MakefileName =', M.Header[Arch].MakefileName

print 'BuildNumber =', M.Header[Arch].BuildNumber

print 'BuildType =', M.Header[Arch].BuildType

print 'FfsExt =', M.Header[Arch].FfsExt

print 'FvExt =', M.Header[Arch].FvExt

print 'SourceFv =', M.Header[Arch].SourceFv

print 'PcdIsDriver =', M.Header[Arch].PcdIsDriver

print 'TianoEdkFlashMap_h =', M.Header[Arch].TianoEdkFlashMap_h

print 'Shadow =', M.Header[Arch].Shadow

print 'LibraryClass =', M.Header[Arch].LibraryClass

for Item in M.Header[Arch].LibraryClass:

print Item.LibraryClass, DataType.TAB_VALUE_SPLIT.join(Item.SupModuleList)

print 'CustomMakefile =', M.Header[Arch].CustomMakefile

print 'Define =', M.Header[Arch].Define

print 'Specification =', M.Header[Arch].Specification

for Item in self.Module.ExternImages:

print '\nEntry_Point = %s, UnloadImage = %s' % (Item.ModuleEntryPoint, Item.ModuleUnloadImage)

for Item in self.Module.ExternLibraries:

print 'Constructor = %s, Destructor = %s' % (Item.Constructor, Item.Destructor)

print '\nBuildOptions =', M.BuildOptions

for Item in M.BuildOptions:

print Item.ToolChainFamily, Item.ToolChain, Item.Option, Item.SupArchList

print '\nIncludes =', M.Includes

for Item in M.Includes:

print Item.FilePath, Item.SupArchList

print '\nLibraries =', M.Libraries

for Item in M.Libraries:

print Item.Library, Item.SupArchList

print '\nLibraryClasses =', M.LibraryClasses

for Item in M.LibraryClasses:

print Item.LibraryClass, Item.RecommendedInstance, Item.FeatureFlag, Item.SupModuleList, Item.SupArchList, Item.Define

print '\nPackageDependencies =', M.PackageDependencies

for Item in M.PackageDependencies:

print Item.FilePath, Item.SupArchList, Item.FeatureFlag

print '\nNmake =', M.Nmake

for Item in M.Nmake:

print Item.Name, Item.Value, Item.SupArchList

print '\nPcds =', M.PcdCodes

for Item in M.PcdCodes:

print '\tCName=', Item.CName, 'TokenSpaceGuidCName=', Item.TokenSpaceGuidCName, 'DefaultValue=', Item.DefaultValue, 'ItemType=', Item.ItemType, Item.SupArchList

print '\nSources =', M.Sources

for Source in M.Sources:

print Source.SourceFile, 'Fam=', Source.ToolChainFamily, 'Pcd=', Source.FeatureFlag, 'Tag=', Source.TagName, 'ToolCode=', Source.ToolCode, Source.SupArchList

print '\nUserExtensions =', M.UserExtensions

for UserExtension in M.UserExtensions:

print UserExtension.UserID, UserExtension.Identifier, UserExtension.Content

print '\nGuids =', M.Guids

for Item in M.Guids:

print Item.CName, Item.SupArchList, Item.FeatureFlag

print '\nProtocols =', M.Protocols

for Item in M.Protocols:

print Item.CName, Item.SupArchList, Item.FeatureFlag

print '\nPpis =', M.Ppis

for Item in M.Ppis:

print Item.CName, Item.SupArchList, Item.FeatureFlag

print '\nDepex =', M.Depex

for Item in M.Depex:

print Item.Depex, Item.SupArchList, Item.Define

print '\nBinaries =', M.Binaries

for Binary in M.Binaries:

print 'Type=', Binary.FileType, 'Target=', Binary.Target, 'Name=', Binary.BinaryFile, 'FeatureFlag=', Binary.FeatureFlag, 'SupArchList=', Binary.SupArchList

## Convert [Defines] section content to ModuleHeaderClass

#

# Convert [Defines] section content to ModuleHeaderClass

#

# @param Defines The content under [Defines] section

# @param ModuleHeader An object of ModuleHeaderClass

# @param Arch The supported ARCH

#

def GenModuleHeader(self, ContainerFile):

EdkLogger.debug(2, "Generate ModuleHeader ...")

File = self.Identification.FileFullPath

#

# Update all defines item in database

#

RecordSet = self.RecordSet[MODEL_META_DATA_HEADER]

for Record in RecordSet:

ValueList = GetSplitValueList(Record[0], TAB_EQUAL_SPLIT)

if len(ValueList) != 2:

RaiseParserError(Record[0], 'Defines', ContainerFile, '<Key> = <Value>', Record[2])

ID, Value1, Value2, Arch, LineNo = Record[3], ValueList[0], ValueList[1], Record[1], Record[2]

SqlCommand = """update %s set Value1 = '%s', Value2 = '%s'

where ID = %s""" % (self.TblInf.Table, ConvertToSqlString2(Value1), ConvertToSqlString2(Value2), ID)

self.TblInf.Exec(SqlCommand)

for Arch in DataType.ARCH_LIST:

ModuleHeader = InfHeader()

ModuleHeader.FileName = self.Identification.FileName

ModuleHeader.FullPath = self.Identification.FileFullPath

DefineList = QueryDefinesItem2(self.TblInf, Arch, self.FileID)

NotProcessedDefineList = []

for D in DefineList:

if D[0] in ModuleHeader:

ModuleHeader[D[0]] = GetSplitValueList(D[1])[0]

else:

NotProcessedDefineList.append(D)

if ModuleHeader.ComponentType == "LIBRARY":

Lib = LibraryClassClass()

Lib.LibraryClass = ModuleHeader.Name

Lib.SupModuleList = DataType.SUP_MODULE_LIST

ModuleHeader.LibraryClass.append(Lib)

# we need to make some key defines resolved first

for D in NotProcessedDefineList:

if D[0] == TAB_INF_DEFINES_LIBRARY_CLASS:

List = GetSplitValueList(D[1], DataType.TAB_VALUE_SPLIT, 1)

Lib = LibraryClassClass()

Lib.LibraryClass = CleanString(List[0])

if len(List) == 1:

Lib.SupModuleList = DataType.SUP_MODULE_LIST

elif len(List) == 2:

Lib.SupModuleList = GetSplitValueList(CleanString(List[1]), ' ')

ModuleHeader.LibraryClass.append(Lib)

elif D[0] == TAB_INF_DEFINES_CUSTOM_MAKEFILE:

List = D[1].split(DataType.TAB_VALUE_SPLIT)

if len(List) == 2:

ModuleHeader.CustomMakefile[CleanString(List[0])] = CleanString(List[1])

else:

RaiseParserError(D[1], 'CUSTOM_MAKEFILE of Defines', File, 'CUSTOM_MAKEFILE=<Family>|<Filename>', D[2])

elif D[0] == TAB_INF_DEFINES_ENTRY_POINT:

Image = ModuleExternImageClass()

Image.ModuleEntryPoint = CleanString(D[1])

self.Module.ExternImages.append(Image)

elif D[0] == TAB_INF_DEFINES_UNLOAD_IMAGE:

Image = ModuleExternImageClass()

Image.ModuleUnloadImage = CleanString(D[1])

self.Module.ExternImages.append(Image)

elif D[0] == TAB_INF_DEFINES_CONSTRUCTOR:

LibraryClass = ModuleExternLibraryClass()

LibraryClass.Constructor = CleanString(D[1])

self.Module.ExternLibraries.append(LibraryClass)

elif D[0] == TAB_INF_DEFINES_DESTRUCTOR:

LibraryClass = ModuleExternLibraryClass()

LibraryClass.Destructor = CleanString(D[1])

self.Module.ExternLibraries.append(LibraryClass)

elif D[0] == TAB_INF_DEFINES_DEFINE:

List = D[1].split(DataType.TAB_EQUAL_SPLIT)

if len(List) != 2:

RaiseParserError(Item, 'DEFINE of Defines', File, 'DEFINE <Word> = <Word>', D[2])

else:

ModuleHeader.Define[CleanString(List[0])] = CleanString(List[1])

elif D[0] == TAB_INF_DEFINES_SPEC:

List = D[1].split(DataType.TAB_EQUAL_SPLIT)

if len(List) != 2:

RaiseParserError(Item, 'SPEC of Defines', File, 'SPEC <Word> = <Version>', D[2])

else:

ModuleHeader.Specification[CleanString(List[0])] = CleanString(List[1])

#

# Get version of INF

#

if ModuleHeader.InfVersion != "":

# EdkII inf

VersionNumber = ModuleHeader.VersionNumber

VersionString = ModuleHeader.VersionString

if len(VersionNumber) > 0 and len(VersionString) == 0:

EdkLogger.warn(2000, 'VERSION_NUMBER depricated; INF file %s should be modified to use VERSION_STRING instead.' % self.Identification.FileFullPath)

ModuleHeader.Version = VersionNumber

if len(VersionString) > 0:

if len(VersionNumber) > 0:

EdkLogger.warn(2001, 'INF file %s defines both VERSION_NUMBER and VERSION_STRING, using VERSION_STRING' % self.Identification.FileFullPath)

ModuleHeader.Version = VersionString

else:

# Edk inf

ModuleHeader.InfVersion = "0x00010000"

if ModuleHeader.ComponentType in gComponentType2ModuleType:

ModuleHeader.ModuleType = gComponentType2ModuleType[ModuleHeader.ComponentType]

elif ModuleHeader.ComponentType != '':

EdkLogger.error("Parser", PARSER_ERROR, "Unsupported Edk component type [%s]" % ModuleHeader.ComponentType, ExtraData=File, RaiseError=EdkLogger.IsRaiseError)

self.Module.Header[Arch] = ModuleHeader

## GenBuildOptions

#

# Gen BuildOptions of Inf

# [<Family>:]<ToolFlag>=Flag

#

# @param ContainerFile: The Inf file full path

#

def GenBuildOptions(self, ContainerFile):

EdkLogger.debug(2, "Generate %s ..." % TAB_BUILD_OPTIONS)

BuildOptions = {}

#

# Get all BuildOptions

#

RecordSet = self.RecordSet[MODEL_META_DATA_BUILD_OPTION]

#

# Go through each arch

#

for Arch in self.SupArchList:

for Record in RecordSet:

if Record[1] == Arch or Record[1] == TAB_ARCH_COMMON:

(Family, ToolChain, Flag) = GetBuildOption(Record[0], ContainerFile, Record[2])

MergeArches(BuildOptions, (Family, ToolChain, Flag), Arch)

#

# Update to Database

#

if self.IsToDatabase:

SqlCommand = """update %s set Value1 = '%s', Value2 = '%s', Value3 = '%s'

where ID = %s""" % (self.TblInf.Table, ConvertToSqlString2(Family), ConvertToSqlString2(ToolChain), ConvertToSqlString2(Flag), Record[3])

self.TblInf.Exec(SqlCommand)

for Key in BuildOptions.keys():

BuildOption = BuildOptionClass(Key[0], Key[1], Key[2])

BuildOption.SupArchList = BuildOptions[Key]

self.Module.BuildOptions.append(BuildOption)

## GenIncludes

#

# Gen Includes of Inf

#

#

# @param ContainerFile: The Inf file full path

#

def GenIncludes(self, ContainerFile):

EdkLogger.debug(2, "Generate %s ..." % TAB_INCLUDES)

Includes = sdict()

#

# Get all Includes

#

RecordSet = self.RecordSet[MODEL_EFI_INCLUDE]

#

# Go through each arch

#

for Arch in self.SupArchList:

for Record in RecordSet:

if Record[1] == Arch or Record[1] == TAB_ARCH_COMMON:

MergeArches(Includes, Record[0], Arch)

for Key in Includes.keys():

Include = IncludeClass()

Include.FilePath = NormPath(Key)

Include.SupArchList = Includes[Key]

self.Module.Includes.append(Include)

## GenLibraries

#

# Gen Libraries of Inf

#

#

# @param ContainerFile: The Inf file full path

#

def GenLibraries(self, ContainerFile):

EdkLogger.debug(2, "Generate %s ..." % TAB_LIBRARIES)

Libraries = sdict()

#

# Get all Includes

#

RecordSet = self.RecordSet[MODEL_EFI_LIBRARY_INSTANCE]

#

# Go through each arch

#

for Arch in self.SupArchList:

for Record in RecordSet:

if Record[1] == Arch or Record[1] == TAB_ARCH_COMMON:

MergeArches(Libraries, Record[0], Arch)

for Key in Libraries.keys():

Library = ModuleLibraryClass()

# replace macro and remove file extension

Library.Library = Key.rsplit('.', 1)[0]

Library.SupArchList = Libraries[Key]

self.Module.Libraries.append(Library)

## GenLibraryClasses

#

# Get LibraryClass of Inf

# <LibraryClassKeyWord>|<LibraryInstance>

#

# @param ContainerFile: The Inf file full path

#

def GenLibraryClasses(self, ContainerFile):

EdkLogger.debug(2, "Generate %s ..." % TAB_LIBRARY_CLASSES)

LibraryClasses = {}

#

# Get all LibraryClasses

#

RecordSet = self.RecordSet[MODEL_EFI_LIBRARY_CLASS]

#

# Go through each arch

#

for Arch in self.SupArchList:

for Record in RecordSet:

if Record[1] == Arch or Record[1] == TAB_ARCH_COMMON:

(LibClassName, LibClassIns, Pcd, SupModelList) = GetLibraryClassOfInf([Record[0], Record[4]], ContainerFile, self.WorkspaceDir, Record[2])

MergeArches(LibraryClasses, (LibClassName, LibClassIns, Pcd, SupModelList), Arch)

#

# Update to Database

#

if self.IsToDatabase:

SqlCommand = """update %s set Value1 = '%s', Value2 = '%s', Value3 = '%s'

where ID = %s""" % (self.TblInf.Table, ConvertToSqlString2(LibClassName), ConvertToSqlString2(LibClassIns), ConvertToSqlString2(SupModelList), Record[3])

self.TblInf.Exec(SqlCommand)

for Key in LibraryClasses.keys():

KeyList = Key[0].split(DataType.TAB_VALUE_SPLIT)

LibraryClass = LibraryClassClass()

LibraryClass.LibraryClass = Key[0]

LibraryClass.RecommendedInstance = NormPath(Key[1])

LibraryClass.FeatureFlag = Key[2]

LibraryClass.SupArchList = LibraryClasses[Key]

LibraryClass.SupModuleList = GetSplitValueList(Key[3])

self.Module.LibraryClasses.append(LibraryClass)

## GenPackages

#

# Gen Packages of Inf

#

#

# @param ContainerFile: The Inf file full path

#

def GenPackages(self, ContainerFile):

EdkLogger.debug(2, "Generate %s ..." % TAB_PACKAGES)

Packages = {}

#

# Get all Packages

#

RecordSet = self.RecordSet[MODEL_META_DATA_PACKAGE]

#

# Go through each arch

#

for Arch in self.SupArchList:

for Record in RecordSet:

if Record[1] == Arch or Record[1] == TAB_ARCH_COMMON:

(Package, Pcd) = GetPackage(Record[0], ContainerFile, self.WorkspaceDir, Record[2])

MergeArches(Packages, (Package, Pcd), Arch)

if self.IsToDatabase:

SqlCommand = """update %s set Value1 = '%s', Value2 = '%s'

where ID = %s""" % (self.TblInf.Table, ConvertToSqlString2(Package), ConvertToSqlString2(Pcd), Record[3])

self.TblInf.Exec(SqlCommand)

for Key in Packages.keys():

Package = ModulePackageDependencyClass()

Package.FilePath = NormPath(Key[0])

Package.SupArchList = Packages[Key]

Package.FeatureFlag = Key[1]

self.Module.PackageDependencies.append(Package)

## GenNmakes

#

# Gen Nmakes of Inf

#

#

# @param ContainerFile: The Inf file full path

#

def GenNmakes(self, ContainerFile):

EdkLogger.debug(2, "Generate %s ..." % TAB_NMAKE)

Nmakes = sdict()

#

# Get all Nmakes

#

RecordSet = self.RecordSet[MODEL_META_DATA_NMAKE]

#

# Go through each arch

#

for Arch in self.SupArchList:

for Record in RecordSet:

if Record[1] == Arch or Record[1] == TAB_ARCH_COMMON:

MergeArches(Nmakes, Record[0], Arch)

for Key in Nmakes.keys():

List = GetSplitValueList(Key, DataType.TAB_EQUAL_SPLIT, MaxSplit=1)

if len(List) != 2:

RaiseParserError(Key, 'Nmake', ContainerFile, '<MacroName> = <Value>')

continue

Nmake = ModuleNmakeClass()

Nmake.Name = List[0]

Nmake.Value = List[1]

Nmake.SupArchList = Nmakes[Key]

self.Module.Nmake.append(Nmake)

# convert Edk format to EdkII format

if Nmake.Name == "IMAGE_ENTRY_POINT":

Image = ModuleExternImageClass()

Image.ModuleEntryPoint = Nmake.Value

self.Module.ExternImages.append(Image)

elif Nmake.Name == "DPX_SOURCE":

Source = ModuleSourceFileClass(NormPath(Nmake.Value), "", "", "", "", Nmake.SupArchList)

self.Module.Sources.append(Source)

else:

ToolList = gNmakeFlagPattern.findall(Nmake.Name)

if len(ToolList) == 0 or len(ToolList) != 1:

EdkLogger.warn("\nParser", "Don't know how to do with MACRO: %s" % Nmake.Name,

ExtraData=ContainerFile)

else:

if ToolList[0] in gNmakeFlagName2ToolCode:

Tool = gNmakeFlagName2ToolCode[ToolList[0]]

else:

Tool = ToolList[0]

BuildOption = BuildOptionClass("MSFT", "*_*_*_%s_FLAGS" % Tool, Nmake.Value)

BuildOption.SupArchList = Nmake.SupArchList

self.Module.BuildOptions.append(BuildOption)

## GenPcds

#

# Gen Pcds of Inf

# <TokenSpaceGuidCName>.<PcdCName>[|<Value>]

#

# @param ContainerFile: The Dec file full path

#

def GenPcds(self, ContainerFile):

EdkLogger.debug(2, "Generate %s ..." % TAB_PCDS)

Pcds = {}

PcdToken = {}

#

# Get all Guids

#

RecordSet1 = self.RecordSet[MODEL_PCD_FIXED_AT_BUILD]

RecordSet2 = self.RecordSet[MODEL_PCD_PATCHABLE_IN_MODULE]

RecordSet3 = self.RecordSet[MODEL_PCD_FEATURE_FLAG]

RecordSet4 = self.RecordSet[MODEL_PCD_DYNAMIC_EX]

RecordSet5 = self.RecordSet[MODEL_PCD_DYNAMIC]

#

# Go through each arch

#

for Arch in self.SupArchList:

for Record in RecordSet1:

if Record[1] == Arch or Record[1] == TAB_ARCH_COMMON:

if self.Module.Header[Arch].LibraryClass != {}:

pass

(TokenGuidCName, TokenName, Value, Type) = GetPcdOfInf(Record[0], TAB_PCDS_FIXED_AT_BUILD, ContainerFile, Record[2])

MergeArches(Pcds, (TokenGuidCName, TokenName, Value, Type), Arch)

PcdToken[Record[3]] = (TokenGuidCName, TokenName)

for Record in RecordSet2:

if Record[1] == Arch or Record[1] == TAB_ARCH_COMMON:

(TokenGuidCName, TokenName, Value, Type) = GetPcdOfInf(Record[0], TAB_PCDS_PATCHABLE_IN_MODULE, ContainerFile, Record[2])

MergeArches(Pcds, (TokenGuidCName, TokenName, Value, Type), Arch)

PcdToken[Record[3]] = (TokenGuidCName, TokenName)

for Record in RecordSet3:

if Record[1] == Arch or Record[1] == TAB_ARCH_COMMON:

(TokenGuidCName, TokenName, Value, Type) = GetPcdOfInf(Record[0], TAB_PCDS_FEATURE_FLAG, ContainerFile, Record[2])

MergeArches(Pcds, (TokenGuidCName, TokenName, Value, Type), Arch)

PcdToken[Record[3]] = (TokenGuidCName, TokenName)

for Record in RecordSet4:

if Record[1] == Arch or Record[1] == TAB_ARCH_COMMON:

(TokenGuidCName, TokenName, Value, Type) = GetPcdOfInf(Record[0], TAB_PCDS_DYNAMIC_EX, ContainerFile, Record[2])

MergeArches(Pcds, (TokenGuidCName, TokenName, Value, Type), Arch)

PcdToken[Record[3]] = (TokenGuidCName, TokenName)

for Record in RecordSet5:

if Record[1] == Arch or Record[1] == TAB_ARCH_COMMON:

(TokenGuidCName, TokenName, Value, Type) = GetPcdOfInf(Record[0], "", ContainerFile, Record[2])

MergeArches(Pcds, (TokenGuidCName, TokenName, Value, Type), Arch)

PcdToken[Record[3]] = (TokenGuidCName, TokenName)

#

# Update to database

#

if self.IsToDatabase:

for Key in PcdToken.keys():

SqlCommand = """update %s set Value2 = '%s' where ID = %s""" % (self.TblInf.Table, ".".join((PcdToken[Key][0], PcdToken[Key][1])), Key)

self.TblInf.Exec(SqlCommand)

for Key in Pcds.keys():

Pcd = PcdClass()

Pcd.CName = Key[1]

Pcd.TokenSpaceGuidCName = Key[0]

Pcd.DefaultValue = Key[2]

Pcd.ItemType = Key[3]

Pcd.SupArchList = Pcds[Key]

self.Module.PcdCodes.append(Pcd)

## GenSources

#

# Gen Sources of Inf

# <Filename>[|<Family>[|<TagName>[|<ToolCode>[|<PcdFeatureFlag>]]]]

#

# @param ContainerFile: The Dec file full path

#

def GenSources(self, ContainerFile):

EdkLogger.debug(2, "Generate %s ..." % TAB_SOURCES)

Sources = {}

#

# Get all Nmakes

#

RecordSet = self.RecordSet[MODEL_EFI_SOURCE_FILE]

#

# Go through each arch

#

for Arch in self.SupArchList:

for Record in RecordSet:

if Record[1] == Arch or Record[1] == TAB_ARCH_COMMON:

(Filename, Family, TagName, ToolCode, Pcd) = GetSource(Record[0], ContainerFile, self.Identification.FileRelativePath, Record[2])

MergeArches(Sources, (Filename, Family, TagName, ToolCode, Pcd), Arch)

if self.IsToDatabase:

SqlCommand = """update %s set Value1 = '%s', Value2 = '%s', Value3 = '%s', Value4 = '%s', Value5 = '%s'

where ID = %s""" % (self.TblInf.Table, ConvertToSqlString2(Filename), ConvertToSqlString2(Family), ConvertToSqlString2(TagName), ConvertToSqlString2(ToolCode), ConvertToSqlString2(Pcd), Record[3])

self.TblInf.Exec(SqlCommand)

for Key in Sources.keys():

Source = ModuleSourceFileClass(Key[0], Key[2], Key[3], Key[1], Key[4], Sources[Key])

self.Module.Sources.append(Source)

## GenUserExtensions

#

# Gen UserExtensions of Inf

#

def GenUserExtensions(self, ContainerFile):

pass

## GenDepexes

#

# Gen Depex of Inf

#

# @param ContainerFile: The Inf file full path

#

def GenDepexes(self, ContainerFile):

EdkLogger.debug(2, "Generate %s ..." % TAB_DEPEX)

Depex = {}

#

# Get all Depexes

#

RecordSet = self.RecordSet[MODEL_EFI_DEPEX]

#

# Go through each arch

#

for Arch in self.SupArchList:

Line = ''

for Record in RecordSet:

if Record[1] == Arch or Record[1] == TAB_ARCH_COMMON:

Line = Line + Record[0] + ' '

if Line != '':

MergeArches(Depex, Line, Arch)

for Key in Depex.keys():

Dep = ModuleDepexClass()

Dep.Depex = Key

Dep.SupArchList = Depex[Key]

self.Module.Depex.append(Dep)

## GenBinaries

#

# Gen Binary of Inf

# <FileType>|<Filename>|<Target>[|<TokenSpaceGuidCName>.<PcdCName>]

#

# @param ContainerFile: The Dec file full path

#

def GenBinaries(self, ContainerFile):

EdkLogger.debug(2, "Generate %s ..." % TAB_BINARIES)

Binaries = {}

#

# Get all Guids

#

RecordSet = self.RecordSet[MODEL_EFI_BINARY_FILE]

#

# Go through each arch

#

for Arch in self.SupArchList:

for Record in RecordSet:

if Record[1] == Arch or Record[1] == TAB_ARCH_COMMON:

(FileType, Filename, Target, Pcd) = GetBinary(Record[0], ContainerFile, self.Identification.FileRelativePath, Record[2])

MergeArches(Binaries, (FileType, Filename, Target, Pcd), Arch)

if self.IsToDatabase:

SqlCommand = """update %s set Value1 = '%s', Value2 = '%s', Value3 = '%s', Value4 = '%s'

where ID = %s""" % (self.TblInf.Table, ConvertToSqlString2(FileType), ConvertToSqlString2(Filename), ConvertToSqlString2(Target), ConvertToSqlString2(Pcd), Record[3])

self.TblInf.Exec(SqlCommand)

for Key in Binaries.keys():

Binary = ModuleBinaryFileClass(NormPath(Key[1]), Key[0], Key[2], Key[3], Binaries[Key])

self.Module.Binaries.append(Binary)

## GenGuids

#

# Gen Guids of Inf

# <CName>=<GuidValue>

#

# @param ContainerFile: The Inf file full path

#

def GenGuidProtocolPpis(self, Type, ContainerFile):

EdkLogger.debug(2, "Generate %s ..." % Type)

Lists = {}

#

# Get all Items

#

RecordSet = self.RecordSet[Section[Type.upper()]]

#

# Go through each arch

#

for Arch in self.SupArchList:

for Record in RecordSet:

if Record[1] == Arch or Record[1] == TAB_ARCH_COMMON:

(Name, Value) = GetGuidsProtocolsPpisOfInf(Record[0], Type, ContainerFile, Record[2])

MergeArches(Lists, (Name, Value), Arch)

if self.IsToDatabase:

SqlCommand = """update %s set Value1 = '%s', Value2 = '%s'

where ID = %s""" % (self.TblInf.Table, ConvertToSqlString2(Name), ConvertToSqlString2(Value), Record[3])

self.TblInf.Exec(SqlCommand)

ListMember = None

if Type == TAB_GUIDS:

ListMember = self.Module.Guids

elif Type == TAB_PROTOCOLS:

ListMember = self.Module.Protocols

elif Type == TAB_PPIS:

ListMember = self.Module.Ppis

for Key in Lists.keys():

ListClass = GuidProtocolPpiCommonClass()

ListClass.CName = Key[0]

ListClass.SupArchList = Lists[Key]

ListClass.FeatureFlag = Key[1]

ListMember.append(ListClass)

if __name__ == '__main__':

EdkLogger.Initialize()

EdkLogger.SetLevel(EdkLogger.DEBUG_0)

W = os.getenv('WORKSPACE')

F = os.path.join(W, 'MdeModulePkg/Application/HelloWorld/HelloWorld.inf')

Db = Database.Database('Inf.db')

Db.InitDatabase()

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

P.ShowModule()

Db.Close()