[tools] Add paranthesese for print in Python

[galou]

Summary

Add paranthesese for print in Python

[galou]

Add parentheses for print in Python (all Python files where the print statement was used).

[jdoerfert]

LGTM. Seems NFC and towards the right syntax, thx :)

clang-tools-extra/clang-include-fixer/find-all-symbols/tool/run-find-all-symbols.py

 Example invocations.
 - Run find-all-symbols on all files in the current working directory.
     run-find-all-symbols.py <source-file>
 
 Compilation database setup:
 http://clang.llvm.org/docs/HowToSetupToolingForLLVM.html
 """
 
+from __future__ import print_function
+
 import argparse
 import json
 import multiprocessing
 import os
 import Queue
 import shutil
 import subprocess
 import sys
 import tempfile
 import threading
 
 
 def find_compilation_database(path):
   """Adjusts the directory until a compilation database is found."""
   result = './'
   while not os.path.isfile(os.path.join(result, path)):
     if os.path.realpath(result) == '/':
-      print 'Error: could not find compilation database.'
+      print('Error: could not find compilation database.', file=sys.stderr)
       sys.exit(1)
     result += '../'
   return os.path.realpath(result)
 
 
 def MergeSymbols(directory, args):
   """Merge all symbol files (yaml) in a given directory into a single file."""
   invocation = [args.binary, '-merge-dir='+directory, args.saving_path]
   subprocess.call(invocation)
-  print 'Merge is finished. Saving results in ' + args.saving_path
+  print('Merge is finished. Saving results in ' + args.saving_path)
 
 
 def run_find_all_symbols(args, tmpdir, build_path, queue):
   """Takes filenames out of queue and runs find-all-symbols on them."""
   while True:
     name = queue.get()
     invocation = [args.binary, name, '-output-dir='+tmpdir, '-p='+build_path]
     sys.stdout.write(' '.join(invocation) + '\n')
try:
     queue.join()
 
     MergeSymbols(tmpdir, args)
 
 
   except KeyboardInterrupt:
     # This is a sad hack. Unfortunately subprocess goes
     # bonkers with ctrl-c and we start forking merrily.
-    print '\nCtrl-C detected, goodbye.'
+    print('\nCtrl-C detected, goodbye.')
     os.kill(0, 9)
 
 
 if __name__ == '__main__':
   main()

clang-tools-extra/clangd/include-mapping/gen_std.py

def main():
 
   symbols = cppreference_parser.GetSymbols(parse_pages)
 
   # We don't have version information from the unzipped offline HTML files.
   # so we use the modified time of the symbol_index.html as the version.
   index_page_path = os.path.join(page_root, "index.html")
   cppreference_modified_date = datetime.datetime.fromtimestamp(
     os.stat(index_page_path).st_mtime).strftime('%Y-%m-%d')
-  print CODE_PREFIX % (args.language.upper(), cppreference_modified_date)
+  print(CODE_PREFIX % (args.language.upper(), cppreference_modified_date))
   for symbol in symbols:
     if len(symbol.headers) == 1:
       # SYMBOL(unqualified_name, namespace, header)
-      print "SYMBOL(%s, %s, %s)" % (symbol.name, symbol.namespace,
-                                    symbol.headers[0])
+      print("SYMBOL(%s, %s, %s)" % (symbol.name, symbol.namespace,
+                                    symbol.headers[0]))
     elif len(symbol.headers) == 0:
       sys.stderr.write("No header found for symbol %s\n" % symbol.name)
     else:
       # FIXME: support symbols with multiple headers (e.g. std::move).
       sys.stderr.write("Ambiguous header for symbol %s: %s\n" % (
           symbol.name, ', '.join(symbol.headers)))
 
 
 if __name__ == '__main__':
   main()

compiler-rt/lib/dfsan/scripts/build-libc-list.py

 #!/usr/bin/env python
 #===- lib/dfsan/scripts/build-libc-list.py ---------------------------------===#
 #
 # Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 # See https://llvm.org/LICENSE.txt for license information.
 # SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 #
 #===------------------------------------------------------------------------===#
 # The purpose of this script is to identify every function symbol in a set of
 # libraries (in this case, libc and libgcc) so that they can be marked as
 # uninstrumented, thus allowing the instrumentation pass to treat calls to those
 # functions correctly.
 
+from __future__ import print_function
+
 import os
 import subprocess
 import sys
 from optparse import OptionParser
 
 def defined_function_list(object):
   functions = []
   readelf_proc = subprocess.Popen(['readelf', '-s', '-W', object],

 if options.with_libstdcxx:
   libs.append(os.path.join(options.libstdcxx_dso_path, 'libstdc++.so.6'))
 
 functions = []
 for l in libs:
   if os.path.exists(l):
     functions += defined_function_list(l)
   else:
-    print >> sys.stderr, 'warning: library %s not found' % l
+    print('warning: library %s not found' % l, file=sys.stderr)
 
 functions = list(set(functions))
 functions.sort()
 
 for f in functions:
-  print 'fun:%s=uninstrumented' % f
+  print('fun:%s=uninstrumented' % f)

compiler-rt/test/sanitizer_common/android_commands/android_common.py

 
 def host_to_device_path(path):
     rel = os.path.relpath(path, "/")
     dev = os.path.join(ANDROID_TMPDIR, rel)
     return dev
 
 def adb(args, attempts = 1):
     if verbose:
-        print args
+        print(args)
     tmpname = tempfile.mktemp()
     out = open(tmpname, 'w')
     ret = 255
     while attempts > 0 and ret != 0:
       attempts -= 1
       ret = subprocess.call([ADB] + args, stdout=out, stderr=subprocess.STDOUT)
       if attempts != 0:
         ret = 5
     if ret != 0:
-      print "adb command failed", args
-      print tmpname
+      print("adb command failed", args)
+      print(tmpname)
       out.close()
       out = open(tmpname, 'r')
-      print out.read()
+      print(out.read())
     out.close()
     os.unlink(tmpname)
     return ret
 
 def pull_from_device(path):
     tmp = tempfile.mktemp()
     adb(['pull', path, tmp], 5)
     text = open(tmp, 'r').read()
     os.unlink(tmp)
     return text
 
 def push_to_device(path):
     dst_path = host_to_device_path(path)
     adb(['push', path, dst_path], 5)

compiler-rt/test/sanitizer_common/android_commands/android_compile.py

while args:
     if arg == '-shared':
         output_type = 'shared'
     elif arg == '-c':
         output_type = 'object'
     elif arg == '-o':
         output = args.pop(0)
 
 if output == None:
-    print "No output file name!"
+    print('No output file name!')
     sys.exit(1)
 
 ret = subprocess.call(sys.argv[1:])
 if ret != 0:
     sys.exit(ret)
 
 if output_type in ['executable', 'shared']:
     push_to_device(output)
 
 if output_type == 'executable':
     os.rename(output, output + '.real')
     os.symlink(android_run, output)

compiler-rt/test/sanitizer_common/ios_commands/iossim_compile.py

while args:
     elif arg == '-c':
         output_type = 'object'
     elif arg == '-S':
         output_type = 'assembly'
     elif arg == '-o':
         output = args.pop(0)
 
 if output == None:
-    print "No output file name!"
+    print('No output file name!')
     sys.exit(1)
 
 ret = subprocess.call(sys.argv[1:])
 if ret != 0:
     sys.exit(ret)
 
 # If we produce a dylib, ad-hoc sign it.
 if output_type in ['shared', 'dylib']:
     ret = subprocess.call(["codesign", "-s", "-", output])

debuginfo-tests/llgdb-tests/llgdb.py

for lldb_python_dir in lldb_python_dirs:
         if os.path.exists(lldb_python_dir):
             if not (sys.path.__contains__(lldb_python_dir)):
                 sys.path.append(lldb_python_dir)
                 try:
                     import lldb
                 except ImportError:
                     pass
                 else:
-                    print 'imported lldb from: "%s"' % (lldb_python_dir)
+                    print('imported lldb from: "%s"' % (lldb_python_dir))
                     success = True
                     break
     if not success:
-        print "error: couldn't locate the 'lldb' module, please set PYTHONPATH correctly"
+        print("error: couldn't locate the 'lldb' module, please set PYTHONPATH correctly")
         sys.exit(1)
 # ----------------------------------------------------------------------
 
 # Command line option handling.
 import argparse
 parser = argparse.ArgumentParser(description=__doc__)
 parser.add_argument('--quiet', '-q', action="store_true", help='ignored')
 parser.add_argument('-batch', action="store_true",

lldb/utils/lui/lldbutil.py

 def get_GPRs(frame):
     """Returns the general purpose registers of the frame as an SBValue.
 
     The returned SBValue object is iterable.  An example:
         ...
         from lldbutil import get_GPRs
         regs = get_GPRs(frame)
         for reg in regs:
