2 # This file is used to create a database used by ECC tool
4 # Copyright (c) 2007 ~ 2008, Intel Corporation
5 # All rights reserved. This program and the accompanying materials
6 # are licensed and made available under the terms and conditions of the BSD License
7 # which accompanies this distribution. The full text of the license may be found at
8 # http://opensource.org/licenses/bsd-license.php
10 # THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
11 # WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
20 import Common
.EdkLogger
as EdkLogger
21 import CommonDataClass
.DataClass
as DataClass
23 from Table
.TableDataModel
import TableDataModel
24 from Table
.TableFile
import TableFile
25 from Table
.TableFunction
import TableFunction
26 from Table
.TablePcd
import TablePcd
27 from Table
.TableIdentifier
import TableIdentifier
28 from Table
.TableReport
import TableReport
29 from Table
.TableInf
import TableInf
30 from Table
.TableDec
import TableDec
31 from Table
.TableDsc
import TableDsc
32 from Table
.TableFdf
import TableFdf
37 DATABASE_PATH
= "Ecc.db"
41 # This class defined the ECC databse
42 # During the phase of initialization, the database will create all tables and
43 # insert all records of table DataModel
45 # @param object: Inherited from object class
46 # @param DbPath: A string for the path of the ECC database
48 # @var Conn: Connection of the ECC database
49 # @var Cur: Cursor of the connection
50 # @var TblDataModel: Local instance for TableDataModel
52 class Database(object):
53 def __init__(self
, DbPath
):
57 self
.TblDataModel
= None
59 self
.TblFunction
= None
60 self
.TblIdentifier
= None
68 ## Initialize ECC database
70 # 1. Delete all old existing tables
71 # 2. Create new tables
72 # 3. Initialize table DataModel
74 def InitDatabase(self
, NewDatabase
= True):
75 EdkLogger
.verbose("\nInitialize ECC database started ...")
77 # Drop all old existing tables
80 if os
.path
.exists(self
.DbPath
):
81 os
.remove(self
.DbPath
)
82 self
.Conn
= sqlite3
.connect(self
.DbPath
, isolation_level
= 'DEFERRED')
83 self
.Conn
.execute("PRAGMA page_size=4096")
84 self
.Conn
.execute("PRAGMA synchronous=OFF")
85 # to avoid non-ascii charater conversion error
86 self
.Conn
.text_factory
= str
87 self
.Cur
= self
.Conn
.cursor()
89 self
.TblDataModel
= TableDataModel(self
.Cur
)
90 self
.TblFile
= TableFile(self
.Cur
)
91 self
.TblFunction
= TableFunction(self
.Cur
)
92 self
.TblIdentifier
= TableIdentifier(self
.Cur
)
93 self
.TblPcd
= TablePcd(self
.Cur
)
94 self
.TblReport
= TableReport(self
.Cur
)
95 self
.TblInf
= TableInf(self
.Cur
)
96 self
.TblDec
= TableDec(self
.Cur
)
97 self
.TblDsc
= TableDsc(self
.Cur
)
98 self
.TblFdf
= TableFdf(self
.Cur
)
104 self
.TblDataModel
.Create()
105 self
.TblFile
.Create()
106 self
.TblFunction
.Create()
108 self
.TblReport
.Create()
115 # Init each table's ID
117 self
.TblDataModel
.InitID()
118 self
.TblFile
.InitID()
119 self
.TblFunction
.InitID()
121 self
.TblReport
.InitID()
128 # Initialize table DataModel
131 self
.TblDataModel
.InitTable()
133 EdkLogger
.verbose("Initialize ECC database ... DONE!")
137 # @param Table: The instance of the table to be queried
139 def QueryTable(self
, Table
):
142 ## Close entire database
145 # Close the connection and cursor
154 # Close connection and cursor
159 ## Insert one file information
161 # Insert one file's information to the database
162 # 1. Create a record in TableFile
163 # 2. Create functions one by one
164 # 2.1 Create variables of function one by one
165 # 2.2 Create pcds of function one by one
166 # 3. Create variables one by one
167 # 4. Create pcds one by one
169 def InsertOneFile(self
, File
):
171 # Insert a record for file
173 FileID
= self
.TblFile
.Insert(File
.Name
, File
.ExtName
, File
.Path
, File
.FullPath
, Model
= File
.Model
, TimeStamp
= File
.TimeStamp
)
174 IdTable
= TableIdentifier(self
.Cur
)
175 IdTable
.Table
= "Identifier%s" % FileID
179 # Insert function of file
181 for Function
in File
.FunctionList
:
182 FunctionID
= self
.TblFunction
.Insert(Function
.Header
, Function
.Modifier
, Function
.Name
, Function
.ReturnStatement
, \
183 Function
.StartLine
, Function
.StartColumn
, Function
.EndLine
, Function
.EndColumn
, \
184 Function
.BodyStartLine
, Function
.BodyStartColumn
, FileID
, \
185 Function
.FunNameStartLine
, Function
.FunNameStartColumn
)
187 # Insert Identifier of function
189 for Identifier
in Function
.IdentifierList
:
190 IdentifierID
= IdTable
.Insert(Identifier
.Modifier
, Identifier
.Type
, Identifier
.Name
, Identifier
.Value
, Identifier
.Model
, \
191 FileID
, FunctionID
, Identifier
.StartLine
, Identifier
.StartColumn
, Identifier
.EndLine
, Identifier
.EndColumn
)
193 # Insert Pcd of function
195 for Pcd
in Function
.PcdList
:
196 PcdID
= self
.TblPcd
.Insert(Pcd
.CName
, Pcd
.TokenSpaceGuidCName
, Pcd
.Token
, Pcd
.DatumType
, Pcd
.Model
, \
197 FileID
, FunctionID
, Pcd
.StartLine
, Pcd
.StartColumn
, Pcd
.EndLine
, Pcd
.EndColumn
)
199 # Insert Identifier of file
201 for Identifier
in File
.IdentifierList
:
202 IdentifierID
= IdTable
.Insert(Identifier
.Modifier
, Identifier
.Type
, Identifier
.Name
, Identifier
.Value
, Identifier
.Model
, \
203 FileID
, -1, Identifier
.StartLine
, Identifier
.StartColumn
, Identifier
.EndLine
, Identifier
.EndColumn
)
207 for Pcd
in File
.PcdList
:
208 PcdID
= self
.TblPcd
.Insert(Pcd
.CName
, Pcd
.TokenSpaceGuidCName
, Pcd
.Token
, Pcd
.DatumType
, Pcd
.Model
, \
209 FileID
, -1, Pcd
.StartLine
, Pcd
.StartColumn
, Pcd
.EndLine
, Pcd
.EndColumn
)
211 EdkLogger
.verbose("Insert information from file %s ... DONE!" % File
.FullPath
)
213 ## UpdateIdentifierBelongsToFunction
215 # Update the field "BelongsToFunction" for each Indentifier
218 def UpdateIdentifierBelongsToFunction_disabled(self
):
219 EdkLogger
.verbose("Update 'BelongsToFunction' for Identifiers started ...")
221 SqlCommand
= """select ID, BelongsToFile, StartLine, EndLine, Model from Identifier"""
222 EdkLogger
.debug(4, "SqlCommand: %s" %SqlCommand
)
223 self
.Cur
.execute(SqlCommand
)
224 Records
= self
.Cur
.fetchall()
225 for Record
in Records
:
226 IdentifierID
= Record
[0]
227 BelongsToFile
= Record
[1]
228 StartLine
= Record
[2]
233 # Check whether an identifier belongs to a function
235 EdkLogger
.debug(4, "For common identifiers ... ")
236 SqlCommand
= """select ID from Function
237 where StartLine < %s and EndLine > %s
238 and BelongsToFile = %s""" % (StartLine
, EndLine
, BelongsToFile
)
239 EdkLogger
.debug(4, "SqlCommand: %s" %SqlCommand
)
240 self
.Cur
.execute(SqlCommand
)
241 IDs
= self
.Cur
.fetchall()
243 SqlCommand
= """Update Identifier set BelongsToFunction = %s where ID = %s""" % (ID
[0], IdentifierID
)
244 EdkLogger
.debug(4, "SqlCommand: %s" %SqlCommand
)
245 self
.Cur
.execute(SqlCommand
)
248 # Check whether the identifier is a function header
250 EdkLogger
.debug(4, "For function headers ... ")
251 if Model
== DataClass
.MODEL_IDENTIFIER_COMMENT
:
252 SqlCommand
= """select ID from Function
253 where StartLine = %s + 1
254 and BelongsToFile = %s""" % (EndLine
, BelongsToFile
)
255 EdkLogger
.debug(4, "SqlCommand: %s" %SqlCommand
)
256 self
.Cur
.execute(SqlCommand
)
257 IDs
= self
.Cur
.fetchall()
259 SqlCommand
= """Update Identifier set BelongsToFunction = %s, Model = %s where ID = %s""" % (ID
[0], DataClass
.MODEL_IDENTIFIER_FUNCTION_HEADER
, IdentifierID
)
260 EdkLogger
.debug(4, "SqlCommand: %s" %SqlCommand
)
261 self
.Cur
.execute(SqlCommand
)
263 EdkLogger
.verbose("Update 'BelongsToFunction' for Identifiers ... DONE")
266 ## UpdateIdentifierBelongsToFunction
268 # Update the field "BelongsToFunction" for each Indentifier
271 def UpdateIdentifierBelongsToFunction(self
):
272 EdkLogger
.verbose("Update 'BelongsToFunction' for Identifiers started ...")
274 SqlCommand
= """select ID, BelongsToFile, StartLine, EndLine from Function"""
275 Records
= self
.TblFunction
.Exec(SqlCommand
)
278 for Record
in Records
:
279 FunctionID
= Record
[0]
280 BelongsToFile
= Record
[1]
281 StartLine
= Record
[2]
283 #Data1.append(("'file%s'" % BelongsToFile, FunctionID, BelongsToFile, StartLine, EndLine))
284 #Data2.append(("'file%s'" % BelongsToFile, FunctionID, DataClass.MODEL_IDENTIFIER_FUNCTION_HEADER, BelongsToFile, DataClass.MODEL_IDENTIFIER_COMMENT, StartLine - 1))
286 SqlCommand
= """Update Identifier%s set BelongsToFunction = %s where BelongsToFile = %s and StartLine > %s and EndLine < %s""" % \
287 (BelongsToFile
, FunctionID
, BelongsToFile
, StartLine
, EndLine
)
288 self
.TblIdentifier
.Exec(SqlCommand
)
290 SqlCommand
= """Update Identifier%s set BelongsToFunction = %s, Model = %s where BelongsToFile = %s and Model = %s and EndLine = %s""" % \
291 (BelongsToFile
, FunctionID
, DataClass
.MODEL_IDENTIFIER_FUNCTION_HEADER
, BelongsToFile
, DataClass
.MODEL_IDENTIFIER_COMMENT
, StartLine
- 1)
292 self
.TblIdentifier
.Exec(SqlCommand
)
294 # # Check whether an identifier belongs to a function
297 # SqlCommand = """Update ? set BelongsToFunction = ? where BelongsToFile = ? and StartLine > ? and EndLine < ?"""
299 # EdkLogger.debug(4, "SqlCommand: %s" %SqlCommand)
300 # self.Cur.executemany(SqlCommand, Data1)
303 # # Check whether the identifier is a function header
305 # EdkLogger.debug(4, "For function headers ... ")
306 # SqlCommand = """Update ? set BelongsToFunction = ?, Model = ? where BelongsToFile = ? and Model = ? and EndLine = ?"""
307 # EdkLogger.debug(4, "SqlCommand: %s" %SqlCommand)
308 # self.Cur.executemany(SqlCommand, Data2)
310 # EdkLogger.verbose("Update 'BelongsToFunction' for Identifiers ... DONE")
315 # This acts like the main() function for the script, unless it is 'import'ed into another
318 if __name__
== '__main__':
319 EdkLogger
.Initialize()
320 #EdkLogger.SetLevel(EdkLogger.VERBOSE)
321 EdkLogger
.SetLevel(EdkLogger
.DEBUG_0
)
322 EdkLogger
.verbose("Start at " + time
.strftime('%H:%M:%S', time
.localtime()))
324 Db
= Database(DATABASE_PATH
)
326 Db
.QueryTable(Db
.TblDataModel
)
328 identifier1
= DataClass
.IdentifierClass(-1, '', '', "i''1", 'aaa', DataClass
.MODEL_IDENTIFIER_COMMENT
, 1, -1, 32, 43, 54, 43)
329 identifier2
= DataClass
.IdentifierClass(-1, '', '', 'i1', 'aaa', DataClass
.MODEL_IDENTIFIER_COMMENT
, 1, -1, 15, 43, 20, 43)
330 identifier3
= DataClass
.IdentifierClass(-1, '', '', 'i1', 'aaa', DataClass
.MODEL_IDENTIFIER_COMMENT
, 1, -1, 55, 43, 58, 43)
331 identifier4
= DataClass
.IdentifierClass(-1, '', '', "i1'", 'aaa', DataClass
.MODEL_IDENTIFIER_COMMENT
, 1, -1, 77, 43, 88, 43)
332 fun1
= DataClass
.FunctionClass(-1, '', '', 'fun1', '', 21, 2, 60, 45, 1, 23, 0, [], [])
333 file = DataClass
.FileClass(-1, 'F1', 'c', 'C:\\', 'C:\\F1.exe', DataClass
.MODEL_FILE_C
, '2007-12-28', [fun1
], [identifier1
, identifier2
, identifier3
, identifier4
], [])
334 Db
.InsertOneFile(file)
335 Db
.UpdateIdentifierBelongsToFunction()
337 Db
.QueryTable(Db
.TblFile
)
338 Db
.QueryTable(Db
.TblFunction
)
339 Db
.QueryTable(Db
.TblPcd
)
340 Db
.QueryTable(Db
.TblIdentifier
)
343 EdkLogger
.verbose("End at " + time
.strftime('%H:%M:%S', time
.localtime()))