Python2/3 compat - print

[joerg]

I'd recomment another pass to reduce the now fully redundant () pairs around % string substitutions, but in principle LGTM.

utils/token-delta.py

189

Please just use a normal for-loop here instead of join + list comprehension?

[serge-sans-paille]

utils/token-delta.py

189

The change you request is unrelated to that commit, I suggest we postpone it to another patch.

[serge-sans-paille]

Add missing file with print-related changes.

[michaelplatings]

docs/tools/dump_ast_matchers.py

45

urllib2 was correct

[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.
 #

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_ast_matchers.py

def esc(text):
   text = re.sub(r'&', '&', text)
   text = re.sub(r'<', '&lt;', text)
   text = re.sub(r'>', '&gt;', text)
   def link_if_exists(m):
     name = m.group(1)
     url = 'https://clang.llvm.org/doxygen/classclang_1_1%s.html' % name
     if url not in doxygen_probes:
       try:
-        print 'Probing %s...' % url
+        print('Probing %s...' % url)
         urllib2.urlopen(url)
         doxygen_probes[url] = True
       except:
         doxygen_probes[url] = False
     if doxygen_probes[url]:
       return r'Matcher&lt;<a href="%s">%s</a>&gt;' % (url, name)
     else:
       return m.group(0)
   text = re.sub(
if m:
       m = re.match(r'.*\s+internal::(Bindable)?Matcher<([^>]+)>$', result)
       if m:
         result_types = [m.group(2)]
       else:
         result_types = extract_result_types(comment)
       if not result_types:
         if not comment:
           # Only overloads don't have their own doxygen comments; ignore those.
-          print 'Ignoring "%s"' % name
+          print('Ignoring "%s"' % name)
         else:
-          print 'Cannot determine result type for "%s"' % name
+          print('Cannot determine result type for "%s"' % name)
       else:
         for result_type in result_types:
           add_matcher(result_type, name, args, comment)
     else:
-      print '*** Unparsable: "' + declaration + '" ***'
+      print('*** Unparsable: "' + declaration + '" ***')
 
 def sort_table(matcher_type, matcher_map):
   """Returns the sorted html table for the given row map."""
   table = ''
   for key in sorted(matcher_map.keys()):
     table += matcher_map[key] + '\n'
   return ('<!-- START_%(type)s_MATCHERS -->\n' +
           '%(table)s' + 

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

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/bin/scan-view

 #!/usr/bin/env python
 
+from __future__ import print_function
+
 """The clang static analyzer results viewer.
 """
 
 import sys
 import imp
 import os
 import posixpath
 import threading
def start_browser(port, options):
     for i in range(kMaxSleeps):
         if url_is_up(url):
             break
         if options.debug:
             sys.stderr.write('.')
             sys.stderr.flush()
         time.sleep(kSleepTimeout)
     else:
-        print >> sys.stderr, 'WARNING: Unable to detect that server started.'
+        print('WARNING: Unable to detect that server started.', file=sys.stderr) 
 
     if options.debug:
-        print >> sys.stderr, '%s: Starting webbrowser...' % sys.argv[0]
+        print('%s: Starting webbrowser...' % sys.argv[0], file=sys.stderr)
     webbrowser.open(url)
 
 
 def run(port, options, root):
     # Prefer to look relative to the installed binary
     share = os.path.dirname(__file__) + "/../share/scan-view"
     if not os.path.isdir(share):
         # Otherwise look relative to the source
         share = os.path.dirname(__file__) + "/../../scan-view/share"
     sys.path.append(share)
 
     import ScanView
     try:
-        print 'Starting scan-view at: http://%s:%d' % (options.host,
-                                                       port)
-        print '  Use Ctrl-C to exit.'
+        print('Starting scan-view at: http://%s:%d' % (options.host,
+                                                       port))
+        print('  Use Ctrl-C to exit.')
         httpd = ScanView.create_server((options.host, port),
                                        options, root)
         httpd.serve_forever()
     except KeyboardInterrupt:
         pass
 
 
 def port_is_open(port):

tools/scan-view/share/ScanView.py

+from __future__ import print_function
 try:
     from http.server import HTTPServer, SimpleHTTPRequestHandler
 except ImportError:
     from BaseHTTPServer import HTTPServer
     from SimpleHTTPServer import SimpleHTTPRequestHandler
 import os
 import sys
 import urllib, urlparse
def __init__(self, report, reporter, parameters, server):
         self.parameters = parameters
         self.success = False
         self.status = None
 
     def run(self):
         result = None
         try:
             if self.server.options.debug:
-                print >>sys.stderr, "%s: SERVER: submitting bug."%(sys.argv[0],)
+                print("%s: SERVER: submitting bug."%(sys.argv[0],), file=sys.stderr)
             self.status = self.reporter.fileReport(self.report, self.parameters)
             self.success = True
             time.sleep(3)
             if self.server.options.debug:
-                print >>sys.stderr, "%s: SERVER: submission complete."%(sys.argv[0],)
+                print("%s: SERVER: submission complete."%(sys.argv[0],), file=sys.stderr)
         except Reporter.ReportFailure as e:
             self.status = e.value
         except Exception as e:
             s = StringIO.StringIO()
             import traceback
-            print >>s,'<b>Unhandled Exception</b><br><pre>'
-            traceback.print_exc(e,file=s)
-            print >>s,'</pre>'
+            print('<b>Unhandled Exception</b><br><pre>', file=s)
+            traceback.print_exc(file=s)
+            print('</pre>', file=s)
             self.status = s.getvalue()
 
 class ScanViewServer(HTTPServer):
     def __init__(self, address, handler, root, reporters, options):
         HTTPServer.__init__(self, address, handler)
         self.root = root
         self.reporters = reporters
         self.options = options        
def save_config(self):
             self.config.write(f)
             f.close()
         except:
             pass
         
     def halt(self):
         self.halted = True
         if self.options.debug:
-            print >>sys.stderr, "%s: SERVER: halting." % (sys.argv[0],)
+            print("%s: SERVER: halting." % (sys.argv[0],), file=sys.stderr)
 
     def serve_forever(self):
         while not self.halted:
             if self.options.debug > 1:
-                print >>sys.stderr, "%s: SERVER: waiting..." % (sys.argv[0],)
+                print("%s: SERVER: waiting..." % (sys.argv[0],), file=sys.stderr)
             try:
                 self.handle_request()
             except OSError as e:
-                print 'OSError',e.errno
+                print('OSError',e.errno)
 
     def finish_request(self, request, client_address):
         if self.options.autoReload:
             import ScanView
             self.RequestHandlerClass = reload(ScanView).ScanViewRequestHandler
         HTTPServer.finish_request(self, request, client_address)
 
     def handle_error(self, request, client_address):
         # Ignore socket errors
         info = sys.exc_info()
         if info and isinstance(info[1], socket.error):
             if self.options.debug > 1:
-                print >>sys.stderr, "%s: SERVER: ignored socket error." % (sys.argv[0],)
+                print("%s: SERVER: ignored socket error." % (sys.argv[0],), file=sys.stderr)
             return
         HTTPServer.handle_error(self, request, client_address)
 
 # Borrowed from Quixote, with simplifications.
 def parse_query(qs, fields=None):
     if fields is None:
         fields = {}
     for chunk in filter(None, qs.split('&')):
def load_crashes(self):
             fields = dict([i.groups() for i in 
                            kReportCrashEntryKeyValueRE.finditer(fieldData)])
             problems.append(fields)
         return problems
 
     def handle_exception(self, exc):
         import traceback
         s = StringIO.StringIO()
-        print >>s, "INTERNAL ERROR\n"
-        traceback.print_exc(exc, s)
+        print("INTERNAL ERROR\n", file=s)
+        traceback.print_exc(file=s)
         f = self.send_string(s.getvalue(), 'text/plain')
         if f:
             self.copyfile(f, self.wfile)
             f.close()        
             
     def get_scalar_field(self, name):
         if name in self.fields:
             return self.fields[name][0]
def send_open_report(self, report):
             return self.send_error(400, 'Invalid report.')
 
         file = keys.get('FILE')
         if not file or not posixpath.exists(file):
             return self.send_error(400, 'File does not exist: "%s"' % file)
 
         import startfile
         if self.server.options.debug:
-            print >>sys.stderr, '%s: SERVER: opening "%s"'%(sys.argv[0],
-                                                            file)
+            print('%s: SERVER: opening "%s"'%(sys.argv[0],
+                                                            file), file=sys.stderr)
 
         status = startfile.open(file)
         if status:
             res = 'Opened: "%s"' % file
         else:
             res = 'Open failed: "%s"' % file
 
         return self.send_string(res, 'text/plain')
def send_head(self, fields=None):
         # Match directory entries.
         if components[-1] == '':
             components[-1] = 'index.html'
 
         relpath = '/'.join(components)
         path = posixpath.join(self.server.root, relpath)
 
         if self.server.options.debug > 1:
-            print >>sys.stderr, '%s: SERVER: sending path "%s"'%(sys.argv[0],
-                                                                 path)
+            print('%s: SERVER: sending path "%s"'%(sys.argv[0],
+                                                                 path), file=sys.stderr)
         return self.send_path(path)
 
     def send_404(self):
         self.send_error(404, "File not found")
         return None
 
     def send_path(self, path):
         # If the requested path is outside the root directory, do not open it

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 *
 
def __init__(self, output, outputHeader=None,
         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,)
+            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):
                 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,))
 
     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,))
 
     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
P = TypePrinter(output,
                     headerName=opts.outputHeader,                    
                     info=info)
 
     def write(N):
         try:
             FT = ftg.get(N)
         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:

 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/ABITest/TypeGen.py

 """Flexible enumeration of C types."""
+from __future__ import print_function
 
 from Enumeration import *
 
 # TODO:
 
 #  - struct improvements (flexible arrays, packed &
 #    unpacked, alignment)
 #  - objective-c qualified id
#    fields0.addGenerator( RecordTypeGenerator(fields1, False, 4) )
     btg = FixedTypeGenerator([BuiltinType('char', 4),
                               BuiltinType('int',  4)])
     etg = EnumTypeGenerator([None, '-1', '1', '1u'], 0, 3)
 
     atg = AnyTypeGenerator()
     atg.addGenerator( btg )
     atg.addGenerator( RecordTypeGenerator(fields0, False, 4) )
     atg.addGenerator( etg )
-    print 'Cardinality:',atg.cardinality
+    print('Cardinality:',atg.cardinality)
     for i in range(100):
         if i == atg.cardinality:
             try:
                 atg.get(i)
                 raise RuntimeError("Cardinality was wrong")
             except AssertionError:
                 break
-        print '%4d: %s'%(i, atg.get(i))
+        print('%4d: %s'%(i, atg.get(i)))
 
 if __name__ == '__main__':
     test()

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/CmpRuns.py

Usage:
     resultsA = loadResultsFromSingleRun(singleRunInfoA, deleteEmpty)
     resultsB = loadResultsFromSingleRun(singleRunInfoB, deleteEmpty)
 
     # 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)
 
 """
+from __future__ import print_function
 
 from collections import defaultdict
 
 from math import log
 from optparse import OptionParser
 import json
 import os
 import plistlib
def deriveStats(results):
     return combined_stats
 
 
 def compareStats(resultsA, resultsB):
     statsA = deriveStats(resultsA)
     statsB = deriveStats(resultsB)
     keys = sorted(statsA.keys())
     for key in keys:
-        print key
+        print(key)
         for kkey in statsA[key]:
             valA = float(statsA[key][kkey])
             valB = float(statsB[key][kkey])
             report = "%.3f -> %.3f" % (valA, valB)
             # Only apply highlighting when writing to TTY and it's not Windows
             if sys.stdout.isatty() and os.name != 'nt':
                 if valB != 0:
                     ratio = (valB - valA) / valB
                     if ratio < -0.2:
                         report = Colors.GREEN + report + Colors.CLEAR
                     elif ratio > 0.2:
                         report = Colors.RED + report + Colors.CLEAR
-            print "\t %s %s" % (kkey, report)
+            print("\t %s %s" % (kkey, report))
 
 def dumpScanBuildResultsDiff(dirA, dirB, opts, deleteEmpty=True,
                              Stdout=sys.stdout):
     # Load the run results.
     resultsA = loadResults(dirA, opts, opts.rootA, deleteEmpty)
     resultsB = loadResults(dirB, opts, opts.rootB, deleteEmpty)
     if opts.show_stats:
         compareStats(resultsA, resultsB)

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/SATestBuild.py

 
 
 # Find Clang for static analysis.
 if 'CC' in os.environ:
     Clang = os.environ['CC']
 else:
     Clang = SATestUtils.which("clang", os.environ['PATH'])
 if not Clang:
-    print "Error: cannot find 'clang' in PATH"
+    print("Error: cannot find 'clang' in PATH")
     sys.exit(1)
 
 # Number of jobs.
 MaxJobs = int(math.ceil(multiprocessing.cpu_count() * 0.75))
 
 # Project map stores info about all the "registered" projects.
 ProjectMapFile = "projectMap.csv"
 
def runCmpResults(Dir, Strictness=0):
 
     # Log folders are also located in the results dir, so ignore them.
     RefLogDir = os.path.join(RefDir, LogFolderName)
     if RefLogDir in RefList:
         RefList.remove(RefLogDir)
     NewList.remove(os.path.join(NewDir, LogFolderName))
 
     if len(RefList) != len(NewList):
-        print "Mismatch in number of results folders: %s vs %s" % (
-            RefList, NewList)
+        print("Mismatch in number of results folders: %s vs %s" % (
+            RefList, NewList))
         sys.exit(1)
 
     # There might be more then one folder underneath - one per each scan-build
     # command (Ex: one for configure and one for make).
     if (len(RefList) > 1):
         # Assume that the corresponding folders have the same names.
         RefList.sort()
         NewList.sort()

 
 
 def validateProjectFile(PMapFile):
     """
     Validate project file.
     """
     for I in iterateOverProjects(PMapFile):
         if len(I) != 2:
-            print "Error: Rows in the ProjectMapFile should have 2 entries."
+            print("Error: Rows in the ProjectMapFile should have 2 entries.")
             raise Exception()
         if I[1] not in ('0', '1', '2'):
-            print "Error: Second entry in the ProjectMapFile should be 0" \
-                  " (single file), 1 (project), or 2(single file c++11)."
+            print("Error: Second entry in the ProjectMapFile should be 0" \
+                  " (single file), 1 (project), or 2(single file c++11).")
             raise Exception()
 
 def singleThreadedTestAll(Args, ProjectsToTest):
     """
     Run all projects.
     :return: whether tests have passed.
     """
     Success = True
if __name__ == '__main__':
     Parser.add_argument('--extra-analyzer-config', dest='extra_analyzer_config',
                         type=str,
                         default="",
                         help="Arguments passed to to -analyzer-config")
     Args = Parser.parse_args()
 
     TestsPassed = testAll(Args)
     if not TestsPassed:
-        print "ERROR: Tests failed."
+        print("ERROR: Tests failed.")
         sys.exit(42)

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/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/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
 
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
 
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?'

utils/token-delta.py

 #!/usr/bin/env python
 
+from __future__ import print_function
 import os
 import re
 import subprocess
 import sys
 import tempfile
 
 ###
 
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.