Make several Python scripts portable across Python2 and Python 3

[serge-sans-paille]

Summary

This part only handles object inheritance

No extra dependency added.

[serge-sans-paille]

Conversion using the `futurize` script, then manual review. For the sake of reviewer sanity, I've left all the difficult part to further separate commits.

[michaelplatings]

In general LGTM, as someone who's done a 2-3 conversion of similar scale before.

The only suggestion I'd make is to consider changing the __future__ imports to from __future__ import absolute_import, division, print_function
I found this gave the best consistency between 2 & 3. Probably you don't need it at this point, but once the conversion is done there's less to go wrong in future.

[serge-sans-paille]

Use generic `from __future__ import ` line whenever it makes sense

[joerg]

Can you split off the pure modernisation changes like new exception or print ? Those are completely non-contentious changes after all. I generally do not like the range and list related changes as many instances are clear regressions for the 2.x case. filter to list comprehension should IMO be a separate change as well, but those are much less problematic and often an improvement in terms of both performance and readability.

[michaelplatings]

LGTM

bindings/python/clang/cindex.py

The major indexing objects are:
 
   SourceRange, SourceLocation, and File
 
     Objects representing information about the input source.
 
 Most object information is exposed using properties, when the underlying API
 call is efficient.
 """
+from __future__ import print_function
 
 # TODO
 # ====
 #
 # o API support for invalid translation units. Currently we can't even get the
 #   diagnostics on failure because they refer to locations in an object that
 #   will have been invalidated.
 #
def location(self):
         return conf.lib.clang_getDiagnosticLocation(self)
 
     @property
     def spelling(self):
         return conf.lib.clang_getDiagnosticSpelling(self)
 
     @property
     def ranges(self):
-        class RangeIterator:
+        class RangeIterator(object):
             def __init__(self, diag):
                 self.diag = diag
 
             def __len__(self):
                 return int(conf.lib.clang_getDiagnosticNumRanges(self.diag))
 
             def __getitem__(self, key):
                 if (key >= len(self)):
                     raise IndexError
                 return conf.lib.clang_getDiagnosticRange(self.diag, key)
 
         return RangeIterator(self)
 
     @property
     def fixits(self):
-        class FixItIterator:
+        class FixItIterator(object):
             def __init__(self, diag):
                 self.diag = diag
 
             def __len__(self):
                 return int(conf.lib.clang_getDiagnosticNumFixIts(self.diag))
 
             def __getitem__(self, key):
                 range = SourceRange()
                 value = conf.lib.clang_getDiagnosticFixIt(self.diag, key,
                         byref(range))
                 if len(value) == 0:
                     raise IndexError
 
                 return FixIt(range, value)
 
         return FixItIterator(self)
 
     @property
     def children(self):
-        class ChildDiagnosticsIterator:
+        class ChildDiagnosticsIterator(object):
             def __init__(self, diag):
                 self.diag_set = conf.lib.clang_getChildDiagnostics(diag)
 
             def __len__(self):
                 return int(conf.lib.clang_getNumDiagnosticsInSet(self.diag_set))
 
             def __getitem__(self, key):
                 diag = conf.lib.clang_getDiagnosticInSet(self.diag_set, key)
def get_tokens(tu, extent):
         # anything and potentially call a destructor on nothing.
         if count < 1:
             return
 
         tokens_array = cast(tokens_memory, POINTER(Token * count)).contents
 
         token_group = TokenGroup(tu, tokens_memory, tokens_count)
 
-        for i in xrange(0, count):
+        for i in range(0, count):
             token = Token()
             token.int_data = tokens_array[i].int_data
             token.ptr_data = tokens_array[i].ptr_data
             token._tu = tu
             token._group = token_group
 
             yield token
 
SpellingCache = {
             # 15: CompletionChunk.Kind("ResultType"),
             16: ':',  # CompletionChunk.Kind("Colon"),
             17: ';',  # CompletionChunk.Kind("SemiColon"),
             18: '=',  # CompletionChunk.Kind("Equal"),
             19: ' ',  # CompletionChunk.Kind("HorizontalSpace"),
             # 20: CompletionChunk.Kind("VerticalSpace")
 }
 
-class CompletionChunk:
-    class Kind:
+class CompletionChunk(object):
+    class Kind(object):
         def __init__(self, name):
             self.name = name
 
         def __str__(self):
             return self.name
 
         def __repr__(self):
             return "<ChunkKind: %s>" % self
completionChunkKindMap = {
             15: CompletionChunk.Kind("ResultType"),
             16: CompletionChunk.Kind("Colon"),
             17: CompletionChunk.Kind("SemiColon"),
             18: CompletionChunk.Kind("Equal"),
             19: CompletionChunk.Kind("HorizontalSpace"),
             20: CompletionChunk.Kind("VerticalSpace")}
 
 class CompletionString(ClangObject):
-    class Availability:
+    class Availability(object):
         def __init__(self, name):
             self.name = name
 
         def __str__(self):
             return self.name
 
         def __repr__(self):
             return "<Availability: %s>" % self
def __del__(self):
         conf.lib.clang_disposeCodeCompleteResults(self)
 
     @property
     def results(self):
         return self.ptr.contents
 
     @property
     def diagnostics(self):
-        class DiagnosticsItr:
+        class DiagnosticsItr(object):
             def __init__(self, ccr):
                 self.ccr= ccr
 
             def __len__(self):
                 return int(\
                   conf.lib.clang_codeCompleteGetNumDiagnostics(self.ccr))
 
             def __getitem__(self, key):
def get_extent(self, filename, locations):
 
         return SourceRange.from_locations(start_location, end_location)
 
     @property
     def diagnostics(self):
         """
         Return an iterable (and indexable) object containing the diagnostics.
         """
-        class DiagIterator:
+        class DiagIterator(object):
             def __init__(self, tu):
                 self.tu = tu
 
             def __len__(self):
                 return int(conf.lib.clang_getNumDiagnostics(self.tu))
 
             def __getitem__(self, key):
                 diag = conf.lib.clang_getDiagnostic(self.tu, key)
class CompileCommand(object):
     def arguments(self):
         """
         Get an iterable object providing each argument in the
         command line for the compiler invocation as a _CXString.
 
         Invariant : the first argument is the compiler executable
         """
         length = conf.lib.clang_CompileCommand_getNumArgs(self.cmd)
-        for i in xrange(length):
+        for i in range(length):
             yield conf.lib.clang_CompileCommand_getArg(self.cmd, i)
 
 class CompileCommands(object):
     """
     CompileCommands is an iterable object containing all CompileCommand
     that can be used for building a specific file.
     """
     def __init__(self, ccmds):
def register_functions(lib, ignore_errors):
     """
 
     def register(item):
         return register_function(lib, item, ignore_errors)
 
     for f in functionList:
         register(f)
 
-class Config:
+class Config(object):
     library_path = None
     library_file = None
     compatibility_check = True
     loaded = False
 
     @staticmethod
     def set_library_path(path):
         """Set the path in which to search for libclang"""

bindings/python/examples/cindex/cindex-dump.py

def main():
     if len(args) == 0:
         parser.error('invalid number arguments')
 
     index = Index.create()
     tu = index.parse(None, args)
     if not tu:
         parser.error("unable to load input")
 
-    pprint(('diags', map(get_diag_info, tu.diagnostics)))
+    pprint(('diags', [get_diag_info(d) for d in  tu.diagnostics]))
     pprint(('nodes', get_info(tu.cursor)))
 
 if __name__ == '__main__':
     main()
 

