Cleanup of analyzer scripts as suggested by pychecker and pep8

[ariccio]

Summary

Pychecker & pep8 noticed a number of issues (thankfully none are bugs) that are easily fixable, so I went ahead and fixed them.

[zaks.anna]

Not sure how you got these changes, but some of them seem wrong and some seem inconsistently applied.

Has this been tested?

C:/LLVM/llvm/tools/clang/utils/analyzer/CmpRuns.py

194

PEP 0008: Don't use spaces around the = sign when used to indicate a keyword argument or a default parameter value.

[ariccio]

Whoops, forgot to submit my earlier comments. Responding to comments right now...

C:/LLVM/llvm/tools/clang/utils/analyzer/CmpRuns.py

31

This file imports itself?

I wasn't sure if I could eliminate this.

C:/LLVM/llvm/tools/clang/utils/analyzer/SATestBuild.py

62

Should this be replaced with multiprocessing.cpu_count?

[ariccio]

In D17253#353000, @zaks.anna wrote:

Not sure how you got these changes, but some of them seem wrong and some seem inconsistently applied.

Has this been tested?

Not yet, I was toying with running the first SARD test under it, and read through the code to get an idea of how it works. I remembered that I had PyChecker and pep8 installed, and ran them.

Line length fixes are inconsistently applied. I figured that I'd deal with the worst right now, and deal with the rest later. I can fix all of them in a revised patch if you'd like.

...but are there any functional changes? I didn't intend to make any here.

PyChecker produced the following output for SATestBuild.py:

C:\Users\Alexander Riccio\Downloads>C:\Python27\python.exe  C:\Python27\Lib\site-packages\pychecker\checker.py --limit 1000 -Q 1 -P SATestBuild.py
[system path]\subprocess.py:406: No doc string for function __init__
[system path]\subprocess.py:410: No doc string for function __str__

SATestBuild.py:67: No module attribute (sysconf_names) found
SATestBuild.py:69: No module attribute (sysconf) found
SATestBuild.py:73: No global (capture) found
SATestBuild.py:114: No doc string for class flushfile
SATestBuild.py:114: No doc string for function __init__
SATestBuild.py:116: No doc string for function write
SATestBuild.py:122: No doc string for function getProjectMapPath
SATestBuild.py:131: No doc string for function getProjectDir
SATestBuild.py:134: No doc string for function getSBOutputDirName
SATestBuild.py:135: Comparisons with True are not necessary and may not work as expected
SATestBuild.py:205: No doc string for function runCleanupScript
SATestBuild.py:211: No doc string for function runDownloadScript
SATestBuild.py:216: No doc string for function runScript
SATestBuild.py:234: No doc string for function downloadAndPatch
SATestBuild.py:255: No doc string for function applyPatch
SATestBuild.py:275: No doc string for function runScanBuild
SATestBuild.py:319: No doc string for function hasNoExtension
SATestBuild.py:325: No doc string for function isValidSingleInputFile
SATestBuild.py:335: No doc string for function getSDKPath
SATestBuild.py:343: No doc string for function runAnalyzePreprocessed
SATestBuild.py:374: Comparisons with False are not necessary and may not work as expected
SATestBuild.py:397: Comparisons with False are not necessary and may not work as expected
SATestBuild.py:400: No doc string for function getBuildLogPath
SATestBuild.py:403: No doc string for function removeLogFile
SATestBuild.py:412: No doc string for function buildProject
SATestBuild.py:469: No doc string for function CleanUpEmptyPlists
SATestBuild.py:482: No doc string for function checkBuild
SATestBuild.py:506: Local variable (FailuresCopied) not used
SATestBuild.py:526: No doc string for class Discarder
SATestBuild.py:526: No doc string for function write
SATestBuild.py:534: No doc string for function runCmpResults
SATestBuild.py:595: No doc string for function cleanupReferenceResults
SATestBuild.py:608: No doc string for function updateSVN
SATestBuild.py:637: No doc string for function testProject
SATestBuild.py:655: Comparisons with False are not necessary and may not work as expected
SATestBuild.py:663: No doc string for function testAll
SATestBuild.py:678: Comparisons with True are not necessary and may not work as expected
SATestBuild.py:679: Comparisons with True are not necessary and may not work as expected
SATestBuild.py:688: Comparisons with True are not necessary and may not work as expected

pep8 produced some noisier output for SATestBuild.py:

