[mirror_edk2.git] / BaseTools / Source / Python / Ecc / Database.py

## @file\r
# This file is used to create a database used by ECC tool\r
#\r
# Copyright (c) 2007 - 2014, 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
from __future__ import absolute_import\r
import sqlite3\r
import Common.LongFilePathOs as os, time\r
\r
import Common.EdkLogger as EdkLogger\r
import CommonDataClass.DataClass as DataClass\r
\r
from Table.TableDataModel import TableDataModel\r
from Table.TableFile import TableFile\r
from Table.TableFunction import TableFunction\r
from Table.TablePcd import TablePcd\r
from Table.TableIdentifier import TableIdentifier\r
from Table.TableReport import TableReport\r
from .MetaFileWorkspace.MetaFileTable import ModuleTable\r
from .MetaFileWorkspace.MetaFileTable import PackageTable\r
from .MetaFileWorkspace.MetaFileTable import PlatformTable\r
from Table.TableFdf import TableFdf\r
\r
##\r
# Static definitions\r
#\r
DATABASE_PATH = "Ecc.db"\r
\r
## Database\r
#\r
# This class defined the ECC databse\r
# During the phase of initialization, the database will create all tables and\r
# insert all records of table DataModel\r
#\r
# @param object:    Inherited from object class\r
# @param DbPath:    A string for the path of the ECC database\r
#\r
# @var Conn:        Connection of the ECC database\r
# @var Cur:         Cursor of the connection\r
# @var TblDataModel:  Local instance for TableDataModel\r
#\r
class Database(object):\r
    def __init__(self, DbPath):\r
        self.DbPath = DbPath\r
        self.Conn = None\r
        self.Cur = None\r
        self.TblDataModel = None\r
        self.TblFile = None\r
        self.TblFunction = None\r
        self.TblIdentifier = None\r
        self.TblPcd = None\r
        self.TblReport = None\r
        self.TblInf = None\r
        self.TblDec = None\r
        self.TblDsc = None\r
        self.TblFdf = None\r
\r
    ## Initialize ECC database\r
    #\r
    # 1. Delete all old existing tables\r
    # 2. Create new tables\r
    # 3. Initialize table DataModel\r
    #\r
    def InitDatabase(self, NewDatabase = True):\r
        EdkLogger.verbose("\nInitialize ECC database started ...")\r
        #\r
        # Drop all old existing tables\r
        #\r
        if NewDatabase:\r
            if os.path.exists(self.DbPath):\r
                os.remove(self.DbPath)\r
        self.Conn = sqlite3.connect(self.DbPath, isolation_level = 'DEFERRED')\r
        self.Conn.execute("PRAGMA page_size=4096")\r
        self.Conn.execute("PRAGMA synchronous=OFF")\r
        # to avoid non-ascii charater conversion error\r
        self.Conn.text_factory = str\r
        self.Cur = self.Conn.cursor()\r
\r
        self.TblDataModel = TableDataModel(self.Cur)\r
        self.TblFile = TableFile(self.Cur)\r
        self.TblFunction = TableFunction(self.Cur)\r
        self.TblIdentifier = TableIdentifier(self.Cur)\r
        self.TblPcd = TablePcd(self.Cur)\r
        self.TblReport = TableReport(self.Cur)\r
        self.TblInf = ModuleTable(self.Cur)\r
        self.TblDec = PackageTable(self.Cur)\r
        self.TblDsc = PlatformTable(self.Cur)\r
        self.TblFdf = TableFdf(self.Cur)\r
\r
        #\r
        # Create new tables\r
        #\r
        if NewDatabase:\r
            self.TblDataModel.Create()\r
            self.TblFile.Create()\r
            self.TblFunction.Create()\r
            self.TblPcd.Create()\r
            self.TblReport.Create()\r
            self.TblInf.Create()\r
            self.TblDec.Create()\r
            self.TblDsc.Create()\r
            self.TblFdf.Create()\r
\r
        #\r
        # Init each table's ID\r
        #\r
        self.TblDataModel.InitID()\r
        self.TblFile.InitID()\r
        self.TblFunction.InitID()\r
        self.TblPcd.InitID()\r
        self.TblReport.InitID()\r
        self.TblInf.InitID()\r
        self.TblDec.InitID()\r
        self.TblDsc.InitID()\r
        self.TblFdf.InitID()\r
\r
        #\r
        # Initialize table DataModel\r
        #\r
        if NewDatabase:\r
            self.TblDataModel.InitTable()\r
