## @file | |
# This file is used to be the main entrance of EOT tool | |
# | |
# Copyright (c) 2008 - 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, time, glob | |
import Common.EdkLogger as EdkLogger | |
import EotGlobalData | |
from optparse import OptionParser | |
from Common.String import NormPath | |
from Common import BuildToolError | |
from Common.Misc import GuidStructureStringToGuidString | |
from InfParserLite import * | |
import c | |
import Database | |
from FvImage import * | |
from array import array | |
from Report import Report | |
from Common.Misc import ParseConsoleLog | |
from Common.BuildVersion import gBUILD_VERSION | |
from Parser import ConvertGuid | |
from Common.LongFilePathSupport import OpenLongFilePath as open | |
## Class Eot | |
# | |
# This class is used to define Eot main entrance | |
# | |
# @param object: Inherited from object class | |
# | |
class Eot(object): | |
## The constructor | |
# | |
# @param self: The object pointer | |
# | |
def __init__(self, CommandLineOption=True, IsInit=True, SourceFileList=None, \ | |
IncludeDirList=None, DecFileList=None, GuidList=None, LogFile=None, | |
FvFileList="", MapFileList="", Report='Report.html', Dispatch=None): | |
# Version and Copyright | |
self.VersionNumber = ("0.02" + " " + gBUILD_VERSION) | |
self.Version = "%prog Version " + self.VersionNumber | |
self.Copyright = "Copyright (c) 2008 - 2010, Intel Corporation All rights reserved." | |
self.Report = Report | |
self.IsInit = IsInit | |
self.SourceFileList = SourceFileList | |
self.IncludeDirList = IncludeDirList | |
self.DecFileList = DecFileList | |
self.GuidList = GuidList | |
self.LogFile = LogFile | |
self.FvFileList = FvFileList | |
self.MapFileList = MapFileList | |
self.Dispatch = Dispatch | |
# Check workspace environment | |
if "EFI_SOURCE" not in os.environ: | |
if "EDK_SOURCE" not in os.environ: | |
pass | |
else: | |
EotGlobalData.gEDK_SOURCE = os.path.normpath(os.getenv("EDK_SOURCE")) | |
else: | |
EotGlobalData.gEFI_SOURCE = os.path.normpath(os.getenv("EFI_SOURCE")) | |
EotGlobalData.gEDK_SOURCE = os.path.join(EotGlobalData.gEFI_SOURCE, 'Edk') | |
if "WORKSPACE" not in os.environ: | |
EdkLogger.error("EOT", BuildToolError.ATTRIBUTE_NOT_AVAILABLE, "Environment variable not found", | |
ExtraData="WORKSPACE") | |
else: | |
EotGlobalData.gWORKSPACE = os.path.normpath(os.getenv("WORKSPACE")) | |
EotGlobalData.gMACRO['WORKSPACE'] = EotGlobalData.gWORKSPACE | |
EotGlobalData.gMACRO['EFI_SOURCE'] = EotGlobalData.gEFI_SOURCE | |
EotGlobalData.gMACRO['EDK_SOURCE'] = EotGlobalData.gEDK_SOURCE | |
# Parse the options and args | |
if CommandLineOption: | |
self.ParseOption() | |
if self.FvFileList: | |
for FvFile in GetSplitValueList(self.FvFileList, ' '): | |
FvFile = os.path.normpath(FvFile) | |
if not os.path.isfile(FvFile): | |
EdkLogger.error("Eot", EdkLogger.EOT_ERROR, "Can not find file %s " % FvFile) | |
EotGlobalData.gFV_FILE.append(FvFile) | |
else: | |
EdkLogger.error("Eot", EdkLogger.EOT_ERROR, "The fv file list of target platform was not specified") | |
if self.MapFileList: | |
for MapFile in GetSplitValueList(self.MapFileList, ' '): | |
MapFile = os.path.normpath(MapFile) | |
if not os.path.isfile(MapFile): | |
EdkLogger.error("Eot", EdkLogger.EOT_ERROR, "Can not find file %s " % MapFile) | |
EotGlobalData.gMAP_FILE.append(MapFile) | |
# Generate source file list | |
self.GenerateSourceFileList(self.SourceFileList, self.IncludeDirList) | |
# Generate guid list of dec file list | |
self.ParseDecFile(self.DecFileList) | |
# Generate guid list from GUID list file | |
self.ParseGuidList(self.GuidList) | |
# Init Eot database | |
EotGlobalData.gDb = Database.Database(Database.DATABASE_PATH) | |
EotGlobalData.gDb.InitDatabase(self.IsInit) | |
# Build ECC database | |
self.BuildDatabase() | |
# Parse Ppi/Protocol | |
self.ParseExecutionOrder() | |
# Merge Identifier tables | |
self.GenerateQueryTable() | |
# Generate report database | |
self.GenerateReportDatabase() | |
# Load Fv Info | |
self.LoadFvInfo() | |
# Load Map Info | |
self.LoadMapInfo() | |
# Generate Report | |
self.GenerateReport() | |
# Convert log file | |
self.ConvertLogFile(self.LogFile) | |
# DONE | |
EdkLogger.quiet("EOT FINISHED!") | |
# Close Database | |
EotGlobalData.gDb.Close() | |
## ParseDecFile() method | |
# | |
# parse DEC file and get all GUID names with GUID values as {GuidName : GuidValue} | |
# The Dict is stored in EotGlobalData.gGuidDict | |
# | |
# @param self: The object pointer | |
# @param DecFileList: A list of all DEC files | |
# | |
def ParseDecFile(self, DecFileList): | |
if DecFileList: | |
path = os.path.normpath(DecFileList) | |
lfr = open(path, 'rb') | |
for line in lfr: | |
path = os.path.normpath(os.path.join(EotGlobalData.gWORKSPACE, line.strip())) | |
if os.path.exists(path): | |
dfr = open(path, 'rb') | |
for line in dfr: | |
line = CleanString(line) | |
list = line.split('=') | |
if len(list) == 2: | |
EotGlobalData.gGuidDict[list[0].strip()] = GuidStructureStringToGuidString(list[1].strip()) | |
## ParseGuidList() method | |
# | |
# Parse Guid list and get all GUID names with GUID values as {GuidName : GuidValue} | |
# The Dict is stored in EotGlobalData.gGuidDict | |
# | |
# @param self: The object pointer | |
# @param GuidList: A list of all GUID and its value | |
# | |
def ParseGuidList(self, GuidList): | |
Path = os.path.join(EotGlobalData.gWORKSPACE, GuidList) | |
if os.path.isfile(Path): | |
for Line in open(Path): | |
(GuidName, GuidValue) = Line.split() | |
EotGlobalData.gGuidDict[GuidName] = GuidValue | |
## ConvertLogFile() method | |
# | |
# Parse a real running log file to get real dispatch order | |
# The result is saved to old file name + '.new' | |
# | |
# @param self: The object pointer | |
# @param LogFile: A real running log file name | |
# | |
def ConvertLogFile(self, LogFile): | |
newline = [] | |
lfr = None | |
lfw = None | |
if LogFile: | |
lfr = open(LogFile, 'rb') | |
lfw = open(LogFile + '.new', 'wb') | |
for line in lfr: | |
line = line.strip() | |
line = line.replace('.efi', '') | |
index = line.find("Loading PEIM at ") | |
if index > -1: | |
newline.append(line[index + 55 : ]) | |
continue | |
index = line.find("Loading driver at ") | |
if index > -1: | |
newline.append(line[index + 57 : ]) | |
continue | |
for line in newline: | |
lfw.write(line + '\r\n') | |
if lfr: | |
lfr.close() | |
if lfw: | |
lfw.close() | |
## GenerateSourceFileList() method | |
# | |
# Generate a list of all source files | |
# 1. Search the file list one by one | |
# 2. Store inf file name with source file names under it like | |
# { INF file name: [source file1, source file2, ...]} | |
# 3. Search the include list to find all .h files | |
# 4. Store source file list to EotGlobalData.gSOURCE_FILES | |
# 5. Store INF file list to EotGlobalData.gINF_FILES | |
# | |
# @param self: The object pointer | |
# @param SourceFileList: A list of all source files | |
# @param IncludeFileList: A list of all include files | |
# | |
def GenerateSourceFileList(self, SourceFileList, IncludeFileList): | |
EdkLogger.quiet("Generating source files list ... ") | |
mSourceFileList = [] | |
mInfFileList = [] | |
mDecFileList = [] | |
mFileList = {} | |
mCurrentInfFile = '' | |
mCurrentSourceFileList = [] | |
if SourceFileList: | |
sfl = open(SourceFileList, 'rb') | |
for line in sfl: | |
line = os.path.normpath(os.path.join(EotGlobalData.gWORKSPACE, line.strip())) | |
if line[-2:].upper() == '.C' or line[-2:].upper() == '.H': | |
if line not in mCurrentSourceFileList: | |
mCurrentSourceFileList.append(line) | |
mSourceFileList.append(line) | |
EotGlobalData.gOP_SOURCE_FILES.write('%s\n' % line) | |
if line[-4:].upper() == '.INF': | |
if mCurrentInfFile != '': | |
mFileList[mCurrentInfFile] = mCurrentSourceFileList | |
mCurrentSourceFileList = [] | |
mCurrentInfFile = os.path.normpath(os.path.join(EotGlobalData.gWORKSPACE, line)) | |
EotGlobalData.gOP_INF.write('%s\n' % mCurrentInfFile) | |
if mCurrentInfFile not in mFileList: | |
mFileList[mCurrentInfFile] = mCurrentSourceFileList | |
# Get all include files from packages | |
if IncludeFileList: | |
ifl = open(IncludeFileList, 'rb') | |
for line in ifl: | |
if not line.strip(): | |
continue | |
newline = os.path.normpath(os.path.join(EotGlobalData.gWORKSPACE, line.strip())) | |
for Root, Dirs, Files in os.walk(str(newline)): | |
for File in Files: | |
FullPath = os.path.normpath(os.path.join(Root, File)) | |
if FullPath not in mSourceFileList and File[-2:].upper() == '.H': | |
mSourceFileList.append(FullPath) | |
EotGlobalData.gOP_SOURCE_FILES.write('%s\n' % FullPath) | |
if FullPath not in mDecFileList and File.upper().find('.DEC') > -1: | |
mDecFileList.append(FullPath) | |
EotGlobalData.gSOURCE_FILES = mSourceFileList | |
EotGlobalData.gOP_SOURCE_FILES.close() | |
EotGlobalData.gINF_FILES = mFileList | |
EotGlobalData.gOP_INF.close() | |
EotGlobalData.gDEC_FILES = mDecFileList | |
## GenerateReport() method | |
# | |
# Generate final HTML report | |
# | |
# @param self: The object pointer | |
# | |
def GenerateReport(self): | |
EdkLogger.quiet("Generating report file ... ") | |
Rep = Report(self.Report, EotGlobalData.gFV, self.Dispatch) | |
Rep.GenerateReport() | |
## LoadMapInfo() method | |
# | |
# Load map files and parse them | |
# | |
# @param self: The object pointer | |
# | |
def LoadMapInfo(self): | |
if EotGlobalData.gMAP_FILE != []: | |
EdkLogger.quiet("Parsing Map file ... ") | |
EotGlobalData.gMap = ParseMapFile(EotGlobalData.gMAP_FILE) | |
## LoadFvInfo() method | |
# | |
# Load FV binary files and parse them | |
# | |
# @param self: The object pointer | |
# | |
def LoadFvInfo(self): | |
EdkLogger.quiet("Parsing FV file ... ") | |
EotGlobalData.gFV = MultipleFv(EotGlobalData.gFV_FILE) | |
EotGlobalData.gFV.Dispatch(EotGlobalData.gDb) | |
for Protocol in EotGlobalData.gProtocolList: | |
EotGlobalData.gOP_UN_MATCHED_IN_LIBRARY_CALLING.write('%s\n' %Protocol) | |
## GenerateReportDatabase() method | |
# | |
# Generate data for the information needed by report | |
# 1. Update name, macro and value of all found PPI/PROTOCOL GUID | |
# 2. Install hard coded PPI/PROTOCOL | |
# | |
# @param self: The object pointer | |
# | |
def GenerateReportDatabase(self): | |
EdkLogger.quiet("Generating the cross-reference table of GUID for Ppi/Protocol ... ") | |
# Update Protocol/Ppi Guid | |
SqlCommand = """select DISTINCT GuidName from Report""" | |
RecordSet = EotGlobalData.gDb.TblReport.Exec(SqlCommand) | |
for Record in RecordSet: | |
GuidName = Record[0] | |
GuidMacro = '' | |
GuidMacro2 = '' | |
GuidValue = '' | |
# Find value for hardcode guid macro | |
if GuidName in EotGlobalData.gGuidMacroDict: | |
GuidMacro = EotGlobalData.gGuidMacroDict[GuidName][0] | |
GuidValue = EotGlobalData.gGuidMacroDict[GuidName][1] | |
SqlCommand = """update Report set GuidMacro = '%s', GuidValue = '%s' where GuidName = '%s'""" %(GuidMacro, GuidValue, GuidName) | |
EotGlobalData.gDb.TblReport.Exec(SqlCommand) | |
continue | |
# Find guid value defined in Dec file | |
if GuidName in EotGlobalData.gGuidDict: | |
GuidValue = EotGlobalData.gGuidDict[GuidName] | |
SqlCommand = """update Report set GuidMacro = '%s', GuidValue = '%s' where GuidName = '%s'""" %(GuidMacro, GuidValue, GuidName) | |
EotGlobalData.gDb.TblReport.Exec(SqlCommand) | |
continue | |
# Search defined Macros for guid name | |
SqlCommand ="""select DISTINCT Value, Modifier from Query where Name like '%s'""" % GuidName | |
GuidMacroSet = EotGlobalData.gDb.TblReport.Exec(SqlCommand) | |
# Ignore NULL result | |
if not GuidMacroSet: | |
continue | |
GuidMacro = GuidMacroSet[0][0].strip() | |
if not GuidMacro: | |
continue | |
# Find Guid value of Guid Macro | |
SqlCommand ="""select DISTINCT Value from Query2 where Value like '%%%s%%' and Model = %s""" % (GuidMacro, MODEL_IDENTIFIER_MACRO_DEFINE) | |
GuidValueSet = EotGlobalData.gDb.TblReport.Exec(SqlCommand) | |
if GuidValueSet != []: | |
GuidValue = GuidValueSet[0][0] | |
GuidValue = GuidValue[GuidValue.find(GuidMacro) + len(GuidMacro) :] | |
GuidValue = GuidValue.lower().replace('\\', '').replace('\r', '').replace('\n', '').replace('l', '').strip() | |
GuidValue = GuidStructureStringToGuidString(GuidValue) | |
SqlCommand = """update Report set GuidMacro = '%s', GuidValue = '%s' where GuidName = '%s'""" %(GuidMacro, GuidValue, GuidName) | |
EotGlobalData.gDb.TblReport.Exec(SqlCommand) | |
continue | |
# Update Hard Coded Ppi/Protocol | |
SqlCommand = """select DISTINCT GuidValue, ItemType from Report where ModuleID = -2 and ItemMode = 'Produced'""" | |
RecordSet = EotGlobalData.gDb.TblReport.Exec(SqlCommand) | |
for Record in RecordSet: | |
if Record[1] == 'Ppi': | |
EotGlobalData.gPpiList[Record[0].lower()] = -2 | |
if Record[1] == 'Protocol': | |
EotGlobalData.gProtocolList[Record[0].lower()] = -2 | |
## GenerateQueryTable() method | |
# | |
# Generate two tables improve query performance | |
# | |
# @param self: The object pointer | |
# | |
def GenerateQueryTable(self): | |
EdkLogger.quiet("Generating temp query table for analysis ... ") | |
for Identifier in EotGlobalData.gIdentifierTableList: | |
SqlCommand = """insert into Query (Name, Modifier, Value, Model) | |
select Name, Modifier, Value, Model from %s where (Model = %s or Model = %s)""" \ | |
% (Identifier[0], MODEL_IDENTIFIER_VARIABLE, MODEL_IDENTIFIER_ASSIGNMENT_EXPRESSION) | |
EotGlobalData.gDb.TblReport.Exec(SqlCommand) | |
SqlCommand = """insert into Query2 (Name, Modifier, Value, Model) | |
select Name, Modifier, Value, Model from %s where Model = %s""" \ | |
% (Identifier[0], MODEL_IDENTIFIER_MACRO_DEFINE) | |
EotGlobalData.gDb.TblReport.Exec(SqlCommand) | |
## ParseExecutionOrder() method | |
# | |
# Get final execution order | |
# 1. Search all PPI | |
# 2. Search all PROTOCOL | |
# | |
# @param self: The object pointer | |
# | |
def ParseExecutionOrder(self): | |
EdkLogger.quiet("Searching Ppi/Protocol ... ") | |
for Identifier in EotGlobalData.gIdentifierTableList: | |
ModuleID, ModuleName, ModuleGuid, SourceFileID, SourceFileFullPath, ItemName, ItemType, ItemMode, GuidName, GuidMacro, GuidValue, BelongsToFunction, Enabled = \ | |
-1, '', '', -1, '', '', '', '', '', '', '', '', 0 | |
SourceFileID = Identifier[0].replace('Identifier', '') | |
SourceFileFullPath = Identifier[1] | |
Identifier = Identifier[0] | |
# Find Ppis | |
ItemMode = 'Produced' | |
SqlCommand = """select Value, Name, BelongsToFile, StartLine, EndLine from %s | |
where (Name like '%%%s%%' or Name like '%%%s%%' or Name like '%%%s%%') and Model = %s""" \ | |
% (Identifier, '.InstallPpi', '->InstallPpi', 'PeiInstallPpi', MODEL_IDENTIFIER_FUNCTION_CALLING) | |
SearchPpi(SqlCommand, Identifier, SourceFileID, SourceFileFullPath, ItemMode) | |
ItemMode = 'Produced' | |
SqlCommand = """select Value, Name, BelongsToFile, StartLine, EndLine from %s | |
where (Name like '%%%s%%' or Name like '%%%s%%') and Model = %s""" \ | |
% (Identifier, '.ReInstallPpi', '->ReInstallPpi', MODEL_IDENTIFIER_FUNCTION_CALLING) | |
SearchPpi(SqlCommand, Identifier, SourceFileID, SourceFileFullPath, ItemMode, 2) | |
SearchPpiCallFunction(Identifier, SourceFileID, SourceFileFullPath, ItemMode) | |
ItemMode = 'Consumed' | |
SqlCommand = """select Value, Name, BelongsToFile, StartLine, EndLine from %s | |
where (Name like '%%%s%%' or Name like '%%%s%%') and Model = %s""" \ | |
% (Identifier, '.LocatePpi', '->LocatePpi', MODEL_IDENTIFIER_FUNCTION_CALLING) | |
SearchPpi(SqlCommand, Identifier, SourceFileID, SourceFileFullPath, ItemMode) | |
SearchFunctionCalling(Identifier, SourceFileID, SourceFileFullPath, 'Ppi', ItemMode) | |
ItemMode = 'Callback' | |
SqlCommand = """select Value, Name, BelongsToFile, StartLine, EndLine from %s | |
where (Name like '%%%s%%' or Name like '%%%s%%') and Model = %s""" \ | |
% (Identifier, '.NotifyPpi', '->NotifyPpi', MODEL_IDENTIFIER_FUNCTION_CALLING) | |
SearchPpi(SqlCommand, Identifier, SourceFileID, SourceFileFullPath, ItemMode) | |
# Find Procotols | |
ItemMode = 'Produced' | |
SqlCommand = """select Value, Name, BelongsToFile, StartLine, EndLine from %s | |
where (Name like '%%%s%%' or Name like '%%%s%%' or Name like '%%%s%%' or Name like '%%%s%%') and Model = %s""" \ | |
% (Identifier, '.InstallProtocolInterface', '.ReInstallProtocolInterface', '->InstallProtocolInterface', '->ReInstallProtocolInterface', MODEL_IDENTIFIER_FUNCTION_CALLING) | |
SearchProtocols(SqlCommand, Identifier, SourceFileID, SourceFileFullPath, ItemMode, 1) | |
SqlCommand = """select Value, Name, BelongsToFile, StartLine, EndLine from %s | |
where (Name like '%%%s%%' or Name like '%%%s%%') and Model = %s""" \ | |
% (Identifier, '.InstallMultipleProtocolInterfaces', '->InstallMultipleProtocolInterfaces', MODEL_IDENTIFIER_FUNCTION_CALLING) | |
SearchProtocols(SqlCommand, Identifier, SourceFileID, SourceFileFullPath, ItemMode, 2) | |
SearchFunctionCalling(Identifier, SourceFileID, SourceFileFullPath, 'Protocol', ItemMode) | |
ItemMode = 'Consumed' | |
SqlCommand = """select Value, Name, BelongsToFile, StartLine, EndLine from %s | |
where (Name like '%%%s%%' or Name like '%%%s%%') and Model = %s""" \ | |
% (Identifier, '.LocateProtocol', '->LocateProtocol', MODEL_IDENTIFIER_FUNCTION_CALLING) | |
SearchProtocols(SqlCommand, Identifier, SourceFileID, SourceFileFullPath, ItemMode, 0) | |
SqlCommand = """select Value, Name, BelongsToFile, StartLine, EndLine from %s | |
where (Name like '%%%s%%' or Name like '%%%s%%') and Model = %s""" \ | |
% (Identifier, '.HandleProtocol', '->HandleProtocol', MODEL_IDENTIFIER_FUNCTION_CALLING) | |
SearchProtocols(SqlCommand, Identifier, SourceFileID, SourceFileFullPath, ItemMode, 1) | |
SearchFunctionCalling(Identifier, SourceFileID, SourceFileFullPath, 'Protocol', ItemMode) | |
ItemMode = 'Callback' | |
SqlCommand = """select Value, Name, BelongsToFile, StartLine, EndLine from %s | |
where (Name like '%%%s%%' or Name like '%%%s%%') and Model = %s""" \ | |
% (Identifier, '.RegisterProtocolNotify', '->RegisterProtocolNotify', MODEL_IDENTIFIER_FUNCTION_CALLING) | |
SearchProtocols(SqlCommand, Identifier, SourceFileID, SourceFileFullPath, ItemMode, 0) | |
SearchFunctionCalling(Identifier, SourceFileID, SourceFileFullPath, 'Protocol', ItemMode) | |
# Hard Code | |
EotGlobalData.gDb.TblReport.Insert(-2, '', '', -1, '', '', 'Ppi', 'Produced', 'gEfiSecPlatformInformationPpiGuid', '', '', '', 0) | |
EotGlobalData.gDb.TblReport.Insert(-2, '', '', -1, '', '', 'Ppi', 'Produced', 'gEfiNtLoadAsDllPpiGuid', '', '', '', 0) | |
EotGlobalData.gDb.TblReport.Insert(-2, '', '', -1, '', '', 'Ppi', 'Produced', 'gNtPeiLoadFileGuid', '', '', '', 0) | |
EotGlobalData.gDb.TblReport.Insert(-2, '', '', -1, '', '', 'Ppi', 'Produced', 'gPeiNtAutoScanPpiGuid', '', '', '', 0) | |
EotGlobalData.gDb.TblReport.Insert(-2, '', '', -1, '', '', 'Ppi', 'Produced', 'gNtFwhPpiGuid', '', '', '', 0) | |
EotGlobalData.gDb.TblReport.Insert(-2, '', '', -1, '', '', 'Ppi', 'Produced', 'gPeiNtThunkPpiGuid', '', '', '', 0) | |
EotGlobalData.gDb.TblReport.Insert(-2, '', '', -1, '', '', 'Ppi', 'Produced', 'gPeiPlatformTypePpiGuid', '', '', '', 0) | |
EotGlobalData.gDb.TblReport.Insert(-2, '', '', -1, '', '', 'Ppi', 'Produced', 'gPeiFrequencySelectionCpuPpiGuid', '', '', '', 0) | |
EotGlobalData.gDb.TblReport.Insert(-2, '', '', -1, '', '', 'Ppi', 'Produced', 'gPeiCachePpiGuid', '', '', '', 0) | |
EotGlobalData.gDb.Conn.commit() | |
## BuildDatabase() methoc | |
# | |
# Build the database for target | |
# | |
# @param self: The object pointer | |
# | |
def BuildDatabase(self): | |
# Clean report table | |
EotGlobalData.gDb.TblReport.Drop() | |
EotGlobalData.gDb.TblReport.Create() | |
# Build database | |
if self.IsInit: | |
self.BuildMetaDataFileDatabase(EotGlobalData.gINF_FILES) | |
EdkLogger.quiet("Building database for source code ...") | |
c.CreateCCodeDB(EotGlobalData.gSOURCE_FILES) | |
EdkLogger.quiet("Building database for source code done!") | |
EotGlobalData.gIdentifierTableList = GetTableList((MODEL_FILE_C, MODEL_FILE_H), 'Identifier', EotGlobalData.gDb) | |
## BuildMetaDataFileDatabase() method | |
# | |
# Build the database for meta data files | |
# | |
# @param self: The object pointer | |
# @param Inf_Files: A list for all INF files | |
# | |
def BuildMetaDataFileDatabase(self, Inf_Files): | |
EdkLogger.quiet("Building database for meta data files ...") | |
for InfFile in Inf_Files: | |
EdkLogger.quiet("Parsing %s ..." % str(InfFile)) | |
EdkInfParser(InfFile, EotGlobalData.gDb, Inf_Files[InfFile], '') | |
EotGlobalData.gDb.Conn.commit() | |
EdkLogger.quiet("Building database for meta data files done!") | |
## ParseOption() method | |
# | |
# Parse command line options | |
# | |
# @param self: The object pointer | |
# | |
def ParseOption(self): | |
(Options, Target) = self.EotOptionParser() | |
# Set log level | |
self.SetLogLevel(Options) | |
if Options.FvFileList: | |
self.FvFileList = Options.FvFileList | |
if Options.MapFileList: | |
self.MapFileList = Options.FvMapFileList | |
if Options.SourceFileList: | |
self.SourceFileList = Options.SourceFileList | |
if Options.IncludeDirList: | |
self.IncludeDirList = Options.IncludeDirList | |
if Options.DecFileList: | |
self.DecFileList = Options.DecFileList | |
if Options.GuidList: | |
self.GuidList = Options.GuidList | |
if Options.LogFile: | |
self.LogFile = Options.LogFile | |
if Options.keepdatabase: | |
self.IsInit = False | |
## SetLogLevel() method | |
# | |
# Set current log level of the tool based on args | |
# | |
# @param self: The object pointer | |
# @param Option: The option list including log level setting | |
# | |
def SetLogLevel(self, Option): | |
if Option.verbose != None: | |
EdkLogger.SetLevel(EdkLogger.VERBOSE) | |
elif Option.quiet != None: | |
EdkLogger.SetLevel(EdkLogger.QUIET) | |
elif Option.debug != None: | |
EdkLogger.SetLevel(Option.debug + 1) | |
else: | |
EdkLogger.SetLevel(EdkLogger.INFO) | |
## EotOptionParser() method | |
# | |
# Using standard Python module optparse to parse command line option of this tool. | |
# | |
# @param self: The object pointer | |
# | |
# @retval Opt A optparse.Values object containing the parsed options | |
# @retval Args Target of build command | |
# | |
def EotOptionParser(self): | |
Parser = OptionParser(description = self.Copyright, version = self.Version, prog = "Eot.exe", usage = "%prog [options]") | |
Parser.add_option("-m", "--makefile filename", action="store", type="string", dest='MakeFile', | |
help="Specify a makefile for the platform.") | |
Parser.add_option("-c", "--dsc filename", action="store", type="string", dest="DscFile", | |
help="Specify a dsc file for the platform.") | |
Parser.add_option("-f", "--fv filename", action="store", type="string", dest="FvFileList", | |
help="Specify fv file list, quoted by \"\".") | |
Parser.add_option("-a", "--map filename", action="store", type="string", dest="MapFileList", | |
help="Specify map file list, quoted by \"\".") | |
Parser.add_option("-s", "--source files", action="store", type="string", dest="SourceFileList", | |
help="Specify source file list by a file") | |
Parser.add_option("-i", "--include dirs", action="store", type="string", dest="IncludeDirList", | |
help="Specify include dir list by a file") | |
Parser.add_option("-e", "--dec files", action="store", type="string", dest="DecFileList", | |
help="Specify dec file list by a file") | |
Parser.add_option("-g", "--guid list", action="store", type="string", dest="GuidList", | |
help="Specify guid file list by a file") | |
Parser.add_option("-l", "--log filename", action="store", type="string", dest="LogFile", | |
help="Specify real execution log file") | |
Parser.add_option("-k", "--keepdatabase", action="store_true", type=None, help="The existing Eot database will not be cleaned except report information if this option is specified.") | |
Parser.add_option("-q", "--quiet", action="store_true", type=None, help="Disable all messages except FATAL ERRORS.") | |
Parser.add_option("-v", "--verbose", action="store_true", type=None, help="Turn on verbose output with informational messages printed, "\ | |
"including library instances selected, final dependency expression, "\ | |
"and warning messages, etc.") | |
Parser.add_option("-d", "--debug", action="store", type="int", help="Enable debug messages at specified level.") | |
(Opt, Args)=Parser.parse_args() | |
return (Opt, Args) | |
## | |
# | |
# This acts like the main() function for the script, unless it is 'import'ed into another | |
# script. | |
# | |
if __name__ == '__main__': | |
# Initialize log system | |
EdkLogger.Initialize() | |
EdkLogger.IsRaiseError = False | |
EdkLogger.quiet(time.strftime("%H:%M:%S, %b.%d %Y ", time.localtime()) + "[00:00]" + "\n") | |
StartTime = time.clock() | |
Eot = Eot() | |
FinishTime = time.clock() | |
BuildDuration = time.strftime("%M:%S", time.gmtime(int(round(FinishTime - StartTime)))) | |
EdkLogger.quiet("\n%s [%s]" % (time.strftime("%H:%M:%S, %b.%d %Y", time.localtime()), BuildDuration)) |