[mirror_edk2.git] / BaseTools / Source / Python / Eot / Eot.py

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