\r
        EdkLogger.verbose("Initialize ECC database ... DONE!")\r
\r
    ## Query a table\r
    #\r
    # @param Table:  The instance of the table to be queried\r
    #\r
    def QueryTable(self, Table):\r
        Table.Query()\r
\r
    ## Close entire database\r
    #\r
    # Commit all first\r
    # Close the connection and cursor\r
    #\r
    def Close(self):\r
        #\r
        # Commit to file\r
        #\r
        self.Conn.commit()\r
\r
        #\r
        # Close connection and cursor\r
        #\r
        self.Cur.close()\r
        self.Conn.close()\r
\r
    ## Insert one file information\r
    #\r
    # Insert one file's information to the database\r
    # 1. Create a record in TableFile\r
    # 2. Create functions one by one\r
    #    2.1 Create variables of function one by one\r
    #    2.2 Create pcds of function one by one\r
    # 3. Create variables one by one\r
    # 4. Create pcds one by one\r
    #\r
    def InsertOneFile(self, File):\r
        #\r
        # Insert a record for file\r
        #\r
        FileID = self.TblFile.Insert(File.Name, File.ExtName, File.Path, File.FullPath, Model = File.Model, TimeStamp = File.TimeStamp)\r
\r
        if File.Model == DataClass.MODEL_FILE_C or File.Model == DataClass.MODEL_FILE_H:\r
            IdTable = TableIdentifier(self.Cur)\r
            IdTable.Table = "Identifier%s" % FileID\r
            IdTable.Create()\r
            #\r
            # Insert function of file\r
            #\r
            for Function in File.FunctionList:\r
                FunctionID = self.TblFunction.Insert(Function.Header, Function.Modifier, Function.Name, Function.ReturnStatement, \\r
                                        Function.StartLine, Function.StartColumn, Function.EndLine, Function.EndColumn, \\r
                                        Function.BodyStartLine, Function.BodyStartColumn, FileID, \\r
                                        Function.FunNameStartLine, Function.FunNameStartColumn)\r
                #\r
                # Insert Identifier of function\r
                #\r
                for Identifier in Function.IdentifierList:\r
                    IdentifierID = IdTable.Insert(Identifier.Modifier, Identifier.Type, Identifier.Name, Identifier.Value, Identifier.Model, \\r
                                            FileID, FunctionID, Identifier.StartLine, Identifier.StartColumn, Identifier.EndLine, Identifier.EndColumn)\r
                #\r
                # Insert Pcd of function\r
                #\r
                for Pcd in Function.PcdList:\r
                    PcdID = self.TblPcd.Insert(Pcd.CName, Pcd.TokenSpaceGuidCName, Pcd.Token, Pcd.DatumType, Pcd.Model, \\r
                                       FileID, FunctionID, Pcd.StartLine, Pcd.StartColumn, Pcd.EndLine, Pcd.EndColumn)\r
            #\r
            # Insert Identifier of file\r
            #\r
            for Identifier in File.IdentifierList:\r
                IdentifierID = IdTable.Insert(Identifier.Modifier, Identifier.Type, Identifier.Name, Identifier.Value, Identifier.Model, \\r
                                        FileID, -1, Identifier.StartLine, Identifier.StartColumn, Identifier.EndLine, Identifier.EndColumn)\r
            #\r
            # Insert Pcd of file\r
            #\r
            for Pcd in File.PcdList:\r
                PcdID = self.TblPcd.Insert(Pcd.CName, Pcd.TokenSpaceGuidCName, Pcd.Token, Pcd.DatumType, Pcd.Model, \\r
                                   FileID, -1, Pcd.StartLine, Pcd.StartColumn, Pcd.EndLine, Pcd.EndColumn)\r
\r
        EdkLogger.verbose("Insert information from file %s ... DONE!" % File.FullPath)\r
\r
    ## UpdateIdentifierBelongsToFunction\r
    #\r
    # Update the field "BelongsToFunction" for each Indentifier\r
    #\r
    #\r
    def UpdateIdentifierBelongsToFunction_disabled(self):\r
        EdkLogger.verbose("Update 'BelongsToFunction' for Identifiers started ...")\r
\r
        SqlCommand = """select ID, BelongsToFile, StartLine, EndLine, Model from Identifier"""\r
        EdkLogger.debug(4, "SqlCommand: %s" %SqlCommand)\r
        self.Cur.execute(SqlCommand)\r
        Records = self.Cur.fetchall()\r
        for Record in Records:\r
            IdentifierID = Record[0]\r
            BelongsToFile = Record[1]\r
            StartLine = Record[2]\r
            EndLine = Record[3]\r
            Model = Record[4]\r