-            print "%s => %s" % (reg.GetName(), reg.GetValue())
+            print("%s => %s" % (reg.GetName(), reg.GetValue()))
         ...
     """
     return get_registers(frame, "general purpose")
 
 
 def get_FPRs(frame):
     """Returns the floating point registers of the frame as an SBValue.
 
     The returned SBValue object is iterable.  An example:
         ...
         from lldbutil import get_FPRs
         regs = get_FPRs(frame)
         for reg in regs:
-            print "%s => %s" % (reg.GetName(), reg.GetValue())
+            print("%s => %s" % (reg.GetName(), reg.GetValue()))
         ...
     """
     return get_registers(frame, "floating point")
 
 
 def get_ESRs(frame):
     """Returns the exception state registers of the frame as an SBValue.
 
     The returned SBValue object is iterable.  An example:
         ...
         from lldbutil import get_ESRs
         regs = get_ESRs(frame)
         for reg in regs:
-            print "%s => %s" % (reg.GetName(), reg.GetValue())
+            print("%s => %s" % (reg.GetName(), reg.GetValue()))
         ...
     """
     return get_registers(frame, "exception state")
 
 # ======================================
 # Utility classes/functions for SBValues
 # ======================================
 

llvm/bindings/python/llvm/object.py

Here are some examples on how to perform iteration:
     # This is OK. Each Section is only accessed inside its own iteration slot.
     section_names = []
     for section in obj.get_sections():
         section_names.append(section.name)
 
     # This is NOT OK. You perform a lookup after the object has expired.
     symbols = list(obj.get_symbols())
     for symbol in symbols:
-        print symbol.name # This raises because the object has expired.
+        print(symbol.name) # This raises because the object has expired.
 
     # In this example, we mix a working and failing scenario.
     symbols = []
     for symbol in obj.get_symbols():
         symbols.append(symbol)
-        print symbol.name
+        print(symbol.name)
 
     for symbol in symbols:
-        print symbol.name # OK
+        print(symbol.name) # OK
         print symbol.address # NOT OK. We didn't look up this property before.
 
     # Cache everything up front.
     symbols = list(obj.get_symbols(cache=True))
     for symbol in symbols:
-        print symbol.name # OK
+        print(symbol.name) # OK
 
 """
 
 from ctypes import c_char_p
 from ctypes import c_char
 from ctypes import POINTER
 from ctypes import c_uint64
 from ctypes import string_at

