Python2/3 compatibility - ranges

[serge-sans-paille]

Summary

ranges

[michaelplatings]

bindings/python/clang/cindex.py

559 ↗

(On Diff #176331)

This is unnecessary as xrange = range has already been declared above.

utils/ABITest/TypeGen.py

244 ↗

(On Diff #176331)

Better to use the xrange = range trick from cindex.py

[serge-sans-paille]

I failed to notice this trick, and I'd rather just use plain range. Overriding builtins is not a very good practice, and the performance drawback of using range instead of xrange in Python2 is negligible for such non-critical piece of software

In [1]: %timeit sum(range(1000))
100000 loops, best of 3: 7.72 µs per loop

In [2]: %timeit sum(xrange(1000))
100000 loops, best of 3: 6.56 µs per loop

[serge-sans-paille]

xrange is the past, favor modern Python3 style :-)

[michaelplatings]

LGTM

cfe/trunk/bindings/python/clang/cindex.py

class c_interop_string(c_char_p):
         def to_python_string(x, *args):
             return x.value
 
     def b(x):
         if isinstance(x, bytes):
             return x
         return x.encode('utf8')
 
-    xrange = range
-
 elif sys.version_info[0] == 2:
     # Python 2 strings are utf8 byte strings, no translation is needed for
     # C-interop.
     c_interop_string = c_char_p
 
     def _to_python_string(x, *args):
         return x
 
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
 
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):

cfe/trunk/utils/ABITest/Enumeration.py

def getNthPairVariableBounds(N, bounds):
     bounds[x]."""
 
     if not bounds:
         raise ValueError("Invalid bounds")
     if not (0 <= N < sum(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:

cfe/trunk/utils/ABITest/TypeGen.py

def num_combinations(n, k):
     return fact(n) / (fact(k) * fact(n - k))
 
 # Enumerate the combinations choosing k elements from the list of values
 def combinations(values, k):
     # From ActiveState Recipe 190465: Generator for permutations,
     # combinations, selections of a sequence
     if k==0: yield []
     else:
-        for i in xrange(len(values)-k+1):
+        for i in range(len(values)-k+1):
             for cc in combinations(values[i+1:],k-1):
                 yield [values[i]]+cc
 
 class EnumTypeGenerator(TypeGenerator):
     def __init__(self, values, minEnumerators, maxEnumerators):
         TypeGenerator.__init__(self)
         self.values = values
         self.minEnumerators = minEnumerators

cfe/trunk/utils/modfuzz.py

except KeyboardInterrupt:
     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: