13 May 2012
Nuitka Release 0.3.22
This is to inform you about the new stable release of Nuitka. It is the extremely compatible Python compiler, “download now”.
This release is a continuation of the trend of previous releases, and added more re-formulations of Python that lower the burden on code generation and optimization.
It also improves Python3 support substantially. In fact this is the first release to not only run itself under Python3, but for Nuitka to compile itself with Nuitka under Python3, which previously only worked for Python2. For the common language subset, it’s quite fine now. List contractions produced extra entries on the call stack, after they became functions, these are no more existent. That was made possible my making frame stack entries an optional element in the node tree, left out for list contractions. Calling a compiled function in an exception handler cleared the exception on return, it no longer does that. Reference counter handling with generator A module “builtins” conflicted with the handling of the Python New Note The way to make a use of a metaclass in a portable way, is to create a based class that has it and then inherit from it. Sad, isn’ it. Surely, the support for The Python3 now also has compatible parameter errors and compatible exception error messages. Python3 has changed scope rules for list contractions (assignments don’t affect outside values) and this is now respected as well. Python3 has gained support for recursive programs and stand alone extension modules, these are now both possible as well. Avoid frame stack entries for functions that cannot raise exceptions, i.e. where they would not be used. This avoids overhead for the very simple functions. And example of this can be seen here: Optimize An example can be seen here: This new optimization applies to all kinds of container creations and the Optimize conditions for non-constant, but known truth values. At this time, known truth values of non-constants means An example can be seen here: It’s clear, that the tuple will be true, we just need to maintain the side effect, which we do. Optimize See above for what has known truth values currently. This will be most useful to predict conditions that need not be evaluated at all due to short circuit nature, and to avoid checking against constant values. Previously this could not be optimized, but now it can: Optimize print arguments to become strings. The arguments to becomes: Combine print arguments to single ones. When multiple strings are printed, these are now combined. becomes: Enhanced Python3 support, enabling support for most basic tests. Check files with PyLint in deterministic (alphabetical) order. Frame stack entries are now part of the node tree instead of part of the template for every function, generator, class or module. The Side effects are now a dedicated node, used in several optimization to maintain the effect of an expression with known value. Expanded and adapted basic tests to work for Python3 as well. Added reference count tests for generator functions Cover calling a function with This release offers enhanced compatibility with Python3, as well as the solution to many structural problems. Calculating lengths of large non-constant values at compile time, is technically a break through, as is avoiding lengthy calculations. The frame guards as nodes is a huge improvement, making that costly operational possible to be optimized away. There still is more work ahead, before value propagation will be safe enough to enable, but we are seeing the glimpse of it already. Not for long, and looking at numbers will make sense.Bug Fixes
throw
method is now correct.builtins
module. Those now use different identifiers.New Features
metaclass
syntax for the class
statement works, and the old __metaclass__
attribute is properly ignored.# Metaclass syntax in Python3, illegal in Python2
class X(metaclass=Y):
pass
# Metaclass syntax in Python2, no effect in Python3
class X:
__metaclass__ = Y
__metaclass__
could still live.# For Python2/3 compatible source, we create a base class that has the
# metaclass used and doesn't require making a choice.
CPythonNodeMetaClassBase = NodeCheckMetaClass("CPythonNodeMetaClassBase", (object,), {})
--dump-xml
option works with Nuitka running under Python3. This was not previously supported.Optimization
def simple():
return 7
len
built-in for non-constant, but known length values.# The range isn't constructed at compile time, but we still know its
# length.
len(range(10000000))
# The string isn't constructed at compile time, but we still know its
# length.
len("*" * 1000)
# The tuple isn't constructed, instead it's known length is used, and
# side effects are maintained.
len((a(), b()))
range
built-in initially.range
built-in calls with know size and container creations.if (a,):
print "In Branch"
or
and and
operators for known truth values.# The access and call to "something()" cannot possibly happen
0 and something()
# Can be replaced with "something()", as "1" is true. If it had a side
# effect, it would be maintained.
1 and something()
# The access and call to "something()" cannot possibly happen, the value
# is already decided, it's "1".
1 or something()
# Can be replaced with "something()", as "0" is false. If it had a side
# effect, it would be maintained.
0 or something()
print
statements are now converted to strings at compile time if possible.print 1
print "1"
print "1+1=", 1 + 1
print "1+1= 2"
Organizational
Cleanups
try
/except
/else
has been re-formulated to use an indicator variable visible in the node tree, that tells if a handler has been executed or not.New Tests
throw
, send
, and close
methods.try
/except
in an exception handler twice. No test was previously doing that.Summary