openmp/runtime/tools/summarizeStats.py

def readFile(fname):
     """Read the statistics from the file. Return a dict with keys "timers", "counters" """
     res = {}
     try:
         with open(fname) as f:
             res["timers"]   = readTimers(f)
             res["counters"] = readCounters(f)
             return res
     except (OSError, IOError):
-        print "Cannot open " + fname
+        print("Cannot open " + fname)
         return None
 
 def usefulValues(l):
     """I.e. values which are neither null nor zero"""
     return [p and q for (p,q) in zip (pd.notnull(l), l != 0.0)]
 
 def uselessValues(l):
     """I.e. values which are null or zero"""
def compPie(data):
     for key in data.keys():
         if key in ('OMP_critical', 'OMP_single', 'OMP_serial',
                    'OMP_parallel', 'OMP_master', 'OMP_task_immediate',
                    'OMP_task_taskwait', 'OMP_task_taskyield', 'OMP_task_taskgroup',
                    'OMP_task_join_bar', 'OMP_task_plain_bar', 'OMP_task_taskyield'):
             compKeys[key] = data[key]
         else:
             nonCompKeys[key] = data[key]
-    print "comp keys:", compKeys, "\n\n non comp keys:", nonCompKeys
+    print("comp keys:", compKeys, "\n\n non comp keys:", nonCompKeys)
     return [compKeys, nonCompKeys]
 
 def drawMainPie(data, filebase, colors):
     sizes = [sum(data[0].values()), sum(data[1].values())]
     explode = [0,0]
     labels = ["Compute - " + "%.2f" % sizes[0], "Non Compute - " + "%.2f" % sizes[1]]
     patches = plt.pie(sizes, explode, colors=colors, startangle=90)
     plt.title("Time Division")
