diff options
Diffstat (limited to '')
| -rwxr-xr-x | src/VBox/Devices/EFI/Firmware/BaseTools/Source/Python/Ecc/Database.py | 340 |
1 files changed, 340 insertions, 0 deletions
diff --git a/src/VBox/Devices/EFI/Firmware/BaseTools/Source/Python/Ecc/Database.py b/src/VBox/Devices/EFI/Firmware/BaseTools/Source/Python/Ecc/Database.py new file mode 100755 index 00000000..94837005 --- /dev/null +++ b/src/VBox/Devices/EFI/Firmware/BaseTools/Source/Python/Ecc/Database.py @@ -0,0 +1,340 @@ +## @file +# This file is used to create a database used by ECC tool +# +# Copyright (c) 2007 - 2014, Intel Corporation. All rights reserved.<BR> +# SPDX-License-Identifier: BSD-2-Clause-Patent +# + +## +# Import Modules +# +from __future__ import absolute_import +import sqlite3 +import Common.LongFilePathOs as os, time + +import Common.EdkLogger as EdkLogger +import CommonDataClass.DataClass as DataClass + +from Table.TableDataModel import TableDataModel +from Table.TableFile import TableFile +from Table.TableFunction import TableFunction +from Table.TablePcd import TablePcd +from Table.TableIdentifier import TableIdentifier +from Table.TableReport import TableReport +from Ecc.MetaFileWorkspace.MetaFileTable import ModuleTable +from Ecc.MetaFileWorkspace.MetaFileTable import PackageTable +from Ecc.MetaFileWorkspace.MetaFileTable import PlatformTable +from Table.TableFdf import TableFdf + +## +# Static definitions +# +DATABASE_PATH = "Ecc.db" + +## Database +# +# This class defined the ECC database +# During the phase of initialization, the database will create all tables and +# insert all records of table DataModel +# +# @param object: Inherited from object class +# @param DbPath: A string for the path of the ECC database +# +# @var Conn: Connection of the ECC database +# @var Cur: Cursor of the connection +# @var TblDataModel: Local instance for TableDataModel +# +class Database(object): + def __init__(self, DbPath): + self.DbPath = DbPath + self.Conn = None + self.Cur = None + self.TblDataModel = None + self.TblFile = None + self.TblFunction = None + self.TblIdentifier = None + self.TblPcd = None + self.TblReport = None + self.TblInf = None + self.TblDec = None + self.TblDsc = None + self.TblFdf = None + + ## Initialize ECC database + # + # 1. Delete all old existing tables + # 2. Create new tables + # 3. Initialize table DataModel + # + def InitDatabase(self, NewDatabase = True): + EdkLogger.verbose("\nInitialize ECC database started ...") + # + # Drop all old existing tables + # + if NewDatabase: + if os.path.exists(self.DbPath): + os.remove(self.DbPath) + self.Conn = sqlite3.connect(self.DbPath, isolation_level = 'DEFERRED') + self.Conn.execute("PRAGMA page_size=4096") + self.Conn.execute("PRAGMA synchronous=OFF") + # to avoid non-ascii character conversion error + self.Conn.text_factory = str + self.Cur = self.Conn.cursor() + + self.TblDataModel = TableDataModel(self.Cur) + self.TblFile = TableFile(self.Cur) + self.TblFunction = TableFunction(self.Cur) + self.TblIdentifier = TableIdentifier(self.Cur) + self.TblPcd = TablePcd(self.Cur) + self.TblReport = TableReport(self.Cur) + self.TblInf = ModuleTable(self.Cur) + self.TblDec = PackageTable(self.Cur) + self.TblDsc = PlatformTable(self.Cur) + self.TblFdf = TableFdf(self.Cur) + + # + # Create new tables + # + if NewDatabase: + self.TblDataModel.Create() + self.TblFile.Create() + self.TblFunction.Create() + self.TblPcd.Create() + self.TblReport.Create() + self.TblInf.Create() + self.TblDec.Create() + self.TblDsc.Create() + self.TblFdf.Create() + + # + # Init each table's ID + # + self.TblDataModel.InitID() + self.TblFile.InitID() + self.TblFunction.InitID() + self.TblPcd.InitID() + self.TblReport.InitID() + self.TblInf.InitID() + self.TblDec.InitID() + self.TblDsc.InitID() + self.TblFdf.InitID() + + # + # Initialize table DataModel + # + if NewDatabase: + self.TblDataModel.InitTable() + + EdkLogger.verbose("Initialize ECC database ... DONE!") + + ## Query a table + # + # @param Table: The instance of the table to be queried + # + def QueryTable(self, Table): + Table.Query() + + ## Close entire database + # + # Commit all first + # Close the connection and cursor + # + def Close(self): + # + # Commit to file + # + self.Conn.commit() + + # + # Close connection and cursor + # + self.Cur.close() + self.Conn.close() + + ## Insert one file information + # + # Insert one file's information to the database + # 1. Create a record in TableFile + # 2. Create functions one by one + # 2.1 Create variables of function one by one + # 2.2 Create pcds of function one by one + # 3. Create variables one by one + # 4. Create pcds one by one + # + def InsertOneFile(self, File): + # + # Insert a record for file + # + FileID = self.TblFile.Insert(File.Name, File.ExtName, File.Path, File.FullPath, Model = File.Model, TimeStamp = File.TimeStamp) + + if File.Model == DataClass.MODEL_FILE_C or File.Model == DataClass.MODEL_FILE_H: + IdTable = TableIdentifier(self.Cur) + IdTable.Table = "Identifier%s" % FileID + IdTable.Create() + # + # Insert function of file + # + for Function in File.FunctionList: + FunctionID = self.TblFunction.Insert(Function.Header, Function.Modifier, Function.Name, Function.ReturnStatement, \ + Function.StartLine, Function.StartColumn, Function.EndLine, Function.EndColumn, \ + Function.BodyStartLine, Function.BodyStartColumn, FileID, \ + Function.FunNameStartLine, Function.FunNameStartColumn) + # + # Insert Identifier of function + # + for Identifier in Function.IdentifierList: + IdentifierID = IdTable.Insert(Identifier.Modifier, Identifier.Type, Identifier.Name, Identifier.Value, Identifier.Model, \ + FileID, FunctionID, Identifier.StartLine, Identifier.StartColumn, Identifier.EndLine, Identifier.EndColumn) + # + # Insert Pcd of function + # + for Pcd in Function.PcdList: + PcdID = self.TblPcd.Insert(Pcd.CName, Pcd.TokenSpaceGuidCName, Pcd.Token, Pcd.DatumType, Pcd.Model, \ + FileID, FunctionID, Pcd.StartLine, Pcd.StartColumn, Pcd.EndLine, Pcd.EndColumn) + # + # Insert Identifier of file + # + for Identifier in File.IdentifierList: + IdentifierID = IdTable.Insert(Identifier.Modifier, Identifier.Type, Identifier.Name, Identifier.Value, Identifier.Model, \ + FileID, -1, Identifier.StartLine, Identifier.StartColumn, Identifier.EndLine, Identifier.EndColumn) + # + # Insert Pcd of file + # + for Pcd in File.PcdList: + PcdID = self.TblPcd.Insert(Pcd.CName, Pcd.TokenSpaceGuidCName, Pcd.Token, Pcd.DatumType, Pcd.Model, \ + FileID, -1, Pcd.StartLine, Pcd.StartColumn, Pcd.EndLine, Pcd.EndColumn) + + EdkLogger.verbose("Insert information from file %s ... DONE!" % File.FullPath) + + ## UpdateIdentifierBelongsToFunction + # + # Update the field "BelongsToFunction" for each Identifier + # + # + def UpdateIdentifierBelongsToFunction_disabled(self): + EdkLogger.verbose("Update 'BelongsToFunction' for Identifiers started ...") + + SqlCommand = """select ID, BelongsToFile, StartLine, EndLine, Model from Identifier""" + EdkLogger.debug(4, "SqlCommand: %s" %SqlCommand) + self.Cur.execute(SqlCommand) + Records = self.Cur.fetchall() + for Record in Records: + IdentifierID = Record[0] + BelongsToFile = Record[1] + StartLine = Record[2] + EndLine = Record[3] + Model = Record[4] + + # + # Check whether an identifier belongs to a function + # + EdkLogger.debug(4, "For common identifiers ... ") + SqlCommand = """select ID from Function + where StartLine < %s and EndLine > %s + and BelongsToFile = %s""" % (StartLine, EndLine, BelongsToFile) + EdkLogger.debug(4, "SqlCommand: %s" %SqlCommand) + self.Cur.execute(SqlCommand) + IDs = self.Cur.fetchall() + for ID in IDs: + SqlCommand = """Update Identifier set BelongsToFunction = %s where ID = %s""" % (ID[0], IdentifierID) + EdkLogger.debug(4, "SqlCommand: %s" %SqlCommand) + self.Cur.execute(SqlCommand) + + # + # Check whether the identifier is a function header + # + EdkLogger.debug(4, "For function headers ... ") + if Model == DataClass.MODEL_IDENTIFIER_COMMENT: + SqlCommand = """select ID from Function + where StartLine = %s + 1 + and BelongsToFile = %s""" % (EndLine, BelongsToFile) + EdkLogger.debug(4, "SqlCommand: %s" %SqlCommand) + self.Cur.execute(SqlCommand) + IDs = self.Cur.fetchall() + for ID in IDs: + SqlCommand = """Update Identifier set BelongsToFunction = %s, Model = %s where ID = %s""" % (ID[0], DataClass.MODEL_IDENTIFIER_FUNCTION_HEADER, IdentifierID) + EdkLogger.debug(4, "SqlCommand: %s" %SqlCommand) + self.Cur.execute(SqlCommand) + + EdkLogger.verbose("Update 'BelongsToFunction' for Identifiers ... DONE") + + + ## UpdateIdentifierBelongsToFunction + # + # Update the field "BelongsToFunction" for each Identifier + # + # + def UpdateIdentifierBelongsToFunction(self): + EdkLogger.verbose("Update 'BelongsToFunction' for Identifiers started ...") + + SqlCommand = """select ID, BelongsToFile, StartLine, EndLine from Function""" + Records = self.TblFunction.Exec(SqlCommand) + Data1 = [] + Data2 = [] + for Record in Records: + FunctionID = Record[0] + BelongsToFile = Record[1] + StartLine = Record[2] + EndLine = Record[3] + #Data1.append(("'file%s'" % BelongsToFile, FunctionID, BelongsToFile, StartLine, EndLine)) + #Data2.append(("'file%s'" % BelongsToFile, FunctionID, DataClass.MODEL_IDENTIFIER_FUNCTION_HEADER, BelongsToFile, DataClass.MODEL_IDENTIFIER_COMMENT, StartLine - 1)) + + SqlCommand = """Update Identifier%s set BelongsToFunction = %s where BelongsToFile = %s and StartLine > %s and EndLine < %s""" % \ + (BelongsToFile, FunctionID, BelongsToFile, StartLine, EndLine) + self.TblIdentifier.Exec(SqlCommand) + + SqlCommand = """Update Identifier%s set BelongsToFunction = %s, Model = %s where BelongsToFile = %s and Model = %s and EndLine = %s""" % \ + (BelongsToFile, FunctionID, DataClass.MODEL_IDENTIFIER_FUNCTION_HEADER, BelongsToFile, DataClass.MODEL_IDENTIFIER_COMMENT, StartLine - 1) + self.TblIdentifier.Exec(SqlCommand) +# # +# # Check whether an identifier belongs to a function +# # +# print Data1 +# SqlCommand = """Update ? set BelongsToFunction = ? where BelongsToFile = ? and StartLine > ? and EndLine < ?""" +# print SqlCommand +# EdkLogger.debug(4, "SqlCommand: %s" %SqlCommand) +# self.Cur.executemany(SqlCommand, Data1) +# +# # +# # Check whether the identifier is a function header +# # +# EdkLogger.debug(4, "For function headers ... ") +# SqlCommand = """Update ? set BelongsToFunction = ?, Model = ? where BelongsToFile = ? and Model = ? and EndLine = ?""" +# EdkLogger.debug(4, "SqlCommand: %s" %SqlCommand) +# self.Cur.executemany(SqlCommand, Data2) +# +# EdkLogger.verbose("Update 'BelongsToFunction' for Identifiers ... DONE") + + +## +# +# This acts like the main() function for the script, unless it is 'import'ed into another +# script. +# +if __name__ == '__main__': + EdkLogger.Initialize() + #EdkLogger.SetLevel(EdkLogger.VERBOSE) + EdkLogger.SetLevel(EdkLogger.DEBUG_0) + EdkLogger.verbose("Start at " + time.strftime('%H:%M:%S', time.localtime())) + + Db = Database(DATABASE_PATH) + Db.InitDatabase() + Db.QueryTable(Db.TblDataModel) + + identifier1 = DataClass.IdentifierClass(-1, '', '', "i''1", 'aaa', DataClass.MODEL_IDENTIFIER_COMMENT, 1, -1, 32, 43, 54, 43) + identifier2 = DataClass.IdentifierClass(-1, '', '', 'i1', 'aaa', DataClass.MODEL_IDENTIFIER_COMMENT, 1, -1, 15, 43, 20, 43) + identifier3 = DataClass.IdentifierClass(-1, '', '', 'i1', 'aaa', DataClass.MODEL_IDENTIFIER_COMMENT, 1, -1, 55, 43, 58, 43) + identifier4 = DataClass.IdentifierClass(-1, '', '', "i1'", 'aaa', DataClass.MODEL_IDENTIFIER_COMMENT, 1, -1, 77, 43, 88, 43) + fun1 = DataClass.FunctionClass(-1, '', '', 'fun1', '', 21, 2, 60, 45, 1, 23, 0, [], []) + file = DataClass.FileClass(-1, 'F1', 'c', 'C:\\', 'C:\\F1.exe', DataClass.MODEL_FILE_C, '2007-12-28', [fun1], [identifier1, identifier2, identifier3, identifier4], []) + Db.InsertOneFile(file) + Db.UpdateIdentifierBelongsToFunction() + + Db.QueryTable(Db.TblFile) + Db.QueryTable(Db.TblFunction) + Db.QueryTable(Db.TblPcd) + Db.QueryTable(Db.TblIdentifier) + + Db.Close() + EdkLogger.verbose("End at " + time.strftime('%H:%M:%S', time.localtime())) + |