ECC: fix the mis-report of function parameter position.
[people/mcb30/basetools.git] / Source / Python / Ecc / Check.py
1 ## @file\r
2 # This file is used to define checkpoints used by ECC tool\r
3 #\r
4 # Copyright (c) 2008, 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 import os\r
14 import re\r
15 from CommonDataClass.DataClass import *\r
16 from EccToolError import *\r
17 import EccGlobalData\r
18 import c\r
19 \r
20 ## Check\r
21 #\r
22 # This class is to define checkpoints used by ECC tool\r
23 #\r
24 # @param object:          Inherited from object class\r
25 #\r
26 class Check(object):\r
27     def __init__(self):\r
28         pass\r
29      \r
30     #\r
31     # Check all required checkpoints\r
32     #   \r
33     def Check(self):\r
34         self.MetaDataFileCheck()\r
35         self.DoxygenCheck()\r
36         self.IncludeFileCheck()\r
37         self.PredicateExpressionCheck()\r
38         self.DeclAndDataTypeCheck()\r
39         self.FunctionLayoutCheck()\r
40         self.NamingConventionCheck()\r
41     \r
42     #\r
43     # C Function Layout Checking\r
44     #\r
45     def FunctionLayoutCheck(self):\r
46         self.FunctionLayoutCheckReturnType()\r
47         self.FunctionLayoutCheckModifier()\r
48         self.FunctionLayoutCheckName()\r
49         self.FunctionLayoutCheckPrototype()\r
50         self.FunctionLayoutCheckBody()\r
51         self.FunctionLayoutCheckLocalVariable()\r
52     \r
53     # Check whether return type exists and in the first line\r
54     def FunctionLayoutCheckReturnType(self):\r
55         if EccGlobalData.gConfig.CFunctionLayoutCheckReturnType == '1' or EccGlobalData.gConfig.CFunctionLayoutCheckAll == '1':\r
56             EdkLogger.quiet("Checking function layout return type ...")\r
57             Tuple = os.walk(EccGlobalData.gTarget)\r
58             IgnoredPattern = re.compile(r'.*[\\/](?:BUILD|CVS|\.SVN|INTELRESTRICTEDTOOLS|INTELRESTRICTEDPKG)[\\/].*')\r
59         \r
60             for Dirpath, Dirnames, Filenames in Tuple:\r
61                 if IgnoredPattern.match(Dirpath.upper()) or Dirpath.find('.svn') != -1:\r
62                     continue\r
63                 for F in Filenames:\r
64                     if os.path.splitext(F)[1] in ('.c', '.h'):\r
65                         FullName = os.path.join(Dirpath, F)\r
66                         c.CheckFuncLayoutReturnType(FullName)\r
67     \r
68     # Check whether any optional functional modifiers exist and next to the return type\r
69     def FunctionLayoutCheckModifier(self):\r
70         if EccGlobalData.gConfig.CFunctionLayoutCheckOptionalFunctionalModifier == '1' or EccGlobalData.gConfig.CFunctionLayoutCheckAll == '1':\r
71             EdkLogger.quiet("Checking function layout modifier ...")\r
72             Tuple = os.walk(EccGlobalData.gTarget)\r
73             IgnoredPattern = re.compile(r'.*[\\/](?:BUILD|CVS|\.SVN|INTELRESTRICTEDTOOLS|INTELRESTRICTEDPKG)[\\/].*')\r
74         \r
75             for Dirpath, Dirnames, Filenames in Tuple:\r
76                 if IgnoredPattern.match(Dirpath.upper()) or Dirpath.find('.svn') != -1:\r
77                     continue\r
78                 for F in Filenames:\r
79                     if os.path.splitext(F)[1] in ('.c', '.h'):\r
80                         FullName = os.path.join(Dirpath, F)\r
81                         c.CheckFuncLayoutModifier(FullName)\r
82                         \r
83     # Check whether the next line contains the function name, left justified, followed by the beginning of the parameter list\r
84     # Check whether the closing parenthesis is on its own line and also indented two spaces\r
85     def FunctionLayoutCheckName(self):\r
86         if EccGlobalData.gConfig.CFunctionLayoutCheckFunctionName == '1' or EccGlobalData.gConfig.CFunctionLayoutCheckAll == '1':\r
87             EdkLogger.quiet("Checking function layout function name ...")\r
88             Tuple = os.walk(EccGlobalData.gTarget)\r
89             IgnoredPattern = re.compile(r'.*[\\/](?:BUILD|CVS|\.SVN|INTELRESTRICTEDTOOLS|INTELRESTRICTEDPKG)[\\/].*')\r
90         \r
91             for Dirpath, Dirnames, Filenames in Tuple:\r
92                 if IgnoredPattern.match(Dirpath.upper()) or Dirpath.find('.svn') != -1:\r
93                     continue\r
94                 for F in Filenames:\r
95                     if os.path.splitext(F)[1] in ('.c', '.h'):\r
96                         FullName = os.path.join(Dirpath, F)\r
97                         c.CheckFuncLayoutName(FullName)\r
98     # Check whether the function prototypes in include files have the same form as function definitions\r
99     def FunctionLayoutCheckPrototype(self):\r
100         if EccGlobalData.gConfig.CFunctionLayoutCheckFunctionPrototype == '1' or EccGlobalData.gConfig.CFunctionLayoutCheckAll == '1':\r
101             EdkLogger.quiet("Checking function layout function prototype ...")\r
102             Tuple = os.walk(EccGlobalData.gTarget)\r
103             IgnoredPattern = re.compile(r'.*[\\/](?:BUILD|CVS|\.SVN|INTELRESTRICTEDTOOLS|INTELRESTRICTEDPKG)[\\/].*')\r
104         \r
105             for Dirpath, Dirnames, Filenames in Tuple:\r
106                 if IgnoredPattern.match(Dirpath.upper()) or Dirpath.find('.svn') != -1:\r
107                     continue\r
108                 for F in Filenames:\r
109                     if os.path.splitext(F)[1] in ('.c'):\r
110                         FullName = os.path.join(Dirpath, F)\r
111                         c.CheckFuncLayoutPrototype(FullName)\r
112 \r
113     # Check whether the body of a function is contained by open and close braces that must be in the first column\r
114     def FunctionLayoutCheckBody(self):\r
115         if EccGlobalData.gConfig.CFunctionLayoutCheckFunctionBody == '1' or EccGlobalData.gConfig.CFunctionLayoutCheckAll == '1':\r
116             EdkLogger.quiet("Checking function layout function body ...")\r
117             Tuple = os.walk(EccGlobalData.gTarget)\r
118             IgnoredPattern = re.compile(r'.*[\\/](?:BUILD|CVS|\.SVN|INTELRESTRICTEDTOOLS|INTELRESTRICTEDPKG)[\\/].*')\r
119         \r
120             for Dirpath, Dirnames, Filenames in Tuple:\r
121                 if IgnoredPattern.match(Dirpath.upper()) or Dirpath.find('.svn') != -1:\r
122                     continue\r
123                 for F in Filenames:\r
124                     if os.path.splitext(F)[1] in ('.c'):\r
125                         FullName = os.path.join(Dirpath, F)\r
126                         c.CheckFuncLayoutBody(FullName)\r
127 \r
128     # Check whether the data declarations is the first code in a module.\r
129     #self.CFunctionLayoutCheckDataDeclaration = 1\r
130     # Check whether no initialization of a variable as part of its declaration\r
131     def FunctionLayoutCheckLocalVariable(self):\r
132         if EccGlobalData.gConfig.CFunctionLayoutCheckNoInitOfVariable == '1' or EccGlobalData.gConfig.CFunctionLayoutCheckAll == '1':\r
133             EdkLogger.quiet("Checking function layout local variables ...")\r
134             Tuple = os.walk(EccGlobalData.gTarget)\r
135             IgnoredPattern = re.compile(r'.*[\\/](?:BUILD|CVS|\.SVN|INTELRESTRICTEDTOOLS|INTELRESTRICTEDPKG)[\\/].*')\r
136         \r
137             for Dirpath, Dirnames, Filenames in Tuple:\r
138                 if IgnoredPattern.match(Dirpath.upper()) or Dirpath.find('.svn') != -1:\r
139                     continue\r
140                 for F in Filenames:\r
141                     if os.path.splitext(F)[1] in ('.c'):\r
142                         FullName = os.path.join(Dirpath, F)\r
143                         c.CheckFuncLayoutLocalVariable(FullName)\r
144 \r
145     # Check whether no use of STATIC for functions\r
146     #self.CFunctionLayoutCheckNoStatic = 1\r
147     \r
148     #\r
149     # Declarations and Data Types Checking\r
150     #\r
151     def DeclAndDataTypeCheck(self):\r
152         self.DeclCheckNoUseCType()\r
153         self.DeclCheckInOutModifier()\r
154         self.DeclCheckEFIAPIModifier()\r
155         self.DeclCheckEnumeratedType()\r
156         self.DeclCheckStructureDeclaration()\r
157         self.DeclCheckUnionType()\r
158     \r
159     \r
160     # Check whether no use of int, unsigned, char, void, static, long in any .c, .h or .asl files.\r
161     def DeclCheckNoUseCType(self):\r
162         if EccGlobalData.gConfig.DeclarationDataTypeCheckNoUseCType == '1' or EccGlobalData.gConfig.DeclarationDataTypeCheckAll == '1':\r
163             EdkLogger.quiet("Checking Declaration No use C type ...")\r
164             Tuple = os.walk(EccGlobalData.gTarget)\r
165             IgnoredPattern = re.compile(r'.*[\\/](?:BUILD|CVS|\.SVN|INTELRESTRICTEDTOOLS|INTELRESTRICTEDPKG)[\\/].*')\r
166         \r
167             for Dirpath, Dirnames, Filenames in Tuple:\r
168                 if IgnoredPattern.match(Dirpath.upper()) or Dirpath.find('.svn') != -1:\r
169                     continue\r
170                 for F in Filenames:\r
171                     if os.path.splitext(F)[1] in ('.h', '.c'):\r
172                         FullName = os.path.join(Dirpath, F)\r
173                         c.CheckDeclNoUseCType(FullName)\r
174     \r
175     # Check whether the modifiers IN, OUT, OPTIONAL, and UNALIGNED are used only to qualify arguments to a function and should not appear in a data type declaration\r
176     def DeclCheckInOutModifier(self):\r
177         if EccGlobalData.gConfig.DeclarationDataTypeCheckInOutModifier == '1' or EccGlobalData.gConfig.DeclarationDataTypeCheckAll == '1':\r
178             EdkLogger.quiet("Checking Declaration argument modifier ...")\r
179             Tuple = os.walk(EccGlobalData.gTarget)\r
180             IgnoredPattern = re.compile(r'.*[\\/](?:BUILD|CVS|\.SVN|INTELRESTRICTEDTOOLS|INTELRESTRICTEDPKG)[\\/].*')\r
181         \r
182             for Dirpath, Dirnames, Filenames in Tuple:\r
183                 if IgnoredPattern.match(Dirpath.upper()) or Dirpath.find('.svn') != -1:\r
184                     continue\r
185                 for F in Filenames:\r
186                     if os.path.splitext(F)[1] in ('.h', '.c'):\r
187                         FullName = os.path.join(Dirpath, F)\r
188                         c.CheckDeclArgModifier(FullName)\r
189     \r
190     # Check whether the EFIAPI modifier should be used at the entry of drivers, events, and member functions of protocols\r
191     def DeclCheckEFIAPIModifier(self):\r
192         if EccGlobalData.gConfig.DeclarationDataTypeCheckEFIAPIModifier == '1' or EccGlobalData.gConfig.DeclarationDataTypeCheckAll == '1':\r
193             pass\r
194     \r
195     # Check whether Enumerated Type has a 'typedef' and the name is capital\r
196     def DeclCheckEnumeratedType(self):\r
197         if EccGlobalData.gConfig.DeclarationDataTypeCheckEnumeratedType == '1' or EccGlobalData.gConfig.DeclarationDataTypeCheckAll == '1':\r
198             EdkLogger.quiet("Checking Declaration enum typedef ...")\r
199             Tuple = os.walk(EccGlobalData.gTarget)\r
200             IgnoredPattern = re.compile(r'.*[\\/](?:BUILD|CVS|\.SVN|INTELRESTRICTEDTOOLS|INTELRESTRICTEDPKG)[\\/].*')\r
201         \r
202             for Dirpath, Dirnames, Filenames in Tuple:\r
203                 if IgnoredPattern.match(Dirpath.upper()) or Dirpath.find('.svn') != -1:\r
204                     continue\r
205                 for F in Filenames:\r
206                     if os.path.splitext(F)[1] in ('.h', '.c'):\r
207                         FullName = os.path.join(Dirpath, F)\r
208                         c.CheckDeclEnumTypedef(FullName)\r
209     \r
210     # Check whether Structure Type has a 'typedef' and the name is capital\r
211     def DeclCheckStructureDeclaration(self):\r
212         if EccGlobalData.gConfig.DeclarationDataTypeCheckStructureDeclaration == '1' or EccGlobalData.gConfig.DeclarationDataTypeCheckAll == '1':\r
213             EdkLogger.quiet("Checking Declaration struct typedef ...")\r
214             Tuple = os.walk(EccGlobalData.gTarget)\r
215             IgnoredPattern = re.compile(r'.*[\\/](?:BUILD|CVS|\.SVN|INTELRESTRICTEDTOOLS|INTELRESTRICTEDPKG)[\\/].*')\r
216         \r
217             for Dirpath, Dirnames, Filenames in Tuple:\r
218                 if IgnoredPattern.match(Dirpath.upper()) or Dirpath.find('.svn') != -1:\r
219                     continue\r
220                 for F in Filenames:\r
221                     if os.path.splitext(F)[1] in ('.h', '.c'):\r
222                         FullName = os.path.join(Dirpath, F)\r
223                         c.CheckDeclStructTypedef(FullName)\r
224     \r
225     # Check whether Union Type has a 'typedef' and the name is capital\r
226     def DeclCheckUnionType(self):\r
227         if EccGlobalData.gConfig.DeclarationDataTypeCheckUnionType == '1' or EccGlobalData.gConfig.DeclarationDataTypeCheckAll == '1':\r
228             EdkLogger.quiet("Checking Declaration union typedef ...")\r
229             Tuple = os.walk(EccGlobalData.gTarget)\r
230             IgnoredPattern = re.compile(r'.*[\\/](?:BUILD|CVS|\.SVN|INTELRESTRICTEDTOOLS|INTELRESTRICTEDPKG)[\\/].*')\r
231         \r
232             for Dirpath, Dirnames, Filenames in Tuple:\r
233                 if IgnoredPattern.match(Dirpath.upper()) or Dirpath.find('.svn') != -1:\r
234                     continue\r
235                 for F in Filenames:\r
236                     if os.path.splitext(F)[1] in ('.h', '.c'):\r
237                         FullName = os.path.join(Dirpath, F)\r
238                         c.CheckDeclUnionTypedef(FullName)\r
239     \r
240     #\r
241     # Predicate Expression Checking\r
242     #\r
243     def PredicateExpressionCheck(self):\r
244         self.PredicateExpressionCheckBooleanValue()\r
245         self.PredicateExpressionCheckNonBooleanOperator()\r
246         self.PredicateExpressionCheckComparisonNullType()\r
247     \r
248     # Check whether Boolean values, variable type BOOLEAN not use explicit comparisons to TRUE or FALSE\r
249     def PredicateExpressionCheckBooleanValue(self):\r
250         if EccGlobalData.gConfig.PredicateExpressionCheckBooleanValue == '1' or EccGlobalData.gConfig.PredicateExpressionCheckAll == '1':\r
251             EdkLogger.quiet("Checking predicate expression Boolean value ...")\r
252             Tuple = os.walk(EccGlobalData.gTarget)\r
253             IgnoredPattern = re.compile(r'.*[\\/](?:BUILD|CVS|\.SVN|INTELRESTRICTEDTOOLS|INTELRESTRICTEDPKG)[\\/].*')\r
254         \r
255             for Dirpath, Dirnames, Filenames in Tuple:\r
256                 if IgnoredPattern.match(Dirpath.upper()) or Dirpath.find('.svn') != -1:\r
257                     continue\r
258                 for F in Filenames:\r
259                     if os.path.splitext(F)[1] in ('.c'):\r
260                         FullName = os.path.join(Dirpath, F)\r
261                         c.CheckBooleanValueComparison(FullName)\r
262     # Check whether Non-Boolean comparisons use a compare operator (==, !=, >, < >=, <=). \r
263     def PredicateExpressionCheckNonBooleanOperator(self):\r
264         if EccGlobalData.gConfig.PredicateExpressionCheckNonBooleanOperator == '1' or EccGlobalData.gConfig.PredicateExpressionCheckAll == '1':\r
265             EdkLogger.quiet("Checking predicate expression Non-Boolean variable...")\r
266             Tuple = os.walk(EccGlobalData.gTarget)\r
267             IgnoredPattern = re.compile(r'.*[\\/](?:BUILD|CVS|\.SVN|INTELRESTRICTEDTOOLS|INTELRESTRICTEDPKG)[\\/].*')\r
268         \r
269             for Dirpath, Dirnames, Filenames in Tuple:\r
270                 if IgnoredPattern.match(Dirpath.upper()) or Dirpath.find('.svn') != -1:\r
271                     continue\r
272                 for F in Filenames:\r
273                     if os.path.splitext(F)[1] in ('.c'):\r
274                         FullName = os.path.join(Dirpath, F)\r
275                         c.CheckNonBooleanValueComparison(FullName)\r
276     # Check whether a comparison of any pointer to zero must be done via the NULL type\r
277     def PredicateExpressionCheckComparisonNullType(self):\r
278         if EccGlobalData.gConfig.PredicateExpressionCheckComparisonNullType == '1' or EccGlobalData.gConfig.PredicateExpressionCheckAll == '1':\r
279             EdkLogger.quiet("Checking predicate expression NULL pointer ...")\r
280             Tuple = os.walk(EccGlobalData.gTarget)\r
281             IgnoredPattern = re.compile(r'.*[\\/](?:BUILD|CVS|\.SVN|INTELRESTRICTEDTOOLS|INTELRESTRICTEDPKG)[\\/].*')\r
282         \r
283             for Dirpath, Dirnames, Filenames in Tuple:\r
284                 if IgnoredPattern.match(Dirpath.upper()) or Dirpath.find('.svn') != -1:\r
285                     continue\r
286                 for F in Filenames:\r
287                     if os.path.splitext(F)[1] in ('.c'):\r
288                         FullName = os.path.join(Dirpath, F)\r
289                         c.CheckPointerNullComparison(FullName)\r
290     #\r
291     # Include file checking\r
292     #\r
293     def IncludeFileCheck(self):\r
294         self.IncludeFileCheckIfndef()\r
295         self.IncludeFileCheckData()\r
296     \r
297     #\r
298     # Check whether all include file contents is guarded by a #ifndef statement.\r
299     #\r
300     def IncludeFileCheckIfndef(self):\r
301         if EccGlobalData.gConfig.IncludeFileCheckIfndefStatement == '1' or EccGlobalData.gConfig.IncludeFileCheckAll == '1':\r
302             EdkLogger.quiet("Checking header file ifndef ...")\r
303             Tuple = os.walk(EccGlobalData.gTarget)\r
304             IgnoredPattern = re.compile(r'.*[\\/](?:BUILD|CVS|\.SVN|INTELRESTRICTEDTOOLS|INTELRESTRICTEDPKG)[\\/].*')\r
305         \r
306             for Dirpath, Dirnames, Filenames in Tuple:\r
307                 if IgnoredPattern.match(Dirpath.upper()) or Dirpath.find('.svn') != -1:\r
308                     continue\r
309                 for F in Filenames:\r
310                     if os.path.splitext(F)[1] in ('.h'):\r
311                         FullName = os.path.join(Dirpath, F)\r
312                         MsgList = c.CheckHeaderFileIfndef(FullName)\r
313     \r
314     #\r
315     # Check whether include files NOT contain code or define data variables\r
316     #\r
317     def IncludeFileCheckData(self):\r
318         if EccGlobalData.gConfig.IncludeFileCheckData == '1' or EccGlobalData.gConfig.IncludeFileCheckAll == '1':\r
319             EdkLogger.quiet("Checking header file data ...")\r
320             Tuple = os.walk(EccGlobalData.gTarget)\r
321             IgnoredPattern = re.compile(r'.*[\\/](?:BUILD|CVS|\.SVN|INTELRESTRICTEDTOOLS|INTELRESTRICTEDPKG)[\\/].*')\r
322         \r
323             for Dirpath, Dirnames, Filenames in Tuple:\r
324                 if IgnoredPattern.match(Dirpath.upper()) or Dirpath.find('.svn') != -1:\r
325                     continue\r
326                 for F in Filenames:\r
327                     if os.path.splitext(F)[1] in ('.h'):\r
328                         FullName = os.path.join(Dirpath, F)\r
329                         MsgList = c.CheckHeaderFileData(FullName)\r
330         \r
331     #\r
332     # Doxygen document checking\r
333     #\r
334     def DoxygenCheck(self):\r
335         self.DoxygenCheckFileHeader()\r
336         self.DoxygenCheckFunctionHeader()\r
337         self.DoxygenCheckCommentDescription()\r
338         self.DoxygenCheckCommentFormat()\r
339         self.DoxygenCheckCommand()\r
340     \r
341     #\r
342     # Check whether the file headers are followed Doxygen special documentation blocks in section 2.3.5\r
343     #\r
344     def DoxygenCheckFileHeader(self):\r
345         if EccGlobalData.gConfig.DoxygenCheckFileHeader == '1' or EccGlobalData.gConfig.DoxygenCheckAll == '1':\r
346             EdkLogger.quiet("Checking Doxygen file header ...")\r
347             Tuple = os.walk(EccGlobalData.gTarget)\r
348             IgnoredPattern = re.compile(r'.*[\\/](?:BUILD|CVS|\.SVN|INTELRESTRICTEDTOOLS|INTELRESTRICTEDPKG)[\\/].*')\r
349         \r
350             for Dirpath, Dirnames, Filenames in Tuple:\r
351                 if IgnoredPattern.match(Dirpath.upper()) or Dirpath.find('.svn') != -1:\r
352                     continue\r
353                 for F in Filenames:\r
354                     if os.path.splitext(F)[1] in ('.h', '.c'):\r
355                         FullName = os.path.join(Dirpath, F)\r
356                         MsgList = c.CheckFileHeaderDoxygenComments(FullName)\r
357     \r
358     #\r
359     # Check whether the function headers are followed Doxygen special documentation blocks in section 2.3.5\r
360     #\r
361     def DoxygenCheckFunctionHeader(self):\r
362         if EccGlobalData.gConfig.DoxygenCheckFunctionHeader == '1' or EccGlobalData.gConfig.DoxygenCheckAll == '1':\r
363             EdkLogger.quiet("Checking Doxygen function header ...")\r
364             Tuple = os.walk(EccGlobalData.gTarget)\r
365             IgnoredPattern = re.compile(r'.*[\\/](?:BUILD|CVS|\.SVN|INTELRESTRICTEDTOOLS|INTELRESTRICTEDPKG)[\\/].*')\r
366 #            ParseErrorFileList = []\r
367         \r
368             for Dirpath, Dirnames, Filenames in Tuple:\r
369                 if IgnoredPattern.match(Dirpath.upper()) or Dirpath.find('.svn') != -1:\r
370                     continue\r
371                 for F in Filenames:\r
372                     if os.path.splitext(F)[1] in ('.h', '.c'):\r
373                         FullName = os.path.join(Dirpath, F)\r
374                         MsgList = c.CheckFuncHeaderDoxygenComments(FullName)\r
375 #                        for Msg in MsgList:\r
376 #                            print Msg                \r
377                             \r
378     #\r
379     # Check whether the first line of text in a comment block is a brief description of the element being documented. \r
380     # The brief description must end with a period.\r
381     #\r
382     def DoxygenCheckCommentDescription(self):\r
383         if EccGlobalData.gConfig.DoxygenCheckCommentDescription == '1' or EccGlobalData.gConfig.DoxygenCheckAll == '1':\r
384             pass\r
385 \r
386     #\r
387     # Check whether comment lines with '///< ... text ...' format, if it is used, it should be after the code section.\r
388     #\r
389     def DoxygenCheckCommentFormat(self):\r
390         if EccGlobalData.gConfig.DoxygenCheckCommentFormat == '1' or EccGlobalData.gConfig.DoxygenCheckAll == '1':\r
391             EdkLogger.quiet("Checking Doxygen comment ///< ...")\r
392             Tuple = os.walk(EccGlobalData.gTarget)\r
393             IgnoredPattern = re.compile(r'.*[\\/](?:BUILD|CVS|\.SVN|INTELRESTRICTEDTOOLS|INTELRESTRICTEDPKG)[\\/].*')\r
394         \r
395             for Dirpath, Dirnames, Filenames in Tuple:\r
396                 if IgnoredPattern.match(Dirpath.upper()) or Dirpath.find('.svn') != -1:\r
397                     continue\r
398                 for F in Filenames:\r
399                     if os.path.splitext(F)[1] in ('.h', '.c'):\r
400                         FullName = os.path.join(Dirpath, F)\r
401                         MsgList = c.CheckDoxygenTripleForwardSlash(FullName)\r
402         \r
403     #\r
404     # Check whether only Doxygen commands allowed to mark the code are @bug and @todo.\r
405     #\r
406     def DoxygenCheckCommand(self):\r
407         if EccGlobalData.gConfig.DoxygenCheckCommand == '1' or EccGlobalData.gConfig.DoxygenCheckAll == '1':\r
408             EdkLogger.quiet("Checking Doxygen command ...")\r
409             Tuple = os.walk(EccGlobalData.gTarget)\r
410             IgnoredPattern = re.compile(r'.*[\\/](?:BUILD|CVS|\.SVN|INTELRESTRICTEDTOOLS|INTELRESTRICTEDPKG)[\\/].*')\r
411         \r
412             for Dirpath, Dirnames, Filenames in Tuple:\r
413                 if IgnoredPattern.match(Dirpath.upper()) or Dirpath.find('.svn') != -1:\r
414                     continue\r
415                 for F in Filenames:\r
416                     if os.path.splitext(F)[1] in ('.h', '.c'):\r
417                         FullName = os.path.join(Dirpath, F)\r
418                         MsgList = c.CheckDoxygenCommand(FullName)\r
419     \r
420     #\r
421     # Meta-Data File Processing Checking\r
422     #\r
423     def MetaDataFileCheck(self):\r
424         self.MetaDataFileCheckPathName()\r
425         self.MetaDataFileCheckGenerateFileList()\r
426         self.MetaDataFileCheckLibraryInstance()\r
427         self.MetaDataFileCheckLibraryInstanceDependent()\r
428         self.MetaDataFileCheckLibraryInstanceOrder()\r
429         self.MetaDataFileCheckLibraryNoUse()\r
430         self.MetaDataFileCheckBinaryInfInFdf()\r
431         self.MetaDataFileCheckPcdDuplicate()\r
432         self.MetaDataFileCheckPcdFlash()\r
433         self.MetaDataFileCheckPcdNoUse()\r
434         self.MetaDataFileCheckGuidDuplicate()\r
435 \r
436     #\r
437     # Check whether each file defined in meta-data exists\r
438     #\r
439     def MetaDataFileCheckPathName(self):\r
440         if EccGlobalData.gConfig.MetaDataFileCheckPathName == '1' or EccGlobalData.gConfig.MetaDataFileCheckAll == '1':\r
441             # This item is covered when parsing Inf/Dec/Dsc files\r
442             pass\r
443     \r
444     #\r
445     # Generate a list for all files defined in meta-data files\r
446     #\r
447     def MetaDataFileCheckGenerateFileList(self):\r
448         if EccGlobalData.gConfig.MetaDataFileCheckGenerateFileList == '1' or EccGlobalData.gConfig.MetaDataFileCheckAll == '1':\r
449             # This item is covered when parsing Inf/Dec/Dsc files\r
450             pass\r
451     \r
452     #\r
453     # Check whether all Library Instances defined for a given module (or dependent library instance) match the module's type.  \r
454     # Each Library Instance must specify the Supported Module Types in its Inf file, \r
455     # and any module specifying the library instance must be one of the supported types.\r
456     #\r
457     def MetaDataFileCheckLibraryInstance(self):\r
458         if EccGlobalData.gConfig.MetaDataFileCheckLibraryInstance == '1' or EccGlobalData.gConfig.MetaDataFileCheckAll == '1':\r
459             EdkLogger.quiet("Checking for library instance type issue ...")\r
460             SqlCommand = """select ID, Value2 from Inf where Value1 = 'LIBRARY_CLASS' and Model = %s group by BelongsToFile""" % MODEL_META_DATA_HEADER\r
461             RecordSet = EccGlobalData.gDb.TblInf.Exec(SqlCommand)\r
462             LibraryClasses = {}\r
463             for Record in RecordSet:\r
464                 List = Record[1].split('|', 1)\r
465                 if len(List) != 2:\r
466                     EccGlobalData.gDb.TblReport.Insert(ERROR_META_DATA_FILE_CHECK_LIBRARY_INSTANCE_2, OtherMsg = "The Library Class '%s' does not specify its supported module types" % (List[0]), BelongsToTable = 'Inf', BelongsToItem = Record[0])\r
467                 else:\r
468                     LibraryClasses[List[0]] = List[1]\r
469             SqlCommand = """select A.ID, A.Value1, B.Value2 from Inf as A left join Inf as B \r
470                             where A.Model = %s and B.Value1 = '%s' and B.Model = %s and B.BelongsToFile = A.BelongsToFile""" \\r
471                             % (MODEL_EFI_LIBRARY_CLASS, 'MODULE_TYPE', MODEL_META_DATA_HEADER)\r
472             RecordSet = EccGlobalData.gDb.TblInf.Exec(SqlCommand)\r
473             for Record in RecordSet:\r
474                 if Record[1] in LibraryClasses and LibraryClasses[Record[1]].find(Record[2]) < 0:\r
475                     EccGlobalData.gDb.TblReport.Insert(ERROR_META_DATA_FILE_CHECK_LIBRARY_INSTANCE_1, OtherMsg = "The type of Library Class '%s' defined in Inf file does not match the type of the module" % (Record[1]), BelongsToTable = 'Inf', BelongsToItem = Record[0])\r
476     #\r
477     # Check whether a Library Instance has been defined for all dependent library classes\r
478     #\r
479     def MetaDataFileCheckLibraryInstanceDependent(self):\r
480         if EccGlobalData.gConfig.MetaDataFileCheckLibraryInstanceDependent == '1' or EccGlobalData.gConfig.MetaDataFileCheckAll == '1':\r
481             EdkLogger.quiet("Checking for library instance dependent issue ...")\r
482             SqlCommand = """select ID, Value1, Value2 from Dsc where Model = %s""" % MODEL_EFI_LIBRARY_CLASS\r
483             LibraryClasses = EccGlobalData.gDb.TblDsc.Exec(SqlCommand)\r
484             for LibraryClass in LibraryClasses:\r
485                 if LibraryClass[1].upper() != 'NULL':\r
486                     LibraryIns = os.path.normpath(os.path.join(EccGlobalData.gWorkspace, LibraryClass[2]))\r
487                     SqlCommand = """select Value2 from Inf where BelongsToFile = \r
488                                     (select ID from File where lower(FullPath) = lower('%s'))\r
489                                     and Value1 = '%s'""" % (LibraryIns, 'LIBRARY_CLASS')\r
490                     RecordSet = EccGlobalData.gDb.TblInf.Exec(SqlCommand)\r
491                     IsFound = False\r
492                     for Record in RecordSet:\r
493                         LibName = Record[0].split('|', 1)[0]\r
494                         if LibraryClass[1] == LibName:\r
495                             IsFound = True\r
496                     if not IsFound:\r
497                         EccGlobalData.gDb.TblReport.Insert(ERROR_META_DATA_FILE_CHECK_LIBRARY_INSTANCE_DEPENDENT, OtherMsg = "The Library Class '%s' is not specified in '%s'" % (LibraryClass[1], LibraryClass[2]), BelongsToTable = 'Dsc', BelongsToItem = LibraryClass[0])\r
498     #\r
499     # Check whether the Library Instances specified by the LibraryClasses sections are listed in order of dependencies\r
500     #\r
501     def MetaDataFileCheckLibraryInstanceOrder(self):\r
502         if EccGlobalData.gConfig.MetaDataFileCheckLibraryInstanceOrder == '1' or EccGlobalData.gConfig.MetaDataFileCheckAll == '1':\r
503             # This checkpoint is not necessary for Ecc check\r
504             pass\r
505 \r
506     #\r
507     # Check whether the unnecessary inclusion of library classes in the Inf file\r
508     #\r
509     def MetaDataFileCheckLibraryNoUse(self):\r
510         if EccGlobalData.gConfig.MetaDataFileCheckLibraryNoUse == '1' or EccGlobalData.gConfig.MetaDataFileCheckAll == '1':\r
511             EdkLogger.quiet("Checking for library instance not used ...")\r
512             SqlCommand = """select ID, Value1 from Inf as A where A.Model = %s and A.Value1 not in (select B.Value1 from Dsc as B where Model = %s)""" % (MODEL_EFI_LIBRARY_CLASS, MODEL_EFI_LIBRARY_CLASS)\r
513             RecordSet = EccGlobalData.gDb.TblInf.Exec(SqlCommand)\r
514             for Record in RecordSet:\r
515                 EccGlobalData.gDb.TblReport.Insert(ERROR_META_DATA_FILE_CHECK_LIBRARY_NO_USE, OtherMsg = "The Library Class '%s' is not used in any platform" % (Record[1]), BelongsToTable = 'Inf', BelongsToItem = Record[0])\r
516 \r
517     #\r
518     # Check whether an Inf file is specified in the FDF file, but not in the Dsc file, then the Inf file must be for a Binary module only\r
519     #\r
520     def MetaDataFileCheckBinaryInfInFdf(self):\r
521         if EccGlobalData.gConfig.MetaDataFileCheckBinaryInfInFdf == '1' or EccGlobalData.gConfig.MetaDataFileCheckAll == '1':\r
522             EdkLogger.quiet("Checking for non-binary modules defined in FDF files ...")\r
523             SqlCommand = """select A.ID, A.Value1 from Fdf as A\r
524                          where A.Model = %s\r
525                          and A.Enabled > -1\r
526                          and A.Value1 not in \r
527                          (select B.Value1 from Dsc as B\r
528                          where B.Model = %s\r
529                          and B.Enabled > -1)""" % (MODEL_META_DATA_COMPONENT, MODEL_META_DATA_COMPONENT)\r
530             RecordSet = EccGlobalData.gDb.TblFdf.Exec(SqlCommand)\r
531             for Record in RecordSet:\r
532                 FdfID = Record[0]\r
533                 FilePath = Record[1]\r
534                 FilePath = os.path.normpath(os.path.join(EccGlobalData.gWorkspace, FilePath))\r
535                 SqlCommand = """select ID from Inf where Model = %s and BelongsToFile = (select ID from File where FullPath like '%s')\r
536                                 """ % (MODEL_EFI_SOURCE_FILE, FilePath)\r
537                 NewRecordSet = EccGlobalData.gDb.TblFile.Exec(SqlCommand)\r
538                 if NewRecordSet!= []:\r
539                     EccGlobalData.gDb.TblReport.Insert(ERROR_META_DATA_FILE_CHECK_BINARY_INF_IN_FDF, OtherMsg = "File %s defined in FDF file and not in DSC file must be a binary module" % (FilePath), BelongsToTable = 'Fdf', BelongsToItem = FdfID)\r
540 \r
541     #\r
542     # Check whether a PCD is set in a Dsc file or the FDF file, but not in both.\r
543     #\r
544     def MetaDataFileCheckPcdDuplicate(self):\r
545         if EccGlobalData.gConfig.MetaDataFileCheckPcdDuplicate == '1' or EccGlobalData.gConfig.MetaDataFileCheckAll == '1':\r
546             EdkLogger.quiet("Checking for duplicate PCDs defined in both DSC and FDF files ...")\r
547             SqlCommand = """\r
548                          select A.ID, A.Value2, B.ID, B.Value2 from Dsc as A, Fdf as B \r
549                          where A.Model >= %s and A.Model < %s \r
550                          and B.Model >= %s and B.Model < %s \r
551                          and A.Value2 = B.Value2\r
552                          and A.Enabled > -1\r
553                          and B.Enabled > -1\r
554                          """% (MODEL_PCD, MODEL_META_DATA_HEADER, MODEL_PCD, MODEL_META_DATA_HEADER)\r
555             RecordSet = EccGlobalData.gDb.TblDsc.Exec(SqlCommand)\r
556             for Record in RecordSet:\r
557                 EccGlobalData.gDb.TblReport.Insert(ERROR_META_DATA_FILE_CHECK_PCD_DUPLICATE, OtherMsg = "The PCD '%s' is defined in both FDF file and DSC file" % (Record[1]), BelongsToTable = 'Dsc', BelongsToItem = Record[0])\r
558                 EccGlobalData.gDb.TblReport.Insert(ERROR_META_DATA_FILE_CHECK_PCD_DUPLICATE, OtherMsg = "The PCD '%s' is defined in both FDF file and DSC file" % (Record[3]), BelongsToTable = 'Fdf', BelongsToItem = Record[2])\r
559 \r
560     #\r
561     # Check whether PCD settings in the FDF file can only be related to flash.\r
562     #\r
563     def MetaDataFileCheckPcdFlash(self):\r
564         if EccGlobalData.gConfig.MetaDataFileCheckPcdFlash == '1' or EccGlobalData.gConfig.MetaDataFileCheckAll == '1':\r
565             EdkLogger.quiet("Checking only Flash related PCDs are used in FDF ...")\r
566             SqlCommand = """\r
567                          select ID, Value2, BelongsToFile from Fdf as A\r
568                          where A.Model >= %s and Model < %s\r
569                          and A.Enabled > -1\r
570                          and A.Value2 not like '%%Flash%%'\r
571                          """% (MODEL_PCD, MODEL_META_DATA_HEADER)\r
572             RecordSet = EccGlobalData.gDb.TblFdf.Exec(SqlCommand)\r
573             for Record in RecordSet:\r
574                 EccGlobalData.gDb.TblReport.Insert(ERROR_META_DATA_FILE_CHECK_PCD_FLASH, OtherMsg = "The PCD '%s' defined in FDF file is not related to Flash" % (Record[1]), BelongsToTable = 'Fdf', BelongsToItem = Record[0])\r
575         \r
576     #\r
577     # Check whether PCDs used in Inf files but not specified in Dsc or FDF files\r
578     #\r
579     def MetaDataFileCheckPcdNoUse(self):\r
580         if EccGlobalData.gConfig.MetaDataFileCheckPcdNoUse == '1' or EccGlobalData.gConfig.MetaDataFileCheckAll == '1':\r
581             EdkLogger.quiet("Checking for non-specified PCDs ...")\r
582             SqlCommand = """\r
583                          select ID, Value2, BelongsToFile from Inf as A \r
584                          where A.Model >= %s and Model < %s\r
585                          and A.Enabled > -1\r
586                          and A.Value2 not in \r
587                              (select Value2 from Dsc as B \r
588                               where B.Model >= %s and B.Model < %s\r
589                               and B.Enabled > -1)\r
590                          and A.Value2 not in\r
591                              (select Value2 from Fdf as C \r
592                               where C.Model >= %s and C.Model < %s\r
593                               and C.Enabled > -1)\r
594                          """% (MODEL_PCD, MODEL_META_DATA_HEADER, MODEL_PCD, MODEL_META_DATA_HEADER, MODEL_PCD, MODEL_META_DATA_HEADER)\r
595             RecordSet = EccGlobalData.gDb.TblInf.Exec(SqlCommand)\r
596             for Record in RecordSet:\r
597                 EccGlobalData.gDb.TblReport.Insert(ERROR_META_DATA_FILE_CHECK_PCD_NO_USE, OtherMsg = "The PCD '%s' defined in INF file is not specified in either DSC or FDF files" % (Record[1]), BelongsToTable = 'Inf', BelongsToItem = Record[0])\r
598         \r
599     #\r
600     # Check whether having duplicate guids defined for Guid/Protocol/Ppi\r
601     #\r
602     def MetaDataFileCheckGuidDuplicate(self):\r
603         if EccGlobalData.gConfig.MetaDataFileCheckGuidDuplicate == '1' or EccGlobalData.gConfig.MetaDataFileCheckAll == '1':\r
604             EdkLogger.quiet("Checking for duplicate GUID/PPI/PROTOCOL ...")\r
605             #\r
606             # Check Guid\r
607             #\r
608             self.CheckGuidProtocolPpi(ERROR_META_DATA_FILE_CHECK_DUPLICATE_GUID, MODEL_EFI_GUID, EccGlobalData.gDb.TblDec)\r
609             self.CheckGuidProtocolPpi(ERROR_META_DATA_FILE_CHECK_DUPLICATE_GUID, MODEL_EFI_GUID, EccGlobalData.gDb.TblDsc)\r
610             self.CheckGuidProtocolPpiValue(ERROR_META_DATA_FILE_CHECK_DUPLICATE_GUID, MODEL_EFI_GUID)\r
611             #\r
612             # Check protocol\r
613             #\r
614             self.CheckGuidProtocolPpi(ERROR_META_DATA_FILE_CHECK_DUPLICATE_PROTOCOL, MODEL_EFI_PROTOCOL, EccGlobalData.gDb.TblDec)\r
615             self.CheckGuidProtocolPpi(ERROR_META_DATA_FILE_CHECK_DUPLICATE_PROTOCOL, MODEL_EFI_PROTOCOL, EccGlobalData.gDb.TblDsc)\r
616             self.CheckGuidProtocolPpiValue(ERROR_META_DATA_FILE_CHECK_DUPLICATE_PROTOCOL, MODEL_EFI_PROTOCOL)\r
617             #\r
618             # Check ppi\r
619             #\r
620             self.CheckGuidProtocolPpi(ERROR_META_DATA_FILE_CHECK_DUPLICATE_PPI, MODEL_EFI_PPI, EccGlobalData.gDb.TblDec)\r
621             self.CheckGuidProtocolPpi(ERROR_META_DATA_FILE_CHECK_DUPLICATE_PPI, MODEL_EFI_PPI, EccGlobalData.gDb.TblDsc)\r
622             self.CheckGuidProtocolPpiValue(ERROR_META_DATA_FILE_CHECK_DUPLICATE_PPI, MODEL_EFI_PPI)\r
623 \r
624             #EdkLogger.quiet("Checking duplicate guid/ppi/protocol done!")\r
625     \r
626     #\r
627     # Check whether these is duplicate Guid/Ppi/Protocol name\r
628     #\r
629     def CheckGuidProtocolPpi(self, ErrorID, Model, Table):\r
630         Name = ''\r
631         if Model == MODEL_EFI_GUID:\r
632             Name = 'guid'\r
633         if Model == MODEL_EFI_PROTOCOL:\r
634             Name = 'protocol'\r
635         if Model == MODEL_EFI_PPI:\r
636             Name = 'ppi'\r
637         SqlCommand = """\r
638                      select A.ID, A.Value1 from %s as A, %s as B \r
639                      where A.Model = %s and B.Model = %s \r
640                      and A.Value1 = B.Value1 and A.ID <> B.ID \r
641                      and A.Enabled > -1\r
642                      and B.Enabled > -1\r
643                      group by A.ID\r
644                      """ % (Table.Table, Table.Table, Model, Model)\r
645         RecordSet = Table.Exec(SqlCommand)\r
646         for Record in RecordSet:\r
647             EccGlobalData.gDb.TblReport.Insert(ErrorID, OtherMsg = "The %s name '%s' is defined more than one time" % (Name.upper(), Record[1]), BelongsToTable = Table.Table, BelongsToItem = Record[0])\r
648 \r
649     #\r
650     # Check whether these is duplicate Guid/Ppi/Protocol value\r
651     #\r
652     def CheckGuidProtocolPpiValue(self, ErrorID, Model):\r
653         Name = ''\r
654         Table = EccGlobalData.gDb.TblDec\r
655         if Model == MODEL_EFI_GUID:\r
656             Name = 'guid'\r
657         if Model == MODEL_EFI_PROTOCOL:\r
658             Name = 'protocol'\r
659         if Model == MODEL_EFI_PPI:\r
660             Name = 'ppi'\r
661         SqlCommand = """\r
662                      select A.ID, A.Value2 from %s as A, %s as B \r
663                      where A.Model = %s and B.Model = %s \r
664                      and A.Value2 = B.Value2 and A.ID <> B.ID \r
665                      group by A.ID\r
666                      """ % (Table.Table, Table.Table, Model, Model)\r
667         RecordSet = Table.Exec(SqlCommand)\r
668         for Record in RecordSet:\r
669             EccGlobalData.gDb.TblReport.Insert(ErrorID, OtherMsg = "The %s value '%s' is used more than one time" % (Name.upper(), Record[1]), BelongsToTable = Table.Table, BelongsToItem = Record[0])\r
670 \r
671     #\r
672     # Naming Convention Check\r
673     #\r
674     def NamingConventionCheck(self):\r
675         self.NamingConventionCheckDefineStatement()\r
676         self.NamingConventionCheckTypedefStatement()\r
677         self.NamingConventionCheckIfndefStatement()\r
678         self.NamingConventionCheckPathName()\r
679         self.NamingConventionCheckVariableName()\r
680         self.NamingConventionCheckFunctionName()\r
681         self.NamingConventionCheckSingleCharacterVariable()\r
682         \r
683     #\r
684     # Check whether only capital letters are used for #define declarations\r
685     #\r
686     def NamingConventionCheckDefineStatement(self):\r
687         if EccGlobalData.gConfig.NamingConventionCheckDefineStatement == '1' or EccGlobalData.gConfig.NamingConventionCheckAll == '1':\r
688             EdkLogger.quiet("Checking naming covention of #define statement ...")\r
689             for IdentifierTable in EccGlobalData.gIdentifierTableList:\r
690                 SqlCommand = """select ID, Value from %s where Model = %s""" %(IdentifierTable, MODEL_IDENTIFIER_MACRO_DEFINE)\r
691                 RecordSet = EccGlobalData.gDb.TblFile.Exec(SqlCommand)\r
692                 for Record in RecordSet:\r
693                     Name = Record[1].strip().split()[1]\r
694                     Name = Name[0:Name.find('(')]\r
695                     if Name.upper() != Name:\r
696                         EccGlobalData.gDb.TblReport.Insert(ERROR_NAMING_CONVENTION_CHECK_DEFINE_STATEMENT, OtherMsg = "The #define name '%s' does not follow the rules" % (Name), BelongsToTable = IdentifierTable, BelongsToItem = Record[0])\r
697     \r
698     #\r
699     # Check whether only capital letters are used for typedef declarations\r
700     #\r
701     def NamingConventionCheckTypedefStatement(self):\r
702         if EccGlobalData.gConfig.NamingConventionCheckTypedefStatement == '1' or EccGlobalData.gConfig.NamingConventionCheckAll == '1':\r
703             EdkLogger.quiet("Checking naming covention of #typedef statement ...")\r
704             for IdentifierTable in EccGlobalData.gIdentifierTableList:\r
705                 SqlCommand = """select ID, Name from %s where Model = %s""" %(IdentifierTable, MODEL_IDENTIFIER_TYPEDEF)\r
706                 RecordSet = EccGlobalData.gDb.TblFile.Exec(SqlCommand)\r
707                 for Record in RecordSet:\r
708                     Name = Record[1].strip()\r
709                     if Name[0] == '(':\r
710                         Name = Name[1:Name.find(')')]\r
711                     if Name.find('(') > -1:\r
712                         Name = Name[Name.find('(') + 1 : Name.find(')')]\r
713                     Name = Name.replace('WINAPI', '')\r
714                     Name = Name.replace('*', '').strip()\r
715                     if Name.upper() != Name:\r
716                         EccGlobalData.gDb.TblReport.Insert(ERROR_NAMING_CONVENTION_CHECK_TYPEDEF_STATEMENT, OtherMsg = "The #typedef name '%s' does not follow the rules" % (Name), BelongsToTable = IdentifierTable, BelongsToItem = Record[0])\r
717     \r
718     #\r
719     # Check whether the #ifndef at the start of an include file uses both prefix and postfix underscore characters, '_'.\r
720     #\r
721     def NamingConventionCheckIfndefStatement(self):\r
722         if EccGlobalData.gConfig.NamingConventionCheckTypedefStatement == '1' or EccGlobalData.gConfig.NamingConventionCheckAll == '1':\r
723             EdkLogger.quiet("Checking naming covention of #ifndef statement ...")\r
724             for IdentifierTable in EccGlobalData.gIdentifierTableList:\r
725                 SqlCommand = """select ID, Value from %s where Model = %s""" %(IdentifierTable, MODEL_IDENTIFIER_MACRO_IFNDEF)\r
726                 RecordSet = EccGlobalData.gDb.TblFile.Exec(SqlCommand)\r
727                 for Record in RecordSet:\r
728                     Name = Record[1].replace('#ifndef', '').strip()\r
729                     if Name[0] != '_' or Name[-1] != '_':\r
730                         EccGlobalData.gDb.TblReport.Insert(ERROR_NAMING_CONVENTION_CHECK_IFNDEF_STATEMENT, OtherMsg = "The #ifndef name '%s' does not follow the rules" % (Name), BelongsToTable = IdentifierTable, BelongsToItem = Record[0])\r
731     \r
732     #\r
733     # Rule for path name, variable name and function name\r
734     # 1. First character should be upper case\r
735     # 2. Existing lower case in a word\r
736     # 3. No space existence\r
737     # Check whether the path name followed the rule\r
738     #\r
739     def NamingConventionCheckPathName(self):\r
740         if EccGlobalData.gConfig.NamingConventionCheckPathName == '1' or EccGlobalData.gConfig.NamingConventionCheckAll == '1':\r
741             EdkLogger.quiet("Checking naming covention of file path name ...")\r
742             Pattern = re.compile(r'^[A-Z]+\S*[a-z]\S*$')\r
743             SqlCommand = """select ID, Name from File"""\r
744             RecordSet = EccGlobalData.gDb.TblFile.Exec(SqlCommand)\r
745             for Record in RecordSet:\r
746                 if not Pattern.match(Record[1]):\r
747                     EccGlobalData.gDb.TblReport.Insert(ERROR_NAMING_CONVENTION_CHECK_PATH_NAME, OtherMsg = "The file path '%s' does not follow the rules" % (Record[1]), BelongsToTable = 'File', BelongsToItem = Record[0])\r
748     \r
749     #\r
750     # Rule for path name, variable name and function name\r
751     # 1. First character should be upper case\r
752     # 2. Existing lower case in a word\r
753     # 3. No space existence\r
754     # 4. Global variable name must start with a 'g'\r
755     # Check whether the variable name followed the rule\r
756     #\r
757     def NamingConventionCheckVariableName(self):\r
758         if EccGlobalData.gConfig.NamingConventionCheckVariableName == '1' or EccGlobalData.gConfig.NamingConventionCheckAll == '1':\r
759             EdkLogger.quiet("Checking naming covention of variable name ...")\r
760             Pattern = re.compile(r'^[A-Zgm]+\S*[a-z]\S*$')\r
761             for IdentifierTable in EccGlobalData.gIdentifierTableList:\r
762                 SqlCommand = """select ID, Name from %s where Model = %s""" %(IdentifierTable, MODEL_IDENTIFIER_VARIABLE)\r
763                 RecordSet = EccGlobalData.gDb.TblFile.Exec(SqlCommand)\r
764                 for Record in RecordSet:\r
765                     if not Pattern.match(Record[1]):\r
766                         EccGlobalData.gDb.TblReport.Insert(ERROR_NAMING_CONVENTION_CHECK_VARIABLE_NAME, OtherMsg = "The variable name '%s' does not follow the rules" % (Record[1]), BelongsToTable = IdentifierTable, BelongsToItem = Record[0])\r
767 \r
768     #\r
769     # Rule for path name, variable name and function name\r
770     # 1. First character should be upper case\r
771     # 2. Existing lower case in a word\r
772     # 3. No space existence\r
773     # Check whether the function name followed the rule\r
774     #\r
775     def NamingConventionCheckFunctionName(self):\r
776         if EccGlobalData.gConfig.NamingConventionCheckFunctionName == '1' or EccGlobalData.gConfig.NamingConventionCheckAll == '1':\r
777             EdkLogger.quiet("Checking naming covention of function name ...")\r
778             Pattern = re.compile(r'^[A-Z]+\S*[a-z]\S*$')\r
779             SqlCommand = """select ID, Name from Function"""\r
780             RecordSet = EccGlobalData.gDb.TblFile.Exec(SqlCommand)\r
781             for Record in RecordSet:\r
782                 if not Pattern.match(Record[1]):\r
783                     EccGlobalData.gDb.TblReport.Insert(ERROR_NAMING_CONVENTION_CHECK_FUNCTION_NAME, OtherMsg = "The function name '%s' does not follow the rules" % (Record[1]), BelongsToTable = 'Function', BelongsToItem = Record[0])\r
784 \r
785     #\r
786     # Check whether NO use short variable name with single character\r
787     #\r
788     def NamingConventionCheckSingleCharacterVariable(self):\r
789         if EccGlobalData.gConfig.NamingConventionCheckSingleCharacterVariable == '1' or EccGlobalData.gConfig.NamingConventionCheckAll == '1':\r
790             EdkLogger.quiet("Checking naming covention of single character variable name ...")\r
791             for IdentifierTable in EccGlobalData.gIdentifierTableList:\r
792                 SqlCommand = """select ID, Name from %s where Model = %s""" %(IdentifierTable, MODEL_IDENTIFIER_VARIABLE)\r
793                 RecordSet = EccGlobalData.gDb.TblFile.Exec(SqlCommand)\r
794                 for Record in RecordSet:\r
795                     Variable = Record[1].replace('*', '')\r
796                     if len(Variable) == 1:\r
797                         EccGlobalData.gDb.TblReport.Insert(ERROR_NAMING_CONVENTION_CHECK_SINGLE_CHARACTER_VARIABLE, OtherMsg = "The variable name '%s' does not follow the rules" % (Record[1]), BelongsToTable = IdentifierTable, BelongsToItem = Record[0])\r
798 \r
799 ##\r
800 #\r
801 # This acts like the main() function for the script, unless it is 'import'ed into another\r
802 # script.\r
803 #\r
804 if __name__ == '__main__':\r
805     Check = Check()\r
806     Check.Check()\r