Log of /BytecodeAssembler/peak/util/assembler.py

Parent Directory

No default branch
Bookmark a link to HEAD: (view) (download) (as text)

Fix BUILD_CLASS stack calculation

Export ord (Forgot to check this one in)

Add 3.x slice support; fix misc. shallow test failures

Move POP_EXCEPT earlier so TryExcept can be an expression

Fix TryExcept() for Python 3+

Emulate DUP_TOPX(2) on Python 3; fix bytes warning

BINARY_DIVIDE and UNARY_CONVERT for Python 3

Provide BINARY_DIVIDE and UNARY_CONVERT polyfills for Python 3

Experimental Python 3 support (3.1/3.2 test failures are shallow)

Make tests pass even with -O or -OO

Full 2.7 support!

Clean tests!

Smooth over dump differences between 2.6 and 2.7

Switch to symbolic disassembly, so we can mask 2.6/2.7 differences.

Grody hack for LIST_APPEND in 2.7; this really needs better handling,
but first I want the tests to pass...

Return labels from simulated jumps

Quick draft at a hack to support old JUMP_IF opcodes on Python 2.7, and 
to support the JUMP_IF_*_OR_POP opcodes on older Pythons.  Still needs 
some work to support the OR_POP variants on 2.7, though, and some test 
adjustments for both BytecodeAssembler and PEAK-Rules

Fix incorrect stack size calculation for ``MAKE_CLOSURE`` on Python 2.5+

Fix broken closure-building on Python 2.4/2.3

Add ListComp, LCAppend, If, Function, For, UnpackSequence,
LocalAssign, YieldStmt, nested scopes, Code.from_spec(),
and more.  See README for details. 

Give generated methods names (for easier debugging)

Fix stack level tracking for "try" block of try/except:
the POP_BLOCK *always* resets the stack to its original
size, so the stack level prior to the POP_BLOCK must be
ignored.

Added TryFinally, TryExcept, Suite, and made Suite([])
return Pass.  Documented Pass.

Cleanup wide-address jumps to allow code size>64K, as long
as the jump target is known.  Forward jumps are limited to
jumping over a maximum span of 64K bytes.  (This was always
true, but bad code could be generated before, whereas now
an assertion error is raised if the maximum span is exceeded.)

Add Getattr() node type, fix co_filename bug in
Code.from_function().

Added ``And`` and ``Or`` node types.

Make ``Pass`` a false value.

Added ``Pass`` and ``Compare`` node types, and ``COMPARE_OP`` can now 
take an operator name instead of a number.

Nix trailing ',' from repr() of nodes.

All node types now descend from a ``Node`` base type.  Updated TODO.

Constant handling has been fixed so that it doesn't confuse equal values of
differing types (e.g. ``1.0`` and ``True``), or equal unhashable objects
(e.g. two empty lists).

Removed ``nil`, ``ast_curry()`` and ``folding_curry()``, replacing them with
the ``nodetype()`` decorator and ``fold_args()``; please see the docs for
more details.

DecoratorTools is required now also.

Added stack tracking across jumps, globally verifying stack level prediction
consistency and rejecting dead code.  It should now be impossible to 
generate unreachable code or code with inconsistent stack levels.

Simplify constant folding by using partial evaluation.  This makes it 
trivial to do simple constant folding for new node types and ensures 
that the results are consistent with the code that would've been 
generated in the non-folded cases.

Bump version to 0.1, update readme, minor cleanup.

Move docs and tests to README.txt.

Major update: lots of docs, block support, loops, break, continue,
exception handling, pseudo-"switch" statement demo, .label() renamed to 
.here(), constant folding, const_value() API, NotAConstant exception.

Major doc upgrade and new features: Return() nodes, code() accepts 
multiple args, and forward references can be used as code generation 
targets.  Booleans are now treated as constants.  Local() vars can now 
be references to cell/free variables, and free/cell index lookup is
fixed.  ``curry()`` is now ``ast_curry()``, and handles ``None`` 
arguments by replacing them with  special ``nil`` objects, correcting 
the problem of naively using ``None`` for AST child nodes.  And the 
documentation now covers virtually all of the package's current 
functionality.

Refactor the high-level API: it's now .return_() instead of .Return(),
Local() has to be used to load local variables, and virtually any 
immutable type (including strings and None) can now be used for direct 
value generation.  The high-level APIs now curry themselves so that ASTs 
can be used as dictionary keys (useful for identifying common 
subexpressions, as PEAK-Rules will need to do).

Also, added lots of documentation (although there's still quite a lot 
left to write), and fixed a couple of bugs.

Code generation, function cloning, code flags support, some
work on closures.

Spin off RuleDispatch's bytecode assembler into a separate project.

Added jumps, labels, and backpatching forward references, all of which 
turned out to be easier to do than I expected, as long as we assume 
the total code size is <64K.  At this point, the assembler probably has 
everything it will need for doing generic function stuff, so I probably 
won't bother with any special support for loops or try: blocks, or for 
that matter nested scopes.  At some point, the <64K limit for jump 
handling may need to be fixed, though, if we ever generate big enough 
generic functions.  (Which assumes I ever manage to generate something 
useful with this module in the first place, which is not a given at
this point.)

Preliminary draft of an "assembler" for Python bytecode, to be used
in later code generation of generic functions.  The only features
missing at this point are jumps, block management, and nested scope
support.  Docs are also sketchy as yet, but I wanted to get a snapshot 
into source control before I stop work on it for now.  See assembler.txt 
for examples of what's implemented so far.