\r
            #\r
            # Check whether an identifier belongs to a function\r
            #\r
            EdkLogger.debug(4, "For common identifiers ... ")\r
            SqlCommand = """select ID from Function\r
                        where StartLine < %s and EndLine > %s\r
                        and BelongsToFile = %s""" % (StartLine, EndLine, BelongsToFile)\r
            EdkLogger.debug(4, "SqlCommand: %s" %SqlCommand)\r
            self.Cur.execute(SqlCommand)\r
            IDs = self.Cur.fetchall()\r
            for ID in IDs:\r
                SqlCommand = """Update Identifier set BelongsToFunction = %s where ID = %s""" % (ID[0], IdentifierID)\r
                EdkLogger.debug(4, "SqlCommand: %s" %SqlCommand)\r
                self.Cur.execute(SqlCommand)\r
\r
            #\r
            # Check whether the identifier is a function header\r
            #\r
            EdkLogger.debug(4, "For function headers ... ")\r
            if Model == DataClass.MODEL_IDENTIFIER_COMMENT:\r
                SqlCommand = """select ID from Function\r
                        where StartLine = %s + 1\r
                        and BelongsToFile = %s""" % (EndLine, BelongsToFile)\r
                EdkLogger.debug(4, "SqlCommand: %s" %SqlCommand)\r
                self.Cur.execute(SqlCommand)\r
                IDs = self.Cur.fetchall()\r
                for ID in IDs:\r
                    SqlCommand = """Update Identifier set BelongsToFunction = %s, Model = %s where ID = %s""" % (ID[0], DataClass.MODEL_IDENTIFIER_FUNCTION_HEADER, IdentifierID)\r
                    EdkLogger.debug(4, "SqlCommand: %s" %SqlCommand)\r
                    self.Cur.execute(SqlCommand)\r
\r
        EdkLogger.verbose("Update 'BelongsToFunction' for Identifiers ... DONE")\r
\r
\r
    ## UpdateIdentifierBelongsToFunction\r
    #\r
    # Update the field "BelongsToFunction" for each Indentifier\r
    #\r
    #\r
    def UpdateIdentifierBelongsToFunction(self):\r
        EdkLogger.verbose("Update 'BelongsToFunction' for Identifiers started ...")\r
\r
        SqlCommand = """select ID, BelongsToFile, StartLine, EndLine from Function"""\r
        Records = self.TblFunction.Exec(SqlCommand)\r
        Data1 = []\r
        Data2 = []\r
        for Record in Records:\r
            FunctionID = Record[0]\r
            BelongsToFile = Record[1]\r
            StartLine = Record[2]\r
            EndLine = Record[3]\r
            #Data1.append(("'file%s'" % BelongsToFile, FunctionID, BelongsToFile, StartLine, EndLine))\r
            #Data2.append(("'file%s'" % BelongsToFile, FunctionID, DataClass.MODEL_IDENTIFIER_FUNCTION_HEADER, BelongsToFile, DataClass.MODEL_IDENTIFIER_COMMENT, StartLine - 1))\r
\r
            SqlCommand = """Update Identifier%s set BelongsToFunction = %s where BelongsToFile = %s and StartLine > %s and EndLine < %s""" % \\r
                        (BelongsToFile, FunctionID, BelongsToFile, StartLine, EndLine)\r
            self.TblIdentifier.Exec(SqlCommand)\r
\r
            SqlCommand = """Update Identifier%s set BelongsToFunction = %s, Model = %s where BelongsToFile = %s and Model = %s and EndLine = %s""" % \\r
                         (BelongsToFile, FunctionID, DataClass.MODEL_IDENTIFIER_FUNCTION_HEADER, BelongsToFile, DataClass.MODEL_IDENTIFIER_COMMENT, StartLine - 1)\r
            self.TblIdentifier.Exec(SqlCommand)\r
