python3 support

Author: jerch

example_basic.py

@@ -3,6 +3,7 @@
 # while the second version does the same with the memory state
 # by symbol resolution with some additional access tests.
 # A third version (commented out) shows how to write an executable.
+from __future__ import print_function
 
 from tinycc import TinyCC
 from ctypes import (CFUNCTYPE, c_int, c_void_p, Structure, c_ubyte,
@@ -77,16 +78,16 @@ def bytes(self, bytes):
     tcc = TinyCC()
 
     # 1st version - simple direct run of main function
-    print 'simple "run" state:'
+    print('simple "run" state:')
     state = tcc.create_state('run')
     state.compile(C_CODE)
     result = state.run(['stuff', 'from', 'the', 'cmdline'])
-    print 'result:', result
+    print('result:', result)
 
-    print
+    print()
 
     # 2nd version - more complex run via symbols
-    print '"memory" state with symbol access:'
+    print('"memory" state with symbol access:')
     state = tcc.create_state() # defaults to 'memory'
     state.compile(C_CODE)
     state.relocate()
@@ -97,21 +98,21 @@ def bytes(self, bytes):
     value = state.get_symbol('value', c_int)
 
     # alter test.bytes
-    test.bytes = bytearray('Python was here...')
+    test.bytes = bytearray(b'Python was here...')
 
     # prepare main arguments
-    arguments = ['this', 'is', 'more', 'interactive...']
+    arguments = [b'this', b'is', b'more', b'interactive...']
     argc = len(arguments)
     argv = (POINTER(c_char) * argc)()
     argv[:] = [create_string_buffer(s) for s in arguments]
 
     # call main
     result = main(argc, argv)
-    print 'result:', result
+    print('result:', result)
 
     # read exported globals
-    print 'global "test.bytes"', repr(test.bytes)
-    print 'global "value":', repr(value)
+    print('global "test.bytes"', repr(test.bytes))
+    print('global "value":', repr(value))
 
     # 3rd version - write an executable
     #state = tcc.create_state('exe')

example_functions.py

@@ -8,10 +8,16 @@
 #
 # NOTE: For trivial tasks the overhead of the ctype conversions
 #       will let the C code run slower than a CPython equivalent.
+from __future__ import print_function
 
 from tinycc import TinyCC, InlineGenerator
 from ctypes import c_int
 
+try:
+    range = xrange
+except NameError:
+    pass
+
 # create a generator object first
 gen = InlineGenerator()
 
@@ -87,14 +93,14 @@ def c_runner_l(n):
 
 def py_runner_r(n):
     sum = 0
-    for _ in xrange(n):
+    for _ in range(n):
         sum += r_fib_py(20)
     return sum
 
 
 def py_runner_l(n):
     sum = 0
-    for _ in xrange(n):
+    for _ in range(n):
         sum += l_fib_py(20)
     return sum
 
@@ -123,14 +129,14 @@ def c_runner_lc(n):
 
 def py_runner_rc(n):
     sum = 0
-    for _ in xrange(n):
+    for _ in range(n):
         sum += r_fib_c(20)
     return sum
 
 
 def py_runner_lc(n):
     sum = 0
-    for _ in xrange(n):
+    for _ in range(n):
         sum += l_fib_c(20)
     return sum
 
@@ -155,14 +161,14 @@ def py_runner_lc(n):
     from timeit import timeit
     py = timeit('r_fib_py(20)', setup='from __main__ import r_fib_py', number=100)
     c = timeit('r_fib_c(20)', setup='from __main__ import r_fib_c', number=100)
-    print 'recursive Python/C:', py, c, float(py) / c
+    print('recursive Python/C:', py, c, float(py) / c)
 
     py = timeit('l_fib_py(20)', setup='from __main__ import l_fib_py', number=100)
     c = timeit('l_fib_c(20)', setup='from __main__ import l_fib_c', number=100)
-    print 'looped Python/C:', py, c, float(py) / c
+    print('looped Python/C:', py, c, float(py) / c)
 
     # some call tests Python <--> C
-    print 'workload - sum(100x fib(20)):'
+    print('workload - sum(100x fib(20)):')
     assert(c_runner_l(100) == py_runner_l(100))
     assert(c_runner_l(100) == py_runner_r(100))
     assert(c_runner_l(100) == c_runner_rc(100))
@@ -173,19 +179,19 @@ def py_runner_lc(n):
     assert(c_runner_r(100) == c_runner_l(100))
     r = timeit('c_runner_r(100)', setup='from __main__ import c_runner_r', number=1)
     l = timeit('c_runner_l(100)', setup='from __main__ import c_runner_l', number=1)
-    print 'fib_py from C (rec/loop):', r, l, float(r) / l
+    print('fib_py from C (rec/loop):', r, l, float(r) / l)
 
     assert(py_runner_r(100) == py_runner_l(100))
     r = timeit('py_runner_r(100)', setup='from __main__ import py_runner_r', number=1)
     l = timeit('py_runner_l(100)', setup='from __main__ import py_runner_l', number=1)
-    print 'fib_py from Py (rec/loop):', r, l, float(r) / l
+    print('fib_py from Py (rec/loop):', r, l, float(r) / l)
 
     assert(c_runner_rc(100) == c_runner_lc(100))
     r = timeit('c_runner_rc(100)', setup='from __main__ import c_runner_rc', number=1)
     l = timeit('c_runner_lc(100)', setup='from __main__ import c_runner_lc', number=1)
-    print 'fib_c from C (rec/loop):', r, l, float(r) / l
+    print('fib_c from C (rec/loop):', r, l, float(r) / l)
 
     assert(py_runner_rc(100) == py_runner_lc(100))
     r = timeit('py_runner_rc(100)', setup='from __main__ import py_runner_rc', number=1)
     l = timeit('py_runner_lc(100)', setup='from __main__ import py_runner_lc', number=1)
-    print 'fib_c from Py (rec/loop):', r, l, float(r) / l
+    print('fib_c from Py (rec/loop):', r, l, float(r) / l)

example_sdl.py

@@ -2,6 +2,7 @@
 # and a callback invocation.
 # NOTE: For Windows the package contains a binary version
 # of the SDL2 library. 
+from __future__ import print_function
 
 from tinycc import TinyCC
 from ctypes import CFUNCTYPE, c_int, c_void_p, CDLL
@@ -61,7 +62,7 @@
 # callback called from C
 @CFUNCTYPE(None, c_int, c_int, c_int)
 def get_color(r, g, b):
-    print 'color is rgb(%d, %d, %d)' % (r, g, b)
+    print('color is rgb(%d, %d, %d)' % (r, g, b))
 
 
 if __name__ == '__main__':

example_struct.py

@@ -1,4 +1,5 @@
 # Example to show inlining with a struct.
+from __future__ import print_function
 
 from tinycc import TinyCC, InlineGenerator
 from ctypes import c_int, addressof, c_long
@@ -34,8 +35,7 @@ def adder_c(self):
 
     @gen.callable_method(c_int)
     def adder_py(self):
-        print 'Test.adder_py: %d + %d = %d' % (
-            self.a, self.b, self.a+self.b)
+        print('Test.adder_py: %d + %d = %d' % (self.a, self.b, self.a+self.b))
         return self.a + self.b
 
     @gen.c_method(c_int)
@@ -57,7 +57,7 @@ def struct_as_return(a, b):
 if __name__ == '__main__':
     state = TinyCC().create_state()
 
-    print gen.code
+    print(gen.code)
 
     state.compile(gen.code)
     state.relocate()
@@ -66,12 +66,12 @@ def struct_as_return(a, b):
 
     # usage
     test = Test(1, 2)
-    print 'addresses equal:', addressof(test) == test.get_address()
-    print test.add_a(10)
-    print test.adder_c()
-    print test.adder_py()
-    print test.call_methods_c()
+    print('addresses equal:', addressof(test) == test.get_address())
+    print(test.add_a(10))
+    print(test.adder_c())
+    print(test.adder_py())
+    print(test.call_methods_c())
 
     # return struct: bug in TCC 0.9.26 zip release
     test2 = struct_as_return(23, 24)
-    print test2, test2.a, test2.b
+    print(test2, test2.a, test2.b)