2 # This file is used to create a database used by ECC tool
4 # Copyright (c) 2007 - 2014, Intel Corporation. All rights reserved.<BR>
5 # 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.
17 from __future__
import absolute_import
19 import Common
.LongFilePathOs
as os
, time
21 import Common
.EdkLogger
as EdkLogger
22 import CommonDataClass
.DataClass
as DataClass
24 from Table
.TableDataModel
import TableDataModel
25 from Table
.TableFile
import TableFile
26 from Table
.TableFunction
import TableFunction
27 from Table
.TablePcd
import TablePcd
28 from Table
.TableIdentifier
import TableIdentifier
29 from Table
.TableReport
import TableReport
30 from Ecc
.MetaFileWorkspace
.MetaFileTable
import ModuleTable
31 from Ecc
.MetaFileWorkspace
.MetaFileTable
import PackageTable
32 from Ecc
.MetaFileWorkspace
.MetaFileTable
import PlatformTable
33 from Table
.TableFdf
import TableFdf
38 DATABASE_PATH
= "Ecc.db"
42 # This class defined the ECC database
43 # During the phase of initialization, the database will create all tables and
44 # insert all records of table DataModel
46 # @param object: Inherited from object class
47 # @param DbPath: A string for the path of the ECC database
49 # @var Conn: Connection of the ECC database
50 # @var Cur: Cursor of the connection
51 # @var TblDataModel: Local instance for TableDataModel
53 class Database(object):
54 def __init__(self
, DbPath
):
58 self
.TblDataModel
= None
60 self
.TblFunction
= None
61 self
.TblIdentifier
= None
69 ## Initialize ECC database
71 # 1. Delete all old existing tables
72 # 2. Create new tables
73 # 3. Initialize table DataModel
75 def InitDatabase(self
, NewDatabase
= True):
76 EdkLogger
.verbose("\nInitialize ECC database started ...")
78 # Drop all old existing tables
81 if os
.path
.exists(self
.DbPath
):
82 os
.remove(self
.DbPath
)
83 self
.Conn
= sqlite3
.connect(self
.DbPath
, isolation_level
= 'DEFERRED')
84 self
.Conn
.execute("PRAGMA page_size=4096")
85 self
.Conn
.execute("PRAGMA synchronous=OFF")
86 # to avoid non-ascii character conversion error
87 self
.Conn
.text_factory
= str
88 self
.Cur
= self
.Conn
.cursor()
90 self
.TblDataModel
= TableDataModel(self
.Cur
)
91 self
.TblFile
= TableFile(self
.Cur
)
92 self
.TblFunction
= TableFunction(self
.Cur
)
93 self
.TblIdentifier
= TableIdentifier(self
.Cur
)
94 self
.TblPcd
= TablePcd(self
.Cur
)
95 self
.TblReport
= TableReport(self
.Cur
)
96 self
.TblInf
= ModuleTable(self
.Cur
)
97 self
.TblDec
= PackageTable(self
.Cur
)
98 self
.TblDsc
= PlatformTable(self
.Cur
)
99 self
.TblFdf
= TableFdf(self
.Cur
)
105 self
.TblDataModel
.Create()
106 self
.TblFile
.Create()
107 self
.TblFunction
.Create()
109 self
.TblReport
.Create()
116 # Init each table's ID
118 self
.TblDataModel
.InitID()
119 self
.TblFile
.InitID()
120 self
.TblFunction
.InitID()
122 self
.TblReport
.InitID()
129 # Initialize table DataModel
132 self
.TblDataModel
.InitTable()
134 EdkLogger
.verbose("Initialize ECC database ... DONE!")
138 # @param Table: The instance of the table to be queried
140 def QueryTable(self
, Table
):
143 ## Close entire database
146 # Close the connection and cursor
155 # Close connection and cursor
160 ## Insert one file information
162 # Insert one file's information to the database
163 # 1. Create a record in TableFile
164 # 2. Create functions one by one
165 # 2.1 Create variables of function one by one
166 # 2.2 Create pcds of function one by one
167 # 3. Create variables one by one
168 # 4. Create pcds one by one
170 def InsertOneFile(self
, File
):
172 # Insert a record for file
174 FileID
= self
.TblFile
.Insert(File
.Name
, File
.ExtName
, File
.Path
, File
.FullPath
, Model
= File
.Model
, TimeStamp
= File
.TimeStamp
)
176 if File
.Model
== DataClass
.MODEL_FILE_C
or File
.Model
== DataClass
.MODEL_FILE_H
:
177 IdTable
= TableIdentifier(self
.Cur
)
178 IdTable
.Table
= "Identifier%s" % FileID
181 # Insert function of file
183 for Function
in File
.FunctionList
:
184 FunctionID
= self
.TblFunction
.Insert(Function
.Header
, Function
.Modifier
, Function
.Name
, Function
.ReturnStatement
, \
185 Function
.StartLine
, Function
.StartColumn
, Function
.EndLine
, Function
.EndColumn
, \
186 Function
.BodyStartLine
, Function
.BodyStartColumn
, FileID
, \
187 Function
.FunNameStartLine
, Function
.FunNameStartColumn
)
189 # Insert Identifier of function
191 for Identifier
in Function
.IdentifierList
:
192 IdentifierID
= IdTable
.Insert(Identifier
.Modifier
, Identifier
.Type
, Identifier
.Name
, Identifier
.Value
, Identifier
.Model
, \
193 FileID
, FunctionID
, Identifier
.StartLine
, Identifier
.StartColumn
, Identifier
.EndLine
, Identifier
.EndColumn
)
195 # Insert Pcd of function
197 for Pcd
in Function
.PcdList
:
198 PcdID
= self
.TblPcd
.Insert(Pcd
.CName
, Pcd
.TokenSpaceGuidCName
, Pcd
.Token
, Pcd
.DatumType
, Pcd
.Model
, \
199 FileID
, FunctionID
, Pcd
.StartLine
, Pcd
.StartColumn
, Pcd
.EndLine
, Pcd
.EndColumn
)
201 # Insert Identifier of file
203 for Identifier
in File
.IdentifierList
:
204 IdentifierID
= IdTable
.Insert(Identifier
.Modifier
, Identifier
.Type
, Identifier
.Name
, Identifier
.Value
, Identifier
.Model
, \
205 FileID
, -1, Identifier
.StartLine
, Identifier
.StartColumn
, Identifier
.EndLine
, Identifier
.EndColumn
)
209 for Pcd
in File
.PcdList
:
210 PcdID
= self
.TblPcd
.Insert(Pcd
.CName
, Pcd
.TokenSpaceGuidCName
, Pcd
.Token
, Pcd
.DatumType
, Pcd
.Model
, \
211 FileID
, -1, Pcd
.StartLine
, Pcd
.StartColumn
, Pcd
.EndLine
, Pcd
.EndColumn
)
213 EdkLogger
.verbose("Insert information from file %s ... DONE!" % File
.FullPath
)
215 ## UpdateIdentifierBelongsToFunction
217 # Update the field "BelongsToFunction" for each Identifier
220 def UpdateIdentifierBelongsToFunction_disabled(self
):
221 EdkLogger
.verbose("Update 'BelongsToFunction' for Identifiers started ...")
223 SqlCommand
= """select ID, BelongsToFile, StartLine, EndLine, Model from Identifier"""
224 EdkLogger
.debug(4, "SqlCommand: %s" %SqlCommand
)
225 self
.Cur
.execute(SqlCommand
)
226 Records
= self
.Cur
.fetchall()
227 for Record
in Records
:
228 IdentifierID
= Record
[0]
229 BelongsToFile
= Record
[1]
230 StartLine
= Record
[2]
235 # Check whether an identifier belongs to a function
237 EdkLogger
.debug(4, "For common identifiers ... ")
238 SqlCommand
= """select ID from Function
239 where StartLine < %s and EndLine > %s
240 and BelongsToFile = %s""" % (StartLine
, EndLine
, BelongsToFile
)
241 EdkLogger
.debug(4, "SqlCommand: %s" %SqlCommand
)
242 self
.Cur
.execute(SqlCommand
)
243 IDs
= self
.Cur
.fetchall()
245 SqlCommand
= """Update Identifier set BelongsToFunction = %s where ID = %s""" % (ID
[0], IdentifierID
)
246 EdkLogger
.debug(4, "SqlCommand: %s" %SqlCommand
)
247 self
.Cur
.execute(SqlCommand
)
250 # Check whether the identifier is a function header
252 EdkLogger
.debug(4, "For function headers ... ")
253 if Model
== DataClass
.MODEL_IDENTIFIER_COMMENT
:
254 SqlCommand
= """select ID from Function
255 where StartLine = %s + 1
256 and BelongsToFile = %s""" % (EndLine
, BelongsToFile
)
257 EdkLogger
.debug(4, "SqlCommand: %s" %SqlCommand
)
258 self
.Cur
.execute(SqlCommand
)
259 IDs
= self
.Cur
.fetchall()
261 SqlCommand
= """Update Identifier set BelongsToFunction = %s, Model = %s where ID = %s""" % (ID
[0], DataClass
.MODEL_IDENTIFIER_FUNCTION_HEADER
, IdentifierID
)
262 EdkLogger
.debug(4, "SqlCommand: %s" %SqlCommand
)
263 self
.Cur
.execute(SqlCommand
)
265 EdkLogger
.verbose("Update 'BelongsToFunction' for Identifiers ... DONE")
268 ## UpdateIdentifierBelongsToFunction
270 # Update the field "BelongsToFunction" for each Identifier
273 def UpdateIdentifierBelongsToFunction(self
):
274 EdkLogger
.verbose("Update 'BelongsToFunction' for Identifiers started ...")
276 SqlCommand
= """select ID, BelongsToFile, StartLine, EndLine from Function"""
277 Records
= self
.TblFunction
.Exec(SqlCommand
)
280 for Record
in Records
:
281 FunctionID
= Record
[0]
282 BelongsToFile
= Record
[1]
283 StartLine
= Record
[2]
285 #Data1.append(("'file%s'" % BelongsToFile, FunctionID, BelongsToFile, StartLine, EndLine))
286 #Data2.append(("'file%s'" % BelongsToFile, FunctionID, DataClass.MODEL_IDENTIFIER_FUNCTION_HEADER, BelongsToFile, DataClass.MODEL_IDENTIFIER_COMMENT, StartLine - 1))
288 SqlCommand
= """Update Identifier%s set BelongsToFunction = %s where BelongsToFile = %s and StartLine > %s and EndLine < %s""" % \
289 (BelongsToFile
, FunctionID
, BelongsToFile
, StartLine
, EndLine
)
290 self
.TblIdentifier
.Exec(SqlCommand
)
292 SqlCommand
= """Update Identifier%s set BelongsToFunction = %s, Model = %s where BelongsToFile = %s and Model = %s and EndLine = %s""" % \
293 (BelongsToFile
, FunctionID
, DataClass
.MODEL_IDENTIFIER_FUNCTION_HEADER
, BelongsToFile
, DataClass
.MODEL_IDENTIFIER_COMMENT
, StartLine
- 1)
294 self
.TblIdentifier
.Exec(SqlCommand
)
296 # # Check whether an identifier belongs to a function
299 # SqlCommand = """Update ? set BelongsToFunction = ? where BelongsToFile = ? and StartLine > ? and EndLine < ?"""
301 # EdkLogger.debug(4, "SqlCommand: %s" %SqlCommand)
302 # self.Cur.executemany(SqlCommand, Data1)
305 # # Check whether the identifier is a function header
307 # EdkLogger.debug(4, "For function headers ... ")
308 # SqlCommand = """Update ? set BelongsToFunction = ?, Model = ? where BelongsToFile = ? and Model = ? and EndLine = ?"""
309 # EdkLogger.debug(4, "SqlCommand: %s" %SqlCommand)
310 # self.Cur.executemany(SqlCommand, Data2)
312 # EdkLogger.verbose("Update 'BelongsToFunction' for Identifiers ... DONE")
317 # This acts like the main() function for the script, unless it is 'import'ed into another
320 if __name__
== '__main__':
321 EdkLogger
.Initialize()
322 #EdkLogger.SetLevel(EdkLogger.VERBOSE)
323 EdkLogger
.SetLevel(EdkLogger
.DEBUG_0
)
324 EdkLogger
.verbose("Start at " + time
.strftime('%H:%M:%S', time
.localtime()))
326 Db
= Database(DATABASE_PATH
)
328 Db
.QueryTable(Db
.TblDataModel
)
330 identifier1
= DataClass
.IdentifierClass(-1, '', '', "i''1", 'aaa', DataClass
.MODEL_IDENTIFIER_COMMENT
, 1, -1, 32, 43, 54, 43)
331 identifier2
= DataClass
.IdentifierClass(-1, '', '', 'i1', 'aaa', DataClass
.MODEL_IDENTIFIER_COMMENT
, 1, -1, 15, 43, 20, 43)
332 identifier3
= DataClass
.IdentifierClass(-1, '', '', 'i1', 'aaa', DataClass
.MODEL_IDENTIFIER_COMMENT
, 1, -1, 55, 43, 58, 43)
333 identifier4
= DataClass
.IdentifierClass(-1, '', '', "i1'", 'aaa', DataClass
.MODEL_IDENTIFIER_COMMENT
, 1, -1, 77, 43, 88, 43)
334 fun1
= DataClass
.FunctionClass(-1, '', '', 'fun1', '', 21, 2, 60, 45, 1, 23, 0, [], [])
335 file = DataClass
.FileClass(-1, 'F1', 'c', 'C:\\', 'C:\\F1.exe', DataClass
.MODEL_FILE_C
, '2007-12-28', [fun1
], [identifier1
, identifier2
, identifier3
, identifier4
], [])
336 Db
.InsertOneFile(file)
337 Db
.UpdateIdentifierBelongsToFunction()
339 Db
.QueryTable(Db
.TblFile
)
340 Db
.QueryTable(Db
.TblFunction
)
341 Db
.QueryTable(Db
.TblPcd
)
342 Db
.QueryTable(Db
.TblIdentifier
)
345 EdkLogger
.verbose("End at " + time
.strftime('%H:%M:%S', time
.localtime()))