C:\Users\Alexander Riccio\Downloads>C:\Python27\Scripts\pep8 --ignore=E111 SATestBuild.py
SATestBuild.py:6:80: E501 line too long (80 > 79 characters)
SATestBuild.py:23:80: E501 line too long (81 > 79 characters)
SATestBuild.py:57:1: E265 block comment should start with '# '
SATestBuild.py:59:1: E265 block comment should start with '# '
SATestBuild.py:61:1: E302 expected 2 blank lines, found 1
SATestBuild.py:67:28: W601 .has_key() is deprecated, use 'in'
SATestBuild.py:72:14: E261 at least two spaces before inline comment
SATestBuild.py:75:18: W601 .has_key() is deprecated, use 'in'
SATestBuild.py:79:13: E261 at least two spaces before inline comment
SATestBuild.py:81:1: E302 expected 2 blank lines, found 1
SATestBuild.py:81:25: E251 unexpected spaces around keyword / parameter equals
SATestBuild.py:81:27: E251 unexpected spaces around keyword / parameter equals
SATestBuild.py:86:37: E231 missing whitespace after ','
SATestBuild.py:113:1: E302 expected 2 blank lines, found 1
SATestBuild.py:116:5: E301 expected 1 blank line, found 0
SATestBuild.py:122:1: E302 expected 2 blank lines, found 1
SATestBuild.py:127:17: E126 continuation line over-indented for hanging indent
SATestBuild.py:131:1: E302 expected 2 blank lines, found 1
SATestBuild.py:134:1: E302 expected 2 blank lines, found 1
SATestBuild.py:134:41: E203 whitespace before ':'
SATestBuild.py:135:25: E712 comparison to True should be 'if cond is True:' or 'if cond:'
SATestBuild.py:135:32: E203 whitespace before ':'
SATestBuild.py:137:9: E203 whitespace before ':'
SATestBuild.py:140:1: E265 block comment should start with '# '
SATestBuild.py:142:1: E265 block comment should start with '# '
SATestBuild.py:178:80: E501 line too long (80 > 79 characters)
SATestBuild.py:196:9: E225 missing whitespace around operator
SATestBuild.py:196:80: E501 line too long (122 > 79 characters)
SATestBuild.py:200:1: E265 block comment should start with '# '
SATestBuild.py:202:1: E265 block comment should start with '# '
SATestBuild.py:205:1: E302 expected 2 blank lines, found 1
SATestBuild.py:211:1: E302 expected 2 blank lines, found 1
SATestBuild.py:216:1: E302 expected 2 blank lines, found 1
SATestBuild.py:221:57: E251 unexpected spaces around keyword / parameter equals
SATestBuild.py:221:59: E251 unexpected spaces around keyword / parameter equals
SATestBuild.py:222:47: E127 continuation line over-indented for visual indent
SATestBuild.py:223:47: E127 continuation line over-indented for visual indent
SATestBuild.py:224:47: E127 continuation line over-indented for visual indent
SATestBuild.py:225:48: E251 unexpected spaces around keyword / parameter equals
SATestBuild.py:225:50: E251 unexpected spaces around keyword / parameter equals
SATestBuild.py:226:47: E127 continuation line over-indented for visual indent
SATestBuild.py:227:47: E127 continuation line over-indented for visual indent
SATestBuild.py:229:80: E501 line too long (80 > 79 characters)
SATestBuild.py:230:17: E128 continuation line under-indented for visual indent
SATestBuild.py:234:1: E302 expected 2 blank lines, found 1
SATestBuild.py:255:1: E302 expected 2 blank lines, found 1
SATestBuild.py:265:21: E127 continuation line over-indented for visual indent
SATestBuild.py:265:24: E251 unexpected spaces around keyword / parameter equals
SATestBuild.py:265:26: E251 unexpected spaces around keyword / parameter equals
SATestBuild.py:266:21: E127 continuation line over-indented for visual indent
SATestBuild.py:267:21: E127 continuation line over-indented for visual indent
SATestBuild.py:268:21: E127 continuation line over-indented for visual indent
SATestBuild.py:275:1: E302 expected 2 blank lines, found 1
SATestBuild.py:282:18: W601 .has_key() is deprecated, use 'in'
SATestBuild.py:288:41: E222 multiple spaces after operator
SATestBuild.py:301:25: E703 statement ends with a semicolon
SATestBuild.py:306:17: E125 continuation line with same indent as next logical line
SATestBuild.py:311:38: E251 unexpected spaces around keyword / parameter equals
SATestBuild.py:311:40: E251 unexpected spaces around keyword / parameter equals
SATestBuild.py:312:48: E127 continuation line over-indented for visual indent
SATestBuild.py:313:48: E127 continuation line over-indented for visual indent
SATestBuild.py:315:47: E231 missing whitespace after ','
SATestBuild.py:319:1: E302 expected 2 blank lines, found 1
SATestBuild.py:321:21: E203 whitespace before ':'
SATestBuild.py:325:1: E302 expected 2 blank lines, found 1
SATestBuild.py:329:9: E129 visually indented line with same indent as next logical line
SATestBuild.py:329:37: E203 whitespace before ':'
SATestBuild.py:335:1: E302 expected 2 blank lines, found 1
SATestBuild.py:343:1: E302 expected 2 blank lines, found 1
SATestBuild.py:346:16: E126 continuation line over-indented for hanging indent
SATestBuild.py:358:51: E225 missing whitespace around operator
SATestBuild.py:360:19: E203 whitespace before ':'
SATestBuild.py:364:51: E703 statement ends with a semicolon
SATestBuild.py:365:26: E703 statement ends with a semicolon
SATestBuild.py:374:46: E712 comparison to False should be 'if cond is False:' or 'if not cond:'
SATestBuild.py:385:36: E251 unexpected spaces around keyword / parameter equals
SATestBuild.py:385:38: E251 unexpected spaces around keyword / parameter equals
SATestBuild.py:386:44: E127 continuation line over-indented for visual indent
SATestBuild.py:387:44: E127 continuation line over-indented for visual indent
SATestBuild.py:391:20: E126 continuation line over-indented for hanging indent
SATestBuild.py:397:19: E712 comparison to False should be 'if cond is False:' or 'if not cond:'
SATestBuild.py:398:36: E703 statement ends with a semicolon
SATestBuild.py:400:1: E302 expected 2 blank lines, found 1
SATestBuild.py:403:1: E302 expected 2 blank lines, found 1
SATestBuild.py:406:36: E203 whitespace before ':'
SATestBuild.py:412:1: E302 expected 2 blank lines, found 1
SATestBuild.py:417:35: E225 missing whitespace around operator
SATestBuild.py:422:37: E203 whitespace before ':'
SATestBuild.py:442:28: E203 whitespace before ':'
SATestBuild.py:455:56: E226 missing whitespace around arithmetic operator
SATestBuild.py:455:60: E502 the backslash is redundant between brackets
SATestBuild.py:456:31: E127 continuation line over-indented for visual indent
SATestBuild.py:456:67: E502 the backslash is redundant between brackets
SATestBuild.py:457:31: E127 continuation line over-indented for visual indent
SATestBuild.py:465:12: E127 continuation line over-indented for visual indent
SATestBuild.py:465:25: E226 missing whitespace around arithmetic operator
SATestBuild.py:469:1: E302 expected 2 blank lines, found 1
SATestBuild.py:482:1: E302 expected 2 blank lines, found 1
SATestBuild.py:485:32: E703 statement ends with a semicolon
SATestBuild.py:490:12: E127 continuation line over-indented for visual indent
SATestBuild.py:491:15: E703 statement ends with a semicolon
SATestBuild.py:494:80: E501 line too long (83 > 79 characters)
SATestBuild.py:503:52: E127 continuation line over-indented for visual indent
SATestBuild.py:510:22: E703 statement ends with a semicolon
SATestBuild.py:512:70: E703 statement ends with a semicolon
SATestBuild.py:513:47: E703 statement ends with a semicolon
SATestBuild.py:515:57: E703 statement ends with a semicolon
SATestBuild.py:525:1: E302 expected 2 blank lines, found 1
SATestBuild.py:527:13: E261 at least two spaces before inline comment
SATestBuild.py:534:1: E302 expected 2 blank lines, found 1
SATestBuild.py:534:34: E251 unexpected spaces around keyword / parameter equals
SATestBuild.py:534:36: E251 unexpected spaces around keyword / parameter equals
SATestBuild.py:575:80: E501 line too long (82 > 79 characters)
SATestBuild.py:582:26: E203 whitespace before ':'
SATestBuild.py:589:80: E501 line too long (82 > 79 characters)
SATestBuild.py:592:72: E226 missing whitespace around arithmetic operator
SATestBuild.py:595:1: E302 expected 2 blank lines, found 1
SATestBuild.py:608:1: E302 expected 2 blank lines, found 1
SATestBuild.py:637:1: E302 expected 2 blank lines, found 1
SATestBuild.py:637:80: E501 line too long (88 > 79 characters)
SATestBuild.py:637:83: E251 unexpected spaces around keyword / parameter equals
SATestBuild.py:637:85: E251 unexpected spaces around keyword / parameter equals
SATestBuild.py:642:19: E203 whitespace before ':'
SATestBuild.py:655:25: E712 comparison to False should be 'if cond is False:' or 'if not cond:'
SATestBuild.py:661:28: E226 missing whitespace around arithmetic operator
SATestBuild.py:663:1: E302 expected 2 blank lines, found 1
SATestBuild.py:663:29: E251 unexpected spaces around keyword / parameter equals
SATestBuild.py:663:31: E251 unexpected spaces around keyword / parameter equals
SATestBuild.py:663:48: E251 unexpected spaces around keyword / parameter equals
SATestBuild.py:663:50: E251 unexpected spaces around keyword / parameter equals
SATestBuild.py:663:68: E251 unexpected spaces around keyword / parameter equals
SATestBuild.py:663:70: E251 unexpected spaces around keyword / parameter equals
SATestBuild.py:668:29: E203 whitespace before ':'
SATestBuild.py:669:80: E501 line too long (80 > 79 characters)
SATestBuild.py:678:22: E712 comparison to True should be 'if cond is True:' or 'if cond:'
SATestBuild.py:679:37: E712 comparison to True should be 'if cond is True:' or 'if cond:'
SATestBuild.py:679:45: E703 statement ends with a semicolon
SATestBuild.py:680:32: E241 multiple spaces after ','
SATestBuild.py:680:43: E703 statement ends with a semicolon
SATestBuild.py:688:22: E712 comparison to True should be 'if cond is True:' or 'if cond:'
SATestBuild.py:689:29: E241 multiple spaces after ','
SATestBuild.py:689:40: E703 statement ends with a semicolon
SATestBuild.py:699:80: E501 line too long (83 > 79 characters)
SATestBuild.py:701:24: E128 continuation line under-indented for visual indent
SATestBuild.py:702:80: E501 line too long (83 > 79 characters)
SATestBuild.py:703:80: E501 line too long (87 > 79 characters)
SATestBuild.py:704:80: E501 line too long (84 > 79 characters)
SATestBuild.py:707:80: E501 line too long (90 > 79 characters)

I ignored the "No doc string for function[...]" and "E265 block comment should start with '# '" warnings entirely.

C:/LLVM/llvm/tools/clang/utils/analyzer/CmpRuns.py