#       #\r
#       # Check whether an identifier belongs to a function\r
#       #\r
#       print Data1\r
#       SqlCommand = """Update ? set BelongsToFunction = ? where BelongsToFile = ? and StartLine > ? and EndLine < ?"""\r
#       print SqlCommand\r
#       EdkLogger.debug(4, "SqlCommand: %s" %SqlCommand)\r
#       self.Cur.executemany(SqlCommand, Data1)\r
#\r
#       #\r
#       # Check whether the identifier is a function header\r
#       #\r
#       EdkLogger.debug(4, "For function headers ... ")\r
#       SqlCommand = """Update ? set BelongsToFunction = ?, Model = ? where BelongsToFile = ? and Model = ? and EndLine = ?"""\r
#       EdkLogger.debug(4, "SqlCommand: %s" %SqlCommand)\r
#       self.Cur.executemany(SqlCommand, Data2)\r
#\r
#       EdkLogger.verbose("Update 'BelongsToFunction' for Identifiers ... DONE")\r
\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
    EdkLogger.Initialize()\r
    #EdkLogger.SetLevel(EdkLogger.VERBOSE)\r
    EdkLogger.SetLevel(EdkLogger.DEBUG_0)\r
    EdkLogger.verbose("Start at " + time.strftime('%H:%M:%S', time.localtime()))\r
\r
    Db = Database(DATABASE_PATH)\r
    Db.InitDatabase()\r
    Db.QueryTable(Db.TblDataModel)\r
\r
    identifier1 = DataClass.IdentifierClass(-1, '', '', "i''1", 'aaa', DataClass.MODEL_IDENTIFIER_COMMENT, 1, -1, 32,  43,  54,  43)\r
    identifier2 = DataClass.IdentifierClass(-1, '', '', 'i1', 'aaa', DataClass.MODEL_IDENTIFIER_COMMENT, 1, -1, 15,  43,  20,  43)\r
    identifier3 = DataClass.IdentifierClass(-1, '', '', 'i1', 'aaa', DataClass.MODEL_IDENTIFIER_COMMENT, 1, -1, 55,  43,  58,  43)\r
    identifier4 = DataClass.IdentifierClass(-1, '', '', "i1'", 'aaa', DataClass.MODEL_IDENTIFIER_COMMENT, 1, -1, 77,  43,  88,  43)\r
    fun1 = DataClass.FunctionClass(-1, '', '', 'fun1', '', 21, 2, 60,  45, 1, 23, 0, [], [])\r
    file = DataClass.FileClass(-1, 'F1', 'c', 'C:\\', 'C:\\F1.exe', DataClass.MODEL_FILE_C, '2007-12-28', [fun1], [identifier1, identifier2, identifier3, identifier4], [])\r
    Db.InsertOneFile(file)\r
    Db.UpdateIdentifierBelongsToFunction()\r
\r
    Db.QueryTable(Db.TblFile)\r
    Db.QueryTable(Db.TblFunction)\r
    Db.QueryTable(Db.TblPcd)\r
    Db.QueryTable(Db.TblIdentifier)\r
\r
    Db.Close()\r
    EdkLogger.verbose("End at " + time.strftime('%H:%M:%S', time.localtime()))\r
\r
Commit	Line	Data
30fdf114 LG	1	## @file\r
	2	# This file is used to create a database used by ECC tool\r
	3	#\r
1be2ed90	4	# Copyright (c) 2007 - 2014, Intel Corporation. All rights reserved.<BR>\r
40d841f6	5	# This program and the accompanying materials\r
30fdf114 LG	6	# are licensed and made available under the terms and conditions of the BSD License\r
	7	# which accompanies this distribution. The full text of the license may be found at\r
	8	# http://opensource.org/licenses/bsd-license.php\r
	9	#\r
	10	# THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,\r
	11	# WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.\r
	12	#\r
	13	\r
	14	##\r
	15	# Import Modules\r
	16	#\r
b6f6b636	17	from __future__ import absolute_import\r
30fdf114	18	import sqlite3\r
1be2ed90	19	import Common.LongFilePathOs as os, time\r
30fdf114 LG	20	\r
	21	import Common.EdkLogger as EdkLogger\r
	22	import CommonDataClass.DataClass as DataClass\r
	23	\r
	24	from Table.TableDataModel import TableDataModel\r
	25	from Table.TableFile import TableFile\r
	26	from Table.TableFunction import TableFunction\r
	27	from Table.TablePcd import TablePcd\r
	28	from Table.TableIdentifier import TableIdentifier\r
	29	from Table.TableReport import TableReport\r
b6f6b636 GL	30	from .MetaFileWorkspace.MetaFileTable import ModuleTable\r
	31	from .MetaFileWorkspace.MetaFileTable import PackageTable\r
	32	from .MetaFileWorkspace.MetaFileTable import PlatformTable\r