bindings/python/tests/cindex/test_translation_unit.py

 """)
                 ])
         spellings = [c.spelling for c in tu.cursor.get_children()]
         self.assertEqual(spellings[-2], 'x')
         self.assertEqual(spellings[-1], 'y')
 
     def test_unsaved_files_2(self):
         try:
-            from StringIO import StringIO
-        except:
             from io import StringIO
+        except:
+            from StringIO import StringIO
         tu = TranslationUnit.from_source('fake.c', unsaved_files = [
                 ('fake.c', StringIO('int x;'))])
         spellings = [c.spelling for c in tu.cursor.get_children()]
         self.assertEqual(spellings[-1], 'x')
 
     @skip_if_no_fspath
     def test_from_source_accepts_pathlike(self):
         tu = TranslationUnit.from_source(str_to_path('fake.c'), ['-Iincludes'], unsaved_files = [

docs/conf.py

 # -*- coding: utf-8 -*-
 #
 # Clang documentation build configuration file, created by
 # sphinx-quickstart on Sun Dec  9 20:01:55 2012.
 #
 # This file is execfile()d with the current directory set to its containing dir.
 #
 # Note that not all possible configuration values are present in this
 # autogenerated file.
 #
 # All configuration values have a default; values that are commented out
 # serve to show the default.
 
+from __future__ import print_function
 import sys, os
 from datetime import date
 
 # If extensions (or modules to document with autodoc) are in another directory,
 # add these directories to sys.path here. If the directory is relative to the
 # documentation root, use os.path.abspath to make it absolute, like shown here.
 #sys.path.insert(0, os.path.abspath('.'))
 
for name in os.listdir(command_guide_path):
 
     # Otherwise, automatically extract the description.
     file_subpath = os.path.join(command_guide_subpath, name)
     with open(os.path.join(command_guide_path, name)) as f:
         title = f.readline().rstrip('\n')
         header = f.readline().rstrip('\n')
 
         if len(header) != len(title):
-            print >>sys.stderr, (
+            print((
                 "error: invalid header in %r (does not match title)" % (
-                    file_subpath,))
+                    file_subpath,)), file=sys.stderr)
         if ' - ' not in title:
-            print >>sys.stderr, (
+            print((
                 ("error: invalid title in %r "
                  "(expected '<name> - <description>')") % (
-                    file_subpath,))
+                    file_subpath,)), file=sys.stderr)
 
         # Split the name out of the title.
         name,description = title.split(' - ', 1)
         man_pages.append((file_subpath.replace('.rst',''), name,
                           description, man_page_authors, 1))
 
 
 # If true, show URL addresses after external links.

docs/tools/dump_format_style.py

 #!/usr/bin/env python
 # A tool to parse the FormatStyle struct from Format.h and update the
 # documentation in ../ClangFormatStyleOptions.rst automatically.
 # Run from the directory in which this file is located to update the docs.
 
 import collections
 import os
 import re
-import urllib2
 
 CLANG_DIR = os.path.join(os.path.dirname(__file__), '../..')
 FORMAT_STYLE_FILE = os.path.join(CLANG_DIR, 'include/clang/Format/Format.h')
 INCLUDE_STYLE_FILE = os.path.join(CLANG_DIR, 'include/clang/Tooling/Inclusions/IncludeStyle.h')
 DOC_FILE = os.path.join(CLANG_DIR, 'docs/ClangFormatStyleOptions.rst')
 
 
 def substitute(text, tag, contents):

 
 def indent(text, columns, indent_first_line=True):
   indent = ' ' * columns
   s = re.sub(r'\n([^\n])', '\n' + indent + '\\1', text, flags=re.S)
   if not indent_first_line or s.startswith('\n'):
     return s
   return indent + s
 
-class Option:
+class Option(object):
   def __init__(self, name, type, comment):
     self.name = name
     self.type = type
     self.comment = comment.strip()
     self.enum = None
     self.nested_struct = None
 
   def __str__(self):
     s = '**%s** (``%s``)\n%s' % (self.name, self.type,
                                  doxygen2rst(indent(self.comment, 2)))
     if self.enum:
       s += indent('\n\nPossible values:\n\n%s\n' % self.enum, 2)
     if self.nested_struct:
       s += indent('\n\nNested configuration flags:\n\n%s\n' %self.nested_struct,
                   2)
     return s
 
-class NestedStruct:
+class NestedStruct(object):
   def __init__(self, name, comment):
     self.name = name
     self.comment = comment.strip()
     self.values = []
 
   def __str__(self):
     return '\n'.join(map(str, self.values))
 
-class NestedField:
+class NestedField(object):
   def __init__(self, name, comment):
     self.name = name
     self.comment = comment.strip()
 
   def __str__(self):
     return '\n* ``%s`` %s' % (
         self.name,
         doxygen2rst(indent(self.comment, 2, indent_first_line=False)))
 
-class Enum:
+class Enum(object):
   def __init__(self, name, comment):
     self.name = name
     self.comment = comment.strip()
     self.values = []
 
   def __str__(self):
     return '\n'.join(map(str, self.values))
 
-class EnumValue:
+class EnumValue(object):
   def __init__(self, name, comment):
     self.name = name
     self.comment = comment
 
   def __str__(self):
     return '* ``%s`` (in configuration: ``%s``)\n%s' % (
         self.name,
         re.sub('.*_', '', self.name),
         doxygen2rst(indent(self.comment, 2)))
 
 def clean_comment_line(line):
   match = re.match(r'^/// \\code(\{.(\w+)\})?$', line)
   if match:
     lang = match.groups()[1]
     if not lang:
       lang = 'c++'
     return '\n.. code-block:: %s\n\n' % lang
   if line == '/// \\endcode':
     return ''
   return line[4:] + '\n'
 
 def read_options(header):
-  class State:
+  class State(object):
     BeforeStruct, Finished, InStruct, InNestedStruct, InNestedFieldComent, \
     InFieldComment, InEnum, InEnumMemberComment = range(8)
   state = State.BeforeStruct
 
   options = []
   enums = {}
   nested_structs = {}
   comment = ''
def read_options(header):
   if state != State.Finished:
     raise Exception('Not finished by the end of file')
 
   for option in options:
     if not option.type in ['bool', 'unsigned', 'int', 'std::string',
                            'std::vector<std::string>',
                            'std::vector<IncludeCategory>',
                            'std::vector<RawStringFormat>']:
-      if enums.has_key(option.type):
+      if option.type in enums:
         option.enum = enums[option.type]
-      elif nested_structs.has_key(option.type):
+      elif option.type in nested_structs:
         option.nested_struct = nested_structs[option.type]
       else:
         raise Exception('Unknown type: %s' % option.type)
   return options
 
 options = read_options(open(FORMAT_STYLE_FILE))
 options += read_options(open(INCLUDE_STYLE_FILE))
 

tools/clang-format/clang-format-diff.py

 This script reads input from a unified diff and reformats all the changed
 lines. This is useful to reformat all the lines touched by a specific patch.
 Example usage for git/svn users:
 
   git diff -U0 --no-color HEAD^ | clang-format-diff.py -p1 -i
   svn diff --diff-cmd=diff -x-U0 | clang-format-diff.py -i
 
 """
+from __future__ import print_function
 
 import argparse
 import difflib
 import re
 import subprocess
 import sys
 try:
-  from StringIO import StringIO
-except ImportError:
-   from io import StringIO
+except ImportError:
+  from StringIO import StringIO
 
 
 def main():
   parser = argparse.ArgumentParser(description=
                                    'Reformat changed lines in diff. Without -i '
                                    'option just output the diff that would be '
                                    'introduced.')
   parser.add_argument('-i', action='store_true', default=False,

tools/scan-build-py/libscanbuild/arguments.py

 # -*- coding: utf-8 -*-
 #                     The LLVM Compiler Infrastructure
 #
 # This file is distributed under the University of Illinois Open Source
 # License. See LICENSE.TXT for details.
 """ This module parses and validates arguments for command-line interfaces.
 
 It uses argparse module to create the command line parser. (This library is
 in the standard python library since 3.2 and backported to 2.7, but not
 earlier.)
 
 It also implements basic validation methods, related to the command.
 Validations are mostly calling specific help methods, or mangling values.
 """
+from __future__ import print_function
 
 import os
 import sys
 import argparse
 import logging
 import tempfile
 from libscanbuild import reconfigure_logging, CtuConfig
 from libscanbuild.clang import get_checkers, is_ctu_capable

tools/scan-view/share/Reporter.py

 
 class ReportFailure(Exception):
     """Generic exception for failures in bug reporting."""
     def __init__(self, value):        
         self.value = value
 
 # Collect information about a bug.
 
-class BugReport:
+class BugReport(object):
     def __init__(self, title, description, files):
         self.title = title
         self.description = description
         self.files = files
 
 # Reporter interfaces.
 
 import os
 
 import email, mimetypes, smtplib
 from email import encoders
 from email.message import Message
 from email.mime.base import MIMEBase
 from email.mime.multipart import MIMEMultipart
 from email.mime.text import MIMEText
 
 #===------------------------------------------------------------------------===#
 # ReporterParameter
 #===------------------------------------------------------------------------===#
 
-class ReporterParameter:
+class ReporterParameter(object):
   def __init__(self, n):
     self.name = n
   def getName(self):
     return self.name
   def getValue(self,r,bugtype,getConfigOption):
      return getConfigOption(r.getName(),self.getName())
   def saveConfigValue(self):
     return True

 <option value="%s"%s>%s</option>"""%(o[0],
                                      o[0] == default and ' selected="selected"' or '',
                                      o[1]) for o in self.values]))
 
 #===------------------------------------------------------------------------===#
 # Reporters
 #===------------------------------------------------------------------------===#
 
-class EmailReporter:
+class EmailReporter(object):
     def getName(self):
         return 'Email'
 
     def getParameters(self):
-        return map(lambda x:TextParameter(x),['To', 'From', 'SMTP Server', 'SMTP Port'])
+        return [TextParameter(x) for x in ['To', 'From', 'SMTP Server', 'SMTP Port']]
 
     # Lifted from python email module examples.
     def attachFile(self, outer, path):
         # Guess the content type based on the file's extension.  Encoding
         # will be ignored, although we should check for simple things like
         # gzip'd or compressed files.
         ctype, encoding = mimetypes.guess_type(path)
         if ctype is None or encoding is not None:
"""%(report.title, report.description)
                              port=parameters.get('SMTP Port'))
             s.sendmail(msg['From'], msg['To'], msg.as_string())
             s.close()
         except:
             raise ReportFailure('Unable to send message via SMTP.')
 
         return "Message sent!"
 