for s in interestingStats:
                     elapsedTime / 1.e9)
                 """Plotting radar charts"""
                 params = setRadarFigure(data.keys())
                 chartType = "radar"
                 drawRadarChart(data, s, filebase, params, colors[n])
                 """radar Charts finish here"""
                 plt.savefig(filebase+"_"+s+"_"+chartType, bbox_inches='tight')
             elif s == 'timers':
-                print "overheads in "+filebase
+                print("overheads in " + filebase)
                 numThreads = tmp[s]['SampleCount']['Total_OMP_parallel']
                 for key in data.keys():
                     if key[0:5] == 'Total':
                         del data[key]
                 stats[filebase] = derivedTimerStats(data)
                 dataSubSet = compPie(stats[filebase])
                 drawMainPie(dataSubSet, filebase, colors)
                 plt.figure(0)

polly/utils/jscop2cloog.py

 %s
 
 0 # We do not want to set manually the schedule dimension names
 """
 
   context = scop['context']
   domains = getDomains(scop)
   schedules = getSchedules(scop)
-  print template % (context, domains, schedules)
+  print(template % (context, domains, schedules))
 
 def __main__():
   description = 'Translate JSCoP into iscc input'
   parser = argparse.ArgumentParser(description)
   parser.add_argument('inputFile', metavar='N', type=file,
                       help='The JSCoP file')
 
   args = parser.parse_args()
   inputFile = args.inputFile
   scop = json.load(inputFile)
 
   writeCloog(scop)
 
 __main__()
 

polly/utils/pyscop/jscop2iscc.py

 #!/usr/bin/env python
+
+from __future__ import print_function
+
 import argparse, isl, os
 import json
 
 def printDomain(scop):
 
   domain = isl.USet('{}')
 
   for statement in scop['statements']:
     domain = domain.union(isl.USet(statement['domain']))
 
-  print "D :=",
-  print str(domain) + ";"
+  print('D :=', end='')
+  print(str(domain) + ';')
 
 def printAccesses(scop):
 
   read = isl.UMap('{}')
 
   for statement in scop['statements']:
     for access in statement['accesses']:
       if access['kind'] == 'read':
         read = read.union(isl.UMap(access['relation']))
 
-  print "R :=",
-  print str(read) + ";"
+  print('R :=', end='')
+  print(str(read) + ';')
 
   write = isl.UMap('{}')
 
   for statement in scop['statements']:
     for access in statement['accesses']:
       if access['kind'] == 'write':
         write = write.union(isl.UMap(access['relation']))
 
-  print "W :=",
-  print str(write) + ";"
+  print('W :=', end='')
+  print(str(write) + ';')
 
 def printSchedule(scop):
 
   schedule = isl.UMap('{}')
 
   for statement in scop['statements']:
     schedule = schedule.union(isl.UMap(statement['schedule']))
 
-  print "S :=",
-  print str(schedule) + ";"
+  print('S :=', end='')
+  print(str(schedule) + ';')
 
 def __main__():
   description = 'Translate JSCoP into iscc input'
   parser = argparse.ArgumentParser(description)
   parser.add_argument('inputFile', metavar='N', type=file,
                       help='The JSCoP file')
 
   args = parser.parse_args()
   inputFile = args.inputFile
   scop = json.load(inputFile)
 
   printDomain(scop)
   printAccesses(scop)
   printSchedule(scop)
 
-  print 'R := R * D;'
-  print 'W := W * D;'
-  print 'Dep := (last W before R under S)[0];'
-  print 'schedule D respecting Dep minimizing Dep;'
+  print('R := R * D;')
+  print('W := W * D;')
+  print('Dep := (last W before R under S)[0];')
+  print('schedule D respecting Dep minimizing Dep;')
 
 
 __main__()