30fdf114 LG	33	from Table.TableFdf import TableFdf\r
	34	\r
	35	##\r
	36	# Static definitions\r
	37	#\r
	38	DATABASE_PATH = "Ecc.db"\r
	39	\r
	40	## Database\r
	41	#\r
	42	# This class defined the ECC databse\r
	43	# During the phase of initialization, the database will create all tables and\r
	44	# insert all records of table DataModel\r
e56468c0	45	#\r
30fdf114 LG	46	# @param object: Inherited from object class\r
	47	# @param DbPath: A string for the path of the ECC database\r
	48	#\r
	49	# @var Conn: Connection of the ECC database\r
	50	# @var Cur: Cursor of the connection\r
	51	# @var TblDataModel: Local instance for TableDataModel\r
	52	#\r
	53	class Database(object):\r
	54	def __init__(self, DbPath):\r
	55	self.DbPath = DbPath\r
	56	self.Conn = None\r
	57	self.Cur = None\r
	58	self.TblDataModel = None\r
	59	self.TblFile = None\r
	60	self.TblFunction = None\r
	61	self.TblIdentifier = None\r
	62	self.TblPcd = None\r
	63	self.TblReport = None\r
	64	self.TblInf = None\r
	65	self.TblDec = None\r
	66	self.TblDsc = None\r
	67	self.TblFdf = None\r
e56468c0	68	\r
30fdf114 LG	69	## Initialize ECC database\r
	70	#\r
	71	# 1. Delete all old existing tables\r
	72	# 2. Create new tables\r
	73	# 3. Initialize table DataModel\r
	74	#\r
	75	def InitDatabase(self, NewDatabase = True):\r
	76	EdkLogger.verbose("\nInitialize ECC database started ...")\r
	77	#\r
	78	# Drop all old existing tables\r
	79	#\r
	80	if NewDatabase:\r
	81	if os.path.exists(self.DbPath):\r
	82	os.remove(self.DbPath)\r
	83	self.Conn = sqlite3.connect(self.DbPath, isolation_level = 'DEFERRED')\r
	84	self.Conn.execute("PRAGMA page_size=4096")\r
	85	self.Conn.execute("PRAGMA synchronous=OFF")\r
	86	# to avoid non-ascii charater conversion error\r
	87	self.Conn.text_factory = str\r
	88	self.Cur = self.Conn.cursor()\r
e56468c0	89	\r
30fdf114 LG	90	self.TblDataModel = TableDataModel(self.Cur)\r
	91	self.TblFile = TableFile(self.Cur)\r
	92	self.TblFunction = TableFunction(self.Cur)\r
	93	self.TblIdentifier = TableIdentifier(self.Cur)\r
	94	self.TblPcd = TablePcd(self.Cur)\r
	95	self.TblReport = TableReport(self.Cur)\r
d0acc87a LG	96	self.TblInf = ModuleTable(self.Cur)\r
	97	self.TblDec = PackageTable(self.Cur)\r
	98	self.TblDsc = PlatformTable(self.Cur)\r
30fdf114	99	self.TblFdf = TableFdf(self.Cur)\r
e56468c0	100	\r
30fdf114 LG	101	#\r
	102	# Create new tables\r
	103	#\r
	104	if NewDatabase:\r
	105	self.TblDataModel.Create()\r
	106	self.TblFile.Create()\r
	107	self.TblFunction.Create()\r
	108	self.TblPcd.Create()\r
	109	self.TblReport.Create()\r
	110	self.TblInf.Create()\r
	111	self.TblDec.Create()\r
	112	self.TblDsc.Create()\r
	113	self.TblFdf.Create()\r
e56468c0	114	\r
30fdf114 LG	115	#\r
	116	# Init each table's ID\r
	117	#\r
	118	self.TblDataModel.InitID()\r
	119	self.TblFile.InitID()\r
	120	self.TblFunction.InitID()\r
	121	self.TblPcd.InitID()\r
	122	self.TblReport.InitID()\r
	123	self.TblInf.InitID()\r
	124	self.TblDec.InitID()\r
	125	self.TblDsc.InitID()\r
	126	self.TblFdf.InitID()\r
e56468c0	127	\r
30fdf114 LG	128	#\r
	129	# Initialize table DataModel\r
	130	#\r
	131	if NewDatabase:\r
	132	self.TblDataModel.InitTable()\r
e56468c0	133	\r
30fdf114 LG	134	EdkLogger.verbose("Initialize ECC database ... DONE!")\r
	135	\r
	136	## Query a table\r
	137	#\r
	138	# @param Table: The instance of the table to be queried\r
	139	#\r
	140	def QueryTable(self, Table):\r
	141	Table.Query()\r