-class BugzillaReporter:
+class BugzillaReporter(object):
     def getName(self):
         return 'Bugzilla'
     
     def getParameters(self):
-        return map(lambda x:TextParameter(x),['URL','Product'])
+        return [TextParameter(x) for x in ['URL','Product']]
 
     def fileReport(self, report, parameters):
         raise NotImplementedError
  
 
 class RadarClassificationParameter(SelectionParameter):
   def __init__(self):
     SelectionParameter.__init__(self,"Classification",
if bugtype.find("leak") != -1:
       return '3'
     elif bugtype.find("dereference") != -1:
       return '2'
     elif bugtype.find("missing ivar release") != -1:
       return '3'
     else:
       return '7'
 
-class RadarReporter:
+class RadarReporter(object):
     @staticmethod
     def isAvailable():
         # FIXME: Find this .scpt better
         path = os.path.join(os.path.dirname(__file__),'../share/scan-view/GetRadarVersion.scpt')
         try:
           p = subprocess.Popen(['osascript',path], 
           stdout=subprocess.PIPE, stderr=subprocess.PIPE)
         except:
def fileReport(self, report, parameters):
 
         if not component.strip():
             component = 'Bugs found by clang Analyzer'
         if not componentVersion.strip():
             componentVersion = 'X'
 
         script = os.path.join(os.path.dirname(__file__),'../share/scan-view/FileRadar.scpt')
         args = ['osascript', script, component, componentVersion, classification, personID, report.title,
-                report.description, diagnosis, config] + map(os.path.abspath, report.files)
+                report.description, diagnosis, config] + [os.path.abspath(f) for f in report.files]
 #        print >>sys.stderr, args
         try:
           p = subprocess.Popen(args, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
         except:
             raise ReportFailure("Unable to file radar (AppleScript failure).")
         data, err = p.communicate()
         res = p.wait()
 

utils/ABITest/ABITestGen.py

 #!/usr/bin/env python
 
+from __future__ import print_function
 from pprint import pprint
 import random, atexit, time
 from random import randrange
 import re
 
 from Enumeration import *
 from TypeGen import *
 
 ####
 
-class TypePrinter:
+class TypePrinter(object):
     def __init__(self, output, outputHeader=None, 
                  outputTests=None, outputDriver=None,
                  headerName=None, info=None):
         self.output = output
         self.outputHeader = outputHeader
         self.outputTests = outputTests
         self.outputDriver = outputDriver
         self.writeBody = outputHeader or outputTests or outputDriver
         self.types = {}
         self.testValues = {}
         self.testReturnValues = {}
         self.layoutTests = []
         self.declarations = set()
 
         if info:
             for f in (self.output,self.outputHeader,self.outputTests,self.outputDriver):
                 if f:
-                    print >>f,info
+                    print(info, file=f)
 
         if self.writeBody:
-            print >>self.output, '#include <stdio.h>\n'
+            print('#include <stdio.h>\n', file=self.output)
             if self.outputTests:
-                print >>self.outputTests, '#include <stdio.h>'
-                print >>self.outputTests, '#include <string.h>'
-                print >>self.outputTests, '#include <assert.h>\n'
+                print('#include <stdio.h>', file=self.outputTests)
+                print('#include <string.h>', file=self.outputTests)
+                print('#include <assert.h>\n', file=self.outputTests)
 
         if headerName:
             for f in (self.output,self.outputTests,self.outputDriver):
                 if f is not None:
-                    print >>f, '#include "%s"\n'%(headerName,)
+                    print('#include "%s"\n'%(headerName,), file=f)
         
         if self.outputDriver:
-            print >>self.outputDriver, '#include <stdio.h>'
-            print >>self.outputDriver, '#include <stdlib.h>\n'
-            print >>self.outputDriver, 'int main(int argc, char **argv) {'
-            print >>self.outputDriver, '  int index = -1;'
-            print >>self.outputDriver, '  if (argc > 1) index = atoi(argv[1]);'
+            print('#include <stdio.h>', file=self.outputDriver)
+            print('#include <stdlib.h>\n', file=self.outputDriver)
+            print('int main(int argc, char **argv) {', file=self.outputDriver)
+            print('  int index = -1;', file=self.outputDriver)
+            print('  if (argc > 1) index = atoi(argv[1]);', file=self.outputDriver)
             
     def finish(self):
         if self.layoutTests:
-            print >>self.output, 'int main(int argc, char **argv) {'
-            print >>self.output, '  int index = -1;'
-            print >>self.output, '  if (argc > 1) index = atoi(argv[1]);'
+            print('int main(int argc, char **argv) {', file=self.output)
+            print('  int index = -1;', file=self.output)
+            print('  if (argc > 1) index = atoi(argv[1]);', file=self.output)
             for i,f in self.layoutTests:
-                print >>self.output, '  if (index == -1 || index == %d)' % i
-                print >>self.output, '    %s();' % f
-            print >>self.output, '  return 0;'
-            print >>self.output, '}' 
+                print('  if (index == -1 || index == %d)' % i, file=self.output)
+                print('    %s();' % f, file=self.output)
+            print('  return 0;', file=self.output)
+            print('}', file=self.output) 
 
         if self.outputDriver:
-            print >>self.outputDriver, '  printf("DONE\\n");'
-            print >>self.outputDriver, '  return 0;'
-            print >>self.outputDriver, '}'        
+            print('  printf("DONE\\n");', file=self.outputDriver)
+            print('  return 0;', file=self.outputDriver)
+            print('}', file=self.outputDriver)        
 
     def addDeclaration(self, decl):
         if decl in self.declarations:
             return False
 
         self.declarations.add(decl)
         if self.outputHeader:
-            print >>self.outputHeader, decl
+            print(decl, file=self.outputHeader)
         else:
-            print >>self.output, decl
+            print(decl, file=self.output)
             if self.outputTests:
-                print >>self.outputTests, decl
+                print(decl, file=self.outputTests)
         return True
 
     def getTypeName(self, T):
         name = self.types.get(T)
         if name is None:            
             # Reserve slot
             self.types[T] = None
             self.types[T] = name = T.getTypeName(self)
         return name
     
     def writeLayoutTest(self, i, ty):
         tyName = self.getTypeName(ty)
         tyNameClean = tyName.replace(' ','_').replace('*','star')
         fnName = 'test_%s' % tyNameClean
             
-        print >>self.output,'void %s(void) {' % fnName
+        print('void %s(void) {' % fnName, file=self.output)
         self.printSizeOfType('    %s'%fnName, tyName, ty, self.output)
         self.printAlignOfType('    %s'%fnName, tyName, ty, self.output)
         self.printOffsetsOfType('    %s'%fnName, tyName, ty, self.output)
-        print >>self.output,'}'
-        print >>self.output
+        print('}', file=self.output)
+        print(file=self.output)
         
         self.layoutTests.append((i,fnName))
         
     def writeFunction(self, i, FT):
         args = ', '.join(['%s arg%d'%(self.getTypeName(t),i) for i,t in enumerate(FT.argTypes)])
         if not args:
             args = 'void'
 
         if FT.returnType is None:
             retvalName = None
             retvalTypeName = 'void'
         else:
             retvalTypeName = self.getTypeName(FT.returnType)
             if self.writeBody or self.outputTests:
                 retvalName = self.getTestReturnValue(FT.returnType)
 
         fnName = 'fn%d'%(FT.index,)
         if self.outputHeader:
-            print >>self.outputHeader,'%s %s(%s);'%(retvalTypeName, fnName, args)
+            print('%s %s(%s);'%(retvalTypeName, fnName, args), file=self.outputHeader)
         elif self.outputTests:
-            print >>self.outputTests,'%s %s(%s);'%(retvalTypeName, fnName, args)
+            print('%s %s(%s);'%(retvalTypeName, fnName, args), file=self.outputTests)
             
-        print >>self.output,'%s %s(%s)'%(retvalTypeName, fnName, args),
+        print('%s %s(%s)'%(retvalTypeName, fnName, args), end=' ', file=self.output)
         if self.writeBody:
-            print >>self.output, '{'
+            print('{', file=self.output)
             
             for i,t in enumerate(FT.argTypes):
                 self.printValueOfType('    %s'%fnName, 'arg%d'%i, t)
 
             if retvalName is not None:
-                print >>self.output, '  return %s;'%(retvalName,)
-            print >>self.output, '}'
+                print('  return %s;'%(retvalName,), file=self.output)
+            print('}', file=self.output)
         else:
-            print >>self.output, '{}'
-        print >>self.output
+            print('{}', file=self.output)
+        print(file=self.output)
 
         if self.outputDriver:
-            print >>self.outputDriver, '  if (index == -1 || index == %d) {' % i
-            print >>self.outputDriver, '    extern void test_%s(void);' % fnName
-            print >>self.outputDriver, '    test_%s();' % fnName
-            print >>self.outputDriver, '   }'
+            print('  if (index == -1 || index == %d) {' % i, file=self.outputDriver)
+            print('    extern void test_%s(void);' % fnName, file=self.outputDriver)
+            print('    test_%s();' % fnName, file=self.outputDriver)
+            print('   }', file=self.outputDriver)
             
         if self.outputTests:
             if self.outputHeader:
-                print >>self.outputHeader, 'void test_%s(void);'%(fnName,)
+                print('void test_%s(void);'%(fnName,), file=self.outputHeader)
 
             if retvalName is None:
                 retvalTests = None
             else:
                 retvalTests = self.getTestValuesArray(FT.returnType)
-            tests = map(self.getTestValuesArray, FT.argTypes)
-            print >>self.outputTests, 'void test_%s(void) {'%(fnName,)
+            tests = [self.getTestValuesArray(ty) for ty in FT.argTypes]
+            print('void test_%s(void) {'%(fnName,), file=self.outputTests)
 
             if retvalTests is not None:
-                print >>self.outputTests, '  printf("%s: testing return.\\n");'%(fnName,)
-                print >>self.outputTests, '  for (int i=0; i<%d; ++i) {'%(retvalTests[1],)
+                print('  printf("%s: testing return.\\n");'%(fnName,), file=self.outputTests)
+                print('  for (int i=0; i<%d; ++i) {'%(retvalTests[1],), file=self.outputTests)
                 args = ', '.join(['%s[%d]'%(t,randrange(l)) for t,l in tests])
-                print >>self.outputTests, '    %s RV;'%(retvalTypeName,)
-                print >>self.outputTests, '    %s = %s[i];'%(retvalName, retvalTests[0])
-                print >>self.outputTests, '    RV = %s(%s);'%(fnName, args)
+                print('    %s RV;'%(retvalTypeName,), file=self.outputTests)
+                print('    %s = %s[i];'%(retvalName, retvalTests[0]), file=self.outputTests)
+                print('    RV = %s(%s);'%(fnName, args), file=self.outputTests)
                 self.printValueOfType('  %s_RV'%fnName, 'RV', FT.returnType, output=self.outputTests, indent=4)
                 self.checkTypeValues('RV', '%s[i]' % retvalTests[0], FT.returnType, output=self.outputTests, indent=4)
-                print >>self.outputTests, '  }'
+                print('  }', file=self.outputTests)
             
             if tests:
-                print >>self.outputTests, '  printf("%s: testing arguments.\\n");'%(fnName,)
+                print('  printf("%s: testing arguments.\\n");'%(fnName,), file=self.outputTests)
             for i,(array,length) in enumerate(tests):
                 for j in range(length):
                     args = ['%s[%d]'%(t,randrange(l)) for t,l in tests]
                     args[i] = '%s[%d]'%(array,j)
-                    print >>self.outputTests, '  %s(%s);'%(fnName, ', '.join(args),)
-            print >>self.outputTests, '}'
+                    print('  %s(%s);'%(fnName, ', '.join(args),), file=self.outputTests)
+            print('}', file=self.outputTests)
 
     def getTestReturnValue(self, type):
         typeName = self.getTypeName(type)        
         info = self.testReturnValues.get(typeName)
         if info is None:
             name = '%s_retval'%(typeName.replace(' ','_').replace('*','star'),)
-            print >>self.output, '%s %s;'%(typeName,name)
+            print('%s %s;'%(typeName,name), file=self.output)
             if self.outputHeader:
-                print >>self.outputHeader, 'extern %s %s;'%(typeName,name)
+                print('extern %s %s;'%(typeName,name), file=self.outputHeader)
             elif self.outputTests:                
-                print >>self.outputTests, 'extern %s %s;'%(typeName,name)
+                print('extern %s %s;'%(typeName,name), file=self.outputTests)
             info = self.testReturnValues[typeName] = name
         return info
 
     def getTestValuesArray(self, type):
         typeName = self.getTypeName(type)        
         info = self.testValues.get(typeName)
         if info is None:
             name = '%s_values'%(typeName.replace(' ','_').replace('*','star'),)
-            print >>self.outputTests, 'static %s %s[] = {'%(typeName,name)
+            print('static %s %s[] = {'%(typeName,name), file=self.outputTests)
             length = 0
             for item in self.getTestValues(type):
-                print >>self.outputTests, '\t%s,'%(item,)
+                print('\t%s,'%(item,), file=self.outputTests)
                 length += 1
-            print >>self.outputTests,'};'
+            print('};', file=self.outputTests)
             info = self.testValues[typeName] = (name,length)
         return info
 
     def getTestValues(self, t):
         if isinstance(t, BuiltinType):
             if t.name=='float':
                 for i in ['0.0','-1.0','1.0']:
                     yield i+'f'
def getTestValues(self, t):
 
             # FIXME: Use designated initializers to access non-first
             # fields of unions.
             if t.isUnion:
                 for v in self.getTestValues(nonPadding[0]):
                     yield '{ %s }' % v
                 return
 
-            fieldValues = map(list, map(self.getTestValues, nonPadding))
+            fieldValues = [list(v) for v in map(self.getTestValues, nonPadding)]
             for i,values in enumerate(fieldValues):
                 for v in values:
-                    elements = map(random.choice,fieldValues)
+                    elements = [random.choice(fv) for fv in fieldValues]
                     elements[i] = v
                     yield '{ %s }'%(', '.join(elements))
 
         elif isinstance(t, ComplexType):
             for t in self.getTestValues(t.elementType):
                 yield '%s + %s * 1i'%(t,t)
         elif isinstance(t, ArrayType):
             values = list(self.getTestValues(t.elementType))
             if not values:
                 yield '{ }'
             for i in range(t.numElements):
                 for v in values:
                     elements = [random.choice(values) for i in range(t.numElements)]
                     elements[i] = v
                     yield '{ %s }'%(', '.join(elements))
         else:
-            raise NotImplementedError,'Cannot make tests values of type: "%s"'%(t,)
+            raise NotImplementedError('Cannot make tests values of type: "%s"'%(t,))
 
     def printSizeOfType(self, prefix, name, t, output=None, indent=2):
-        print >>output, '%*sprintf("%s: sizeof(%s) = %%ld\\n", (long)sizeof(%s));'%(indent, '', prefix, name, name) 
+        print('%*sprintf("%s: sizeof(%s) = %%ld\\n", (long)sizeof(%s));'%(indent, '', prefix, name, name), file=output) 
     def printAlignOfType(self, prefix, name, t, output=None, indent=2):
-        print >>output, '%*sprintf("%s: __alignof__(%s) = %%ld\\n", (long)__alignof__(%s));'%(indent, '', prefix, name, name) 
+        print('%*sprintf("%s: __alignof__(%s) = %%ld\\n", (long)__alignof__(%s));'%(indent, '', prefix, name, name), file=output) 
     def printOffsetsOfType(self, prefix, name, t, output=None, indent=2):
         if isinstance(t, RecordType):
             for i,f in enumerate(t.fields):
                 if f.isBitField():
                     continue
                 fname = 'field%d' % i
-                print >>output, '%*sprintf("%s: __builtin_offsetof(%s, %s) = %%ld\\n", (long)__builtin_offsetof(%s, %s));'%(indent, '', prefix, name, fname, name, fname) 
+                print('%*sprintf("%s: __builtin_offsetof(%s, %s) = %%ld\\n", (long)__builtin_offsetof(%s, %s));'%(indent, '', prefix, name, fname, name, fname), file=output) 
                 
     def printValueOfType(self, prefix, name, t, output=None, indent=2):
         if output is None:
             output = self.output
         if isinstance(t, BuiltinType):
             value_expr = name
             if t.name.split(' ')[-1] == '_Bool':
                 # Hack to work around PR5579.
                 value_expr = "%s ? 2 : 0" % name
 
             if t.name.endswith('long long'):
                 code = 'lld'
             elif t.name.endswith('long'):
                 code = 'ld'
             elif t.name.split(' ')[-1] in ('_Bool','char','short',
                                            'int','unsigned'):
                 code = 'd'
             elif t.name in ('float','double'):
                 code = 'f'
             elif t.name == 'long double':
                 code = 'Lf'
             else:
                 code = 'p'
-            print >>output, '%*sprintf("%s: %s = %%%s\\n", %s);'%(
-                indent, '', prefix, name, code, value_expr)
+            print('%*sprintf("%s: %s = %%%s\\n", %s);'%(
+                indent, '', prefix, name, code, value_expr), file=output)
         elif isinstance(t, EnumType):
-            print >>output, '%*sprintf("%s: %s = %%d\\n", %s);'%(indent, '', prefix, name, name)
+            print('%*sprintf("%s: %s = %%d\\n", %s);'%(indent, '', prefix, name, name), file=output)
         elif isinstance(t, RecordType):
             if not t.fields:
-                print >>output, '%*sprintf("%s: %s (empty)\\n");'%(indent, '', prefix, name) 
+                print('%*sprintf("%s: %s (empty)\\n");'%(indent, '', prefix, name), file=output) 
             for i,f in enumerate(t.fields):
                 if f.isPaddingBitField():
                     continue
                 fname = '%s.field%d'%(name,i)
                 self.printValueOfType(prefix, fname, f, output=output, indent=indent)
         elif isinstance(t, ComplexType):
             self.printValueOfType(prefix, '(__real %s)'%name, t.elementType, output=output,indent=indent)
             self.printValueOfType(prefix, '(__imag %s)'%name, t.elementType, output=output,indent=indent)
         elif isinstance(t, ArrayType):
             for i in range(t.numElements):
                 # Access in this fashion as a hackish way to portably
                 # access vectors.
                 if t.isVector:
                     self.printValueOfType(prefix, '((%s*) &%s)[%d]'%(t.elementType,name,i), t.elementType, output=output,indent=indent)
                 else:
                     self.printValueOfType(prefix, '%s[%d]'%(name,i), t.elementType, output=output,indent=indent)                    
         else:
-            raise NotImplementedError,'Cannot print value of type: "%s"'%(t,)
+            raise NotImplementedError('Cannot print value of type: "%s"'%(t,))
 
     def checkTypeValues(self, nameLHS, nameRHS, t, output=None, indent=2):
         prefix = 'foo'
         if output is None:
             output = self.output
         if isinstance(t, BuiltinType):
-            print >>output, '%*sassert(%s == %s);' % (indent, '', nameLHS, nameRHS)
+            print('%*sassert(%s == %s);' % (indent, '', nameLHS, nameRHS), file=output)
         elif isinstance(t, EnumType):
-            print >>output, '%*sassert(%s == %s);' % (indent, '', nameLHS, nameRHS)
+            print('%*sassert(%s == %s);' % (indent, '', nameLHS, nameRHS), file=output)
         elif isinstance(t, RecordType):
             for i,f in enumerate(t.fields):
                 if f.isPaddingBitField():
                     continue
                 self.checkTypeValues('%s.field%d'%(nameLHS,i), '%s.field%d'%(nameRHS,i), 
                                      f, output=output, indent=indent)
                 if t.isUnion:
                     break
         elif isinstance(t, ComplexType):
             self.checkTypeValues('(__real %s)'%nameLHS, '(__real %s)'%nameRHS, t.elementType, output=output,indent=indent)
             self.checkTypeValues('(__imag %s)'%nameLHS, '(__imag %s)'%nameRHS, t.elementType, output=output,indent=indent)
         elif isinstance(t, ArrayType):
             for i in range(t.numElements):
                 # Access in this fashion as a hackish way to portably
                 # access vectors.
                 if t.isVector:
                     self.checkTypeValues('((%s*) &%s)[%d]'%(t.elementType,nameLHS,i), 
                                          '((%s*) &%s)[%d]'%(t.elementType,nameRHS,i), 
                                          t.elementType, output=output,indent=indent)
                 else:
                     self.checkTypeValues('%s[%d]'%(nameLHS,i), '%s[%d]'%(nameRHS,i), 
                                          t.elementType, output=output,indent=indent)                    
         else:
-            raise NotImplementedError,'Cannot print value of type: "%s"'%(t,)
+            raise NotImplementedError('Cannot print value of type: "%s"'%(t,))
 
 import sys
 
 def main():
     from optparse import OptionParser, OptionGroup
     parser = OptionParser("%prog [options] {indices}")
     parser.add_option("", "--mode", dest="mode",
                       help="autogeneration mode (random or linear) [default %default]",
P = TypePrinter(output,
                     outputTests=outputTests,
                     outputDriver=outputDriver,
                     headerName=opts.outputHeader,                    
                     info=info)
 
     def write(N):
         try:
             FT = ftg.get(N)
-        except RuntimeError,e:
+        except RuntimeError as e:
             if e.args[0]=='maximum recursion depth exceeded':
-                print >>sys.stderr,'WARNING: Skipped %d, recursion limit exceeded (bad arguments?)'%(N,)
+                print('WARNING: Skipped %d, recursion limit exceeded (bad arguments?)'%(N,), file=sys.stderr)
                 return
             raise
         if opts.testLayout:
             P.writeLayoutTest(N, FT)
         else:
             P.writeFunction(N, FT)
 
     if args:

utils/ABITest/Enumeration.py

 """Utilities for enumeration of finite and countably infinite sets.
 """
+from __future__ import print_function
 ###
 # Countable iteration
 
 # Simplifies some calculations
 class Aleph0(int):
     _singleton = None
     def __new__(type):
         if type._singleton is None:
             type._singleton = int.__new__(type)
         return type._singleton
     def __repr__(self): return '<aleph0>'
     def __str__(self): return 'inf'
     
     def __cmp__(self, b):
         return 1
 
     def __sub__(self, b):
-        raise ValueError,"Cannot subtract aleph0"
+        raise ValueError("Cannot subtract aleph0")
     __rsub__ = __sub__
 
     def __add__(self, b): 
         return self
     __radd__ = __add__
 
     def __mul__(self, b): 
         if b == 0: return b            
class Aleph0(int):
     def __pow__(self, b):
         if b == 0: return 1
         return self
 aleph0 = Aleph0()
 
 def base(line):
     return line*(line+1)//2
 
-def pairToN((x,y)):
+def pairToN(pair):
+    x,y = pair
     line,index = x+y,y
     return base(line)+index
 
 def getNthPairInfo(N):
     # Avoid various singularities
     if N==0:
         return (0,0)
 
def getNthPair(N):
     return (line - index, index)
 
 def getNthPairBounded(N,W=aleph0,H=aleph0,useDivmod=False):
     """getNthPairBounded(N, W, H) -> (x, y)
     
     Return the N-th pair such that 0 <= x < W and 0 <= y < H."""
 
     if W <= 0 or H <= 0:
-        raise ValueError,"Invalid bounds"
+        raise ValueError("Invalid bounds")
     elif N >= W*H:
-        raise ValueError,"Invalid input (out of bounds)"
+        raise ValueError("Invalid input (out of bounds)")
 
     # Simple case...
     if W is aleph0 and H is aleph0:
         return getNthPair(N)
 
     # Otherwise simplify by assuming W < H
     if H < W:
         x,y = getNthPairBounded(N,H,W,useDivmod=useDivmod)
def getNthTuple(N, maxSize=aleph0, maxElement=aleph0, useDivmod=False, useLeftToRight=False):
     y < maxElement."""
 
     # All zero sized tuples are isomorphic, don't ya know.
     if N == 0:
         return ()
     N -= 1
     if maxElement is not aleph0:
         if maxSize is aleph0:
-            raise NotImplementedError,'Max element size without max size unhandled'
+            raise NotImplementedError('Max element size without max size unhandled')
         bounds = [maxElement**i for i in range(1, maxSize+1)]
         S,M = getNthPairVariableBounds(N, bounds)
     else:
         S,M = getNthPairBounded(N, maxSize, useDivmod=useDivmod)
     return getNthNTuple(M, S+1, maxElement, useLeftToRight=useLeftToRight)
 def getNthTupleChecked(N, maxSize=aleph0, maxElement=aleph0, 
                        useDivmod=False, useLeftToRight=False, GNT=getNthTuple):
     # FIXME: maxsize is inclusive
     t = GNT(N,maxSize,maxElement,useDivmod,useLeftToRight)
     assert len(t) <= maxSize
     for i in t:
         assert i < maxElement
     return t
 
 def getNthPairVariableBounds(N, bounds):
     """getNthPairVariableBounds(N, bounds) -> (x, y)
 
     Given a finite list of bounds (which may be finite or aleph0),
     return the N-th pair such that 0 <= x < len(bounds) and 0 <= y <
     bounds[x]."""
 
     if not bounds:
-        raise ValueError,"Invalid bounds"
+        raise ValueError("Invalid bounds")
     if not (0 <= N < sum(bounds)):
-        raise ValueError,"Invalid input (out of bounds)"
+        raise ValueError("Invalid input (out of bounds)")
 
     level = 0
-    active = range(len(bounds))
+    active = list(range(len(bounds)))
     active.sort(key=lambda i: bounds[i])
     prevLevel = 0
     for i,index in enumerate(active):
         level = bounds[index]
         W = len(active) - i
         if level is aleph0:
             H = aleph0
         else:
             H = level - prevLevel
         levelSize = W*H
         if N<levelSize: # Found the level
             idelta,delta = getNthPairBounded(N, W, H)
             return active[i+idelta],prevLevel+delta
         else:
             N -= levelSize
             prevLevel = level
     else:
-        raise RuntimError,"Unexpected loop completion"
+        raise RuntimError("Unexpected loop completion")
 
 def getNthPairVariableBoundsChecked(N, bounds, GNVP=getNthPairVariableBounds):
     x,y = GNVP(N,bounds)
     assert 0 <= x < len(bounds) and 0 <= y < bounds[x]
     return (x,y)
 
 ###
 
 def testPairs():
     W = 3
     H = 6
     a = [['  ' for x in range(10)] for y in range(10)]
     b = [['  ' for x in range(10)] for y in range(10)]
     for i in range(min(W*H,40)):
         x,y = getNthPairBounded(i,W,H)
         x2,y2 = getNthPairBounded(i,W,H,useDivmod=True)
-        print i,(x,y),(x2,y2)
+        print(i,(x,y),(x2,y2))
         a[y][x] = '%2d'%i
         b[y2][x2] = '%2d'%i
 
-    print '-- a --'
+    print('-- a --')
     for ln in a[::-1]:
         if ''.join(ln).strip():
-            print '  '.join(ln)
-    print '-- b --'
+            print('  '.join(ln))
+    print('-- b --')
     for ln in b[::-1]:
         if ''.join(ln).strip():
-            print '  '.join(ln)
+            print('  '.join(ln))
 
 def testPairsVB():
     bounds = [2,2,4,aleph0,5,aleph0]
     a = [['  ' for x in range(15)] for y in range(15)]
     b = [['  ' for x in range(15)] for y in range(15)]
     for i in range(min(sum(bounds),40)):
         x,y = getNthPairVariableBounds(i, bounds)
-        print i,(x,y)
+        print(i,(x,y))
         a[y][x] = '%2d'%i
 
-    print '-- a --'
+    print('-- a --')
     for ln in a[::-1]:
         if ''.join(ln).strip():
-            print '  '.join(ln)
+            print('  '.join(ln))
 
 ###
 
 # Toggle to use checked versions of enumeration routines.
 if False:
     getNthPairVariableBounds = getNthPairVariableBoundsChecked
     getNthPairBounded = getNthPairBoundedChecked
     getNthNTuple = getNthNTupleChecked
     getNthTuple = getNthTupleChecked
 
 if __name__ == '__main__':
     testPairs()
 
     testPairsVB()
 

utils/CIndex/completion_logger_server.py

 #!/usr/bin/env python
+from __future__ import print_function
 import sys
 from socket import *
 from time import strftime
 import datetime
 
 def main():
   if len(sys.argv) < 4:
-    print "completion_logger_server.py <listen address> <listen port> <log file>"
+    print("completion_logger_server.py <listen address> <listen port> <log file>")
     exit(1)
 
   host = sys.argv[1]
   port = int(sys.argv[2])
   buf = 1024 * 8
   addr = (host,port)
   
   # Create socket and bind to address
   UDPSock = socket(AF_INET,SOCK_DGRAM)
   UDPSock.bind(addr)
   
-  print "Listing on {0}:{1} and logging to '{2}'".format(host, port, sys.argv[3])
+  print("Listing on {0}:{1} and logging to '{2}'".format(host, port, sys.argv[3]))
 
   # Open the logging file.
   f = open(sys.argv[3], "a")
 
   # Receive messages
   while 1:
     data,addr = UDPSock.recvfrom(buf)
     if not data:

utils/TestUtils/deep-stack.py

 #!/usr/bin/env python
 
+from __future__ import print_function
 def pcall(f, N):
     if N == 0:
-        print >>f, '    f(0)'
+        print('    f(0)', file=f)
         return
 
-    print >>f, '    f('
+    print('    f(', file=f)
     pcall(f, N - 1)
-    print >>f, '     )'
+    print('     )', file=f)
 
 def main():
     f = open('t.c','w')
-    print >>f, 'int f(int n) { return n; }'
-    print >>f, 'int t() {'
-    print >>f, '  return'
+    print('int f(int n) { return n; }', file=f)
+    print('int t() {', file=f)
+    print('  return', file=f)
     pcall(f, 10000)
-    print >>f, '  ;'
-    print >>f, '}'
+    print('  ;', file=f)
+    print('}', file=f)
 
 if __name__ == "__main__":
     import sys
     sys.setrecursionlimit(100000)
     main()

utils/analyzer/SATestAdd.py

The project should use the following files for set up:
                                      CachedSource to another directory (for
                                      example, PatchedSource) and make any
                                      needed modifications to the copied
                                      source.
                                      Then run:
                                           diff -ur CachedSource PatchedSource \
                                               > changes_for_analyzer.patch
 """
+from __future__ import print_function
 import SATestBuild
 
 import os
 import csv
 import sys
 
 
 def isExistingProject(PMapFile, projectID):
     PMapReader = csv.reader(PMapFile)
     for I in PMapReader:
         if projectID == I[0]:
             return True
     return False
 
 
 def addNewProject(ID, BuildMode):
     """
     Add a new project for testing: build it and add to the Project Map file.
     :param ID: is a short string used to identify a project.
     """
 
     CurDir = os.path.abspath(os.curdir)
     Dir = SATestBuild.getProjectDir(ID)
     if not os.path.exists(Dir):
-        print "Error: Project directory is missing: %s" % Dir
+        print("Error: Project directory is missing: %s" % Dir)
         sys.exit(-1)
 
     # Build the project.
     SATestBuild.testProject(ID, BuildMode, IsReferenceBuild=True)
 
     # Add the project ID to the project map.
     ProjectMapPath = os.path.join(CurDir, SATestBuild.ProjectMapFile)
 
     if os.path.exists(ProjectMapPath):
         FileMode = "r+b"
     else:
-        print "Warning: Creating the Project Map file!!"
+        print("Warning: Creating the Project Map file!!")
         FileMode = "w+b"
 
     with open(ProjectMapPath, FileMode) as PMapFile:
         if (isExistingProject(PMapFile, ID)):
-            print >> sys.stdout, 'Warning: Project with ID \'', ID, \
-                                 '\' already exists.'
-            print >> sys.stdout, "Reference output has been regenerated."
+            print('Warning: Project with ID \'', ID, \
+                                 '\' already exists.', file=sys.stdout)
+            print("Reference output has been regenerated.", file=sys.stdout)
         else:
             PMapWriter = csv.writer(PMapFile)
             PMapWriter.writerow((ID, int(BuildMode)))
-            print "The project map is updated: ", ProjectMapPath
+            print("The project map is updated: ", ProjectMapPath)
 
 
 # TODO: Add an option not to build.
 # TODO: Set the path to the Repository directory.
 if __name__ == '__main__':
     if len(sys.argv) < 2 or sys.argv[1] in ('-h', '--help'):
-        print >> sys.stderr, 'Add a new project for testing to the analyzer'\
+        print('Add a new project for testing to the analyzer'\
                              '\nUsage: ', sys.argv[0],\
                              'project_ID <mode>\n' \
                              'mode: 0 for single file project, ' \
                              '1 for scan_build, ' \
-                             '2 for single file c++11 project'
+                             '2 for single file c++11 project', file=sys.stderr)
         sys.exit(-1)
 
     BuildMode = 1
     if (len(sys.argv) >= 3):
         BuildMode = int(sys.argv[2])
     assert((BuildMode == 0) | (BuildMode == 1) | (BuildMode == 2))
 
     addNewProject(sys.argv[1], BuildMode)

utils/analyzer/SATestUpdateDiffs.py

 #!/usr/bin/env python
 
 """
 Update reference results for static analyzer.
 """
+from __future__ import print_function
 
 import SATestBuild
 
 from subprocess import check_call
 import os
 import sys
 
 Verbose = 0
 
 
 def runCmd(Command, **kwargs):
     if Verbose:
-        print "Executing %s" % Command
+        print("Executing %s" % Command)
     check_call(Command, shell=True, **kwargs)
 
 
 def updateReferenceResults(ProjName, ProjBuildMode):
     ProjDir = SATestBuild.getProjectDir(ProjName)
 
     RefResultsPath = os.path.join(
         ProjDir,
         SATestBuild.getSBOutputDirName(IsReferenceBuild=True))
     CreatedResultsPath = os.path.join(
         ProjDir,
         SATestBuild.getSBOutputDirName(IsReferenceBuild=False))
 
     if not os.path.exists(CreatedResultsPath):
-        print >> sys.stderr, "New results not found, was SATestBuild.py "\
-                             "previously run?"
+        print("New results not found, was SATestBuild.py "\
+                             "previously run?", file=sys.stderr)
         sys.exit(1)
 
     BuildLogPath = SATestBuild.getBuildLogPath(RefResultsPath)
     Dirname = os.path.dirname(os.path.abspath(BuildLogPath))
     runCmd("mkdir -p '%s'" % Dirname)
     with open(BuildLogPath, "wb+") as PBuildLogFile:
         # Remove reference results: in git, and then again for a good measure
         # with rm, as git might not remove things fully if there are empty
with open(BuildLogPath, "wb+") as PBuildLogFile:
         # Clean up the generated difference results.
         SATestBuild.cleanupReferenceResults(RefResultsPath)
 
         runCmd('git add "%s"' % (RefResultsPath,), stdout=PBuildLogFile)
 
 
 def main(argv):
     if len(argv) == 2 and argv[1] in ('-h', '--help'):
-        print >> sys.stderr, "Update static analyzer reference results based "\
+        print("Update static analyzer reference results based "\
                              "\non the previous run of SATestBuild.py.\n"\
-                             "\nN.B.: Assumes that SATestBuild.py was just run"
+                             "\nN.B.: Assumes that SATestBuild.py was just run", file=sys.stderr)
         sys.exit(1)
 
     with SATestBuild.projectFileHandler() as f:
         for (ProjName, ProjBuildMode) in SATestBuild.iterateOverProjects(f):
             updateReferenceResults(ProjName, int(ProjBuildMode))
 
 
 if __name__ == '__main__':
     main(sys.argv)

utils/analyzer/SumTimerInfo.py

 #!/usr/bin/env python
 
 """
 Script to Summarize statistics in the scan-build output.
 
 Statistics are enabled by passing '-internal-stats' option to scan-build
 (or '-analyzer-stats' to the analyzer).
 """
+from __future__ import print_function
 
 import sys
 
 if __name__ == '__main__':
     if len(sys.argv) < 2:
-        print >> sys.stderr, 'Usage: ', sys.argv[0],\
-                             'scan_build_output_file'
+        print('Usage: ', sys.argv[0],\
+                             'scan_build_output_file', file=sys.stderr)
         sys.exit(-1)
 
     f = open(sys.argv[1], 'r')
     Time = 0.0
     TotalTime = 0.0
     MaxTime = 0.0
     Warnings = 0
     Count = 0
for line in f:
         if "The # of times we split the path due \
                 to imprecise dynamic dispatch info" in line:
             s = line.split()
             NumBifurcatedCallSites = NumBifurcatedCallSites + int(s[0])
         if ")  Total" in line:
             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)
+    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))

