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