e56468c0	142	\r
30fdf114 LG	143	## Close entire database\r
	144	#\r
	145	# Commit all first\r
	146	# Close the connection and cursor\r
	147	#\r
	148	def Close(self):\r
	149	#\r
	150	# Commit to file\r
e56468c0	151	#\r
30fdf114	152	self.Conn.commit()\r
e56468c0	153	\r
30fdf114 LG	154	#\r
	155	# Close connection and cursor\r
	156	#\r
	157	self.Cur.close()\r
	158	self.Conn.close()\r
e56468c0	159	\r
30fdf114 LG	160	## Insert one file information\r
	161	#\r
	162	# Insert one file's information to the database\r
	163	# 1. Create a record in TableFile\r
	164	# 2. Create functions one by one\r
	165	# 2.1 Create variables of function one by one\r
	166	# 2.2 Create pcds of function one by one\r
	167	# 3. Create variables one by one\r
	168	# 4. Create pcds one by one\r
	169	#\r
	170	def InsertOneFile(self, File):\r
	171	#\r
	172	# Insert a record for file\r
	173	#\r
	174	FileID = self.TblFile.Insert(File.Name, File.ExtName, File.Path, File.FullPath, Model = File.Model, TimeStamp = File.TimeStamp)\r
30fdf114	175	\r
e56468c0	176	if File.Model == DataClass.MODEL_FILE_C or File.Model == DataClass.MODEL_FILE_H:\r
	177	IdTable = TableIdentifier(self.Cur)\r
	178	IdTable.Table = "Identifier%s" % FileID\r
	179	IdTable.Create()\r
	180	#\r
	181	# Insert function of file\r
	182	#\r
	183	for Function in File.FunctionList:\r
	184	FunctionID = self.TblFunction.Insert(Function.Header, Function.Modifier, Function.Name, Function.ReturnStatement, \\r
	185	Function.StartLine, Function.StartColumn, Function.EndLine, Function.EndColumn, \\r
	186	Function.BodyStartLine, Function.BodyStartColumn, FileID, \\r
	187	Function.FunNameStartLine, Function.FunNameStartColumn)\r
	188	#\r
	189	# Insert Identifier of function\r
	190	#\r
	191	for Identifier in Function.IdentifierList:\r
	192	IdentifierID = IdTable.Insert(Identifier.Modifier, Identifier.Type, Identifier.Name, Identifier.Value, Identifier.Model, \\r
	193	FileID, FunctionID, Identifier.StartLine, Identifier.StartColumn, Identifier.EndLine, Identifier.EndColumn)\r
	194	#\r
	195	# Insert Pcd of function\r
	196	#\r
	197	for Pcd in Function.PcdList:\r
	198	PcdID = self.TblPcd.Insert(Pcd.CName, Pcd.TokenSpaceGuidCName, Pcd.Token, Pcd.DatumType, Pcd.Model, \\r
	199	FileID, FunctionID, Pcd.StartLine, Pcd.StartColumn, Pcd.EndLine, Pcd.EndColumn)\r
30fdf114	200	#\r
e56468c0	201	# Insert Identifier of file\r
30fdf114	202	#\r
e56468c0	203	for Identifier in File.IdentifierList:\r
30fdf114	204	IdentifierID = IdTable.Insert(Identifier.Modifier, Identifier.Type, Identifier.Name, Identifier.Value, Identifier.Model, \\r
e56468c0	205	FileID, -1, Identifier.StartLine, Identifier.StartColumn, Identifier.EndLine, Identifier.EndColumn)\r
30fdf114	206	#\r
e56468c0	207	# Insert Pcd of file\r
30fdf114	208	#\r
e56468c0	209	for Pcd in File.PcdList:\r
30fdf114	210	PcdID = self.TblPcd.Insert(Pcd.CName, Pcd.TokenSpaceGuidCName, Pcd.Token, Pcd.DatumType, Pcd.Model, \\r
e56468c0	211	FileID, -1, Pcd.StartLine, Pcd.StartColumn, Pcd.EndLine, Pcd.EndColumn)\r
e56468c0	212	\r
30fdf114 LG	213	EdkLogger.verbose("Insert information from file %s ... DONE!" % File.FullPath)\r
	214	\r
	215	## UpdateIdentifierBelongsToFunction\r
	216	#\r
	217	# Update the field "BelongsToFunction" for each Indentifier\r
	218	#\r
	219	#\r
	220	def UpdateIdentifierBelongsToFunction_disabled(self):\r
	221	EdkLogger.verbose("Update 'BelongsToFunction' for Identifiers started ...")\r
e56468c0	222	\r
30fdf114 LG	223	SqlCommand = """select ID, BelongsToFile, StartLine, EndLine, Model from Identifier"""\r
	224	EdkLogger.debug(4, "SqlCommand: %s" %SqlCommand)\r
	225	self.Cur.execute(SqlCommand)\r
	226	Records = self.Cur.fetchall()\r
	227	for Record in Records:\r
	228	IdentifierID = Record[0]\r
	229	BelongsToFile = Record[1]\r
	230	StartLine = Record[2]\r
	231	EndLine = Record[3]\r
	232	Model = Record[4]\r
	233	\r
	234	#\r
	235	# Check whether an identifier belongs to a function\r
	236	#\r
	237	EdkLogger.debug(4, "For common identifiers ... ")\r
e56468c0	238	SqlCommand = """select ID from Function\r
30fdf114 LG	239	where StartLine < %s and EndLine > %s\r
	240	and BelongsToFile = %s""" % (StartLine, EndLine, BelongsToFile)\r
	241	EdkLogger.debug(4, "SqlCommand: %s" %SqlCommand)\r
	242	self.Cur.execute(SqlCommand)\r
	243	IDs = self.Cur.fetchall()\r
	244	for ID in IDs:\r
	245	SqlCommand = """Update Identifier set BelongsToFunction = %s where ID = %s""" % (ID[0], IdentifierID)\r
	246	EdkLogger.debug(4, "SqlCommand: %s" %SqlCommand)\r
	247	self.Cur.execute(SqlCommand)\r
e56468c0	248	\r
30fdf114 LG	249	#\r
	250	# Check whether the identifier is a function header\r
	251	#\r
e56468c0	252	EdkLogger.debug(4, "For function headers ... ")\r
30fdf114	253	if Model == DataClass.MODEL_IDENTIFIER_COMMENT:\r
e56468c0	254	SqlCommand = """select ID from Function\r
30fdf114 LG	255	where StartLine = %s + 1\r
	256	and BelongsToFile = %s""" % (EndLine, BelongsToFile)\r
	257	EdkLogger.debug(4, "SqlCommand: %s" %SqlCommand)\r
	258	self.Cur.execute(SqlCommand)\r
	259	IDs = self.Cur.fetchall()\r
	260	for ID in IDs:\r
	261	SqlCommand = """Update Identifier set BelongsToFunction = %s, Model = %s where ID = %s""" % (ID[0], DataClass.MODEL_IDENTIFIER_FUNCTION_HEADER, IdentifierID)\r
	262	EdkLogger.debug(4, "SqlCommand: %s" %SqlCommand)\r
	263	self.Cur.execute(SqlCommand)\r
e56468c0	264	\r
30fdf114 LG	265	EdkLogger.verbose("Update 'BelongsToFunction' for Identifiers ... DONE")\r
	266	\r
	267	\r
	268	## UpdateIdentifierBelongsToFunction\r
	269	#\r
	270	# Update the field "BelongsToFunction" for each Indentifier\r
	271	#\r
	272	#\r
	273	def UpdateIdentifierBelongsToFunction(self):\r
	274	EdkLogger.verbose("Update 'BelongsToFunction' for Identifiers started ...")\r
