Code brief scrubs to fix some python syntax error and incorrect copyright format
[efi/basetools/.git] / Source / Python / Eot / Eot.py
1 ## @file\r
2 # This file is used to be the main entrance of EOT tool\r
3 #\r
4 # Copyright (c) 2008 - 2010, Intel Corporation\r
5 # All rights reserved. This program and the accompanying materials\r
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
17 import os, time, glob\r
18 import Common.EdkLogger as EdkLogger\r
19 import EotGlobalData\r
20 from optparse import OptionParser\r
21 from Common.String import NormPath\r
22 from Common import BuildToolError\r
23 from Common.Misc import GuidStructureStringToGuidString\r
24 from InfParserLite import *\r
25 import c\r
26 import Database\r
27 from FvImage import *\r
28 from array import array\r
29 from Report import Report\r
30 from Common.Misc import ParseConsoleLog\r
31 from Parser import ConvertGuid\r
32 \r
33 ## Class Eot\r
34 #\r
35 # This class is used to define Eot main entrance\r
36 #\r
37 # @param object:          Inherited from object class\r
38 #\r
39 class Eot(object):\r
40     ## The constructor\r
41     #\r
42     #   @param  self:      The object pointer\r
43     #\r
44     def __init__(self):\r
45         # Version and Copyright\r
46         self.VersionNumber = "0.01"\r
47         self.Version = "%prog Version " + self.VersionNumber\r
48         self.Copyright = "Copyright (c) 2008, Intel Corporation  All rights reserved."\r
49         self.Report = 'Report.html'\r
50 \r
51         self.IsInit = True\r
52 \r
53         self.SourceFileList = None\r
54         self.IncludeDirList = None\r
55         self.DecFileList = None\r
56         self.LogFile = None\r
57 \r
58         # Parse the options and args\r
59         self.ParseOption()\r
60 \r
61         # Generate source file list\r
62         self.GenerateSourceFileList(self.SourceFileList, self.IncludeDirList)\r
63 \r
64         # Generate guid list of dec file list\r
65         self.ParseDecFile(self.DecFileList)\r
66 \r
67         # Init Eot database\r
68         EotGlobalData.gDb = Database.Database(Database.DATABASE_PATH)\r
69         EotGlobalData.gDb.InitDatabase(self.IsInit)\r
70 \r
71         # Build ECC database\r
72         self.BuildDatabase()\r
73 \r
74         # Parse Ppi/Protocol\r
75         self.ParseExecutionOrder()\r
76 \r
77         # Merge Identifier tables\r
78         self.GenerateQueryTable()\r
79 \r
80         # Generate report database\r
81         self.GenerateReportDatabase()\r
82 \r
83         # Load Fv Info\r
84         self.LoadFvInfo()\r
85 \r
86         # Load Map Info\r
87         self.LoadMapInfo()\r
88 \r
89         # Generate Report\r
90         self.GenerateReport()\r
91 \r
92         # Convert log file\r
93         self.ConvertLogFile(self.LogFile)\r
94 \r
95         # DONE\r
96         EdkLogger.quiet("EOT FINISHED!")\r
97 \r
98         # Close Database\r
99         EotGlobalData.gDb.Close()\r
100 \r
101     ## ParseDecFile() method\r
102     #\r
103     #  parse DEC file and get all GUID names with GUID values as {GuidName : GuidValue}\r
104     #  The Dict is stored in EotGlobalData.gGuidDict\r
105     #\r
106     #  @param self: The object pointer\r
107     #  @param DecFileList: A list of all DEC files\r
108     #\r
109     def ParseDecFile(self, DecFileList):\r
110         if DecFileList:\r
111             path = os.path.normpath(DecFileList)\r
112             lfr = open(path, 'rb')\r
113             for line in lfr:\r
114                 path = os.path.normpath(os.path.join(EotGlobalData.gWORKSPACE, line.strip()))\r
115                 if os.path.exists(path):\r
116                     dfr = open(path, 'rb')\r
117                     for line in dfr:\r
118                         line = CleanString(line)\r
119                         list = line.split('=')\r
120                         if len(list) == 2:\r
121                             EotGlobalData.gGuidDict[list[0].strip()] = GuidStructureStringToGuidString(list[1].strip())\r
122 \r
123     ## ConvertLogFile() method\r
124     #\r
125     #  Parse a real running log file to get real dispatch order\r
126     #  The result is saved to old file name + '.new'\r
127     #\r
128     #  @param self: The object pointer\r
129     #  @param LogFile: A real running log file name\r
130     #\r
131     def ConvertLogFile(self, LogFile):\r
132         newline = []\r
133         if LogFile:\r
134             lfr = open(LogFile, 'rb')\r
135             lfw = open(LogFile + '.new', 'wb')\r
136             for line in lfr:\r
137                 line = line.strip()\r
138                 line = line.replace('.efi', '')\r
139                 index = line.find("Loading PEIM at ")\r
140                 if index > -1:\r
141                     newline.append(line[index + 55 : ])\r
142                     continue\r
143                 index = line.find("Loading driver at ")\r
144                 if index > -1:\r
145                     newline.append(line[index + 57 : ])\r
146                     continue\r
147 \r
148         for line in newline:\r
149             lfw.write(line + '\r\n')\r
150 \r
151         if lfr:\r
152             lfr.close()\r
153         if lfw:\r
154             lfw.close()\r
155 \r
156     ## GenerateSourceFileList() method\r
157     #\r
158     #  Generate a list of all source files\r
159     #  1. Search the file list one by one\r
160     #  2. Store inf file name with source file names under it like\r
161     #  { INF file name: [source file1, source file2, ...]}\r
162     #  3. Search the include list to find all .h files\r
163     #  4. Store source file list to EotGlobalData.gSOURCE_FILES\r
164     #  5. Store INF file list to EotGlobalData.gINF_FILES\r
165     #\r
166     #  @param self: The object pointer\r
167     #  @param SourceFileList: A list of all source files\r
168     #  @param IncludeFileList: A list of all include files\r
169     #\r
170     def GenerateSourceFileList(self, SourceFileList, IncludeFileList):\r
171         EdkLogger.quiet("Generating source files list ... ")\r
172         mSourceFileList = []\r
173         mInfFileList = []\r
174         mDecFileList = []\r
175         mFileList = {}\r
176         mCurrentInfFile = ''\r
177         mCurrentSourceFileList = []\r
178 \r
179         if SourceFileList:\r
180             sfl = open(SourceFileList, 'rb')\r
181             for line in sfl:\r
182                 line = os.path.normpath(os.path.join(EotGlobalData.gWORKSPACE, line.strip()))\r
183                 if line[-2:].upper() == '.C' or  line[-2:].upper() == '.H':\r
184                     if line not in mCurrentSourceFileList:\r
185                         mCurrentSourceFileList.append(line)\r
186                         mSourceFileList.append(line)\r
187                         EotGlobalData.gOP_SOURCE_FILES.write('%s\n' % line)\r
188                 if line[-4:].upper() == '.INF':\r
189                     if mCurrentInfFile != '':\r
190                         mFileList[mCurrentInfFile] = mCurrentSourceFileList\r
191                         mCurrentSourceFileList = []\r
192                     mCurrentInfFile = os.path.normpath(os.path.join(EotGlobalData.gWORKSPACE, line))\r
193                     EotGlobalData.gOP_INF.write('%s\n' % mCurrentInfFile)\r
194             if mCurrentInfFile not in mFileList:\r
195                 mFileList[mCurrentInfFile] = mCurrentSourceFileList\r
196 \r
197         # Get all include files from packages\r
198         if IncludeFileList:\r
199             ifl = open(IncludeFileList, 'rb')\r
200             for line in ifl:\r
201                 if not line.strip():\r
202                     continue\r
203                 newline = os.path.normpath(os.path.join(EotGlobalData.gWORKSPACE, line.strip()))\r
204                 for Root, Dirs, Files in os.walk(str(newline)):\r
205                     for File in Files:\r
206                         FullPath = os.path.normpath(os.path.join(Root, File))\r
207                         if FullPath not in mSourceFileList and File[-2:].upper() == '.H':\r
208                             mSourceFileList.append(FullPath)\r
209                             EotGlobalData.gOP_SOURCE_FILES.write('%s\n' % FullPath)\r
210                         if FullPath not in mDecFileList and File.upper().find('.DEC') > -1:\r
211                             mDecFileList.append(FullPath)\r
212 \r
213         EotGlobalData.gSOURCE_FILES = mSourceFileList\r
214         EotGlobalData.gOP_SOURCE_FILES.close()\r
215 \r
216         EotGlobalData.gINF_FILES = mFileList\r
217         EotGlobalData.gOP_INF.close()\r
218 \r
219         EotGlobalData.gDEC_FILES = mDecFileList\r
220 \r
221 \r
222     ## GenerateReport() method\r
223     #\r
224     #  Generate final HTML report\r
225     #\r
226     #  @param self: The object pointer\r
227     #\r
228     def GenerateReport(self):\r
229         EdkLogger.quiet("Generating report file ... ")\r
230         Rep = Report('Report.html', EotGlobalData.gFV)\r
231         Rep.GenerateReport()\r
232 \r
233     ## LoadMapInfo() method\r
234     #\r
235     #  Load map files and parse them\r
236     #\r
237     #  @param self: The object pointer\r
238     #\r
239     def LoadMapInfo(self):\r
240         if EotGlobalData.gMAP_FILE != []:\r
241             EdkLogger.quiet("Parsing Map file ... ")\r
242             EotGlobalData.gMap = ParseMapFile(EotGlobalData.gMAP_FILE)\r
243 \r
244     ## LoadFvInfo() method\r
245     #\r
246     #  Load FV binary files and parse them\r
247     #\r
248     #  @param self: The object pointer\r
249     #\r
250     def LoadFvInfo(self):\r
251         EdkLogger.quiet("Parsing FV file ... ")\r
252         EotGlobalData.gFV = MultipleFv(EotGlobalData.gFV_FILE)\r
253         EotGlobalData.gFV.Dispatch(EotGlobalData.gDb)\r
254 \r
255         for Protocol in EotGlobalData.gProtocolList:\r
256             EotGlobalData.gOP_UN_MATCHED_IN_LIBRARY_CALLING.write('%s\n' %Protocol)\r
257 \r
258     ## GenerateReportDatabase() method\r
259     #\r
260     #  Generate data for the information needed by report\r
261     #  1. Update name, macro and value of all found PPI/PROTOCOL GUID\r
262     #  2. Install hard coded PPI/PROTOCOL\r
263     #\r
264     #  @param self: The object pointer\r
265     #\r
266     def GenerateReportDatabase(self):\r
267         EdkLogger.quiet("Generating the cross-reference table of GUID for Ppi/Protocol ... ")\r
268 \r
269         # Update Protocol/Ppi Guid\r
270         SqlCommand = """select DISTINCT GuidName from Report"""\r
271         RecordSet = EotGlobalData.gDb.TblReport.Exec(SqlCommand)\r
272         for Record in RecordSet:\r
273             GuidName = Record[0]\r
274             GuidMacro = ''\r
275             GuidMacro2 = ''\r
276             GuidValue = ''\r
277 \r
278             # Find value for hardcode guid macro\r
279             if GuidName in EotGlobalData.gGuidMacroDict:\r
280                 GuidMacro = EotGlobalData.gGuidMacroDict[GuidName][0]\r
281                 GuidValue = EotGlobalData.gGuidMacroDict[GuidName][1]\r
282                 SqlCommand = """update Report set GuidMacro = '%s', GuidValue = '%s' where GuidName = '%s'""" %(GuidMacro, GuidValue, GuidName)\r
283                 EotGlobalData.gDb.TblReport.Exec(SqlCommand)\r
284                 continue\r
285 \r
286             # Find guid value defined in Dec file\r
287             if GuidName in EotGlobalData.gGuidDict:\r
288                 GuidValue = EotGlobalData.gGuidDict[GuidName]\r
289                 SqlCommand = """update Report set GuidMacro = '%s', GuidValue = '%s' where GuidName = '%s'""" %(GuidMacro, GuidValue, GuidName)\r
290                 EotGlobalData.gDb.TblReport.Exec(SqlCommand)\r
291                 continue\r
292 \r
293             # Search defined Macros for guid name\r
294             SqlCommand ="""select DISTINCT Value, Modifier from Query where Name like '%s'""" % GuidName\r
295             GuidMacroSet = EotGlobalData.gDb.TblReport.Exec(SqlCommand)\r
296             # Ignore NULL result\r
297             if not GuidMacroSet:\r
298                 continue\r
299             GuidMacro = GuidMacroSet[0][0].strip()\r
300             if not GuidMacro:\r
301                 continue\r
302             # Find Guid value of Guid Macro\r
303             SqlCommand ="""select DISTINCT Value from Query2 where Value like '%%%s%%' and Model = %s""" % (GuidMacro, MODEL_IDENTIFIER_MACRO_DEFINE)\r
304             GuidValueSet = EotGlobalData.gDb.TblReport.Exec(SqlCommand)\r
305             if GuidValueSet != []:\r
306                 GuidValue = GuidValueSet[0][0]\r
307                 GuidValue = GuidValue[GuidValue.find(GuidMacro) + len(GuidMacro) :]\r
308                 GuidValue = GuidValue.lower().replace('\\', '').replace('\r', '').replace('\n', '').replace('l', '').strip()\r
309                 GuidValue = GuidStructureStringToGuidString(GuidValue)\r
310                 SqlCommand = """update Report set GuidMacro = '%s', GuidValue = '%s' where GuidName = '%s'""" %(GuidMacro, GuidValue, GuidName)\r
311                 EotGlobalData.gDb.TblReport.Exec(SqlCommand)\r
312                 continue\r
313 \r
314         # Update Hard Coded Ppi/Protocol\r
315         SqlCommand = """select DISTINCT GuidValue, ItemType from Report where ModuleID = -2 and ItemMode = 'Produced'"""\r
316         RecordSet = EotGlobalData.gDb.TblReport.Exec(SqlCommand)\r
317         for Record in RecordSet:\r
318             if Record[1] == 'Ppi':\r
319                 EotGlobalData.gPpiList[Record[0].lower()] = -2\r
320             if Record[1] == 'Protocol':\r
321                 EotGlobalData.gProtocolList[Record[0].lower()] = -2\r
322 \r
323     ## GenerateQueryTable() method\r
324     #\r
325     #  Generate two tables improve query performance\r
326     #\r
327     #  @param self: The object pointer\r
328     #\r
329     def GenerateQueryTable(self):\r
330         EdkLogger.quiet("Generating temp query table for analysis ... ")\r
331         for Identifier in EotGlobalData.gIdentifierTableList:\r
332             SqlCommand = """insert into Query (Name, Modifier, Value, Model)\r
333                             select Name, Modifier, Value, Model from %s where (Model = %s or Model = %s)""" \\r
334                             % (Identifier[0], MODEL_IDENTIFIER_VARIABLE, MODEL_IDENTIFIER_ASSIGNMENT_EXPRESSION)\r
335             EotGlobalData.gDb.TblReport.Exec(SqlCommand)\r
336             SqlCommand = """insert into Query2 (Name, Modifier, Value, Model)\r
337                             select Name, Modifier, Value, Model from %s where Model = %s""" \\r
338                             % (Identifier[0], MODEL_IDENTIFIER_MACRO_DEFINE)\r
339             EotGlobalData.gDb.TblReport.Exec(SqlCommand)\r
340 \r
341     ## ParseExecutionOrder() method\r
342     #\r
343     #  Get final execution order\r
344     #  1. Search all PPI\r
345     #  2. Search all PROTOCOL\r
346     #\r
347     #  @param self: The object pointer\r
348     #\r
349     def ParseExecutionOrder(self):\r
350         EdkLogger.quiet("Searching Ppi/Protocol ... ")\r
351         for Identifier in EotGlobalData.gIdentifierTableList:\r
352             ModuleID, ModuleName, ModuleGuid, SourceFileID, SourceFileFullPath, ItemName, ItemType, ItemMode, GuidName, GuidMacro, GuidValue, BelongsToFunction, Enabled = \\r
353             -1, '', '', -1, '', '', '', '', '', '', '', '', 0\r
354 \r
355             SourceFileID = Identifier[0].replace('Identifier', '')\r
356             SourceFileFullPath = Identifier[1]\r
357             Identifier = Identifier[0]\r
358 \r
359             # Find Ppis\r
360             ItemMode = 'Produced'\r
361             SqlCommand = """select Value, Name, BelongsToFile, StartLine, EndLine from %s\r
362                             where (Name like '%%%s%%' or Name like '%%%s%%' or Name like '%%%s%%') and Model = %s""" \\r
363                             % (Identifier, '.InstallPpi', '->InstallPpi', 'PeiInstallPpi', MODEL_IDENTIFIER_FUNCTION_CALLING)\r
364             SearchPpi(SqlCommand, Identifier, SourceFileID, SourceFileFullPath, ItemMode)\r
365 \r
366             ItemMode = 'Produced'\r
367             SqlCommand = """select Value, Name, BelongsToFile, StartLine, EndLine from %s\r
368                             where (Name like '%%%s%%' or Name like '%%%s%%') and Model = %s""" \\r
369                             % (Identifier, '.ReInstallPpi', '->ReInstallPpi', MODEL_IDENTIFIER_FUNCTION_CALLING)\r
370             SearchPpi(SqlCommand, Identifier, SourceFileID, SourceFileFullPath, ItemMode, 2)\r
371 \r
372             SearchPpiCallFunction(Identifier, SourceFileID, SourceFileFullPath, ItemMode)\r
373 \r
374             ItemMode = 'Consumed'\r
375             SqlCommand = """select Value, Name, BelongsToFile, StartLine, EndLine from %s\r
376                             where (Name like '%%%s%%' or Name like '%%%s%%') and Model = %s""" \\r
377                             % (Identifier, '.LocatePpi', '->LocatePpi', MODEL_IDENTIFIER_FUNCTION_CALLING)\r
378             SearchPpi(SqlCommand, Identifier, SourceFileID, SourceFileFullPath, ItemMode)\r
379 \r
380             SearchFunctionCalling(Identifier, SourceFileID, SourceFileFullPath, 'Ppi', ItemMode)\r
381 \r
382             ItemMode = 'Callback'\r
383             SqlCommand = """select Value, Name, BelongsToFile, StartLine, EndLine from %s\r
384                             where (Name like '%%%s%%' or Name like '%%%s%%') and Model = %s""" \\r
385                             % (Identifier, '.NotifyPpi', '->NotifyPpi', MODEL_IDENTIFIER_FUNCTION_CALLING)\r
386             SearchPpi(SqlCommand, Identifier, SourceFileID, SourceFileFullPath, ItemMode)\r
387 \r
388             # Find Procotols\r
389             ItemMode = 'Produced'\r
390             SqlCommand = """select Value, Name, BelongsToFile, StartLine, EndLine from %s\r
391                             where (Name like '%%%s%%' or Name like '%%%s%%' or Name like '%%%s%%' or Name like '%%%s%%') and Model = %s""" \\r
392                             % (Identifier, '.InstallProtocolInterface', '.ReInstallProtocolInterface', '->InstallProtocolInterface', '->ReInstallProtocolInterface', MODEL_IDENTIFIER_FUNCTION_CALLING)\r
393             SearchProtocols(SqlCommand, Identifier, SourceFileID, SourceFileFullPath, ItemMode, 1)\r
394 \r
395             SqlCommand = """select Value, Name, BelongsToFile, StartLine, EndLine from %s\r
396                             where (Name like '%%%s%%' or Name like '%%%s%%') and Model = %s""" \\r
397                             % (Identifier, '.InstallMultipleProtocolInterfaces', '->InstallMultipleProtocolInterfaces', MODEL_IDENTIFIER_FUNCTION_CALLING)\r
398             SearchProtocols(SqlCommand, Identifier, SourceFileID, SourceFileFullPath, ItemMode, 2)\r
399 \r
400             SearchFunctionCalling(Identifier, SourceFileID, SourceFileFullPath, 'Protocol', ItemMode)\r
401 \r
402             ItemMode = 'Consumed'\r
403             SqlCommand = """select Value, Name, BelongsToFile, StartLine, EndLine from %s\r
404                             where (Name like '%%%s%%' or Name like '%%%s%%') and Model = %s""" \\r
405                             % (Identifier, '.LocateProtocol', '->LocateProtocol', MODEL_IDENTIFIER_FUNCTION_CALLING)\r
406             SearchProtocols(SqlCommand, Identifier, SourceFileID, SourceFileFullPath, ItemMode, 0)\r
407 \r
408             SqlCommand = """select Value, Name, BelongsToFile, StartLine, EndLine from %s\r
409                             where (Name like '%%%s%%' or Name like '%%%s%%') and Model = %s""" \\r
410                             % (Identifier, '.HandleProtocol', '->HandleProtocol', MODEL_IDENTIFIER_FUNCTION_CALLING)\r
411             SearchProtocols(SqlCommand, Identifier, SourceFileID, SourceFileFullPath, ItemMode, 1)\r
412 \r
413             SearchFunctionCalling(Identifier, SourceFileID, SourceFileFullPath, 'Protocol', ItemMode)\r
414 \r
415             ItemMode = 'Callback'\r
416             SqlCommand = """select Value, Name, BelongsToFile, StartLine, EndLine from %s\r
417                             where (Name like '%%%s%%' or Name like '%%%s%%') and Model = %s""" \\r
418                             % (Identifier, '.RegisterProtocolNotify', '->RegisterProtocolNotify', MODEL_IDENTIFIER_FUNCTION_CALLING)\r
419             SearchProtocols(SqlCommand, Identifier, SourceFileID, SourceFileFullPath, ItemMode, 0)\r
420 \r
421             SearchFunctionCalling(Identifier, SourceFileID, SourceFileFullPath, 'Protocol', ItemMode)\r
422 \r
423         # Hard Code\r
424         EotGlobalData.gDb.TblReport.Insert(-2, '', '', -1, '', '', 'Ppi', 'Produced', 'gEfiSecPlatformInformationPpiGuid', '', '', '', 0)\r
425         EotGlobalData.gDb.TblReport.Insert(-2, '', '', -1, '', '', 'Ppi', 'Produced', 'gEfiNtLoadAsDllPpiGuid', '', '', '', 0)\r
426         EotGlobalData.gDb.TblReport.Insert(-2, '', '', -1, '', '', 'Ppi', 'Produced', 'gNtPeiLoadFileGuid', '', '', '', 0)\r
427         EotGlobalData.gDb.TblReport.Insert(-2, '', '', -1, '', '', 'Ppi', 'Produced', 'gPeiNtAutoScanPpiGuid', '', '', '', 0)\r
428         EotGlobalData.gDb.TblReport.Insert(-2, '', '', -1, '', '', 'Ppi', 'Produced', 'gNtFwhPpiGuid', '', '', '', 0)\r
429         EotGlobalData.gDb.TblReport.Insert(-2, '', '', -1, '', '', 'Ppi', 'Produced', 'gPeiNtThunkPpiGuid', '', '', '', 0)\r
430         EotGlobalData.gDb.TblReport.Insert(-2, '', '', -1, '', '', 'Ppi', 'Produced', 'gPeiPlatformTypePpiGuid', '', '', '', 0)\r
431         EotGlobalData.gDb.TblReport.Insert(-2, '', '', -1, '', '', 'Ppi', 'Produced', 'gPeiFrequencySelectionCpuPpiGuid', '', '', '', 0)\r
432         EotGlobalData.gDb.TblReport.Insert(-2, '', '', -1, '', '', 'Ppi', 'Produced', 'gPeiCachePpiGuid', '', '', '', 0)\r
433 \r
434         EotGlobalData.gDb.Conn.commit()\r
435 \r
436 \r
437     ## BuildDatabase() methoc\r
438     #\r
439     #  Build the database for target\r
440     #\r
441     #  @param self: The object pointer\r
442     #\r
443     def BuildDatabase(self):\r
444         # Clean report table\r
445         EotGlobalData.gDb.TblReport.Drop()\r
446         EotGlobalData.gDb.TblReport.Create()\r
447 \r
448         # Build database\r
449         if self.IsInit:\r
450             self.BuildMetaDataFileDatabase(EotGlobalData.gINF_FILES)\r
451             EdkLogger.quiet("Building database for source code ...")\r
452             c.CreateCCodeDB(EotGlobalData.gSOURCE_FILES)\r
453             EdkLogger.quiet("Building database for source code done!")\r
454 \r
455         EotGlobalData.gIdentifierTableList = GetTableList((MODEL_FILE_C, MODEL_FILE_H), 'Identifier', EotGlobalData.gDb)\r
456 \r
457     ## BuildMetaDataFileDatabase() method\r
458     #\r
459     #  Build the database for meta data files\r
460     #\r
461     #  @param self: The object pointer\r
462     #  @param Inf_Files: A list for all INF files\r
463     #\r
464     def BuildMetaDataFileDatabase(self, Inf_Files):\r
465         EdkLogger.quiet("Building database for meta data files ...")\r
466         for InfFile in Inf_Files:\r
467             EdkLogger.quiet("Parsing %s ..."  % str(InfFile))\r
468             EdkInfParser(InfFile, EotGlobalData.gDb, Inf_Files[InfFile], '')\r
469 \r
470         EotGlobalData.gDb.Conn.commit()\r
471         EdkLogger.quiet("Building database for meta data files done!")\r
472 \r
473     ## ParseOption() method\r
474     #\r
475     #  Parse command line options\r
476     #\r
477     #  @param self: The object pointer\r
478     #\r
479     def ParseOption(self):\r
480         (Options, Target) = self.EotOptionParser()\r
481         # Check workspace envirnoment\r
482         if "EFI_SOURCE" not in os.environ:\r
483             if "EDK_SOURCE" not in os.environ:\r
484                 pass\r
485             else:\r
486                 EotGlobalData.gEDK_SOURCE = os.path.normpath(os.getenv("EDK_SOURCE"))\r
487         else:\r
488             EotGlobalData.gEFI_SOURCE = os.path.normpath(os.getenv("EFI_SOURCE"))\r
489             EotGlobalData.gEDK_SOURCE = os.path.join(EotGlobalData.gEFI_SOURCE, 'Edk')\r
490 \r
491         if "WORKSPACE" not in os.environ:\r
492             EdkLogger.error("EOT", BuildToolError.ATTRIBUTE_NOT_AVAILABLE, "Environment variable not found",\r
493                             ExtraData="WORKSPACE")\r
494         else:\r
495             EotGlobalData.gWORKSPACE = os.path.normpath(os.getenv("WORKSPACE"))\r
496 \r
497         EotGlobalData.gMACRO['WORKSPACE'] = EotGlobalData.gWORKSPACE\r
498         EotGlobalData.gMACRO['EFI_SOURCE'] = EotGlobalData.gEFI_SOURCE\r
499         EotGlobalData.gMACRO['EDK_SOURCE'] = EotGlobalData.gEDK_SOURCE\r
500 \r
501         # Set log level\r
502         self.SetLogLevel(Options)\r
503 \r
504         if Options.FvFileList:\r
505             for FvFile in GetSplitValueList(Options.FvFileList, ' '):\r
506                 FvFile = os.path.normpath(FvFile)\r
507                 if not os.path.isfile(FvFile):\r
508                     EdkLogger.error("Eot", EdkLogger.EOT_ERROR, "Can not find file %s " % FvFile)\r
509                 EotGlobalData.gFV_FILE.append(FvFile)\r
510         else:\r
511             EdkLogger.error("Eot", EdkLogger.EOT_ERROR, "The fv file list of target platform was not specified")\r
512 \r
513         if Options.MapFileList:\r
514             for MapFile in GetSplitValueList(Options.MapFileList, ' '):\r
515                 MapFile = os.path.normpath(MapFile)\r
516                 if not os.path.isfile(MapFile):\r
517                     EdkLogger.error("Eot", EdkLogger.EOT_ERROR, "Can not find file %s " % MapFile)\r
518                 EotGlobalData.gMAP_FILE.append(MapFile)\r
519 \r
520         if Options.SourceFileList:\r
521             self.SourceFileList = Options.SourceFileList\r
522 \r
523         if Options.IncludeDirList:\r
524             self.IncludeDirList = Options.IncludeDirList\r
525 \r
526         if Options.DecFileList:\r
527             self.DecFileList = Options.DecFileList\r
528 \r
529         if Options.LogFile:\r
530             self.LogFile = Options.LogFile\r
531 \r
532         if Options.keepdatabase:\r
533             self.IsInit = False\r
534 \r
535     ## SetLogLevel() method\r
536     #\r
537     #  Set current log level of the tool based on args\r
538     #\r
539     #  @param self: The object pointer\r
540     #  @param Option: The option list including log level setting\r
541     #\r
542     def SetLogLevel(self, Option):\r
543         if Option.verbose != None:\r
544             EdkLogger.SetLevel(EdkLogger.VERBOSE)\r
545         elif Option.quiet != None:\r
546             EdkLogger.SetLevel(EdkLogger.QUIET)\r
547         elif Option.debug != None:\r
548             EdkLogger.SetLevel(Option.debug + 1)\r
549         else:\r
550             EdkLogger.SetLevel(EdkLogger.INFO)\r
551 \r
552     ## EotOptionParser() method\r
553     #\r
554     #  Using standard Python module optparse to parse command line option of this tool.\r
555     #\r
556     #  @param self: The object pointer\r
557     #\r
558     #  @retval Opt   A optparse.Values object containing the parsed options\r
559     #  @retval Args  Target of build command\r
560     #\r
561     def EotOptionParser(self):\r
562         Parser = OptionParser(description = self.Copyright, version = self.Version, prog = "Eot.exe", usage = "%prog [options]")\r
563         Parser.add_option("-m", "--makefile filename", action="store", type="string", dest='MakeFile',\r
564             help="Specify a makefile for the platform.")\r
565         Parser.add_option("-c", "--dsc filename", action="store", type="string", dest="DscFile",\r
566             help="Specify a dsc file for the platform.")\r
567         Parser.add_option("-f", "--fv filename", action="store", type="string", dest="FvFileList",\r
568             help="Specify fv file list, quoted by \"\".")\r
569         Parser.add_option("-a", "--map filename", action="store", type="string", dest="MapFileList",\r
570             help="Specify map file list, quoted by \"\".")\r
571         Parser.add_option("-s", "--source files", action="store", type="string", dest="SourceFileList",\r
572             help="Specify source file list by a file")\r
573         Parser.add_option("-i", "--include dirs", action="store", type="string", dest="IncludeDirList",\r
574             help="Specify include dir list by a file")\r
575         Parser.add_option("-e", "--dec files", action="store", type="string", dest="DecFileList",\r
576             help="Specify dec file list by a file")\r
577         Parser.add_option("-l", "--log filename", action="store", type="string", dest="LogFile",\r
578             help="Specify real execution log file")\r
579 \r
580         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
581 \r
582         Parser.add_option("-q", "--quiet", action="store_true", type=None, help="Disable all messages except FATAL ERRORS.")\r
583         Parser.add_option("-v", "--verbose", action="store_true", type=None, help="Turn on verbose output with informational messages printed, "\\r
584                                                                                    "including library instances selected, final dependency expression, "\\r
585                                                                                    "and warning messages, etc.")\r
586         Parser.add_option("-d", "--debug", action="store", type="int", help="Enable debug messages at specified level.")\r
587 \r
588         (Opt, Args)=Parser.parse_args()\r
589 \r
590         return (Opt, Args)\r
591 \r
592 ##\r
593 #\r
594 # This acts like the main() function for the script, unless it is 'import'ed into another\r
595 # script.\r
596 #\r
597 if __name__ == '__main__':\r
598     # Initialize log system\r
599     EdkLogger.Initialize()\r
600     EdkLogger.IsRaiseError = False\r
601     EdkLogger.quiet(time.strftime("%H:%M:%S, %b.%d %Y ", time.localtime()) + "[00:00]" + "\n")\r
602 \r
603     StartTime = time.clock()\r
604     Eot = Eot()\r
605     FinishTime = time.clock()\r
606 \r
607     BuildDuration = time.strftime("%M:%S", time.gmtime(int(round(FinishTime - StartTime))))\r
608     EdkLogger.quiet("\n%s [%s]" % (time.strftime("%H:%M:%S, %b.%d %Y", time.localtime()), BuildDuration))\r