194

...agreed? Huh?

[ariccio]

I've added a few comments where I think the changes are not quite clear.

C:/LLVM/llvm/tools/clang/utils/analyzer/CmpRuns.py

159

This was to fix E711 comparison to None should be 'if cond is None:'.

C:/LLVM/llvm/tools/clang/utils/analyzer/SATestBuild.py

68

This was to fix W601 .has_key() is deprecated, use 'in'.

317

This funny looking change was to fix E125 continuation line with same indent as next logical line.

341

I replaced | with or here because I'm fairly certain we want the logical or, not the bitwise or.

410

This was to fix SATestBuild.py:397:19: E712 comparison to False should be 'if cond is False:' or 'if not cond:'

471

This was to fix E502 the backslash is redundant between brackets.

679

This was also to fix E712 comparison to False should be 'if cond is False:' or 'if not cond:'.

703

This was to fix E712 comparison to True should be 'if cond is True:' or 'if cond:'.

[zaks.anna]

Please, test these changes.

Thanks!
Anna.

C:/LLVM/llvm/tools/clang/utils/analyzer/CmpRuns.py

31

Might be left over from refactoring.

C:/LLVM/llvm/tools/clang/utils/analyzer/SATestBuild.py

521

Is removing '%' correct here?

[ariccio]

C:/LLVM/llvm/tools/clang/utils/analyzer/SATestBuild.py

521

Nope. Good catch!

[zaks.anna]

Once tested, this can land.

C:/LLVM/llvm/tools/clang/utils/analyzer/CmpRuns.py

Usage:
     # Generate a relation from diagnostics in run A to diagnostics in run B
     # to obtain a list of triples (a, b, confidence).
     diff = compareResults(resultsA, resultsB)
 
 """
 
 import os
 import plistlib
-import CmpRuns
+import CmpRuns  # ?
 
 # Information about analysis run:
 # path - the analysis output directory
 # root - the name of the root directory, which will be disregarded when
 # determining the source file name
 class SingleRunInfo:
     def __init__(self, path, root="", verboseLog=None):
         self.path = path
         self.root = root.rstrip("/\\")
         self.verboseLog = verboseLog
 
+
 class AnalysisDiagnostic:
     def __init__(self, data, report, htmlReport):
         self._data = data
         self._loc = self._data['location']
         self._report = report
         self._htmlReport = htmlReport
 
     def getFileName(self):
         root = self._report.run.root
         fileName = self._report.files[self._loc['file']]
         if fileName.startswith(root) and len(root) > 0:
-            return fileName[len(root)+1:]
+            return fileName[len(root) + 1:]
         return fileName
 
     def getLine(self):
         return self._loc['line']
 
     def getColumn(self):
         return self._loc['col']
 
     def getCategory(self):
         return self._data['category']
 
     def getDescription(self):
         return self._data['description']
 
     def getIssueIdentifier(self) :
-        id = self.getFileName() + "+"
-        if 'issue_context' in self._data :
-          id += self._data['issue_context'] + "+"
-        if 'issue_hash_content_of_line_in_context' in self._data :
-          id += str(self._data['issue_hash_content_of_line_in_context'])
-        return id
+        myid = self.getFileName() + "+"
+        if 'issue_context' in self._data:
+          myid += self._data['issue_context'] + "+"
+        if 'issue_hash_content_of_line_in_context' in self._data:
+          myid += str(self._data['issue_hash_content_of_line_in_context'])
+        return myid
 
     def getReport(self):
         if self._htmlReport is None:
             return " "
         return os.path.join(self._report.run.path, self._htmlReport)
 
     def getReadableName(self):
         return '%s:%d:%d, %s: %s' % (self.getFileName(), self.getLine(),
                                      self.getColumn(), self.getCategory(),
                                      self.getDescription())
 
     # Note, the data format is not an API and may change from one analyzer
     # version to another.
     def getRawData(self):
         return self._data
 
+
 class multidict:
     def __init__(self, elts=()):
         self.data = {}
-        for key,value in elts:
+        for key, value in elts:
             self[key] = value
 
     def __getitem__(self, item):
         return self.data[item]
+
     def __setitem__(self, key, value):
         if key in self.data:
             self.data[key].append(value)
         else:
             self.data[key] = [value]
+
     def items(self):
         return self.data.items()
+
     def values(self):
         return self.data.values()
+
     def keys(self):
         return self.data.keys()
+
     def __len__(self):
         return len(self.data)
+
     def get(self, key, default=None):
         return self.data.get(key, default)
 
+
 class CmpOptions:
     def __init__(self, verboseLog=None, rootA="", rootB=""):
         self.rootA = rootA
         self.rootB = rootB
         self.verboseLog = verboseLog
 
+
 class AnalysisReport:
     def __init__(self, run, files):
         self.run = run
         self.files = files
         self.diagnostics = []
 
+
 class AnalysisRun:
     def __init__(self, info):
         self.path = info.path
         self.root = info.root
         self.info = info
         self.reports = []
         # Cumulative list of all diagnostics from all the reports.
         self.diagnostics = []
         self.clang_version = None
 
     def getClangVersion(self):
         return self.clang_version
 
     def readSingleFile(self, p, deleteEmpty):
         data = plistlib.readPlist(p)
 
         # We want to retrieve the clang version even if there are no
         # reports. Assume that all reports were created using the same
         # clang version (this is always true and is more efficient).
         if 'clang_version' in data:
-            if self.clang_version == None:
+            if self.clang_version is None:
                 self.clang_version = data.pop('clang_version')
             else:
                 data.pop('clang_version')
 
         # Ignore/delete empty reports.
         if not data['files']:
-            if deleteEmpty == True:
+            if deleteEmpty:
                 os.remove(p)
             return
 
         # Extract the HTML reports, if they exists.
         if 'HTMLDiagnostics_files' in data['diagnostics'][0]:
             htmlFiles = []
             for d in data['diagnostics']:
                 # FIXME: Why is this named files, when does it have multiple
                 # files?
                 assert len(d['HTMLDiagnostics_files']) == 1
                 htmlFiles.append(d.pop('HTMLDiagnostics_files')[0])
         else:
             htmlFiles = [None] * len(data['diagnostics'])
 
         report = AnalysisReport(self, data.pop('files'))
         diagnostics = [AnalysisDiagnostic(d, report, h)
-                       for d,h in zip(data.pop('diagnostics'),
+                       for d, h in zip(data.pop('diagnostics'),
                                       htmlFiles)]
 
         assert not data
 
         report.diagnostics.extend(diagnostics)
         self.reports.append(report)
         self.diagnostics.extend(diagnostics)
 
 
 # Backward compatibility API.
-def loadResults(path, opts, root = "", deleteEmpty=True):
+def loadResults(path, opts, root="", deleteEmpty=True):
     return loadResultsFromSingleRun(SingleRunInfo(path, root, opts.verboseLog),
                                     deleteEmpty)
 
+
 # Load results of the analyzes from a given output folder.
 # - info is the SingleRunInfo object
 # - deleteEmpty specifies if the empty plist files should be deleted
 def loadResultsFromSingleRun(info, deleteEmpty=True):
     path = info.path
     run = AnalysisRun(info)
 
     if os.path.isfile(path):
         run.readSingleFile(path, deleteEmpty)
     else:
         for (dirpath, dirnames, filenames) in os.walk(path):
             for f in filenames:
                 if (not f.endswith('plist')):
                     continue
                 p = os.path.join(dirpath, f)
                 run.readSingleFile(p, deleteEmpty)
 
     return run
 
-def cmpAnalysisDiagnostic(d) :
+
+def cmpAnalysisDiagnostic(d):
     return d.getIssueIdentifier()
 
+
 def compareResults(A, B):
     """
     compareResults - Generate a relation from diagnostics in run A to
     diagnostics in run B.
 
     The result is the relation as a list of triples (a, b, confidence) where
     each element {a,b} is None or an element from the respective run, and
     confidence is a measure of the match quality (where 0 indicates equality,
     and None is used if either element is None).
     """
 
     res = []
 
     # Quickly eliminate equal elements.
     neqA = []
     neqB = []
     eltsA = list(A.diagnostics)
     eltsB = list(B.diagnostics)
-    eltsA.sort(key = cmpAnalysisDiagnostic)
-    eltsB.sort(key = cmpAnalysisDiagnostic)
+    eltsA.sort(key=cmpAnalysisDiagnostic)
+    eltsB.sort(key=cmpAnalysisDiagnostic)
     while eltsA and eltsB:
         a = eltsA.pop()
         b = eltsB.pop()
-        if (a.getIssueIdentifier() == b.getIssueIdentifier()) :
+        if (a.getIssueIdentifier() == b.getIssueIdentifier()):
             res.append((a, b, 0))
         elif a.getIssueIdentifier() > b.getIssueIdentifier():
             eltsB.append(b)
             neqA.append(a)
         else:
             eltsA.append(a)
             neqB.append(b)
     neqA.extend(eltsA)
     neqB.extend(eltsB)
 
     # FIXME: Add fuzzy matching. One simple and possible effective idea would be
     # to bin the diagnostics, print them in a normalized form (based solely on
     # the structure of the diagnostic), compute the diff, then use that as the
     # basis for matching. This has the nice property that we don't depend in any
     # way on the diagnostic format.
 
     for a in neqA:
         res.append((a, None, None))
     for b in neqB:
         res.append((None, b, None))
 
     return res
 
+
 def dumpScanBuildResultsDiff(dirA, dirB, opts, deleteEmpty=True):
     # Load the run results.
     resultsA = loadResults(dirA, opts, opts.rootA, deleteEmpty)
     resultsB = loadResults(dirB, opts, opts.rootB, deleteEmpty)
 
     # Open the verbose log, if given.
     if opts.verboseLog:
         auxLog = open(opts.verboseLog, "wb")
     else:
         auxLog = None
 
     diff = compareResults(resultsA, resultsB)
     foundDiffs = 0
     for res in diff:
-        a,b,confidence = res
+        a, b, confidence = res
         if a is None:
             print "ADDED: %r" % b.getReadableName()
             foundDiffs += 1
             if auxLog:
                 print >>auxLog, ("('ADDED', %r, %r)" % (b.getReadableName(),
                                                         b.getReport()))
         elif b is None:
             print "REMOVED: %r" % a.getReadableName()
def dumpScanBuildResultsDiff(dirA, dirB, opts, deleteEmpty=True):
     print "TOTAL REPORTS: %r" % TotalReports
     print "TOTAL DIFFERENCES: %r" % foundDiffs
     if auxLog:
         print >>auxLog, "('TOTAL NEW REPORTS', %r)" % TotalReports
         print >>auxLog, "('TOTAL DIFFERENCES', %r)" % foundDiffs
 
     return foundDiffs, len(resultsA.diagnostics), len(resultsB.diagnostics)
 
+
 def main():
     from optparse import OptionParser
     parser = OptionParser("usage: %prog [options] [dir A] [dir B]")
     parser.add_option("", "--rootA", dest="rootA",
                       help="Prefix to ignore on source files for directory A",
                       action="store", type=str, default="")
     parser.add_option("", "--rootB", dest="rootB",
                       help="Prefix to ignore on source files for directory B",
                       action="store", type=str, default="")
     parser.add_option("", "--verbose-log", dest="verboseLog",
                       help="Write additional information to LOG [default=None]",
                       action="store", type=str, default=None,
                       metavar="LOG")
     (opts, args) = parser.parse_args()
 
     if len(args) != 2:
         parser.error("invalid number of arguments")
 
-    dirA,dirB = args
+    dirA, dirB = args
 
     dumpScanBuildResultsDiff(dirA, dirB, opts)
 
 if __name__ == '__main__':
     main()

C:/LLVM/llvm/tools/clang/utils/analyzer/SATestAdd.py

The project should use the following files for set up:
                                               > changes_for_analyzer.patch
 """
 import SATestBuild
 
 import os
 import csv
 import sys
 
-def isExistingProject(PMapFile, projectID) :
+def isExistingProject(PMapFile, projectID):
     PMapReader = csv.reader(PMapFile)
     for I in PMapReader:
         if projectID == I[0]:
             return True
     return False
 
+
 # Add a new project for testing: build it and add to the Project Map file.
 # Params:
 #   Dir is the directory where the sources are.
 #   ID is a short string used to identify a project.
-def addNewProject(ID, BuildMode) :
+def addNewProject(ID, BuildMode):
     CurDir = os.path.abspath(os.curdir)
     Dir = SATestBuild.getProjectDir(ID)
     if not os.path.exists(Dir):
         print "Error: Project directory is missing: %s" % Dir
         sys.exit(-1)
 
     # Build the project.
     SATestBuild.testProject(ID, BuildMode, IsReferenceBuild=True, Dir=Dir)
 
     # Add the project ID to the project map.
     ProjectMapPath = os.path.join(CurDir, SATestBuild.ProjectMapFile)
     if os.path.exists(ProjectMapPath):
         PMapFile = open(ProjectMapPath, "r+b")
     else:
         print "Warning: Creating the Project Map file!!"
         PMapFile = open(ProjectMapPath, "w+b")
     try:
-        if (isExistingProject(PMapFile, ID)) :
+        if (isExistingProject(PMapFile, ID)):
             print >> sys.stdout, 'Warning: Project with ID \'', ID, \
                                  '\' already exists.'
             print >> sys.stdout, "Reference output has been regenerated."
         else:
             PMapWriter = csv.writer(PMapFile)
-            PMapWriter.writerow( (ID, int(BuildMode)) );
+            PMapWriter.writerow((ID, int(BuildMode)))
             print "The project map is updated: ", ProjectMapPath
     finally:
         PMapFile.close()
 
 
 # TODO: Add an option not to build.
 # TODO: Set the path to the Repository directory.
 if __name__ == '__main__':