e56468c0	275	\r
30fdf114 LG	276	SqlCommand = """select ID, BelongsToFile, StartLine, EndLine from Function"""\r
	277	Records = self.TblFunction.Exec(SqlCommand)\r
	278	Data1 = []\r
	279	Data2 = []\r
	280	for Record in Records:\r
	281	FunctionID = Record[0]\r
	282	BelongsToFile = Record[1]\r
	283	StartLine = Record[2]\r
	284	EndLine = Record[3]\r
	285	#Data1.append(("'file%s'" % BelongsToFile, FunctionID, BelongsToFile, StartLine, EndLine))\r
	286	#Data2.append(("'file%s'" % BelongsToFile, FunctionID, DataClass.MODEL_IDENTIFIER_FUNCTION_HEADER, BelongsToFile, DataClass.MODEL_IDENTIFIER_COMMENT, StartLine - 1))\r
	287	\r
	288	SqlCommand = """Update Identifier%s set BelongsToFunction = %s where BelongsToFile = %s and StartLine > %s and EndLine < %s""" % \\r
	289	(BelongsToFile, FunctionID, BelongsToFile, StartLine, EndLine)\r
	290	self.TblIdentifier.Exec(SqlCommand)\r
	291	\r
	292	SqlCommand = """Update Identifier%s set BelongsToFunction = %s, Model = %s where BelongsToFile = %s and Model = %s and EndLine = %s""" % \\r
	293	(BelongsToFile, FunctionID, DataClass.MODEL_IDENTIFIER_FUNCTION_HEADER, BelongsToFile, DataClass.MODEL_IDENTIFIER_COMMENT, StartLine - 1)\r
	294	self.TblIdentifier.Exec(SqlCommand)\r
	295	# #\r
	296	# # Check whether an identifier belongs to a function\r
	297	# #\r
	298	# print Data1\r
	299	# SqlCommand = """Update ? set BelongsToFunction = ? where BelongsToFile = ? and StartLine > ? and EndLine < ?"""\r
	300	# print SqlCommand\r
	301	# EdkLogger.debug(4, "SqlCommand: %s" %SqlCommand)\r
	302	# self.Cur.executemany(SqlCommand, Data1)\r
	303	#\r
	304	# #\r
	305	# # Check whether the identifier is a function header\r
	306	# #\r
	307	# EdkLogger.debug(4, "For function headers ... ")\r
	308	# SqlCommand = """Update ? set BelongsToFunction = ?, Model = ? where BelongsToFile = ? and Model = ? and EndLine = ?"""\r
	309	# EdkLogger.debug(4, "SqlCommand: %s" %SqlCommand)\r
	310	# self.Cur.executemany(SqlCommand, Data2)\r
	311	#\r
	312	# EdkLogger.verbose("Update 'BelongsToFunction' for Identifiers ... DONE")\r
e56468c0	313	\r
30fdf114 LG	314	\r
	315	##\r
	316	#\r
	317	# This acts like the main() function for the script, unless it is 'import'ed into another\r
	318	# script.\r
	319	#\r
	320	if __name__ == '__main__':\r
	321	EdkLogger.Initialize()\r
	322	#EdkLogger.SetLevel(EdkLogger.VERBOSE)\r
	323	EdkLogger.SetLevel(EdkLogger.DEBUG_0)\r
	324	EdkLogger.verbose("Start at " + time.strftime('%H:%M:%S', time.localtime()))\r
e56468c0	325	\r
30fdf114 LG	326	Db = Database(DATABASE_PATH)\r
	327	Db.InitDatabase()\r
	328	Db.QueryTable(Db.TblDataModel)\r
e56468c0	329	\r
30fdf114 LG	330	identifier1 = DataClass.IdentifierClass(-1, '', '', "i''1", 'aaa', DataClass.MODEL_IDENTIFIER_COMMENT, 1, -1, 32, 43, 54, 43)\r
	331	identifier2 = DataClass.IdentifierClass(-1, '', '', 'i1', 'aaa', DataClass.MODEL_IDENTIFIER_COMMENT, 1, -1, 15, 43, 20, 43)\r
	332	identifier3 = DataClass.IdentifierClass(-1, '', '', 'i1', 'aaa', DataClass.MODEL_IDENTIFIER_COMMENT, 1, -1, 55, 43, 58, 43)\r
	333	identifier4 = DataClass.IdentifierClass(-1, '', '', "i1'", 'aaa', DataClass.MODEL_IDENTIFIER_COMMENT, 1, -1, 77, 43, 88, 43)\r
	334	fun1 = DataClass.FunctionClass(-1, '', '', 'fun1', '', 21, 2, 60, 45, 1, 23, 0, [], [])\r
	335	file = DataClass.FileClass(-1, 'F1', 'c', 'C:\\', 'C:\\F1.exe', DataClass.MODEL_FILE_C, '2007-12-28', [fun1], [identifier1, identifier2, identifier3, identifier4], [])\r
	336	Db.InsertOneFile(file)\r
	337	Db.UpdateIdentifierBelongsToFunction()\r
e56468c0	338	\r
30fdf114 LG	339	Db.QueryTable(Db.TblFile)\r
	340	Db.QueryTable(Db.TblFunction)\r
	341	Db.QueryTable(Db.TblPcd)\r
	342	Db.QueryTable(Db.TblIdentifier)\r
e56468c0	343	\r
30fdf114 LG	344	Db.Close()\r
30fdf114 LG	345	EdkLogger.verbose("End at " + time.strftime('%H:%M:%S', time.localtime()))\r
e56468c0	346	\r