utils/check_cfc/obj_diff.py

-#!/usr/bin/env python2.7
+#!/usr/bin/env python
 
 from __future__ import print_function
 
 import argparse
 import difflib
 import filecmp
 import os
 import subprocess
def disassemble(objfile):
     """Disassemble object to a file."""
     p = subprocess.Popen([disassembler, '-d', objfile],
                          stdout=subprocess.PIPE,
                          stderr=subprocess.PIPE)
     (out, err) = p.communicate()
     if p.returncode or err:
         print("Disassemble failed: {}".format(objfile))
         sys.exit(1)
-    return filter(keep_line, out.split(os.linesep))
+    return [line for line in out.split(os.linesep) if keep_line(line)]
 
 def dump_debug(objfile):
     """Dump all of the debug info from a file."""
     p = subprocess.Popen([disassembler, '-WliaprmfsoRt', objfile], stdout=subprocess.PIPE, stderr=subprocess.PIPE)
     (out, err) = p.communicate()
     if p.returncode or err:
         print("Dump debug failed: {}".format(objfile))
         sys.exit(1)
-    return filter(keep_line, out.split(os.linesep))
+    return [line for line in out.split(os.linesep) if keep_line(line)]
 
 def first_diff(a, b, fromfile, tofile):
     """Returns the first few lines of a difference, if there is one.  Python
     diff can be very slow with large objects and the most interesting changes
     are the first ones. Truncate data before sending to difflib.  Returns None
     is there is no difference."""
 
     # Find first diff

utils/check_cfc/setup.py

 """For use on Windows. Run with:
     python.exe setup.py py2exe
     """
+from __future__ import print_function
 from distutils.core import setup
 try:
     import py2exe
 except ImportError:
     import platform
     import sys
     if platform.system() == 'Windows':
-        print "Could not find py2exe. Please install then run setup.py py2exe."
+        print("Could not find py2exe. Please install then run setup.py py2exe.")
         raise
     else:
-        print "setup.py only required on Windows."
+        print("setup.py only required on Windows.")
         sys.exit(1)
 
 setup(
       console=['check_cfc.py'],
       name="Check CFC",
       description='Check Compile Flow Consistency'
       )

utils/check_cfc/test_check_cfc.py

-#!/usr/bin/env python2.7
+#!/usr/bin/env python
 
 """Test internal functions within check_cfc.py."""
 
 import check_cfc
 import os
 import platform
 import unittest
 

utils/clangdiag.py

 #!/usr/bin/python
 
 #----------------------------------------------------------------------
 # Be sure to add the python path that points to the LLDB shared library.
 #
 # # To use this in the embedded python interpreter using "lldb" just
 # import it with the full path using the "command script import"
 # command
 #   (lldb) command script import /path/to/clandiag.py
 #----------------------------------------------------------------------
 