C:/LLVM/llvm/tools/clang/utils/analyzer/SATestBuild.py

 #!/usr/bin/env python
 
 """
 Static Analyzer qualification infrastructure.
 
-The goal is to test the analyzer against different projects, check for failures,
-compare results, and measure performance.
+The goal is to test the analyzer against different projects,
+check for failures, compare results, and measure performance.
 
 Repository Directory will contain sources of the projects as well as the
 information on how to build them and the expected output.
 Repository Directory structure:
    - ProjectMap file
    - Historical Performance Data
    - Project Dir1
      - ReferenceOutput
    - Project Dir2
      - ReferenceOutput
    ..
 Note that the build tree must be inside the project dir.
 
 To test the build of the analyzer one would:
-   - Copy over a copy of the Repository Directory. (TODO: Prefer to ensure that
-     the build directory does not pollute the repository to min network traffic).
+   - Copy over a copy of the Repository Directory.
+    (TODO: Prefer to ensure that the build directory does not pollute
+    the repository to min network traffic).
    - Build all projects, until error. Produce logs to report errors.
    - Compare results.
 
 The files which should be kept around for failure investigations:
    RepositoryCopy/Project DirI/ScanBuildResults
    RepositoryCopy/Project DirI/run_static_analyzer.log
 
 Assumptions (TODO: shouldn't need to assume these.):

 import plistlib
 import argparse
 from subprocess import check_call, check_output, CalledProcessError
 
 #------------------------------------------------------------------------------
 # Helper functions.
 #------------------------------------------------------------------------------
 
 def detectCPUs():
     """
     Detects the number of CPUs on a system. Cribbed from pp.
     """
     # Linux, Unix and MacOS:
     if hasattr(os, "sysconf"):
-        if os.sysconf_names.has_key("SC_NPROCESSORS_ONLN"):
+        if "SC_NPROCESSORS_ONLN" in os.sysconf_names:
             # Linux & Unix:
             ncpus = os.sysconf("SC_NPROCESSORS_ONLN")
             if isinstance(ncpus, int) and ncpus > 0:
                 return ncpus
         else: # OSX:
             return int(capture(['sysctl', '-n', 'hw.ncpu']))
     # Windows:
-    if os.environ.has_key("NUMBER_OF_PROCESSORS"):
+    if "NUMBER_OF_PROCESSORS" in os.environ:
         ncpus = int(os.environ["NUMBER_OF_PROCESSORS"])
         if ncpus > 0:
             return ncpus
     return 1 # Default
 
-def which(command, paths = None):
+def which(command, paths=None):
    """which(command, [paths]) - Look up the given command in the paths string
    (or the PATH environment variable, if unspecified)."""
 
    if paths is None:
-       paths = os.environ.get('PATH','')
+       paths = os.environ.get('PATH', '')
 
    # Check for absolute match first.
    if os.path.exists(command):
        return command
 
    # Would be nice if Python had a lib function for this.
    if not paths:
        paths = os.defpath
def which(command, paths=None):
    for path in paths.split(os.pathsep):
        for ext in pathext:
            p = os.path.join(path, command + ext)
            if os.path.exists(p):
                return p
 
    return None
 
+
 # Make sure we flush the output after every print statement.
 class flushfile(object):
     def __init__(self, f):
         self.f = f
+
     def write(self, x):
         self.f.write(x)
         self.f.flush()
 
+
 sys.stdout = flushfile(sys.stdout)
 
+
 def getProjectMapPath():
     ProjectMapPath = os.path.join(os.path.abspath(os.curdir),
                                   ProjectMapFile)
     if not os.path.exists(ProjectMapPath):
         print "Error: Cannot find the Project Map file " + ProjectMapPath +\
-                "\nRunning script for the wrong directory?"
         sys.exit(-1)
     return ProjectMapPath
 
+
 def getProjectDir(ID):
     return os.path.join(os.path.abspath(os.curdir), ID)
 
-def getSBOutputDirName(IsReferenceBuild) :
-    if IsReferenceBuild == True :
+
+def getSBOutputDirName(IsReferenceBuild):
+    if IsReferenceBuild:
         return SBOutputDirReferencePrefix + SBOutputDirName
-    else :
+    else:
         return SBOutputDirName
 
 #------------------------------------------------------------------------------
 # Configuration setup.
 #------------------------------------------------------------------------------
 
 # Find Clang for static analysis.
 Clang = which("clang", os.environ['PATH'])

 # The script that needs to be executed before the build can start.
 CleanupScript = "cleanup_run_static_analyzer.sh"
 # This is a file containing commands for scan-build.
 BuildScript = "run_static_analyzer.cmd"
 
 # The log file name.
 LogFolderName = "Logs"
 BuildLogName = "run_static_analyzer.log"
-# Summary file - contains the summary of the failures. Ex: This info can be be
-# displayed when buildbot detects a build failure.
+# Summary file - contains the summary of the failures.
+# Ex: This info can be be displayed when buildbot detects a build failure.
 NumOfFailuresInSummary = 10
 FailuresSummaryFileName = "failures.txt"
 # Summary of the result diffs.
 DiffsSummaryFileName = "diffs.txt"
 
 # The scan-build result directory.
 SBOutputDirName = "ScanBuildResults"
 SBOutputDirReferencePrefix = "Ref"
 
-# The name of the directory storing the cached project source. If this directory
-# does not exist, the download script will be executed. That script should
-# create the "CachedSource" directory and download the project source into it.
+# The name of the directory storing the cached project source. If this
+# directory does not exist, the download script will be executed. That
+# script should create the "CachedSource" directory and download the project
+# source into it.
 CachedSourceDirName = "CachedSource"
 
 # The name of the directory containing the source code that will be analyzed.
 # Each time a project is analyzed, a fresh copy of its CachedSource directory
 # will be copied to the PatchedSource directory and then the local patches
 # in PatchfileName will be applied (if PatchfileName exists).
 PatchedSourceDirName = "PatchedSource"
 
 # The name of the patchfile specifying any changes that should be applied
 # to the CachedSource before analyzing.
 PatchfileName = "changes_for_analyzer.patch"
 
 # The list of checkers used during analyzes.
 # Currently, consists of all the non-experimental checkers, plus a few alpha
 # checkers we don't want to regress on.
-Checkers="alpha.unix.SimpleStream,alpha.security.taint,cplusplus.NewDeleteLeaks,core,cplusplus,deadcode,security,unix,osx"
+Checkers = "alpha.unix.SimpleStream,alpha.security.taint,cplusplus.NewDeleteLeaks,core,cplusplus,deadcode,security,unix,osx"
 
 Verbose = 1
 
 #------------------------------------------------------------------------------
 # Test harness logic.
 #------------------------------------------------------------------------------
 
 # Run pre-processing script if any.
 def runCleanupScript(Dir, PBuildLogFile):
     Cwd = os.path.join(Dir, PatchedSourceDirName)
     ScriptPath = os.path.join(Dir, CleanupScript)
     runScript(ScriptPath, PBuildLogFile, Cwd)
 
+
 # Run the script to download the project, if it exists.
 def runDownloadScript(Dir, PBuildLogFile):
     ScriptPath = os.path.join(Dir, DownloadScript)
     runScript(ScriptPath, PBuildLogFile, Dir)
 
+
 # Run the provided script if it exists.
 def runScript(ScriptPath, PBuildLogFile, Cwd):
     if os.path.exists(ScriptPath):
         try:
             if Verbose == 1:
                 print "  Executing: %s" % (ScriptPath,)
-            check_call("chmod +x '%s'" % ScriptPath, cwd = Cwd,
-                                              stderr=PBuildLogFile,
-                                              stdout=PBuildLogFile,
-                                              shell=True)
-            check_call("'%s'" % ScriptPath, cwd = Cwd, stderr=PBuildLogFile,
-                                              stdout=PBuildLogFile,
-                                              shell=True)
+            check_call("chmod +x '%s'" % ScriptPath, cwd=Cwd,
+                       stderr=PBuildLogFile, stdout=PBuildLogFile,
+            check_call("'%s'" % ScriptPath, cwd=Cwd, stderr=PBuildLogFile,
+                       stdout=PBuildLogFile, shell=True)
         except:
             print "Error: Running %s failed. See %s for details." % (ScriptPath,
                   PBuildLogFile.name)
             sys.exit(-1)
 
+
 # Download the project and apply the local patchfile if it exists.
 def downloadAndPatch(Dir, PBuildLogFile):
     CachedSourceDirPath = os.path.join(Dir, CachedSourceDirName)
 
     # If the we don't already have the cached source, run the project's
     # download script to download it.
     if not os.path.exists(CachedSourceDirPath):
       runDownloadScript(Dir, PBuildLogFile)
       if not os.path.exists(CachedSourceDirPath):
         print "Error: '%s' not found after download." % (CachedSourceDirPath)
         exit(-1)
 
     PatchedSourceDirPath = os.path.join(Dir, PatchedSourceDirName)
 
     # Remove potentially stale patched source.
     if os.path.exists(PatchedSourceDirPath):
         shutil.rmtree(PatchedSourceDirPath)
 
     # Copy the cached source and apply any patches to the copy.
     shutil.copytree(CachedSourceDirPath, PatchedSourceDirPath, symlinks=True)
     applyPatch(Dir, PBuildLogFile)
 
+
 def applyPatch(Dir, PBuildLogFile):
     PatchfilePath = os.path.join(Dir, PatchfileName)
     PatchedSourceDirPath = os.path.join(Dir, PatchedSourceDirName)
     if not os.path.exists(PatchfilePath):
         print "  No local patches."
         return
 
     print "  Applying patch."
     try:
         check_call("patch -p1 < '%s'" % (PatchfilePath),
-                    cwd = PatchedSourceDirPath,
-                    stderr=PBuildLogFile,
-                    stdout=PBuildLogFile,
-                    shell=True)
+                   cwd=PatchedSourceDirPath,
     except:
         print "Error: Patch failed. See %s for details." % (PBuildLogFile.name)
         sys.exit(-1)
 
+
 # Build the project with scan-build by reading in the commands and
 # prefixing them with the scan-build options.
 def runScanBuild(Dir, SBOutputDir, PBuildLogFile):
     BuildScriptPath = os.path.join(Dir, BuildScript)
     if not os.path.exists(BuildScriptPath):
         print "Error: build script is not defined: %s" % BuildScriptPath
         sys.exit(-1)
 
     AllCheckers = Checkers
-    if os.environ.has_key('SA_ADDITIONAL_CHECKERS'):
+    if 'SA_ADDITIONAL_CHECKERS' in os.environ:
         AllCheckers = AllCheckers + ',' + os.environ['SA_ADDITIONAL_CHECKERS']
 
     # Run scan-build from within the patched source directory.
     SBCwd = os.path.join(Dir, PatchedSourceDirName)
 
-    SBOptions = "--use-analyzer '%s' " %  Clang
+    SBOptions = "--use-analyzer '%s' " % Clang
     SBOptions += "-plist-html -o '%s' " % SBOutputDir
     SBOptions += "-enable-checker " + AllCheckers + " "
     SBOptions += "--keep-empty "
     # Always use ccc-analyze to ensure that we can locate the failures
     # directory.
     SBOptions += "--override-compiler "
     try:
         SBCommandFile = open(BuildScriptPath, "r")
         SBPrefix = "scan-build " + SBOptions + " "
         for Command in SBCommandFile:
             Command = Command.strip()
             if len(Command) == 0:
-                continue;
+                continue
             # If using 'make', auto imply a -jX argument
             # to speed up analysis.  xcodebuild will
             # automatically use the maximum number of cores.
             if (Command.startswith("make ") or Command == "make") and \
                     "-j" not in Command:
                 Command += " -j%d" % Jobs
             SBCommand = SBPrefix + Command
             if Verbose == 1:
-                print "  Executing: %s" % (SBCommand,)
-            check_call(SBCommand, cwd = SBCwd, stderr=PBuildLogFile,
-                                               stdout=PBuildLogFile,
-                                               shell=True)
+                print "  Executing: %s" % (SBCommand, )
+            check_call(SBCommand, cwd=SBCwd, stderr=PBuildLogFile,
+                       stdout=PBuildLogFile, shell=True)
     except:
-        print "Error: scan-build failed. See ",PBuildLogFile.name,\
+        print "Error: scan-build failed. See ", PBuildLogFile.name,\
               " for details."
         raise
 
+
 def hasNoExtension(FileName):
     (Root, Ext) = os.path.splitext(FileName)
-    if ((Ext == "")) :
+    if ((Ext == "")):
         return True
     return False
 
+
 def isValidSingleInputFile(FileName):
     (Root, Ext) = os.path.splitext(FileName)
-    if ((Ext == ".i") | (Ext == ".ii") |
-        (Ext == ".c") | (Ext == ".cpp") |
-        (Ext == ".m") | (Ext == "")) :
+    if ((Ext == ".i") or (Ext == ".ii") or
+            (Ext == ".c") or (Ext == ".cpp") or
+            (Ext == ".m") or (Ext == "")):
         return True
     return False
 
+
 # Get the path to the SDK for the given SDK name. Returns None if
 # the path cannot be determined.
 def getSDKPath(SDKName):
     if which("xcrun") is None:
         return None
 
     Cmd = "xcrun --sdk " + SDKName + " --show-sdk-path"
     return check_output(Cmd, shell=True).rstrip()
 
+
 # Run analysis on a set of preprocessed files.
 def runAnalyzePreprocessed(Dir, SBOutputDir, Mode):
     if os.path.exists(os.path.join(Dir, BuildScript)):
         print "Error: The preprocessed files project should not contain %s" % \
-               BuildScript
         raise Exception()
 
     CmdPrefix = Clang + " -cc1 "
 
     # For now, we assume the preprocessed files should be analyzed
     # with the OS X SDK.
     SDKPath = getSDKPath("macosx")
     if SDKPath is not None:
       CmdPrefix += "-isysroot " + SDKPath + " "
 
     CmdPrefix += "-analyze -analyzer-output=plist -w "
-    CmdPrefix += "-analyzer-checker=" + Checkers +" -fcxx-exceptions -fblocks "
+    CmdPrefix += "-analyzer-checker=" + Checkers + " -fcxx-exceptions -fblocks "
 
-    if (Mode == 2) :
+    if (Mode == 2):
         CmdPrefix += "-std=c++11 "
 
     PlistPath = os.path.join(Dir, SBOutputDir, "date")
-    FailPath = os.path.join(PlistPath, "failures");
-    os.makedirs(FailPath);
+    FailPath = os.path.join(PlistPath, "failures")
+    os.makedirs(FailPath)
 
     for FullFileName in glob.glob(Dir + "/*"):
         FileName = os.path.basename(FullFileName)
         Failed = False
 
         # Only run the analyzes on supported files.
         if (hasNoExtension(FileName)):
             continue
-        if (isValidSingleInputFile(FileName) == False):
+        if (not isValidSingleInputFile(FileName)):
             print "Error: Invalid single input file %s." % (FullFileName,)
             raise Exception()
 
         # Build and call the analyzer command.
         OutputOption = "-o '%s.plist' " % os.path.join(PlistPath, FileName)
         Command = CmdPrefix + OutputOption + ("'%s'" % FileName)
         LogFile = open(os.path.join(FailPath, FileName + ".stderr.txt"), "w+b")
         try:
             if Verbose == 1:
                 print "  Executing: %s" % (Command,)
-            check_call(Command, cwd = Dir, stderr=LogFile,
-                                           stdout=LogFile,
-                                           shell=True)
+            check_call(Command, cwd=Dir, stderr=LogFile, stdout=LogFile,
         except CalledProcessError, e:
             print "Error: Analyzes of %s failed. See %s for details." \
                   "Error code %d." % \
-                   (FullFileName, LogFile.name, e.returncode)
             Failed = True
         finally:
             LogFile.close()
 
         # If command did not fail, erase the log file.
-        if Failed == False:
-            os.remove(LogFile.name);
+        if not Failed:
+            os.remove(LogFile.name)
+
 
 def getBuildLogPath(SBOutputDir):
   return os.path.join(SBOutputDir, LogFolderName, BuildLogName)
 
+
 def removeLogFile(SBOutputDir):
   BuildLogPath = getBuildLogPath(SBOutputDir)
   # Clean up the log file.
-  if (os.path.exists(BuildLogPath)) :
+  if (os.path.exists(BuildLogPath)):
       RmCommand = "rm '%s'" % BuildLogPath
       if Verbose == 1:
           print "  Executing: %s" % (RmCommand,)
       check_call(RmCommand, shell=True)
 
+
 def buildProject(Dir, SBOutputDir, ProjectBuildMode, IsReferenceBuild):
     TBegin = time.time()
 
     BuildLogPath = getBuildLogPath(SBOutputDir)
     print "Log file: %s" % (BuildLogPath,)
-    print "Output directory: %s" %(SBOutputDir, )
+    print "Output directory: %s" % (SBOutputDir, )
 
     removeLogFile(SBOutputDir)
 
     # Clean up scan build results.
-    if (os.path.exists(SBOutputDir)) :
+    if (os.path.exists(SBOutputDir)):
         RmCommand = "rm -r '%s'" % SBOutputDir
         if Verbose == 1:
             print "  Executing: %s" % (RmCommand,)
             check_call(RmCommand, shell=True)
     assert(not os.path.exists(SBOutputDir))
     os.makedirs(os.path.join(SBOutputDir, LogFolderName))
 
     # Open the log file.
     PBuildLogFile = open(BuildLogPath, "wb+")
 
     # Build and analyze the project.
     try:
         if (ProjectBuildMode == 1):
             downloadAndPatch(Dir, PBuildLogFile)
             runCleanupScript(Dir, PBuildLogFile)
             runScanBuild(Dir, SBOutputDir, PBuildLogFile)
         else:
             runAnalyzePreprocessed(Dir, SBOutputDir, ProjectBuildMode)
 
-        if IsReferenceBuild :
+        if IsReferenceBuild:
             runCleanupScript(Dir, PBuildLogFile)
 
             # Make the absolute paths relative in the reference results.
             for (DirPath, Dirnames, Filenames) in os.walk(SBOutputDir):
                 for F in Filenames:
                     if (not F.endswith('plist')):
                         continue
                     Plist = os.path.join(DirPath, F)
                     Data = plistlib.readPlist(Plist)
                     PathPrefix = Dir
                     if (ProjectBuildMode == 1):
                         PathPrefix = os.path.join(Dir, PatchedSourceDirName)
-                    Paths = [SourceFile[len(PathPrefix)+1:]\
-                              if SourceFile.startswith(PathPrefix)\
-                              else SourceFile for SourceFile in Data['files']]
+                    Paths = [SourceFile[len(PathPrefix) + 1:]
+                             if SourceFile.startswith(PathPrefix)
                     Data['files'] = Paths
                     plistlib.writePlist(Data, Plist)
 
     finally:
         PBuildLogFile.close()
 
     print "Build complete (time: %.2f). See the log for more details: %s" % \
-           ((time.time()-TBegin), BuildLogPath)
+          ((time.time() - TBegin), BuildLogPath)
 
+
 # A plist file is created for each call to the analyzer(each source file).
 # We are only interested on the once that have bug reports, so delete the rest.
 def CleanUpEmptyPlists(SBOutputDir):
     for F in glob.glob(SBOutputDir + "/*/*.plist"):
         P = os.path.join(SBOutputDir, F)
 
         Data = plistlib.readPlist(P)
         # Delete empty reports.
         if not Data['files']:
             os.remove(P)
             continue
 
+
 # Given the scan-build output directory, checks if the build failed
 # (by searching for the failures directories). If there are failures, it
 # creates a summary file in the output directory.
 def checkBuild(SBOutputDir):
     # Check if there are failures.
     Failures = glob.glob(SBOutputDir + "/*/failures/*.stderr.txt")
-    TotalFailed = len(Failures);
+    TotalFailed = len(Failures)
     if TotalFailed == 0:
         CleanUpEmptyPlists(SBOutputDir)
         Plists = glob.glob(SBOutputDir + "/*/*.plist")
         print "Number of bug reports (non-empty plist files) produced: %d" %\
               len(Plists)
-        return;
+        return
 
     # Create summary file to display when the build fails.
     SummaryPath = os.path.join(SBOutputDir, LogFolderName, FailuresSummaryFileName)
     if (Verbose > 0):
         print "  Creating the failures summary file %s" % (SummaryPath,)
 
     SummaryLog = open(SummaryPath, "w+")
     try:
         SummaryLog.write("Total of %d failures discovered.\n" % (TotalFailed,))
         if TotalFailed > NumOfFailuresInSummary:
             SummaryLog.write("See the first %d below.\n"
-                                                   % (NumOfFailuresInSummary,))
+                             (NumOfFailuresInSummary,))
         # TODO: Add a line "See the results folder for more."
 
-        FailuresCopied = NumOfFailuresInSummary
         Idx = 0
         for FailLogPathI in Failures:
             if Idx >= NumOfFailuresInSummary:
-                break;
+                break
             Idx += 1
-            SummaryLog.write("\n-- Error #%d -----------\n" % (Idx,));
-            FailLogI = open(FailLogPathI, "r");
+            SummaryLog.write("\n-- Error #%d -----------\n" % (Idx,))
+            FailLogI = open(FailLogPathI, "r")
             try:
-                shutil.copyfileobj(FailLogI, SummaryLog);
+                shutil.copyfileobj(FailLogI, SummaryLog)
             finally:
                 FailLogI.close()
     finally:
         SummaryLog.close()
 
     print "Error: analysis failed. See ", SummaryPath
     sys.exit(-1)
 
+
 # Auxiliary object to discard stdout.
 class Discarder(object):
     def write(self, text):
-        pass # do nothing
+        pass  # do nothing
 
+
 # Compare the warnings produced by scan-build.
 # Strictness defines the success criteria for the test:
 #   0 - success if there are no crashes or analyzer failure.
 #   1 - success if there are no difference in the number of reported bugs.
 #   2 - success if all the bug reports are identical.
-def runCmpResults(Dir, Strictness = 0):
+def runCmpResults(Dir, Strictness=0):
     TBegin = time.time()
 
     RefDir = os.path.join(Dir, SBOutputDirReferencePrefix + SBOutputDirName)
     NewDir = os.path.join(Dir, SBOutputDirName)
 
     # We have to go one level down the directory tree.
     RefList = glob.glob(RefDir + "/*")
     NewList = glob.glob(NewDir + "/*")
for P in PairList:
 
         assert(RefDir != NewDir)
         if Verbose == 1:
             print "  Comparing Results: %s %s" % (RefDir, NewDir)
 
         DiffsPath = os.path.join(NewDir, DiffsSummaryFileName)
         PatchedSourceDirPath = os.path.join(Dir, PatchedSourceDirName)
         Opts = CmpRuns.CmpOptions(DiffsPath, "", PatchedSourceDirPath)
-        # Discard everything coming out of stdout (CmpRun produces a lot of them).
+        # Discard everything coming out of stdout
+        # (CmpRun produces a lot of them).
         OLD_STDOUT = sys.stdout
         sys.stdout = Discarder()
         # Scan the results, delete empty plist files.
         NumDiffs, ReportsInRef, ReportsInNew = \
             CmpRuns.dumpScanBuildResultsDiff(RefDir, NewDir, Opts, False)
         sys.stdout = OLD_STDOUT
-        if (NumDiffs > 0) :
+        if (NumDiffs > 0):
             print "Warning: %r differences in diagnostics. See %s" % \
                   (NumDiffs, DiffsPath,)
         if Strictness >= 2 and NumDiffs > 0:
             print "Error: Diffs found in strict mode (2)."
             sys.exit(-1)
         elif Strictness >= 1 and ReportsInRef != ReportsInNew:
             print "Error: The number of results are different in strict mode (1)."
             sys.exit(-1)
 
-    print "Diagnostic comparison complete (time: %.2f)." % (time.time()-TBegin)
+    print "Diagnostic comparison complete (time: %.2f)." % (time.time() - TBegin)
     return (NumDiffs > 0)
 
+
 def cleanupReferenceResults(SBOutputDir):
     # Delete html, css, and js files from reference results. These can
     # include multiple copies of the benchmark source and so get very large.
     Extensions = ["html", "css", "js"]
     for E in Extensions:
         for F in glob.glob("%s/*/*.%s" % (SBOutputDir, E)):
             P = os.path.join(SBOutputDir, F)
             RmCommand = "rm '%s'" % P
             check_call(RmCommand, shell=True)
 
     # Remove the log file. It leaks absolute path names.
     removeLogFile(SBOutputDir)
 
+
 def updateSVN(Mode, ProjectsMap):
     try:
         ProjectsMap.seek(0)
         for I in csv.reader(ProjectsMap):
             ProjName = I[0]
             Path = os.path.join(ProjName, getSBOutputDirName(True))
 
             if Mode == "delete":
try:
                             "reference results.\""
         if Verbose == 1:
             print "  Executing: %s" % (CommitCommand,)
         check_call(CommitCommand, shell=True)
     except:
         print "Error: SVN update failed."
         sys.exit(-1)
 
-def testProject(ID, ProjectBuildMode, IsReferenceBuild=False, Dir=None, Strictness = 0):
+
+def testProject(ID, ProjectBuildMode, IsReferenceBuild=False, Dir=None,
+                Strictness=0):
     print " \n\n--- Building project %s" % (ID,)
 
     TBegin = time.time()
 
-    if Dir is None :
+    if Dir is None:
         Dir = getProjectDir(ID)
     if Verbose == 1:
         print "  Build directory: %s." % (Dir,)
 
     # Set the build results directory.
     RelOutputDir = getSBOutputDirName(IsReferenceBuild)
     SBOutputDir = os.path.join(Dir, RelOutputDir)
 
     buildProject(Dir, SBOutputDir, ProjectBuildMode, IsReferenceBuild)
 
     checkBuild(SBOutputDir)
 
-    if IsReferenceBuild == False:
+    if not IsReferenceBuild:
         runCmpResults(Dir, Strictness)
     else:
         cleanupReferenceResults(SBOutputDir)
 
     print "Completed tests for project %s (time: %.2f)." % \
-          (ID, (time.time()-TBegin))
+          (ID, (time.time() - TBegin))
 
-def testAll(IsReferenceBuild = False, UpdateSVN = False, Strictness = 0):
+
+def testAll(IsReferenceBuild=False, UpdateSVN=False, Strictness=0):
     PMapFile = open(getProjectMapPath(), "rb")
     try:
         # Validate the input.
         for I in csv.reader(PMapFile):
-            if (len(I) != 2) :
+            if (len(I) != 2):
                 print "Error: Rows in the ProjectMapFile should have 3 entries."
                 raise Exception()
             if (not ((I[1] == "0") | (I[1] == "1") | (I[1] == "2"))):
                 print "Error: Second entry in the ProjectMapFile should be 0" \
                       " (single file), 1 (project), or 2(single file c++11)."
                 raise Exception()
 
         # When we are regenerating the reference results, we might need to
         # update svn. Remove reference results from SVN.
-        if UpdateSVN == True:
-            assert(IsReferenceBuild == True);
-            updateSVN("delete",  PMapFile);
+        if UpdateSVN:
+            assert(IsReferenceBuild)
+            updateSVN("delete", PMapFile)
 
         # Test the projects.
         PMapFile.seek(0)
         for I in csv.reader(PMapFile):
             testProject(I[0], int(I[1]), IsReferenceBuild, None, Strictness)
 
         # Add reference results to SVN.
-        if UpdateSVN == True:
-            updateSVN("add",  PMapFile);
+        if UpdateSVN:
+            updateSVN("add", PMapFile)
 
     except:
         print "Error occurred. Premature termination."
         raise
     finally:
         PMapFile.close()
 
 if __name__ == '__main__':
     # Parse command line arguments.
     Parser = argparse.ArgumentParser(description='Test the Clang Static Analyzer.')
     Parser.add_argument('--strictness', dest='strictness', type=int, default=0,
                         help='0 to fail on runtime errors, 1 to fail when the number\
                              of found bugs are different from the reference, 2 to \
                              fail on any difference from the reference. Default is 0.')
-    Parser.add_argument('-r', dest='regenerate', action='store_true', default=False,
-                        help='Regenerate reference output.')
+    Parser.add_argument('-r', dest='regenerate', action='store_true',
+                        default=False, help='Regenerate reference output.')
     Parser.add_argument('-rs', dest='update_reference', action='store_true',
-                        default=False, help='Regenerate reference output and update svn.')
+                        default=False,
+                        help='Regenerate reference output and update svn.')
     Args = Parser.parse_args()
 
     IsReference = False
     UpdateSVN = False
     Strictness = Args.strictness
     if Args.regenerate:
         IsReference = True
     elif Args.update_reference:
         IsReference = True
         UpdateSVN = True
 
     testAll(IsReference, UpdateSVN, Strictness)

C:/LLVM/llvm/tools/clang/utils/analyzer/SumTimerInfo.py

if __name__ == '__main__':
     ReachableBlocks = 0
     ReachedMaxSteps = 0
     NumSteps = 0
     NumInlinedCallSites = 0
     NumBifurcatedCallSites = 0
     MaxCFGSize = 0
     Mode = 1
     for line in f:
-        if ("Miscellaneous Ungrouped Timers" in line) :
+        if ("Miscellaneous Ungrouped Timers" in line):
           Mode = 1
-        if (("Analyzer Total Time" in line) and (Mode == 1)) :
+        if (("Analyzer Total Time" in line) and (Mode == 1)):
           s = line.split()
           Time = Time + float(s[6])
           Count = Count + 1
-          if (float(s[6]) > MaxTime) :
+          if (float(s[6]) > MaxTime):
             MaxTime = float(s[6])
-        if ((("warning generated." in line) or ("warnings generated" in line)) and Mode == 1) :
+        if ((("warning generated." in line) or ("warnings generated" in line)) and Mode == 1):
           s = line.split()
           Warnings = Warnings + int(s[0])
-        if (("The # of functions analysed (as top level)" in line) and (Mode == 1)) :
+        if (("The # of functions analysed (as top level)" in line) and (Mode == 1)):
           s = line.split()
           FunctionsAnalyzed = FunctionsAnalyzed + int(s[0])
-        if (("The % of reachable basic blocks" in line) and (Mode == 1)) :
+        if (("The % of reachable basic blocks" in line) and (Mode == 1)):
           s = line.split()
           ReachableBlocks = ReachableBlocks + int(s[0])
-        if (("The # of times we reached the max number of steps" in line) and (Mode == 1)) :
+        if (("The # of times we reached the max number of steps" in line) and (Mode == 1)):
           s = line.split()
           ReachedMaxSteps = ReachedMaxSteps + int(s[0])
-        if (("The maximum number of basic blocks in a function" in line) and (Mode == 1)) :
+        if (("The maximum number of basic blocks in a function" in line) and (Mode == 1)):
           s = line.split()
-          if (MaxCFGSize < int(s[0])) :
+          if (MaxCFGSize < int(s[0])):
             MaxCFGSize = int(s[0])
-        if (("The # of steps executed" in line) and (Mode == 1)) :
+        if (("The # of steps executed" in line) and (Mode == 1)):
           s = line.split()
           NumSteps = NumSteps + int(s[0])
-        if (("The # of times we inlined a call" in line) and (Mode == 1)) :
+        if (("The # of times we inlined a call" in line) and (Mode == 1)):
           s = line.split()
           NumInlinedCallSites = NumInlinedCallSites + int(s[0])
-        if (("The # of times we split the path due to imprecise dynamic dispatch info" in line) and (Mode == 1)) :
+        if (("The # of times we split the path due to imprecise dynamic dispatch info" in line)
+            and (Mode == 1)):
           s = line.split()
           NumBifurcatedCallSites = NumBifurcatedCallSites + int(s[0])
-        if ((")  Total" in line) and (Mode == 1)) :
+        if ((")  Total" in line) and (Mode == 1)):
           s = line.split()
           TotalTime = TotalTime + float(s[6])
 
     print "TU Count %d" % (Count)
     print "Time %f" % (Time)
     print "Warnings %d" % (Warnings)
     print "Functions Analyzed %d" % (FunctionsAnalyzed)
     print "Reachable Blocks %d" % (ReachableBlocks)
     print "Reached Max Steps %d" % (ReachedMaxSteps)
     print "Number of Steps %d" % (NumSteps)
     print "Number of Inlined calls %d (bifurcated %d)" % (NumInlinedCallSites, NumBifurcatedCallSites)
     print "MaxTime %f" % (MaxTime)
     print "TotalTime %f" % (TotalTime)
     print "Max CFG Size %d" % (MaxCFGSize)