Python 2/3 compatibility - iterable

[serge-sans-paille]

Summary

map, items, zip, filter

[michaelplatings]

utils/ABITest/ABITestGen.py

233 ↗

(On Diff #176338)

Need to change the inner map

[serge-sans-paille]

utils/ABITest/ABITestGen.py

233 ↗

(On Diff #176338)

I don't think so: we don't care if the inner map produces a generator as it's immediately consumed.

[michaelplatings]

LGTM

cfe/trunk/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()
 

cfe/trunk/tools/scan-view/share/Reporter.py

 # Reporters
 #===------------------------------------------------------------------------===#
 
 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)
 
         return "Message sent!"
 
 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",
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()
 

cfe/trunk/tools/scan-view/share/ScanView.py

def handle_error(self, request, client_address):
                 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('&')):
+    for chunk in (_f for _f in qs.split('&') if _f):
         if '=' not in chunk:
             name = chunk
             value = ''
         else:
             name, value = chunk.split('=', 1)
         name = urllib.unquote(name.replace('+', ' '))
         value = urllib.unquote(value.replace('+', ' '))
         item = fields.get(name)

cfe/trunk/utils/ABITest/ABITestGen.py

def writeFunction(self, i, FT):
         if self.outputTests:
             if self.outputHeader:
                 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)
+            tests = [self.getTestValuesArray(ty) for ty in FT.argTypes]
             print('void test_%s(void) {'%(fnName,), file=self.outputTests)
 
             if retvalTests is not None:
                 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('    %s RV;'%(retvalTypeName,), file=self.outputTests)
                 print('    %s = %s[i];'%(retvalName, retvalTests[0]), file=self.outputTests)
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))

cfe/trunk/utils/ABITest/TypeGen.py

def getTypedefDef(self, name, printer):
             if t.isBitField():
                 if t.isPaddingBitField():
                     return '%s : 0;'%(printer.getTypeName(t),)
                 else:
                     return '%s field%d : %d;'%(printer.getTypeName(t),i,
                                                t.getBitFieldSize())
             else:
                 return '%s field%d;'%(printer.getTypeName(t),i)
-        fields = map(getField, enumerate(self.fields))
+        fields = [getField(f) for f in enumerate(self.fields)]
         # Name the struct for more readable LLVM IR.
         return 'typedef %s %s { %s } %s;'%(('struct','union')[self.isUnion],
                                            name, ' '.join(fields), name)
                                            
 class ArrayType(Type):
     def __init__(self, index, isVector, elementType, size):
         if isVector:
             # Note that for vectors, this is the size in bytes.
def setCardinality(self):
             for i in range(self.maxSize+1):
                 S += M * (self.typeGen.cardinality ** i)
         self.cardinality = S
 
     def generateType(self, N):
         isUnion,I = False,N
         if self.useUnion:
             isUnion,I = (I&1),I>>1
-        fields = map(self.typeGen.get,getNthTuple(I,self.maxSize,self.typeGen.cardinality))
+        fields = [self.typeGen.get(f) for f in getNthTuple(I,self.maxSize,self.typeGen.cardinality)]
         return RecordType(N, isUnion, fields)
 
 class FunctionTypeGenerator(TypeGenerator):
     def __init__(self, typeGen, useReturn, maxSize):
         TypeGenerator.__init__(self)
         self.typeGen = typeGen
         self.useReturn = useReturn
         self.maxSize = maxSize
def generateType(self, N):
         if self.useReturn:
             # Skip the empty tuple
             argIndices = getNthTuple(N+1, self.maxSize+1, self.typeGen.cardinality)
             retIndex,argIndices = argIndices[0],argIndices[1:]
             retTy = self.typeGen.get(retIndex)
         else:
             retTy = None
             argIndices = getNthTuple(N, self.maxSize, self.typeGen.cardinality)
-        args = map(self.typeGen.get, argIndices)
+        args = [self.typeGen.get(i) for i in argIndices]
         return FunctionType(N, retTy, args)
 
 class AnyTypeGenerator(TypeGenerator):
     def __init__(self):
         TypeGenerator.__init__(self)
         self.generators = []
         self.bounds = []
         self.setCardinality()

cfe/trunk/utils/analyzer/CmpRuns.py

def deriveStats(results):
     combined_data = defaultdict(list)
 
     # Collect data on paths length.
     for report in results.reports:
         for diagnostic in report.diagnostics:
             combined_data['PathsLength'].append(diagnostic.getPathLength())
 
     for stat in results.stats:
-        for key, value in stat.iteritems():
+        for key, value in stat.items():
             combined_data[key].append(value)
     combined_stats = {}
-    for key, values in combined_data.iteritems():
+    for key, values in combined_data.items():
         combined_stats[str(key)] = {
             "max": max(values),
             "min": min(values),
             "mean": sum(values) / len(values),
             "90th %tile": computePercentile(values, 0.9),
             "95th %tile": computePercentile(values, 0.95),
             "median": sorted(values)[len(values) // 2],
             "total": sum(values)

cfe/trunk/utils/analyzer/SATestBuild.py

def runCmpResults(Dir, Strictness=0):
     # 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()
 
     # Iterate and find the differences.
     NumDiffs = 0
-    PairList = zip(RefList, NewList)
-    for P in PairList:
+    for P in zip(RefList, NewList):
         RefDir = P[0]
         NewDir = P[1]
 
         assert(RefDir != NewDir)
         if Verbose == 1:
             Local.stdout.write("  Comparing Results: %s %s\n" % (
                                RefDir, NewDir))
 

cfe/trunk/utils/check_cfc/check_cfc.py

if main_is_frozen():
         return os.path.dirname(sys.executable)
     return os.path.dirname(sys.argv[0])
 
 def remove_dir_from_path(path_var, directory):
     """Remove the specified directory from path_var, a string representing
     PATH"""
     pathlist = path_var.split(os.pathsep)
     norm_directory = os.path.normpath(os.path.normcase(directory))
-    pathlist = filter(lambda x: os.path.normpath(
-        os.path.normcase(x)) != norm_directory, pathlist)
+    pathlist = [x for x in pathlist if os.path.normpath(
+        os.path.normcase(x)) != norm_directory]
     return os.pathsep.join(pathlist)
 
 def path_without_wrapper():
     """Returns the PATH variable modified to remove the path to this program."""
     scriptdir = get_main_dir()
     path = os.environ['PATH']
     return remove_dir_from_path(path, scriptdir)
 

cfe/trunk/utils/check_cfc/obj_diff.py

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

cfe/trunk/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")

cfe/trunk/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)