+from __future__ import print_function
 import lldb
 import argparse
-import commands
 import shlex
 import os
 import re
 import subprocess
 
 class MyParser(argparse.ArgumentParser):
     def format_help(self):
         return '''     Commands for managing clang diagnostic breakpoints
def __lldb_init_module(debugger, dict):
     # This initializer is being run from LLDB in the embedded command interpreter
     # Make the options so we can generate the help text for the new LLDB
     # command line command prior to registering it with LLDB below
     parser = create_diag_options()
     the_diag_command.__doc__ = parser.format_help()
     # Add any commands contained in this module to LLDB
     debugger.HandleCommand(
         'command script add -f clangdiag.the_diag_command clangdiag')
-    print 'The "clangdiag" command has been installed, type "help clangdiag" or "clangdiag --help" for detailed help.'
+    print('The "clangdiag" command has been installed, type "help clangdiag" or "clangdiag --help" for detailed help.')

utils/modfuzz.py

 #! /usr/bin/env python
 
 # To use:
 #  1) Update the 'decls' list below with your fuzzing configuration.
 #  2) Run with the clang binary as the command-line argument.
 
+from __future__ import print_function
 import random
 import subprocess
 import sys
 import os
 
 clang = sys.argv[1]
 none_opts = 0.3
 
-class Decl:
+class Decl(object):
   def __init__(self, text, depends=[], provides=[], conflicts=[]):
     self.text = text
     self.depends = depends
     self.provides = provides
     self.conflicts = conflicts
 
   def valid(self, model):
     for i in self.depends:
def apply(self, model, name):
     model.source += self.text % {'name': name}
 
 decls = [
   Decl('struct X { int n; };\n', provides=['X'], conflicts=['X']),
   Decl('static_assert(X{.n=1}.n == 1, "");\n', depends=['X']),
   Decl('X %(name)s;\n', depends=['X']),
 ]
 
-class FS:
+class FS(object):
   def __init__(self):
     self.fs = {}
     self.prevfs = {}
 
   def write(self, path, contents):
     self.fs[path] = contents
 
   def done(self):
     for f, s in self.fs.items():
       if self.prevfs.get(f) != s:
         f = file(f, 'w')
         f.write(s)
         f.close()
 
     for f in self.prevfs:
       if f not in self.fs:
         os.remove(f)
 
     self.prevfs, self.fs = self.fs, {}
 
 fs = FS()
 
-class CodeModel:
+class CodeModel(object):
   def __init__(self):
     self.source = ''
     self.modules = {}
     self.decls = {}
     self.i = 0
 
   def make_name(self):
     self.i += 1
def generate():
 
   try:
     for d in mutations(model):
       d(model)
       m.append(d)
     if not model.fails():
       return
   except KeyboardInterrupt:
-    print
+    print()
     return True
 
   sys.stdout.write('\nReducing:\n')
   sys.stdout.flush()
 
   try:
     while True:
       assert m, 'got a failure with no steps; broken clang binary?'
-      i = random.choice(range(len(m)))
+      i = random.choice(list(range(len(m))))
       x = m[0:i] + m[i+1:]
       m2 = CodeModel()
       for d in x:
         d(m2)
       if m2.fails():
         m = x
         model = m2
       else:

utils/perf-training/perf-helper.py

def form_by_frequency(symbol_lists):
   # Form the order file by just putting the most commonly occurring symbols
   # first. This assumes the data files didn't use the oneshot dtrace method.
  
   counts = {}
   for symbols in symbol_lists:
     for a in symbols:
       counts[a] = counts.get(a,0) + 1
 
-  by_count = counts.items()
-  by_count.sort(key = lambda (_,n): -n)
+  by_count = list(counts.items())
+  by_count.sort(key = lambda __n: -__n[1])
   return [s for s,n in by_count]
  
 def form_by_random(symbol_lists):
   # Randomize the symbols.
   merged_symbols = uniq(s for symbols in symbol_lists
                           for s in symbols)
   random.shuffle(merged_symbols)
   return merged_symbols
def genOrderFile(args):
   parser.add_argument("--show-missing-symbols", dest="show_missing_symbols",
     help="show symbols which are 'fixed up' to a valid name (requires --binary)",
     action="store_true", default=None)
   parser.add_argument("--output-unordered-symbols",
     dest="output_unordered_symbols_path",
     help="write a list of the unordered symbols to PATH (requires --binary)",
     default=None, metavar="PATH")
   parser.add_argument("--method", dest="method",
-    help="order file generation method to use", choices=methods.keys(),
+    help="order file generation method to use", choices=list(methods.keys()),
     default='call_order')
   opts = parser.parse_args(args)
 
   # If the user gave us a binary, get all the symbols in the binary by
   # snarfing 'nm' output.
   if opts.binary_path is not None:
      output = subprocess.check_output(['nm', '-P', opts.binary_path])
      lines = output.split("\n")

utils/token-delta.py

 #!/usr/bin/env python
 
+from __future__ import print_function
 import os
 import re
 import subprocess
 import sys
 import tempfile
 
 ###
 
class DeltaAlgorithm(object):
 
     def run(self, changes, force=False):
         # Make sure the initial test passes, if not then (a) either
         # the user doesn't expect monotonicity, and we may end up
         # doing O(N^2) tests, or (b) the test is wrong. Avoid the
         # O(N^2) case unless user requests it.
         if not force:
             if not self.getTestResult(changes):
-                raise ValueError,'Initial test passed to delta fails.'
+                raise ValueError('Initial test passed to delta fails.')
 
         # Check empty set first to quickly find poor test functions.
         if self.getTestResult(set()):
             return set()
         else:
             return self.delta(changes, self.split(changes))
 
     def split(self, S):
def search(self, c, sets):
             # pases without this subset.
             if len(sets) > 2:
                 complement = sum(sets[:i] + sets[i+1:],[])
                 if self.getTestResult(complement):
                     return self.delta(complement, sets[:i] + sets[i+1:])
 
 ###
 
-class Token:
+class Token(object):
     def __init__(self, type, data, flags, file, line, column):
         self.type   = type
         self.data   = data
         self.flags  = flags
         self.file   = file
         self.line   = line
         self.column = column
         
def writeFiles(self, changes, fileNames):
         return byFile
 
     def test(self, changes):
         self.numTests += 1
 
         byFile = self.writeFiles(changes, self.tempFiles)
 
         if self.log:
-            print >>sys.stderr, 'TEST - ',
+            print('TEST - ', end=' ', file=sys.stderr)
             if self.log > 1:
                 for i,(file,_) in enumerate(self.tokenLists):
                     indices = byFile[i]
                     if i:
                         sys.stderr.write('\n      ')
                     sys.stderr.write('%s:%d tokens: [' % (file,len(byFile[i])))
                     prev = None
                     for j in byFile[i]:
                         if prev is None or j != prev + 1:
                             if prev:
                                 sys.stderr.write('%d][' % prev)
                             sys.stderr.write(str(j))
                             sys.stderr.write(':')
                         prev = j
                     if byFile[i]:
                         sys.stderr.write(str(byFile[i][-1]))
                     sys.stderr.write('] ')
             else:
-                print >>sys.stderr, ', '.join(['%s:%d tokens' % (file, len(byFile[i]))
-                                               for i,(file,_) in enumerate(self.tokenLists)]),
+                print(', '.join(['%s:%d tokens' % (file, len(byFile[i]))
+                                               for i,(file,_) in enumerate(self.tokenLists)]), end=' ', file=sys.stderr)
 
         p = subprocess.Popen([self.testProgram] + self.tempFiles)
         res = p.wait() == 0
 
         if res:
             self.writeFiles(changes, self.targetFiles)
 
         if self.log:
-            print >>sys.stderr, '=> %s' % res
+            print('=> %s' % res, file=sys.stderr)
         else:
             if res:
-                print '\nSUCCESS (%d tokens)' % len(changes)
+                print('\nSUCCESS (%d tokens)' % len(changes))
             else:                
                 sys.stderr.write('.')
 
         return res
 
     def run(self):
         res = super(TMBDDelta, self).run([(i,j)
                                           for i,(file,tokens) in enumerate(self.tokenLists)
                                           for j in range(len(tokens))])
         self.writeFiles(res, self.targetFiles)
         if not self.log:
-            print >>sys.stderr
+            print(file=sys.stderr)
         return res
 
 def tokenBasedMultiDelta(program, files, log):            
     # Read in the lists of tokens.
     tokenLists = [(file, [t.data for t in getTokens(file)])
                   for file in files]
 
     numTokens = sum([len(tokens) for _,tokens in tokenLists])
-    print "Delta on %s with %d tokens." % (', '.join(files), numTokens)
+    print("Delta on %s with %d tokens." % (', '.join(files), numTokens))
     
     tbmd = TMBDDelta(program, tokenLists, log)
 
     res = tbmd.run()
 
-    print "Finished %s with %d tokens (in %d tests)." % (', '.join(tbmd.targetFiles),
+    print("Finished %s with %d tokens (in %d tests)." % (', '.join(tbmd.targetFiles),
                                                          len(res),
-                                                         tbmd.numTests)
+                                                         tbmd.numTests))
         
 def main():
     from optparse import OptionParser, OptionGroup
     parser = OptionParser("%prog <test program> {files+}")
     parser.add_option("", "--debug", dest="debugLevel",
                      help="set debug level [default %default]",
                      action="store", type=int, default=0)
     (opts, args) = parser.parse_args()
 
     if len(args) <= 1:
         parser.error('Invalid number of arguments.')
         
     program,files = args[0],args[1:]
 
     md = tokenBasedMultiDelta(program, files, log=opts.debugLevel)
         
 if __name__ == '__main__':
     try:
         main()
     except KeyboardInterrupt:
-        print >>sys.stderr,'Interrupted.'
+        print('Interrupted.', file=sys.stderr)
         os._exit(1) # Avoid freeing our giant cache.

www/builtins.py

 
 def report_repl(builtin, repl):
   sys.stderr.write("%s:%d: x86 builtin %s used, replaced with %s\n" % (fileinput.filename(), fileinput.filelineno(), builtin, repl))
 
 def report_cant(builtin):
   sys.stderr.write("%s:%d: x86 builtin %s used, too many replacements\n" % (fileinput.filename(), fileinput.filelineno(), builtin))
 
 for line in fileinput.input(inplace=1):
-  for builtin, repl in repl_map.iteritems():
+  for builtin, repl in repl_map.items():
     if builtin in line:
       line = line.replace(builtin, repl)
       report_repl(builtin, repl)
   for unh in unhandled:
     if unh in line:
         report_cant(unh)
   sys.stdout.write(line)
 
 sys.exit(err)