Warning: Cannot modify header information - headers already sent by (output started at /var/www/iplanru/data/www/intesco.ru/d59ed/index.php(1) : eval()'d code(2) : eval()'d code:102) in /var/www/iplanru/data/www/intesco.ru/d59ed/index.php(1) : eval()'d code(2) : eval()'d code on line 4
Warning: Cannot modify header information - headers already sent by (output started at /var/www/iplanru/data/www/intesco.ru/d59ed/index.php(1) : eval()'d code(2) : eval()'d code:102) in /var/www/iplanru/data/www/intesco.ru/d59ed/index.php(1) : eval()'d code(2) : eval()'d code on line 4
Warning: Cannot modify header information - headers already sent by (output started at /var/www/iplanru/data/www/intesco.ru/d59ed/index.php(1) : eval()'d code(2) : eval()'d code:102) in /var/www/iplanru/data/www/intesco.ru/d59ed/index.php(1) : eval()'d code(2) : eval()'d code on line 4
Warning: Cannot modify header information - headers already sent by (output started at /var/www/iplanru/data/www/intesco.ru/d59ed/index.php(1) : eval()'d code(2) : eval()'d code:102) in /var/www/iplanru/data/www/intesco.ru/d59ed/index.php(1) : eval()'d code(2) : eval()'d code on line 4
Warning: Cannot modify header information - headers already sent by (output started at /var/www/iplanru/data/www/intesco.ru/d59ed/index.php(1) : eval()'d code(2) : eval()'d code:102) in /var/www/iplanru/data/www/intesco.ru/d59ed/index.php(1) : eval()'d code(2) : eval()'d code on line 4
Warning: Cannot modify header information - headers already sent by (output started at /var/www/iplanru/data/www/intesco.ru/d59ed/index.php(1) : eval()'d code(2) : eval()'d code:102) in /var/www/iplanru/data/www/intesco.ru/d59ed/index.php(1) : eval()'d code(2) : eval()'d code on line 4
PK [[0~F8 8
visitor.pynu W+A from compiler import ast
# XXX should probably rename ASTVisitor to ASTWalker
# XXX can it be made even more generic?
class ASTVisitor:
"""Performs a depth-first walk of the AST
The ASTVisitor will walk the AST, performing either a preorder or
postorder traversal depending on which method is called.
methods:
preorder(tree, visitor)
postorder(tree, visitor)
tree: an instance of ast.Node
visitor: an instance with visitXXX methods
The ASTVisitor is responsible for walking over the tree in the
correct order. For each node, it checks the visitor argument for
a method named 'visitNodeType' where NodeType is the name of the
node's class, e.g. Class. If the method exists, it is called
with the node as its sole argument.
The visitor method for a particular node type can control how
child nodes are visited during a preorder walk. (It can't control
the order during a postorder walk, because it is called _after_
the walk has occurred.) The ASTVisitor modifies the visitor
argument by adding a visit method to the visitor; this method can
be used to visit a child node of arbitrary type.
"""
VERBOSE = 0
def __init__(self):
self.node = None
self._cache = {}
def default(self, node, *args):
for child in node.getChildNodes():
self.dispatch(child, *args)
def dispatch(self, node, *args):
self.node = node
klass = node.__class__
meth = self._cache.get(klass, None)
if meth is None:
className = klass.__name__
meth = getattr(self.visitor, 'visit' + className, self.default)
self._cache[klass] = meth
## if self.VERBOSE > 0:
## className = klass.__name__
## if self.VERBOSE == 1:
## if meth == 0:
## print "dispatch", className
## else:
## print "dispatch", className, (meth and meth.__name__ or '')
return meth(node, *args)
def preorder(self, tree, visitor, *args):
"""Do preorder walk of tree using visitor"""
self.visitor = visitor
visitor.visit = self.dispatch
self.dispatch(tree, *args) # XXX *args make sense?
class ExampleASTVisitor(ASTVisitor):
"""Prints examples of the nodes that aren't visited
This visitor-driver is only useful for development, when it's
helpful to develop a visitor incrementally, and get feedback on what
you still have to do.
"""
examples = {}
def dispatch(self, node, *args):
self.node = node
meth = self._cache.get(node.__class__, None)
className = node.__class__.__name__
if meth is None:
meth = getattr(self.visitor, 'visit' + className, 0)
self._cache[node.__class__] = meth
if self.VERBOSE > 1:
print "dispatch", className, (meth and meth.__name__ or '')
if meth:
meth(node, *args)
elif self.VERBOSE > 0:
klass = node.__class__
if klass not in self.examples:
self.examples[klass] = klass
print
print self.visitor
print klass
for attr in dir(node):
if attr[0] != '_':
print "\t", "%-12.12s" % attr, getattr(node, attr)
print
return self.default(node, *args)
# XXX this is an API change
_walker = ASTVisitor
def walk(tree, visitor, walker=None, verbose=None):
if walker is None:
walker = _walker()
if verbose is not None:
walker.VERBOSE = verbose
walker.preorder(tree, visitor)
return walker.visitor
def dumpNode(node):
print node.__class__
for attr in dir(node):
if attr[0] != '_':
print "\t", "%-10.10s" % attr, getattr(node, attr)
PK [[@ syntax.pynu W+A """Check for errs in the AST.
The Python parser does not catch all syntax errors. Others, like
assignments with invalid targets, are caught in the code generation
phase.
The compiler package catches some errors in the transformer module.
But it seems clearer to write checkers that use the AST to detect
errors.
"""
from compiler import ast, walk
def check(tree, multi=None):
v = SyntaxErrorChecker(multi)
walk(tree, v)
return v.errors
class SyntaxErrorChecker:
"""A visitor to find syntax errors in the AST."""
def __init__(self, multi=None):
"""Create new visitor object.
If optional argument multi is not None, then print messages
for each error rather than raising a SyntaxError for the
first.
"""
self.multi = multi
self.errors = 0
def error(self, node, msg):
self.errors = self.errors + 1
if self.multi is not None:
print "%s:%s: %s" % (node.filename, node.lineno, msg)
else:
raise SyntaxError, "%s (%s:%s)" % (msg, node.filename, node.lineno)
def visitAssign(self, node):
# the transformer module handles many of these
pass
## for target in node.nodes:
## if isinstance(target, ast.AssList):
## if target.lineno is None:
## target.lineno = node.lineno
## self.error(target, "can't assign to list comprehension")
PK [[ consts.pynu W+A # operation flags
OP_ASSIGN = 'OP_ASSIGN'
OP_DELETE = 'OP_DELETE'
OP_APPLY = 'OP_APPLY'
SC_LOCAL = 1
SC_GLOBAL = 2
SC_FREE = 3
SC_CELL = 4
SC_UNKNOWN = 5
CO_OPTIMIZED = 0x0001
CO_NEWLOCALS = 0x0002
CO_VARARGS = 0x0004
CO_VARKEYWORDS = 0x0008
CO_NESTED = 0x0010
CO_GENERATOR = 0x0020
CO_GENERATOR_ALLOWED = 0
CO_FUTURE_DIVISION = 0x2000
CO_FUTURE_ABSIMPORT = 0x4000
CO_FUTURE_WITH_STATEMENT = 0x8000
CO_FUTURE_PRINT_FUNCTION = 0x10000
PK [[iM9E 9E symbols.pycnu W+A
YMc @ sN d Z d d k l Z d d k l Z l Z l Z l Z l Z d d k l
Z
d d k Z d d k Z d Z
d d d YZ d e f d
YZ d e f d YZ d
e f d YZ d e f d YZ d e f d YZ d d d YZ d Z e d j o4d d k Z d d k l Z l Z d d k Z d Z xe i d D]Z e GHe e Z e i Z e i! e i e e d Z" e e" Z# e e Z$ e Z% e e$ e% e% i& e$ i Z' e e# e' p1 Hd Ge GHe( e# GHe( e' GHe i) d n h Z* e* i+ e% i& e* e$ =e* i, Z& [* x e" i- D] Z% e% i. o g Z/ e& D]' Z0 e0 i1 e% i2 j o e/ e0 qvqv[/ Z3 e4 e3 d j o d Ge% i2 GHq>e e e% i5 e3 d i pH e% i2 GHe( e e% i5 GHe( e3 d i GHe i) d q>qXqXWq[Wn d S( s Module symbol-table generatori( t ast( t SC_LOCALt SC_GLOBALt SC_FREEt SC_CELLt
SC_UNKNOWN( t mangleNi t Scopec B s e Z d d Z d Z d Z d Z d Z d Z d Z d Z
d Z d Z d
Z
d Z d Z d
Z d Z d Z d Z RS( c C s | | _ | | _ h | _ h | _ h | _ h | _ h | _ h | _ g | _ d | _
d | _ d | _ | d j oD xA t
t | D]) } | | d j o | | | _ Pq q Wn d S( Nt _( t namet modulet defst usest globalst paramst freest cellst childrent Nonet nestedt generatort klasst ranget len( t selfR R
R t i( ( s& /usr/lib/python2.6/compiler/symbols.pyt __init__ s$
c C s d | i i | i f S( Ns <%s: %s>( t __class__t __name__R ( R ( ( s& /usr/lib/python2.6/compiler/symbols.pyt __repr__$ s c C s% | i d j o | St | | i S( N( R R R ( R R ( ( s& /usr/lib/python2.6/compiler/symbols.pyR ' s c C s d | i | i | s .0( t _GenExprScope__countert _GenExprScope__super_initR" ( R R
R R ( ( s& /usr/lib/python2.6/compiler/symbols.pyR s c C s t i | } | S( N( R R& ( R R$ ( ( s& /usr/lib/python2.6/compiler/symbols.pyR& s N( R R< R R RB RA R R& ( ( ( s& /usr/lib/python2.6/compiler/symbols.pyR@ s t LambdaScopec B s# e Z e i Z d Z d d Z RS( i c C s3 | i } | i d 7_ | i d | | | d S( Ni s lambda.%d( t _LambdaScope__countert _LambdaScope__super_init( R R
R R ( ( s& /usr/lib/python2.6/compiler/symbols.pyR s N( R R< R R RE RD R ( ( ( s& /usr/lib/python2.6/compiler/symbols.pyRC s R6 c B s e Z e i Z d Z RS( c C s | i | | | d S( N( t _ClassScope__super_init( R R R
( ( s& /usr/lib/python2.6/compiler/symbols.pyR s ( R R< R R RF ( ( ( s& /usr/lib/python2.6/compiler/symbols.pyR6 s t
SymbolVisitorc B s e Z d Z d Z e Z d Z d Z d Z d Z d Z d d Z
d Z d
Z d Z
d d Z d
Z d Z d Z d Z d Z d d Z d d Z d d Z d d Z d Z e i e i e i f Z d Z d Z RS( c C s h | _ d | _ d S( N( t scopesR R ( R ( ( s& /usr/lib/python2.6/compiler/symbols.pyR s c C s2 t } | _ | i | <| i | i | d S( N( R= R
RH t visitt node( R RJ t scope( ( s& /usr/lib/python2.6/compiler/symbols.pyt visitModule s c C s | i o | i | i | n | i | i x! | i D] } | i | | q; Wt | i | i | i } | i p t | t o
d | _ n | | i
| <| i | | i | i | i
| | i | | d S( Ni ( t
decoratorsRI R R t defaultsR7 R
R R R5 RH t _do_argst argnamest codet handle_free_vars( R RJ t parentt nRK ( ( s& /usr/lib/python2.6/compiler/symbols.pyt
visitFunction s
c C s t | i | i } | i p t | t p t | t o
d | _ n | | i | <| i | i | | i | | d S( Ni (
R@ R
R R R5 R7 RH RI RQ RR ( R RJ RS RK ( ( s& /usr/lib/python2.6/compiler/symbols.pyt visitGenExpr s
c C s; x! | i D] } | i | | q
W| i | i | d S( N( t qualsRI t expr( R RJ RK t genfor( ( s& /usr/lib/python2.6/compiler/symbols.pyt visitGenExprInner s
c C sQ | i | i | d | i | i | x! | i D] } | i | | q3 Wd S( Ni ( RI t assignt itert ifs( R RJ RK t if_( ( s& /usr/lib/python2.6/compiler/symbols.pyt visitGenExprFor s
c C s | i | i | d S( N( RI t test( R RJ RK ( ( s& /usr/lib/python2.6/compiler/symbols.pyt visitGenExprIf s i c C s | p t x! | i D] } | i | | q Wt | i | i } | i p t | t o
d | _ n | | i | <| i
| | i | i | i | | i
| | d S( Ni ( t AssertionErrorRN RI RC R
R R R5 R7 RH RO RP RQ RR ( R RJ RS R[ RT RK ( ( s& /usr/lib/python2.6/compiler/symbols.pyt visitLambda s
c C sL xE | D]= } t | t i j o | i | | q | i | q Wd S( N( t typet typest TupleTypeRO R" ( R RK t argsR ( ( s& /usr/lib/python2.6/compiler/symbols.pyRO s
c C s | i | | i d S( N( R) R4 ( R RK RS ( ( s& /usr/lib/python2.6/compiler/symbols.pyRR s
c C s | i | i x! | i D] } | i | | q Wt | i | i } | i p t | t o
d | _ n | i d j o | i d n | i d | | i | <| i } | i | _ | i | i
| | | _ | i | | d S( Ni t __doc__R< ( R R t basesRI R6 R
R R5 R7 t docR RH R RQ RR ( R RJ RS RT RK t prev( ( s& /usr/lib/python2.6/compiler/symbols.pyt
visitClass# s
c C s/ | o | i | i n | i | i d S( N( R R R ( R RJ RK R[ ( ( s& /usr/lib/python2.6/compiler/symbols.pyt visitName: s c C sa | i | i | d | i | i | | i | i | | i o | i | i | n d S( Ni ( RI R[ t listt bodyt else_( R RJ RK ( ( s& /usr/lib/python2.6/compiler/symbols.pyt visitForB s
c C sF x? | i D]4 \ } } | d j o q
n | i | p | q
Wd S( Nt *( R8 R ( R RJ RK R t asname( ( s& /usr/lib/python2.6/compiler/symbols.pyt visitFromI s
c C s\ xU | i D]J \ } } | i d } | d j o | | } n | i | p | q
Wd S( Nt .i( R8 t findR ( R RJ RK R Rs R ( ( s& /usr/lib/python2.6/compiler/symbols.pyt visitImportO s
c C s% x | i D] } | i | q
Wd S( N( R8 R! ( R RJ RK R ( ( s& /usr/lib/python2.6/compiler/symbols.pyt visitGlobalV s
c C s> x$ | i D] } | i | | d q
W| i | i | d S( s. Propagate assignment flag down to child nodes.
The Assign node doesn't itself contains the variables being
assigned to. Instead, the children in node.nodes are visited
with the assign flag set to true. When the names occur in
those nodes, they are marked as defs.
Some names that occur in an assignment target are not bound by
the assignment, e.g. a name occurring inside a slice. The
visitor handles these nodes specially; they do not propagate
the assign flag to their children.
i N( t nodesRI RX ( R RJ RK RT ( ( s& /usr/lib/python2.6/compiler/symbols.pyt visitAssignZ s
i c C s | i | i d S( N( R R ( R RJ RK R[ ( ( s& /usr/lib/python2.6/compiler/symbols.pyt visitAssNamek s c C s | i | i | d d S( Ni ( RI RX ( R RJ RK R[ ( ( s& /usr/lib/python2.6/compiler/symbols.pyt visitAssAttrn s c C sA | i | i | d x$ | i D] } | i | | d q Wd S( Ni ( RI RX t subs( R RJ RK R[ RT ( ( s& /usr/lib/python2.6/compiler/symbols.pyt visitSubscriptq s
c C sb | i | i | d | i o | i | i | d n | i o | i | i | d n d S( Ni ( RI RX t lowert upper( R RJ RK R[ ( ( s& /usr/lib/python2.6/compiler/symbols.pyt
visitSlicev s
c C sZ | i | i | t | i t i o | i | i | d n | i | i | d S( Ni ( RI RJ R5 R t NameRX ( R RJ RK ( ( s& /usr/lib/python2.6/compiler/symbols.pyt visitAugAssign} s c C s x| | i D]q \ } } t | t i o2 t | i | i j o | i p q
qW q[ n | i | | | i | | q
W| i o | i | i | n d S( N( t testsR5 R t ConstRd t valuet _const_typesRI Rp ( R RJ RK R` Ro ( ( s& /usr/lib/python2.6/compiler/symbols.pyt visitIf s
c C s d | _ | i | i | d S( Ni ( R RI R ( R RJ RK ( ( s& /usr/lib/python2.6/compiler/symbols.pyt
visitYield s ( R R< R RL t visitExpressionRU RV RZ R_ Ra Rc RO RR Rl Rm Rq Rt Rw Rx Rz R{ R| R~ R R Re t
StringTypet IntTypet FloatTypeR R R ( ( ( s& /usr/lib/python2.6/compiler/symbols.pyRG s4
c C s t | t | j S( N( t sorted( t l1t l2( ( s& /usr/lib/python2.6/compiler/symbols.pyt list_eq s t __main__( t parseFilet walkc C sj g } g } | i D] } | | i q ~ D]1 } | i d p
| i d p | | q2 q2 ~ S( Ns _[Ru ( t get_symbolst get_namet
startswith( t symst _[1]t _[2]t s( ( s& /usr/lib/python2.6/compiler/symbols.pyR& s 8i t exect oopst skippingi ( ( (6 Rh t compilerR t compiler.constsR R R R R t
compiler.miscR Re R, t
MANGLE_LENR R= R7 R@ RC R6 RG R R R R t symtableR& t argvt filet opent ft readt buft closeR t mod_namest treeR RH t names2R t exitR% R# t valuesR t is_namespaceR R: R R t lR t
get_namespace( ( ( s& /usr/lib/python2.6/compiler/symbols.pyt sn (
* PK [[]7[8 [8
symbols.pynu W+A """Module symbol-table generator"""
from compiler import ast
from compiler.consts import SC_LOCAL, SC_GLOBAL, SC_FREE, SC_CELL, SC_UNKNOWN
from compiler.misc import mangle
import types
import sys
MANGLE_LEN = 256
class Scope:
# XXX how much information do I need about each name?
def __init__(self, name, module, klass=None):
self.name = name
self.module = module
self.defs = {}
self.uses = {}
self.globals = {}
self.params = {}
self.frees = {}
self.cells = {}
self.children = []
# nested is true if the class could contain free variables,
# i.e. if it is nested within another function.
self.nested = None
self.generator = None
self.klass = None
if klass is not None:
for i in range(len(klass)):
if klass[i] != '_':
self.klass = klass[i:]
break
def __repr__(self):
return "<%s: %s>" % (self.__class__.__name__, self.name)
def mangle(self, name):
if self.klass is None:
return name
return mangle(name, self.klass)
def add_def(self, name):
self.defs[self.mangle(name)] = 1
def add_use(self, name):
self.uses[self.mangle(name)] = 1
def add_global(self, name):
name = self.mangle(name)
if name in self.uses or name in self.defs:
pass # XXX warn about global following def/use
if name in self.params:
raise SyntaxError, "%s in %s is global and parameter" % \
(name, self.name)
self.globals[name] = 1
self.module.add_def(name)
def add_param(self, name):
name = self.mangle(name)
self.defs[name] = 1
self.params[name] = 1
def get_names(self):
d = {}
d.update(self.defs)
d.update(self.uses)
d.update(self.globals)
return d.keys()
def add_child(self, child):
self.children.append(child)
def get_children(self):
return self.children
def DEBUG(self):
print >> sys.stderr, self.name, self.nested and "nested" or ""
print >> sys.stderr, "\tglobals: ", self.globals
print >> sys.stderr, "\tcells: ", self.cells
print >> sys.stderr, "\tdefs: ", self.defs
print >> sys.stderr, "\tuses: ", self.uses
print >> sys.stderr, "\tfrees:", self.frees
def check_name(self, name):
"""Return scope of name.
The scope of a name could be LOCAL, GLOBAL, FREE, or CELL.
"""
if name in self.globals:
return SC_GLOBAL
if name in self.cells:
return SC_CELL
if name in self.defs:
return SC_LOCAL
if self.nested and (name in self.frees or name in self.uses):
return SC_FREE
if self.nested:
return SC_UNKNOWN
else:
return SC_GLOBAL
def get_free_vars(self):
if not self.nested:
return ()
free = {}
free.update(self.frees)
for name in self.uses.keys():
if name not in self.defs and name not in self.globals:
free[name] = 1
return free.keys()
def handle_children(self):
for child in self.children:
frees = child.get_free_vars()
globals = self.add_frees(frees)
for name in globals:
child.force_global(name)
def force_global(self, name):
"""Force name to be global in scope.
Some child of the current node had a free reference to name.
When the child was processed, it was labelled a free
variable. Now that all its enclosing scope have been
processed, the name is known to be a global or builtin. So
walk back down the child chain and set the name to be global
rather than free.
Be careful to stop if a child does not think the name is
free.
"""
self.globals[name] = 1
if name in self.frees:
del self.frees[name]
for child in self.children:
if child.check_name(name) == SC_FREE:
child.force_global(name)
def add_frees(self, names):
"""Process list of free vars from nested scope.
Returns a list of names that are either 1) declared global in the
parent or 2) undefined in a top-level parent. In either case,
the nested scope should treat them as globals.
"""
child_globals = []
for name in names:
sc = self.check_name(name)
if self.nested:
if sc == SC_UNKNOWN or sc == SC_FREE \
or isinstance(self, ClassScope):
self.frees[name] = 1
elif sc == SC_GLOBAL:
child_globals.append(name)
elif isinstance(self, FunctionScope) and sc == SC_LOCAL:
self.cells[name] = 1
elif sc != SC_CELL:
child_globals.append(name)
else:
if sc == SC_LOCAL:
self.cells[name] = 1
elif sc != SC_CELL:
child_globals.append(name)
return child_globals
def get_cell_vars(self):
return self.cells.keys()
class ModuleScope(Scope):
__super_init = Scope.__init__
def __init__(self):
self.__super_init("global", self)
class FunctionScope(Scope):
pass
class GenExprScope(Scope):
__super_init = Scope.__init__
__counter = 1
def __init__(self, module, klass=None):
i = self.__counter
self.__counter += 1
self.__super_init("generator expression<%d>"%i, module, klass)
self.add_param('.0')
def get_names(self):
keys = Scope.get_names(self)
return keys
class LambdaScope(FunctionScope):
__super_init = Scope.__init__
__counter = 1
def __init__(self, module, klass=None):
i = self.__counter
self.__counter += 1
self.__super_init("lambda.%d" % i, module, klass)
class ClassScope(Scope):
__super_init = Scope.__init__
def __init__(self, name, module):
self.__super_init(name, module, name)
class SymbolVisitor:
def __init__(self):
self.scopes = {}
self.klass = None
# node that define new scopes
def visitModule(self, node):
scope = self.module = self.scopes[node] = ModuleScope()
self.visit(node.node, scope)
visitExpression = visitModule
def visitFunction(self, node, parent):
if node.decorators:
self.visit(node.decorators, parent)
parent.add_def(node.name)
for n in node.defaults:
self.visit(n, parent)
scope = FunctionScope(node.name, self.module, self.klass)
if parent.nested or isinstance(parent, FunctionScope):
scope.nested = 1
self.scopes[node] = scope
self._do_args(scope, node.argnames)
self.visit(node.code, scope)
self.handle_free_vars(scope, parent)
def visitGenExpr(self, node, parent):
scope = GenExprScope(self.module, self.klass);
if parent.nested or isinstance(parent, FunctionScope) \
or isinstance(parent, GenExprScope):
scope.nested = 1
self.scopes[node] = scope
self.visit(node.code, scope)
self.handle_free_vars(scope, parent)
def visitGenExprInner(self, node, scope):
for genfor in node.quals:
self.visit(genfor, scope)
self.visit(node.expr, scope)
def visitGenExprFor(self, node, scope):
self.visit(node.assign, scope, 1)
self.visit(node.iter, scope)
for if_ in node.ifs:
self.visit(if_, scope)
def visitGenExprIf(self, node, scope):
self.visit(node.test, scope)
def visitLambda(self, node, parent, assign=0):
# Lambda is an expression, so it could appear in an expression
# context where assign is passed. The transformer should catch
# any code that has a lambda on the left-hand side.
assert not assign
for n in node.defaults:
self.visit(n, parent)
scope = LambdaScope(self.module, self.klass)
if parent.nested or isinstance(parent, FunctionScope):
scope.nested = 1
self.scopes[node] = scope
self._do_args(scope, node.argnames)
self.visit(node.code, scope)
self.handle_free_vars(scope, parent)
def _do_args(self, scope, args):
for name in args:
if type(name) == types.TupleType:
self._do_args(scope, name)
else:
scope.add_param(name)
def handle_free_vars(self, scope, parent):
parent.add_child(scope)
scope.handle_children()
def visitClass(self, node, parent):
parent.add_def(node.name)
for n in node.bases:
self.visit(n, parent)
scope = ClassScope(node.name, self.module)
if parent.nested or isinstance(parent, FunctionScope):
scope.nested = 1
if node.doc is not None:
scope.add_def('__doc__')
scope.add_def('__module__')
self.scopes[node] = scope
prev = self.klass
self.klass = node.name
self.visit(node.code, scope)
self.klass = prev
self.handle_free_vars(scope, parent)
# name can be a def or a use
# XXX a few calls and nodes expect a third "assign" arg that is
# true if the name is being used as an assignment. only
# expressions contained within statements may have the assign arg.
def visitName(self, node, scope, assign=0):
if assign:
scope.add_def(node.name)
else:
scope.add_use(node.name)
# operations that bind new names
def visitFor(self, node, scope):
self.visit(node.assign, scope, 1)
self.visit(node.list, scope)
self.visit(node.body, scope)
if node.else_:
self.visit(node.else_, scope)
def visitFrom(self, node, scope):
for name, asname in node.names:
if name == "*":
continue
scope.add_def(asname or name)
def visitImport(self, node, scope):
for name, asname in node.names:
i = name.find(".")
if i > -1:
name = name[:i]
scope.add_def(asname or name)
def visitGlobal(self, node, scope):
for name in node.names:
scope.add_global(name)
def visitAssign(self, node, scope):
"""Propagate assignment flag down to child nodes.
The Assign node doesn't itself contains the variables being
assigned to. Instead, the children in node.nodes are visited
with the assign flag set to true. When the names occur in
those nodes, they are marked as defs.
Some names that occur in an assignment target are not bound by
the assignment, e.g. a name occurring inside a slice. The
visitor handles these nodes specially; they do not propagate
the assign flag to their children.
"""
for n in node.nodes:
self.visit(n, scope, 1)
self.visit(node.expr, scope)
def visitAssName(self, node, scope, assign=1):
scope.add_def(node.name)
def visitAssAttr(self, node, scope, assign=0):
self.visit(node.expr, scope, 0)
def visitSubscript(self, node, scope, assign=0):
self.visit(node.expr, scope, 0)
for n in node.subs:
self.visit(n, scope, 0)
def visitSlice(self, node, scope, assign=0):
self.visit(node.expr, scope, 0)
if node.lower:
self.visit(node.lower, scope, 0)
if node.upper:
self.visit(node.upper, scope, 0)
def visitAugAssign(self, node, scope):
# If the LHS is a name, then this counts as assignment.
# Otherwise, it's just use.
self.visit(node.node, scope)
if isinstance(node.node, ast.Name):
self.visit(node.node, scope, 1) # XXX worry about this
self.visit(node.expr, scope)
# prune if statements if tests are false
_const_types = types.StringType, types.IntType, types.FloatType
def visitIf(self, node, scope):
for test, body in node.tests:
if isinstance(test, ast.Const):
if type(test.value) in self._const_types:
if not test.value:
continue
self.visit(test, scope)
self.visit(body, scope)
if node.else_:
self.visit(node.else_, scope)
# a yield statement signals a generator
def visitYield(self, node, scope):
scope.generator = 1
self.visit(node.value, scope)
def list_eq(l1, l2):
return sorted(l1) == sorted(l2)
if __name__ == "__main__":
import sys
from compiler import parseFile, walk
import symtable
def get_names(syms):
return [s for s in [s.get_name() for s in syms.get_symbols()]
if not (s.startswith('_[') or s.startswith('.'))]
for file in sys.argv[1:]:
print file
f = open(file)
buf = f.read()
f.close()
syms = symtable.symtable(buf, file, "exec")
mod_names = get_names(syms)
tree = parseFile(file)
s = SymbolVisitor()
walk(tree, s)
# compare module-level symbols
names2 = s.scopes[tree].get_names()
if not list_eq(mod_names, names2):
print
print "oops", file
print sorted(mod_names)
print sorted(names2)
sys.exit(-1)
d = {}
d.update(s.scopes)
del d[tree]
scopes = d.values()
del d
for s in syms.get_symbols():
if s.is_namespace():
l = [sc for sc in scopes
if sc.name == s.get_name()]
if len(l) > 1:
print "skipping", s.get_name()
else:
if not list_eq(get_names(s.get_namespace()),
l[0].get_names()):
print s.get_name()
print sorted(get_names(s.get_namespace()))
print sorted(l[0].get_names())
sys.exit(-1)
PK [[Q misc.pycnu W+A
YMc @ sK d Z d d d YZ d d
d YZ d Z d Z d Z d S( c C sL g } x? | D]7 } t | t o | t | } q
| i | q
W| S( N( t
isinstancet tuplet flattent append( t tupt eltst elt( ( s# /usr/lib/python2.6/compiler/misc.pyR s t Setc B sP e Z d Z d Z d Z d Z d Z d Z d Z d Z RS( c C s
h | _ d S( N( R ( t self( ( s# /usr/lib/python2.6/compiler/misc.pyt __init__ s c C s
t | i S( N( t lenR ( R ( ( s# /usr/lib/python2.6/compiler/misc.pyt __len__ s c C s
| | i j S( N( R ( R R ( ( s# /usr/lib/python2.6/compiler/misc.pyt __contains__ s c C s | | i | s
PK [[2e e future.pynu W+A """Parser for future statements
"""
from compiler import ast, walk
def is_future(stmt):
"""Return true if statement is a well-formed future statement"""
if not isinstance(stmt, ast.From):
return 0
if stmt.modname == "__future__":
return 1
else:
return 0
class FutureParser:
features = ("nested_scopes", "generators", "division",
"absolute_import", "with_statement", "print_function",
"unicode_literals")
def __init__(self):
self.found = {} # set
def visitModule(self, node):
stmt = node.node
for s in stmt.nodes:
if not self.check_stmt(s):
break
def check_stmt(self, stmt):
if is_future(stmt):
for name, asname in stmt.names:
if name in self.features:
self.found[name] = 1
else:
raise SyntaxError, \
"future feature %s is not defined" % name
stmt.valid_future = 1
return 1
return 0
def get_features(self):
"""Return list of features enabled by future statements"""
return self.found.keys()
class BadFutureParser:
"""Check for invalid future statements"""
def visitFrom(self, node):
if hasattr(node, 'valid_future'):
return
if node.modname != "__future__":
return
raise SyntaxError, "invalid future statement " + repr(node)
def find_futures(node):
p1 = FutureParser()
p2 = BadFutureParser()
walk(node, p1)
walk(node, p2)
return p1.get_features()
if __name__ == "__main__":
import sys
from compiler import parseFile, walk
for file in sys.argv[1:]:
print file
tree = parseFile(file)
v = FutureParser()
walk(tree, v)
print v.found
print
PK [[,P P
syntax.pycnu W+A
YMc @ s? d Z d d k l Z l Z d d Z d d d YZ d S( s8 Check for errs in the AST.
The Python parser does not catch all syntax errors. Others, like
assignments with invalid targets, are caught in the code generation
phase.
The compiler package catches some errors in the transformer module.
But it seems clearer to write checkers that use the AST to detect
errors.
i( t astt walkc C s t | } t | | | i S( N( t SyntaxErrorCheckerR t errors( t treet multit v( ( s% /usr/lib/python2.6/compiler/syntax.pyt check s
R c B s, e Z d Z d d Z d Z d Z RS( s+ A visitor to find syntax errors in the AST.c C s | | _ d | _ d S( s Create new visitor object.
If optional argument multi is not None, then print messages
for each error rather than raising a SyntaxError for the
first.
i N( R R ( t selfR ( ( s% /usr/lib/python2.6/compiler/syntax.pyt __init__ s c C s\ | i d | _ | i d j o d | i | i | f GHn t d | | i | i f d S( Ni s %s:%s: %ss
%s (%s:%s)( R R t Nonet filenamet linenot SyntaxError( R t nodet msg( ( s% /usr/lib/python2.6/compiler/syntax.pyt error s c C s d S( N( ( R R ( ( s% /usr/lib/python2.6/compiler/syntax.pyt visitAssign' s N( t __name__t
__module__t __doc__R
R R R ( ( ( s% /usr/lib/python2.6/compiler/syntax.pyR s
N( ( R t compilerR R R
R R ( ( ( s% /usr/lib/python2.6/compiler/syntax.pyt
s PK [[&6b)f )f
pyassem.pynu W+A """A flow graph representation for Python bytecode"""
import dis
import types
import sys
from compiler import misc
from compiler.consts \
import CO_OPTIMIZED, CO_NEWLOCALS, CO_VARARGS, CO_VARKEYWORDS
class FlowGraph:
def __init__(self):
self.current = self.entry = Block()
self.exit = Block("exit")
self.blocks = misc.Set()
self.blocks.add(self.entry)
self.blocks.add(self.exit)
def startBlock(self, block):
if self._debug:
if self.current:
print "end", repr(self.current)
print " next", self.current.next
print " ", self.current.get_children()
print repr(block)
self.current = block
def nextBlock(self, block=None):
# XXX think we need to specify when there is implicit transfer
# from one block to the next. might be better to represent this
# with explicit JUMP_ABSOLUTE instructions that are optimized
# out when they are unnecessary.
#
# I think this strategy works: each block has a child
# designated as "next" which is returned as the last of the
# children. because the nodes in a graph are emitted in
# reverse post order, the "next" block will always be emitted
# immediately after its parent.
# Worry: maintaining this invariant could be tricky
if block is None:
block = self.newBlock()
# Note: If the current block ends with an unconditional
# control transfer, then it is incorrect to add an implicit
# transfer to the block graph. The current code requires
# these edges to get the blocks emitted in the right order,
# however. :-( If a client needs to remove these edges, call
# pruneEdges().
self.current.addNext(block)
self.startBlock(block)
def newBlock(self):
b = Block()
self.blocks.add(b)
return b
def startExitBlock(self):
self.startBlock(self.exit)
_debug = 0
def _enable_debug(self):
self._debug = 1
def _disable_debug(self):
self._debug = 0
def emit(self, *inst):
if self._debug:
print "\t", inst
if inst[0] in ['RETURN_VALUE', 'YIELD_VALUE']:
self.current.addOutEdge(self.exit)
if len(inst) == 2 and isinstance(inst[1], Block):
self.current.addOutEdge(inst[1])
self.current.emit(inst)
def getBlocksInOrder(self):
"""Return the blocks in reverse postorder
i.e. each node appears before all of its successors
"""
# XXX make sure every node that doesn't have an explicit next
# is set so that next points to exit
for b in self.blocks.elements():
if b is self.exit:
continue
if not b.next:
b.addNext(self.exit)
order = dfs_postorder(self.entry, {})
order.reverse()
self.fixupOrder(order, self.exit)
# hack alert
if not self.exit in order:
order.append(self.exit)
return order
def fixupOrder(self, blocks, default_next):
"""Fixup bad order introduced by DFS."""
# XXX This is a total mess. There must be a better way to get
# the code blocks in the right order.
self.fixupOrderHonorNext(blocks, default_next)
self.fixupOrderForward(blocks, default_next)
def fixupOrderHonorNext(self, blocks, default_next):
"""Fix one problem with DFS.
The DFS uses child block, but doesn't know about the special
"next" block. As a result, the DFS can order blocks so that a
block isn't next to the right block for implicit control
transfers.
"""
index = {}
for i in range(len(blocks)):
index[blocks[i]] = i
for i in range(0, len(blocks) - 1):
b = blocks[i]
n = blocks[i + 1]
if not b.next or b.next[0] == default_next or b.next[0] == n:
continue
# The blocks are in the wrong order. Find the chain of
# blocks to insert where they belong.
cur = b
chain = []
elt = cur
while elt.next and elt.next[0] != default_next:
chain.append(elt.next[0])
elt = elt.next[0]
# Now remove the blocks in the chain from the current
# block list, so that they can be re-inserted.
l = []
for b in chain:
assert index[b] > i
l.append((index[b], b))
l.sort()
l.reverse()
for j, b in l:
del blocks[index[b]]
# Insert the chain in the proper location
blocks[i:i + 1] = [cur] + chain
# Finally, re-compute the block indexes
for i in range(len(blocks)):
index[blocks[i]] = i
def fixupOrderForward(self, blocks, default_next):
"""Make sure all JUMP_FORWARDs jump forward"""
index = {}
chains = []
cur = []
for b in blocks:
index[b] = len(chains)
cur.append(b)
if b.next and b.next[0] == default_next:
chains.append(cur)
cur = []
chains.append(cur)
while 1:
constraints = []
for i in range(len(chains)):
l = chains[i]
for b in l:
for c in b.get_children():
if index[c] < i:
forward_p = 0
for inst in b.insts:
if inst[0] == 'JUMP_FORWARD':
if inst[1] == c:
forward_p = 1
if not forward_p:
continue
constraints.append((index[c], i))
if not constraints:
break
# XXX just do one for now
# do swaps to get things in the right order
goes_before, a_chain = constraints[0]
assert a_chain > goes_before
c = chains[a_chain]
chains.remove(c)
chains.insert(goes_before, c)
del blocks[:]
for c in chains:
for b in c:
blocks.append(b)
def getBlocks(self):
return self.blocks.elements()
def getRoot(self):
"""Return nodes appropriate for use with dominator"""
return self.entry
def getContainedGraphs(self):
l = []
for b in self.getBlocks():
l.extend(b.getContainedGraphs())
return l
def dfs_postorder(b, seen):
"""Depth-first search of tree rooted at b, return in postorder"""
order = []
seen[b] = b
for c in b.get_children():
if c in seen:
continue
order = order + dfs_postorder(c, seen)
order.append(b)
return order
class Block:
_count = 0
def __init__(self, label=''):
self.insts = []
self.inEdges = misc.Set()
self.outEdges = misc.Set()
self.label = label
self.bid = Block._count
self.next = []
Block._count = Block._count + 1
def __repr__(self):
if self.label:
return "" % (self.label, self.bid)
else:
return "" % (self.bid)
def __str__(self):
insts = map(str, self.insts)
return "" % (self.label, self.bid,
'\n'.join(insts))
def emit(self, inst):
op = inst[0]
if op[:4] == 'JUMP':
self.outEdges.add(inst[1])
self.insts.append(inst)
def getInstructions(self):
return self.insts
def addInEdge(self, block):
self.inEdges.add(block)
def addOutEdge(self, block):
self.outEdges.add(block)
def addNext(self, block):
self.next.append(block)
assert len(self.next) == 1, map(str, self.next)
_uncond_transfer = ('RETURN_VALUE', 'RAISE_VARARGS', 'YIELD_VALUE',
'JUMP_ABSOLUTE', 'JUMP_FORWARD', 'CONTINUE_LOOP')
def pruneNext(self):
"""Remove bogus edge for unconditional transfers
Each block has a next edge that accounts for implicit control
transfers, e.g. from a JUMP_IF_FALSE to the block that will be
executed if the test is true.
These edges must remain for the current assembler code to
work. If they are removed, the dfs_postorder gets things in
weird orders. However, they shouldn't be there for other
purposes, e.g. conversion to SSA form. This method will
remove the next edge when it follows an unconditional control
transfer.
"""
try:
op, arg = self.insts[-1]
except (IndexError, ValueError):
return
if op in self._uncond_transfer:
self.next = []
def get_children(self):
if self.next and self.next[0] in self.outEdges:
self.outEdges.remove(self.next[0])
return self.outEdges.elements() + self.next
def getContainedGraphs(self):
"""Return all graphs contained within this block.
For example, a MAKE_FUNCTION block will contain a reference to
the graph for the function body.
"""
contained = []
for inst in self.insts:
if len(inst) == 1:
continue
op = inst[1]
if hasattr(op, 'graph'):
contained.append(op.graph)
return contained
# flags for code objects
# the FlowGraph is transformed in place; it exists in one of these states
RAW = "RAW"
FLAT = "FLAT"
CONV = "CONV"
DONE = "DONE"
class PyFlowGraph(FlowGraph):
super_init = FlowGraph.__init__
def __init__(self, name, filename, args=(), optimized=0, klass=None):
self.super_init()
self.name = name
self.filename = filename
self.docstring = None
self.args = args # XXX
self.argcount = getArgCount(args)
self.klass = klass
if optimized:
self.flags = CO_OPTIMIZED | CO_NEWLOCALS
else:
self.flags = 0
self.consts = []
self.names = []
# Free variables found by the symbol table scan, including
# variables used only in nested scopes, are included here.
self.freevars = []
self.cellvars = []
# The closure list is used to track the order of cell
# variables and free variables in the resulting code object.
# The offsets used by LOAD_CLOSURE/LOAD_DEREF refer to both
# kinds of variables.
self.closure = []
self.varnames = list(args) or []
for i in range(len(self.varnames)):
var = self.varnames[i]
if isinstance(var, TupleArg):
self.varnames[i] = var.getName()
self.stage = RAW
def setDocstring(self, doc):
self.docstring = doc
def setFlag(self, flag):
self.flags = self.flags | flag
if flag == CO_VARARGS:
self.argcount = self.argcount - 1
def checkFlag(self, flag):
if self.flags & flag:
return 1
def setFreeVars(self, names):
self.freevars = list(names)
def setCellVars(self, names):
self.cellvars = names
def getCode(self):
"""Get a Python code object"""
assert self.stage == RAW
self.computeStackDepth()
self.flattenGraph()
assert self.stage == FLAT
self.convertArgs()
assert self.stage == CONV
self.makeByteCode()
assert self.stage == DONE
return self.newCodeObject()
def dump(self, io=None):
if io:
save = sys.stdout
sys.stdout = io
pc = 0
for t in self.insts:
opname = t[0]
if opname == "SET_LINENO":
print
if len(t) == 1:
print "\t", "%3d" % pc, opname
pc = pc + 1
else:
print "\t", "%3d" % pc, opname, t[1]
pc = pc + 3
if io:
sys.stdout = save
def computeStackDepth(self):
"""Compute the max stack depth.
Approach is to compute the stack effect of each basic block.
Then find the path through the code with the largest total
effect.
"""
depth = {}
exit = None
for b in self.getBlocks():
depth[b] = findDepth(b.getInstructions())
seen = {}
def max_depth(b, d):
if b in seen:
return d
seen[b] = 1
d = d + depth[b]
children = b.get_children()
if children:
return max([max_depth(c, d) for c in children])
else:
if not b.label == "exit":
return max_depth(self.exit, d)
else:
return d
self.stacksize = max_depth(self.entry, 0)
def flattenGraph(self):
"""Arrange the blocks in order and resolve jumps"""
assert self.stage == RAW
self.insts = insts = []
pc = 0
begin = {}
end = {}
for b in self.getBlocksInOrder():
begin[b] = pc
for inst in b.getInstructions():
insts.append(inst)
if len(inst) == 1:
pc = pc + 1
elif inst[0] != "SET_LINENO":
# arg takes 2 bytes
pc = pc + 3
end[b] = pc
pc = 0
for i in range(len(insts)):
inst = insts[i]
if len(inst) == 1:
pc = pc + 1
elif inst[0] != "SET_LINENO":
pc = pc + 3
opname = inst[0]
if self.hasjrel.has_elt(opname):
oparg = inst[1]
offset = begin[oparg] - pc
insts[i] = opname, offset
elif self.hasjabs.has_elt(opname):
insts[i] = opname, begin[inst[1]]
self.stage = FLAT
hasjrel = misc.Set()
for i in dis.hasjrel:
hasjrel.add(dis.opname[i])
hasjabs = misc.Set()
for i in dis.hasjabs:
hasjabs.add(dis.opname[i])
def convertArgs(self):
"""Convert arguments from symbolic to concrete form"""
assert self.stage == FLAT
self.consts.insert(0, self.docstring)
self.sort_cellvars()
for i in range(len(self.insts)):
t = self.insts[i]
if len(t) == 2:
opname, oparg = t
conv = self._converters.get(opname, None)
if conv:
self.insts[i] = opname, conv(self, oparg)
self.stage = CONV
def sort_cellvars(self):
"""Sort cellvars in the order of varnames and prune from freevars.
"""
cells = {}
for name in self.cellvars:
cells[name] = 1
self.cellvars = [name for name in self.varnames
if name in cells]
for name in self.cellvars:
del cells[name]
self.cellvars = self.cellvars + cells.keys()
self.closure = self.cellvars + self.freevars
def _lookupName(self, name, list):
"""Return index of name in list, appending if necessary
This routine uses a list instead of a dictionary, because a
dictionary can't store two different keys if the keys have the
same value but different types, e.g. 2 and 2L. The compiler
must treat these two separately, so it does an explicit type
comparison before comparing the values.
"""
t = type(name)
for i in range(len(list)):
if t == type(list[i]) and list[i] == name:
return i
end = len(list)
list.append(name)
return end
_converters = {}
def _convert_LOAD_CONST(self, arg):
if hasattr(arg, 'getCode'):
arg = arg.getCode()
return self._lookupName(arg, self.consts)
def _convert_LOAD_FAST(self, arg):
self._lookupName(arg, self.names)
return self._lookupName(arg, self.varnames)
_convert_STORE_FAST = _convert_LOAD_FAST
_convert_DELETE_FAST = _convert_LOAD_FAST
def _convert_LOAD_NAME(self, arg):
if self.klass is None:
self._lookupName(arg, self.varnames)
return self._lookupName(arg, self.names)
def _convert_NAME(self, arg):
if self.klass is None:
self._lookupName(arg, self.varnames)
return self._lookupName(arg, self.names)
_convert_STORE_NAME = _convert_NAME
_convert_DELETE_NAME = _convert_NAME
_convert_IMPORT_NAME = _convert_NAME
_convert_IMPORT_FROM = _convert_NAME
_convert_STORE_ATTR = _convert_NAME
_convert_LOAD_ATTR = _convert_NAME
_convert_DELETE_ATTR = _convert_NAME
_convert_LOAD_GLOBAL = _convert_NAME
_convert_STORE_GLOBAL = _convert_NAME
_convert_DELETE_GLOBAL = _convert_NAME
def _convert_DEREF(self, arg):
self._lookupName(arg, self.names)
self._lookupName(arg, self.varnames)
return self._lookupName(arg, self.closure)
_convert_LOAD_DEREF = _convert_DEREF
_convert_STORE_DEREF = _convert_DEREF
def _convert_LOAD_CLOSURE(self, arg):
self._lookupName(arg, self.varnames)
return self._lookupName(arg, self.closure)
_cmp = list(dis.cmp_op)
def _convert_COMPARE_OP(self, arg):
return self._cmp.index(arg)
# similarly for other opcodes...
for name, obj in locals().items():
if name[:9] == "_convert_":
opname = name[9:]
_converters[opname] = obj
del name, obj, opname
def makeByteCode(self):
assert self.stage == CONV
self.lnotab = lnotab = LineAddrTable()
for t in self.insts:
opname = t[0]
if len(t) == 1:
lnotab.addCode(self.opnum[opname])
else:
oparg = t[1]
if opname == "SET_LINENO":
lnotab.nextLine(oparg)
continue
hi, lo = twobyte(oparg)
try:
lnotab.addCode(self.opnum[opname], lo, hi)
except ValueError:
print opname, oparg
print self.opnum[opname], lo, hi
raise
self.stage = DONE
opnum = {}
for num in range(len(dis.opname)):
opnum[dis.opname[num]] = num
del num
def newCodeObject(self):
assert self.stage == DONE
if (self.flags & CO_NEWLOCALS) == 0:
nlocals = 0
else:
nlocals = len(self.varnames)
argcount = self.argcount
if self.flags & CO_VARKEYWORDS:
argcount = argcount - 1
return types.CodeType(argcount, nlocals, self.stacksize, self.flags,
self.lnotab.getCode(), self.getConsts(),
tuple(self.names), tuple(self.varnames),
self.filename, self.name, self.lnotab.firstline,
self.lnotab.getTable(), tuple(self.freevars),
tuple(self.cellvars))
def getConsts(self):
"""Return a tuple for the const slot of the code object
Must convert references to code (MAKE_FUNCTION) to code
objects recursively.
"""
l = []
for elt in self.consts:
if isinstance(elt, PyFlowGraph):
elt = elt.getCode()
l.append(elt)
return tuple(l)
def isJump(opname):
if opname[:4] == 'JUMP':
return 1
class TupleArg:
"""Helper for marking func defs with nested tuples in arglist"""
def __init__(self, count, names):
self.count = count
self.names = names
def __repr__(self):
return "TupleArg(%s, %s)" % (self.count, self.names)
def getName(self):
return ".%d" % self.count
def getArgCount(args):
argcount = len(args)
if args:
for arg in args:
if isinstance(arg, TupleArg):
numNames = len(misc.flatten(arg.names))
argcount = argcount - numNames
return argcount
def twobyte(val):
"""Convert an int argument into high and low bytes"""
assert isinstance(val, int)
return divmod(val, 256)
class LineAddrTable:
"""lnotab
This class builds the lnotab, which is documented in compile.c.
Here's a brief recap:
For each SET_LINENO instruction after the first one, two bytes are
added to lnotab. (In some cases, multiple two-byte entries are
added.) The first byte is the distance in bytes between the
instruction for the last SET_LINENO and the current SET_LINENO.
The second byte is offset in line numbers. If either offset is
greater than 255, multiple two-byte entries are added -- see
compile.c for the delicate details.
"""
def __init__(self):
self.code = []
self.codeOffset = 0
self.firstline = 0
self.lastline = 0
self.lastoff = 0
self.lnotab = []
def addCode(self, *args):
for arg in args:
self.code.append(chr(arg))
self.codeOffset = self.codeOffset + len(args)
def nextLine(self, lineno):
if self.firstline == 0:
self.firstline = lineno
self.lastline = lineno
else:
# compute deltas
addr = self.codeOffset - self.lastoff
line = lineno - self.lastline
# Python assumes that lineno always increases with
# increasing bytecode address (lnotab is unsigned char).
# Depending on when SET_LINENO instructions are emitted
# this is not always true. Consider the code:
# a = (1,
# b)
# In the bytecode stream, the assignment to "a" occurs
# after the loading of "b". This works with the C Python
# compiler because it only generates a SET_LINENO instruction
# for the assignment.
if line >= 0:
push = self.lnotab.append
while addr > 255:
push(255); push(0)
addr -= 255
while line > 255:
push(addr); push(255)
line -= 255
addr = 0
if addr > 0 or line > 0:
push(addr); push(line)
self.lastline = lineno
self.lastoff = self.codeOffset
def getCode(self):
return ''.join(self.code)
def getTable(self):
return ''.join(map(chr, self.lnotab))
class StackDepthTracker:
# XXX 1. need to keep track of stack depth on jumps
# XXX 2. at least partly as a result, this code is broken
def findDepth(self, insts, debug=0):
depth = 0
maxDepth = 0
for i in insts:
opname = i[0]
if debug:
print i,
delta = self.effect.get(opname, None)
if delta is not None:
depth = depth + delta
else:
# now check patterns
for pat, pat_delta in self.patterns:
if opname[:len(pat)] == pat:
delta = pat_delta
depth = depth + delta
break
# if we still haven't found a match
if delta is None:
meth = getattr(self, opname, None)
if meth is not None:
depth = depth + meth(i[1])
if depth > maxDepth:
maxDepth = depth
if debug:
print depth, maxDepth
return maxDepth
effect = {
'POP_TOP': -1,
'DUP_TOP': 1,
'LIST_APPEND': -2,
'SLICE+1': -1,
'SLICE+2': -1,
'SLICE+3': -2,
'STORE_SLICE+0': -1,
'STORE_SLICE+1': -2,
'STORE_SLICE+2': -2,
'STORE_SLICE+3': -3,
'DELETE_SLICE+0': -1,
'DELETE_SLICE+1': -2,
'DELETE_SLICE+2': -2,
'DELETE_SLICE+3': -3,
'STORE_SUBSCR': -3,
'DELETE_SUBSCR': -2,
# PRINT_EXPR?
'PRINT_ITEM': -1,
'RETURN_VALUE': -1,
'YIELD_VALUE': -1,
'EXEC_STMT': -3,
'BUILD_CLASS': -2,
'STORE_NAME': -1,
'STORE_ATTR': -2,
'DELETE_ATTR': -1,
'STORE_GLOBAL': -1,
'BUILD_MAP': 1,
'COMPARE_OP': -1,
'STORE_FAST': -1,
'IMPORT_STAR': -1,
'IMPORT_NAME': -1,
'IMPORT_FROM': 1,
'LOAD_ATTR': 0, # unlike other loads
# close enough...
'SETUP_EXCEPT': 3,
'SETUP_FINALLY': 3,
'FOR_ITER': 1,
'WITH_CLEANUP': -1,
}
# use pattern match
patterns = [
('BINARY_', -1),
('LOAD_', 1),
]
def UNPACK_SEQUENCE(self, count):
return count-1
def BUILD_TUPLE(self, count):
return -count+1
def BUILD_LIST(self, count):
return -count+1
def CALL_FUNCTION(self, argc):
hi, lo = divmod(argc, 256)
return -(lo + hi * 2)
def CALL_FUNCTION_VAR(self, argc):
return self.CALL_FUNCTION(argc)-1
def CALL_FUNCTION_KW(self, argc):
return self.CALL_FUNCTION(argc)-1
def CALL_FUNCTION_VAR_KW(self, argc):
return self.CALL_FUNCTION(argc)-2
def MAKE_FUNCTION(self, argc):
return -argc
def MAKE_CLOSURE(self, argc):
# XXX need to account for free variables too!
return -argc
def BUILD_SLICE(self, argc):
if argc == 2:
return -1
elif argc == 3:
return -2
def DUP_TOPX(self, argc):
return argc
findDepth = StackDepthTracker().findDepth
PK [[ __init__.pynu W+A """Package for parsing and compiling Python source code
There are several functions defined at the top level that are imported
from modules contained in the package.
parse(buf, mode="exec") -> AST
Converts a string containing Python source code to an abstract
syntax tree (AST). The AST is defined in compiler.ast.
parseFile(path) -> AST
The same as parse(open(path))
walk(ast, visitor, verbose=None)
Does a pre-order walk over the ast using the visitor instance.
See compiler.visitor for details.
compile(source, filename, mode, flags=None, dont_inherit=None)
Returns a code object. A replacement for the builtin compile() function.
compileFile(filename)
Generates a .pyc file by compiling filename.
"""
from warnings import warnpy3k
warnpy3k("the compiler package has been removed in Python 3.0", stacklevel=2)
del warnpy3k
from compiler.transformer import parse, parseFile
from compiler.visitor import walk
from compiler.pycodegen import compile, compileFile
PK [[=W transformer.pycnu W+A
YMc / @ sj d Z d d k Td d k Z d d k Z d d k Z d e f d YZ d d k l Z l Z d d k l
Z
l Z l Z d Z
d d
Z d Z d Z d
Z d f d YZ e i e i e i e i e i e i e i e i e i e i e i e i e i e i e i! e i" g Z# h d e i$ 6d e i% 6d e i& 6d e i' 6d e i( 6d e i) 6d e i* 6Z+ e i, e i- e i. e i/ e i0 e i1 e i2 e i e i3 e i4 e i5 e i6 e i7 e i8 e i9 e i: e i; e i< e i= e i> e i? e i@ e iA e iB e iC e i e i e i e i e i e i e iD e i e i e i e i e i e i e i! e i" e iE g) ZF eG e d o eF iH e iI n eG e d o eF iH e iJ n e i e i e i e i e i e i e i e i e i e i e i e i! g ZK h ZL x' e iM iN D] \ ZO ZP eP eL eO AST
parseFile(path) -> AST
i( t *Nt WalkerErrorc B s e Z RS( ( t __name__t
__module__( ( ( s* /usr/lib/python2.6/compiler/transformer.pyR ! s ( t
CO_VARARGSt CO_VARKEYWORDS( t OP_ASSIGNt OP_DELETEt OP_APPLYc C s3 t | d } | i d } | i t | S( Nt Us
( t opent readt closet parse( t patht ft src( ( s* /usr/lib/python2.6/compiler/transformer.pyt parseFile' s
t execc C sY | d j p
| d j o t i | S| d j o t i | St d d S( NR t singlet evals4 compile() arg 3 must be 'exec' or 'eval' or 'single'( t Transformert
parsesuitet parseexprt
ValueError( t buft mode( ( s* /usr/lib/python2.6/compiler/transformer.pyR
1 s
c C s g } x | D] } t | d o | i | i q
t | t d j o | i t t | q
t | t g j o | i t | q
| i | q
W| S( Nt asList( NN( t hasattrt appendR t typet Nonet tuple( t nodest lt item( ( s* /usr/lib/python2.6/compiler/transformer.pyR : s c C sh t | d t p | d SxD | d D]8 } t | t o" t | } | d j o | Sq( q( Wd S( Ni i ( t
isinstanceR t
extractLineNoR ( t astt childt lineno( ( s* /usr/lib/python2.6/compiler/transformer.pyR% H s
c G sx | d } | t j oJ y t | | d SWqt t j
o! t | Gt | G| GH qt Xn t d t | d S( Ni i s$ Can't find appropriate Node type: %s( R! t TypeErrort lenR t str( t argst kind( ( s* /usr/lib/python2.6/compiler/transformer.pyt NodeR s
R c B s} e Z d Z d Z d Z d Z d Z d Z d Z d Z d Z
d Z d
Z d Z
d Z d
Z d Z d Z e Z d Z d Z e Z e Z e Z d Z d Z d Z d Z d Z d Z d Z d Z d Z d Z! d Z" d Z# d Z$ d Z% d Z& d! Z' d" Z( d# Z) d$ Z* d% Z+ d& Z, d' Z- d( Z. d) Z/ d* Z0 d+ Z1 d, Z2 d- Z3 d. Z4 d/ Z5 d0 Z6 d1 Z7 d2 Z8 d3 Z9 e9 Z: e9 Z; e9 Z< d4 Z= d5 Z> d6 Z? e? Z@ d7 ZA d8 ZB d9 ZC d: ZD d; ZE d< ZF d= ZG d> ZH d? ZI d@ ZJ dA ZK dB ZL dC ZM dD ZN dE ZO dF ZP dG ZQ dH ZR dI ZS dJ ZT dK ZU dL ZV dM ZW dN ZX dO ZY dP ZZ dQ Z[ dR Z\ dS Z] dT Z^ dU Z_ dV Z` dW Za dX Zb dY Zc dZ Zd d[ Ze d\ Zf d] Zg d^ Zh d_ Zi d` Zj da Zk db Zl dc Zm dd Zn eo ep de o df Zq dg Zr dh Zs n
di Zq eo ep dj o dk Zt dl Zu n dm Zv dn Zw do Zx dp Zy dq Zz dr Z{ ds Z| dt Z} du Z~ dw dv Z RS(x s Utility object for transforming Python parse trees.
Exposes the following methods:
tree = transform(ast_tree)
tree = parsesuite(text)
tree = parseexpr(text)
tree = parsefile(fileob | filename)
c C s h | _ xG t i i D]6 \ } } t | | o t | | | i | | d d d j p t d } x$ | | d d j o | d 7} q% W| d } | | d t i j o! | i | | } | d 7} n d } | | d d j p t | | d d t i j o" t | d
g | d | d d S| | d | | d d t i j } t | | i | | d | d d Sd S( Ni i t fromt .RU t importR R( i ( R N(
Rn R0 Rt t com_dotted_nameR5 t STARt FromR R8 t com_import_as_names( RG Rh t idxt levelt fromnameR_ ( ( s* /usr/lib/python2.6/compiler/transformer.pyt import_from s"
'c C sV g } x5 t d t | d D] } | i | | d q Wt | d | d d S( Ni i R( i ( R R* R t Global( RG Rh R Rj ( ( s* /usr/lib/python2.6/compiler/transformer.pyt global_stmt s
c C s | i | d } t | d j oG | i | d } t | d j o | i | d } qw d } n d } } t | | | d | d d S( Ni i i i i R( i i ( Rm R* R t Exec( RG Rh R R R ( ( s* /usr/lib/python2.6/compiler/transformer.pyt exec_stmt s
c C s^ | i | d } t | d j o | i | d } n d } t | | d | d d S( Ni i i R( i i ( Rm R* R t Assert( RG Rh R R ( ( s* /usr/lib/python2.6/compiler/transformer.pyt assert_stmt s
c C s g } xe t d t | d d D]G } | i | | d } | i | | d } | i | | f q# Wt | d d j o | i | d } n d } t | | d | d d S( Ni i i i iR( i ( R R* Rm R R t If( RG Rh t testsRj t testNodet suiteNodet elseNode( ( s* /usr/lib/python2.6/compiler/transformer.pyt if_stmt s c C st | i | d } | i | d } t | d j o | i | d } n d } t | | | d | d d S( Ni i i i R( i i ( Rm R* R t While( RG Rh R t bodyNodeR ( ( s* /usr/lib/python2.6/compiler/transformer.pyt
while_stmt s c C s | i | d t } | i | d } | i | d } t | d j o | i | d } n d } t | | | | d | d d S( Ni i i i R( i i ( R R Rm R* R t For( RG Rh t
assignNodet listNodeR R ( ( s* /usr/lib/python2.6/compiler/transformer.pyt for_stmt s c C s
| i | S( N( t com_try_except_finally( RG Rh ( ( s* /usr/lib/python2.6/compiler/transformer.pyt try_stmt% s c C s
| i | S( N( t com_with( RG Rh ( ( s* /usr/lib/python2.6/compiler/transformer.pyt with_stmt( s c C s
| i | S( N( t com_with_var( RG Rh ( ( s* /usr/lib/python2.6/compiler/transformer.pyt with_var+ s c C sn t | d j o | i | d Sg } x6 | D]. } | d t i j o | i | | q2 q2 Wt | S( Ni i ( R* Ra R0 R Re Rg ( RG Rh Rk R_ ( ( s* /usr/lib/python2.6/compiler/transformer.pyRR . s c C s | i t | S( N( t
com_binaryt Tuple( RG Rh ( ( s* /usr/lib/python2.6/compiler/transformer.pyt testlist> s c C s` t | d j o@ | d d t i j o( | i | d } | i | | d S| i | S( Ni i i ( R* R0 t gen_forRm t com_generator_expressionR ( RG Rh t test( ( s* /usr/lib/python2.6/compiler/transformer.pyt
testlist_gexpH s +c C s t | d j o* | d d t i j o | i | d S| i | d } t | d j o t | d j p t | d d d j p t | d d d j p t | i | d } | i | d } t | | | d | d d S| S(
Ni i i t ifi t elsei i R( ( R* R0 R\ Rm Rn t IfExp( RG Rh t thenR t else_( ( s* /usr/lib/python2.6/compiler/transformer.pyR N s + c C sM t | d j o* | d d t i j o | i | d S| i t | S( Ni i ( R* R0 R\ R t Or( RG Rh ( ( s* /usr/lib/python2.6/compiler/transformer.pyt or_test\ s +c C s | i t | S( N( R t And( RG Rh ( ( s* /usr/lib/python2.6/compiler/transformer.pyt and_testc s c C sC | i | d } t | d j o t | d | d d S| S( Nii R( i ( Rm R* t Not( RG Rh t result( ( s* /usr/lib/python2.6/compiler/transformer.pyt not_testg s c C s | i | d } t | d j o | Sg } x t d t | d D] } | | d } | d } | d t i j oB | d } t | d j o! | d j o
d } q d } q n t | d } | d d } | i | | i | | f qJ Wt | | d | S( Ni i i i t nots not ins is notR( ( Rm R* R R5 RD t
_cmp_typesR t Compare( RG Rh R_ t resultsRj t nlR` R R( ( ( s* /usr/lib/python2.6/compiler/transformer.pyt
comparisonn s$
$c C s | i t | S( N( R t Bitor( RG Rh ( ( s* /usr/lib/python2.6/compiler/transformer.pyRT s c C s | i t | S( N( R t Bitxor( RG Rh ( ( s* /usr/lib/python2.6/compiler/transformer.pyt xor_expr s c C s | i t | S( N( R t Bitand( RG Rh ( ( s* /usr/lib/python2.6/compiler/transformer.pyt and_expr s c C s | i | d } x t d t | d D] } | i | | } | | d d t i j o$ t | | g d | d d } q, | | d d t i j o$ t | | g d | d d } q, t d | | d d q, W| S( Ni i i R( s unexpected token: %s( Rm R R* R5 t LEFTSHIFTt LeftShiftR t
RightShiftR ( RG Rh R_ Rj t right( ( s* /usr/lib/python2.6/compiler/transformer.pyt
shift_expr s $ $ c C s | i | d } x t d t | d D] } | i | | } | | d d t i j o$ t | | g d | d d } q, | | d d t i j o$ t | | g d | d d } q, t d | | d d q, W| S( Ni i i R( s unexpected token: %s( Rm R R* R5 t PLUSt Addt MINUSt SubR ( RG Rh R_ Rj R ( ( s* /usr/lib/python2.6/compiler/transformer.pyt
arith_expr s $ $ c C s | i | d } x t d t | d D] } | i | | } | | d d } | t i j o t | | g } n | t i j o t | | g } nZ | t i j o t | | g } n4 | t i
j o t | | g } n t d | | d d | _
q, W| S( Ni i i s unexpected token: %s( Rm R R* R5 R t Mult SLASHt Divt PERCENTt Modt DOUBLESLASHt FloorDivR R( ( RG Rh R_ Rj R t t( ( s* /usr/lib/python2.6/compiler/transformer.pyt term s
c C s | d } | d } | i | d | d d } | t i j o t | d | d S| t i j o t | d | d S| t i j o t | d | d } n | S( Ni ii R( i ( R R5 R t UnaryAddR t UnarySubt TILDEt Invert( RG Rh t eltR R_ ( ( s* /usr/lib/python2.6/compiler/transformer.pyt factor s
!c C s | i | d } xy t d t | D]b } | | } | d t i j o, t | | i | | d g d | d S| i | | } q) W| S( Ni i R( i ( Rm R R* R5 t
DOUBLESTARt Powert com_apply_trailer( RG Rh R_ Rj R ( ( s* /usr/lib/python2.6/compiler/transformer.pyt power s
c C s | i | d d | S( Ni ( RE ( RG Rh ( ( s* /usr/lib/python2.6/compiler/transformer.pyt atom s c C sB | d d t i j o t d d | d d S| i | d S( Ni i R( i ( ( R5 R R Rm ( RG Rh ( ( s* /usr/lib/python2.6/compiler/transformer.pyR7 s c C sB | d d t i j o t d d | d d S| i | d S( Ni i R( i ( ( R5 t RSQBt Listt com_list_constructor( RG Rh ( ( s* /usr/lib/python2.6/compiler/transformer.pyR9 s c C sB | d d t i j o t d d | d d S| i | d S( Ni i R( i ( ( R5 t RBRACEt Dictt
com_dictmaker( RG Rh ( ( s* /usr/lib/python2.6/compiler/transformer.pyR; s c C s t | i | d S( Ni ( t BackquoteRm ( RG Rh ( ( s* /usr/lib/python2.6/compiler/transformer.pyR= s c C s, t | d d } t | d | d d S( Ni i R( i ( R R ( RG Rh t k( ( s* /usr/lib/python2.6/compiler/transformer.pyR? s c C s_ | i oG | i d j o t | d i | i } n t d | i | f St | Sd S( Ns utf-8s
iso-8859-1s # coding: %s
%s( s utf-8s
iso-8859-1( RF t unicodet encodeR ( RG t lit( ( s* /usr/lib/python2.6/compiler/transformer.pyt decode_literal s
c C sF d } x% | D] } | | i | d 7} q
Wt | d | d d S( NRU i R( i i ( R) R ( RG Rh R% R_ ( ( s* /usr/lib/python2.6/compiler/transformer.pyRA s
c C s t | d d d | d d S( Ni i R( i ( t Name( RG Rh ( ( s* /usr/lib/python2.6/compiler/transformer.pyRC s c C s | i | d S( Ni ( R/ ( RG R_ ( ( s* /usr/lib/python2.6/compiler/transformer.pyR s c C s | i | d | d S( Ni i ( R/ ( RG R_ ( ( s* /usr/lib/python2.6/compiler/transformer.pyRm s c G s t t d S( N( R R R ( RG R, ( ( s* /usr/lib/python2.6/compiler/transformer.pyR4 % s c C s g } g } d } d } x| t | j o| | } | d t i j p | d t i j o | d t i j oO | | d } | d t i j o) | i | d | t B} | d } q n | t | j o\ | | d } | t i j o | | d } n t d | | i | d | t B} n Pn | i | i | | d } | t | j oD | | d t i
j o, | i | i | | d | d } n t | o
t d n | d } q W| | | f S( Ni i i s unexpected token: %si s- non-default argument follows default argument(
R* R5 R R RD R R R R t com_fpdefR Rm t SyntaxError( RG Rh R R R Rj R_ R ( ( s* /usr/lib/python2.6/compiler/transformer.pyR~ + s>
(
+
c C s6 | d d t i j o | i | d S| d d S( Ni i i ( R5 R8 t
com_fplist( RG R_ ( ( s* /usr/lib/python2.6/compiler/transformer.pyR+ ] s c C sr t | d j o | i | d Sg } x: t d t | d D] } | i | i | | qD Wt | S( Ni i ( R* R+ R R R ( RG R_ RL Rj ( ( s* /usr/lib/python2.6/compiler/transformer.pyR- c s c C s_ d } xN | D]F } t | t d j o' | d d j o | | d d } q
q
W| d S( NRU i i R i( ( R ( RG R_ RI R` ( ( s* /usr/lib/python2.6/compiler/transformer.pyR l s *c C s | d t i j p t | d } | i | d d } t | d j o | d f S| d d d j p t | d d t i j p t | | d d f S( Ni i t asi ( R0 t dotted_as_nameRn R R* R R5 RD ( RG R_ t dot( ( s* /usr/lib/python2.6/compiler/transformer.pyt com_dotted_as_namet s
c C s| | d t i j p t | d } | i | d g } x: t d t | d D] } | i | i | | qT W| S( Ni i i ( R0 t dotted_as_namesRn R1 R R* R ( RG R_ R Rj ( ( s* /usr/lib/python2.6/compiler/transformer.pyR ~ s
c C s | d t i j p t | d } | d d t i j p t t | d j o | d d d f S| d d d j p
t | | d d t i j p t | d d | d d f S( Ni i R. i ( R0 t import_as_nameRn R5 RD R* R ( RG R_ ( ( s* /usr/lib/python2.6/compiler/transformer.pyt com_import_as_name s
c C s| | d t i j p t | d } | i | d g } x: t d t | d D] } | i | i | | qT W| S( Ni i i ( R0 t import_as_namesRn R4 R R* R ( RG R_ R Rj ( ( s* /usr/lib/python2.6/compiler/transformer.pyR s
c C sG g } x: t d t | d D] } | i | i | | q W| S( Ni i ( R R* R Rm ( RG R_ R Rj ( ( s* /usr/lib/python2.6/compiler/transformer.pyR s
c
C s | d d t i j o6 t | i | d | i | d d | d d Sg } d } d } x@t d t | d D]&} | | } | d t i j o t | d j oJ | i | d } t | d j o | i | d t
} qd } n d } } | i | | | i | | d f n | d t i j o\ | d d j o | i | | d } q| d d j o | i | | d } qqy qy Wt | i | d | | d | d d } | o t | | d | d d S| Sd S(
Ni i i i R( i i R t finally(
R5 RD t
TryFinallyRm R R R* R0 t
except_clauseR R R t TryExcept(
RG Rh t clausesR t finallyNodeRj R_ R R t
try_except( ( s* /usr/lib/python2.6/compiler/transformer.pyR s8
+# c C s | i | d } | i | d } | d d t i j o
d } n | i | d d t } t | | | d | d d S( Ni ii i R( ( Rm R5 R R R R t With( RG Rh RT t bodyt var( ( s* /usr/lib/python2.6/compiler/transformer.pyR s
c C s | i | d S( Ni ( Rm ( RG Rh ( ( s* /usr/lib/python2.6/compiler/transformer.pyR s c C s# | d t i j p t | d S( Ni i ( R0 t augassignRn ( RG R_ ( ( s* /usr/lib/python2.6/compiler/transformer.pyR s c C sG | i | } | i t t t t f j o | St d | i i d S( s Return node suitable for lvalue of augmented assignment
Names, slices, and attributes are the only allowable nodes.
s can't assign to %sN( Rm t __class__R* t Slicet SubscriptRp R, R ( RG R_ R" ( ( s* /usr/lib/python2.6/compiler/transformer.pyR s c C sp xi| d } | t i t i t i t i f j o2 t | d j o | i | | S| d } q | t j o. t | d j o
t d n | d } q | t i j o | d d t i
j o
t d n t | d j o | i | d } x^ t d t | d D]C } | | } | d t
i j o
t d n | i | | } qW| i | | d | S| d } q | t i
j o | d d } | t
i j o/ | d } | d t
i j o
t d qXqi| t
i j o< | d } | d t
i j o
t d n | i | | S| t
i j o | i | d | St d q t d | q d S(
Ni i i s can't assign to operatoris can't assign to ()s can't assign to []s can't assign to literals bad assignment (%s)( R0 t exprlistR t
testlist_safeR R* t com_assign_tuplet
_assign_typesR, R R Rm R R5 R R t com_assign_trailerR8 R R: R t com_assign_listRD t com_assign_name( RG R_ t assigningR t primaryRj t ch( ( s* /usr/lib/python2.6/compiler/transformer.pyR sN
%
c C s\ g } x= t d t | d D]# } | i | i | | | q Wt | d t | S( Ni i R( ( R R* R R t AssTupleR% ( RG R_ RK t assignsRj ( ( s* /usr/lib/python2.6/compiler/transformer.pyRF s
!c C s g } x t d t | d D] } | d t | j o[ | | d d t i j o
t d n | | d d t i j p t | | d n | i | i | | | q Wt
| d t | S( Ni i i s" can't assign to list comprehensionR( ( R R* R0 t list_forR, R5 R Rn R R t AssListR% ( RG R_ RK RO Rj ( ( s* /usr/lib/python2.6/compiler/transformer.pyRI s
2!c C s t | d | d | d S( Ni R( i ( t AssName( RG R_ RK ( ( s* /usr/lib/python2.6/compiler/transformer.pyRJ s c C s | d d } | t i j o | i | | d | S| t i j o | i | | d | S| t i j o
t d n t d | d S( Ni i i s can't assign to function calls unknown trailer type: %s( R5 Ro t com_assign_attrR: t com_subscriptlistR8 R, ( RG RL R_ RK R ( ( s* /usr/lib/python2.6/compiler/transformer.pyRH " s
c C s t | | d | d | d S( Ni R( i( t AssAttr( RG RL R_ RK ( ( s* /usr/lib/python2.6/compiler/transformer.pyRS , s c C s t | } | d j o" | d } | i | | d Sg } xD t d | d D]0 } | | } | i | i | | d qT W| | d t | S( s= Compile 'NODE (OP NODE)*' into (type, [ node1, ..., nodeN ]).i i i R( ( R* R R R R% ( RG t constructorRh R" R` R2 Rj ( ( s* /usr/lib/python2.6/compiler/transformer.pyR / s
$c C sO | i | | d } | d j p t t | t o | St | g S( Ni ( R R Rn R$ Rg ( RG R_ R ( ( s* /usr/lib/python2.6/compiler/transformer.pyRa ; s
c C sb | i | | d } | d j p t t | t o | i | i n | i | d S( Ni ( R R Rn R$ Rg t extendR! R ( RG Rk R_ R ( ( s* /usr/lib/python2.6/compiler/transformer.pyRe B s
RP c C s g } x t d t | D] } | | d t i j o7 t | | d j p t | i | d | | S| | d t i j o q n | i | i | | q Wt
| d | d i S( Ni i R( ( R R* R0 RP Rn t com_list_comprehensionR5 R R Rm R R( ( RG Rh t valuesRj ( ( s* /usr/lib/python2.6/compiler/transformer.pyR K s
c C so | d d } g } xE| o=| d d } | d j o | i | d t } | i | d } t | | g } | d d | _ | i | t | d j o
d } qW| i | d } q | d j oq | i | d } t | d | d d }
| i
i |
t | d j o
d } qW| i | d } q t d | | f q Wt | | d | S(
Ni i t fori i R R( i s, unexpected list comprehension element: %s %d(
R R Rm t ListCompForR( R R* R t
com_list_itert
ListCompIft ifsR, t ListComp( RG RT R_ R( t forsR R R t newforR t newif( ( s* /usr/lib/python2.6/compiler/transformer.pyRX X s2
c C s# | d t i j p t | d S( Ni i ( R0 t list_iterRn ( RG R_ ( ( s* /usr/lib/python2.6/compiler/transformer.pyR\ { s c C sZ g } x: t d t | d D] } | i | i | | q Wt | d | d i S( Ni i R( i ( R R* R Rm R R( ( RG Rh RY Rj ( ( s* /usr/lib/python2.6/compiler/transformer.pyR s
R c C s | d d } g } xB| o:| d d } | d j o | i | d t } | i | d } t | | g d | d d } | i | t | d j o
d } qT| i | d } q | d j oq | i | d } t | d | d d }
| i i |
t | d j o
d } qT| i | d } q t
d | | f q Wt | d
_ t
t | | d | S( Ni i RZ i R( i R i s. unexpected generator expression element: %s %di ( R R Rm t
GenExprForR R* R t com_gen_itert GenExprIfR^ R, t Truet
is_outmostt GenExprt GenExprInner( RG RT R_ R( R` R R t genNodeRa R Rb ( ( s* /usr/lib/python2.6/compiler/transformer.pyR s4
c C s# | d t i j p t | d S( Ni i ( R0 t gen_iterRn ( RG R_ ( ( s* /usr/lib/python2.6/compiler/transformer.pyRe s c C su g } xQ t d t | d D]7 } | i | i | | | i | | d f q Wt | d | d d i S( Ni i i R( i ( R R* R Rm R" R( ( RG Rh R2 Rj ( ( s* /usr/lib/python2.6/compiler/transformer.pyR# s c C s | d d } | t i j o | i | | d S| t i j o | i | | d S| t i j o | i | | d t St d | d S( Ni i i s unknown node type: %s( R5 R8 Ru Ro t com_select_memberR: RT R R, ( RG t primaryNodeRh R ( ( s* /usr/lib/python2.6/compiler/transformer.pyR s c C s< | d t i j o
t d n t | | d d | d S( Ni s member must be a namei R( i ( R5 RD R, Rp ( RG Rn Rh ( ( s* /usr/lib/python2.6/compiler/transformer.pyRm s
c C s | d t i j o t | g d t | Sg } d } d } } t | } d } xO| | j oA| | } | d t i j oB | d j o
t d n | i | | d } | d } qY nW | d t i j oB | d j o
t d n | i | | d } | d } qY n | i
| | | \ } }
| d j oH t |
t o8 t | d j o% | d d t
i j o
t d n | i |
| d } qY Wt | | | | d t | S( Ni R( i s$ already have the varargs indentifieri s# already have the kwargs indentifieri s& generator expression needs parenthesis( R5 R t CallFuncR% R R* R R, Rm R t com_argumentR$ Ri R0 R R ( RG Rn Rh R, t kwt star_nodet
dstar_nodet len_nodelistRj R_ R ( ( s* /usr/lib/python2.6/compiler/transformer.pyRu s<
+
c C sR t | d j oF | d d t i j o. | i | d } d | i | | d f St | d j o@ | o
t d n | o
t d n d | i | d f S| i | d } | d } x6 t | d j o" | d t i j o | d } q W| d t i j o t d | d n t | d | d | d } d | f S( Ni i i i s! non-keyword arg after keyword args+ only named arguments may follow *expressions# keyword can't be an expression (%s)R( ( R* R0 R Rm R R, R5 RD t Keyword( RG Rh Rq Rr R R R` R_ ( ( s* /usr/lib/python2.6/compiler/transformer.pyRp s$ +
' c C s t | d j o} | d } | d d t i j p+ t | d j o- | d d t i j o, | d d t i j o | i | | | Sn g } x: t d t | d D] } | i | i | | q Wt | | | d t
| S( Ni i i iR( ( R* R5 R R0 R t com_sliceR R t
com_subscriptRC R% ( RG RL Rh RK t subt
subscriptsRj ( ( s* /usr/lib/python2.6/compiler/transformer.pyRT s
+ c C s | d } | d } | t i j o | d d t i j o t S| t i j p t | d j o | i | S| i | S( Ni i i ( R5 Ro t EllipsisR R* t com_sliceobjRm ( RG R_ RM R ( ( s* /usr/lib/python2.6/compiler/transformer.pyRw s
(#c C sE g } | d d t i j o | i t d d } n! | i | i | d d } | t | j o@ | | d t i j o( | i | i | | | d } n | i t d xk t | t | D]T } | | } t | d j o | i t d q | i | i | d q Wt
| d t | S( Ni i i i R( ( R5 R R R R Rm R* R0 R R t SliceobjR% ( RG R_ R2 Rj t jRM ( ( s* /usr/lib/python2.6/compiler/transformer.pyR{ s"
+
c C s d } } t | d j oF | d d t i j o | i | d } q | i | d } n> t | d j o* | i | d } | i | d } n t | | | | d t | S( Ni i i i i R( ( R R* R5 R Rm RB R% ( RG RL R_ RK t lowert upper( ( s* /usr/lib/python2.6/compiler/transformer.pyRv @ s
c
C s | d j o | d } | d } n | t i j o] t | d j o | i | d Sx0 | D]( } | d t i j o | i | Sqa Wd S| t i j o8 x0 | D]( } | d t i j o | i | Sq Wd S| t i j oM | d d t i j o0 d } x" | D] } | t
| d } qW| Sd S| t i j p | t i j p | t i j o | i | d S| t
j o% t | d j o | i | d Sd S( Ni i RU ( R R0 RR R* Rc R RZ R R5 RB R R t
small_stmtt
_doc_nodes( RG R_ R` Rx t sR ( ( s* /usr/lib/python2.6/compiler/transformer.pyRc N s>
N( R R t __doc__RJ RQ R R RW RO RY RZ R[ Rr Rw Rz R| R] R\ t old_lambdefR^ R R t flow_stmtt
compound_stmtR R R} R R Rt R R R R R R R R R R R R R R R R R R R R R R R R R R RR R RE t testlist1RD R R R t old_testR R R RT R R R R R R R R R7 R9 R; R= R? R) RA RC R Rm R4 R~ R+ R- R R1 R R4 R R R R R R R R RF RI RJ RH RS R Ra Re R R0 R RX R\ R Re R# R Rm Ru Rp RT Rw R{ Rv R Rc ( ( ( s* /usr/lib/python2.6/compiler/transformer.pyR ^ s
!
!
2
)
,
#
"
'
$ t s ==s <=s >=s !=R R c C s| g } xo | D]g } t | t o | i t i | | q
t | t o | i | q
| i t | q
W| S( N( R$ t intR t _namest getR+ t
debug_tree( RP R" R ( ( s* /usr/lib/python2.6/compiler/transformer.pyR s (S R t compiler.astRM R0 R5 t
StandardErrorR t compiler.constsR R R R R R R
R R% R. R R R RE R R R R R RT R R R R R R R R t LESSt GREATERt EQEQUALR t LESSEQUALt GREATEREQUALt NOTEQUALR R] R^ R R R R R R R R R R R R R R R R R R R R R RR RD R t _legal_node_typesR R R R RG R R1 R2 R% t vt tok_nameR ( ( ( s* /usr/lib/python2.6/compiler/transformer.pyt s
PK [[l l pyassem.pycnu W+A
YMc @ s d Z d d k Z d d k Z d d k Z d d k l Z d d k l Z l Z l Z l
Z
d f d YZ d Z d f d YZ
d
Z d Z d Z d
Z d e f d YZ d Z d f d YZ d Z d Z d f d YZ d f d YZ e i Z d S( s/ A flow graph representation for Python bytecodeiN( t misc( t CO_OPTIMIZEDt CO_NEWLOCALSt
CO_VARARGSt CO_VARKEYWORDSt FlowGraphc B s e Z d Z d Z d d Z d Z d Z d Z d Z d Z
d Z d Z d
Z
d Z d Z d
Z d Z d Z RS( c C s[ t | _ | _ t d | _ t i | _ | i i | i | i i | i d S( Nt exit( t Blockt currentt entryR R t Sett blockst add( t self( ( s& /usr/lib/python2.6/compiler/pyassem.pyt __init__ s
c C sg | i oP | i o7 d Gt | i GHd G| i i GHd G| i i GHn t | GHn | | _ d S( Nt ends nexts ( t _debugR t reprt nextt get_children( R
t block( ( s& /usr/lib/python2.6/compiler/pyassem.pyt
startBlock s
c C s> | d j o | i } n | i i | | i | d S( N( t Nonet newBlockR t addNextR ( R
R ( ( s& /usr/lib/python2.6/compiler/pyassem.pyt nextBlock s
c C s t } | i i | | S( N( R R R ( R
t b( ( s& /usr/lib/python2.6/compiler/pyassem.pyR 5 s c C s | i | i d S( N( R R ( R
( ( s& /usr/lib/python2.6/compiler/pyassem.pyt startExitBlock: s i c C s
d | _ d S( Ni ( R ( R
( ( s& /usr/lib/python2.6/compiler/pyassem.pyt
_enable_debug? s c C s
d | _ d S( Ni ( R ( R
( ( s& /usr/lib/python2.6/compiler/pyassem.pyt _disable_debugB s c G s | i o
d G| GHn | d d j o | i i | i n t | d j o, t | d t o | i i | d n | i i | d S( Ns i t RETURN_VALUEt YIELD_VALUEi i ( R R ( R R t
addOutEdgeR t lent
isinstanceR t emit( R
t inst( ( s& /usr/lib/python2.6/compiler/pyassem.pyR# E s
'c C s xL | i i D]; } | | i j o q n | i p | i | i q q Wt | i h } | i | i | | i | i | j o | i | i n | S( sl Return the blocks in reverse postorder
i.e. each node appears before all of its successors
(
R t elementsR R R t
dfs_postorderR t reverset
fixupOrdert append( R
R t order( ( s& /usr/lib/python2.6/compiler/pyassem.pyt getBlocksInOrderN s
c C s$ | i | | | i | | d S( s" Fixup bad order introduced by DFS.N( t fixupOrderHonorNextt fixupOrderForward( R
R t default_next( ( s& /usr/lib/python2.6/compiler/pyassem.pyR( c s c C s h } x( t t | D] } | | | |
3
c
C s h } g } g } x` | D]X } t | | | <| i | | i o+ | i d | j o | i | g } q q W| i | x3g } x t t | D] } | | } x | D] } x | i D] }
| |
| j os d } xA | i D]6 } | d d j o | d |
j o
d } q%q q W| p q n | i | |
| f q q Wq Wq W| p Pn | d \ }
} | |
j p t | | }
| i |
| i |
|
q | 2x, | D]$ }
x |
D] } | i | qWqWd S( s( Make sure all JUMP_FORWARDs jump forwardi t JUMP_FORWARDi N( R! R) R R/ R t instsR0 t removet insert( R
R R. R2 t chainsR5 R t constraintsR3 R8 t ct forward_pR$ t goes_beforet a_chain( ( s& /usr/lib/python2.6/compiler/pyassem.pyR- sV
'
c C s
| i i S( N( R R% ( R
( ( s& /usr/lib/python2.6/compiler/pyassem.pyt getBlocks s c C s | i S( s/ Return nodes appropriate for use with dominator( R ( R
( ( s& /usr/lib/python2.6/compiler/pyassem.pyt getRoot s c C s4 g } x' | i D] } | i | i q W| S( N( RD t extendt getContainedGraphs( R
R8 R ( ( s& /usr/lib/python2.6/compiler/pyassem.pyRG s
N( t __name__t
__module__R R R R R R R R R R# R+ R( R, R- RD RE RG ( ( ( s& /usr/lib/python2.6/compiler/pyassem.pyR s ) . c C s_ g } | | | s
( RN RP ( R
( ( s& /usr/lib/python2.6/compiler/pyassem.pyt __repr__ s
c C s2 t t | i } d | i | i d i | f S( Ns s
( t mapt strR; RN RP t join( R
R; ( ( s& /usr/lib/python2.6/compiler/pyassem.pyt __str__ s c C sG | d } | d d j o | i i | d n | i i | d S( Ni i t JUMPi ( RM R R; R) ( R
R$ t op( ( s& /usr/lib/python2.6/compiler/pyassem.pyR# s
c C s | i S( N( R; ( R
( ( s& /usr/lib/python2.6/compiler/pyassem.pyt getInstructions s c C s | i i | d S( N( RL R ( R
R ( ( s& /usr/lib/python2.6/compiler/pyassem.pyt addInEdge s c C s | i i | d S( N( RM R ( R
R ( ( s& /usr/lib/python2.6/compiler/pyassem.pyR s c C s@ | i i | t | i d j p t t t | i d S( Ni ( R R) R! R0 RR RS ( R
R ( ( s& /usr/lib/python2.6/compiler/pyassem.pyR s R t
RAISE_VARARGSR t
JUMP_ABSOLUTER: t
CONTINUE_LOOPc C sU y | i d \ } } Wn t t f j
o d SX| | i j o
g | _ n d S( sL Remove bogus edge for unconditional transfers
Each block has a next edge that accounts for implicit control
transfers, e.g. from a JUMP_IF_FALSE to the block that will be
executed if the test is true.
These edges must remain for the current assembler code to
work. If they are removed, the dfs_postorder gets things in
weird orders. However, they shouldn't be there for other
purposes, e.g. conversion to SSA form. This method will
remove the next edge when it follows an unconditional control
transfer.
iN( R; t
IndexErrort
ValueErrort _uncond_transferR ( R
RW t arg( ( s& /usr/lib/python2.6/compiler/pyassem.pyt pruneNext s c C sP | i o2 | i d | i j o | i i | i d n | i i | i S( Ni ( R RM R< R% ( R
( ( s& /usr/lib/python2.6/compiler/pyassem.pyR s !c C sf g } xY | i D]N } t | d j o q n | d } t | d o | i | i q q W| S( s Return all graphs contained within this block.
For example, a MAKE_FUNCTION block will contain a reference to
the graph for the function body.
i t graph( R; R! t hasattrR) Rb ( R
t containedR$ RW ( ( s& /usr/lib/python2.6/compiler/pyassem.pyRG " s
( s RETURN_VALUERZ s YIELD_VALUER[ s JUMP_FORWARDR\ ( RH RI RO R RQ RU R# RX RY R R R_ Ra R RG ( ( ( s& /usr/lib/python2.6/compiler/pyassem.pyR s t RAWt FLATt CONVt DONEt PyFlowGraphc B sI e Z e i Z d d d d Z d Z d Z d Z d Z d Z
d Z d d Z d Z
d
Z e i Z x% e i D] Z e i e i e q We i Z x% e i D] Z e i e i e q Wd Z d Z d
Z h Z d Z d Z e Z e Z d Z d Z e Z! e Z" e Z# e Z$ e Z% e Z& e Z' e Z( e Z) e Z* d Z+ e+ Z, e+ Z- d Z. e/ e i0 Z1 d Z2 xF e3 i4 D]5 \ Z5 Z6 e5 d d j o e5 d Z e6 e e | i D]3 } t | t o | i } n | i | q Wt | S( s Return a tuple for the const slot of the code object
Must convert references to code (MAKE_FUNCTION) to code
objects recursively.
( Rs R" Ri R R) R ( R
R8 R7 ( ( s& /usr/lib/python2.6/compiler/pyassem.pyR ] s
( N(> RH RI R R Rj R R R R R R R R R R R R
R t disR3 R R R R R R R R R t _convert_STORE_FASTt _convert_DELETE_FASTR R t _convert_STORE_NAMEt _convert_DELETE_NAMEt _convert_IMPORT_NAMEt _convert_IMPORT_FROMt _convert_STORE_ATTRt _convert_LOAD_ATTRt _convert_DELETE_ATTRt _convert_LOAD_GLOBALt _convert_STORE_GLOBALt _convert_DELETE_GLOBALR t _convert_LOAD_DEREFt _convert_STORE_DEREFR Rx t cmp_opR R t localst itemsRk t objR R R/ R! t numR R ( ( ( s& /usr/lib/python2.6/compiler/pyassem.pyRi 9 sv !
c C s | d d j o d Sd S( Ni RV i ( ( R ( ( s& /usr/lib/python2.6/compiler/pyassem.pyt isJumpj s Rz c B s) e Z d Z d Z d Z d Z RS( s: Helper for marking func defs with nested tuples in arglistc C s | | _ | | _ d S( N( t countRt ( R
R Rt ( ( s& /usr/lib/python2.6/compiler/pyassem.pyR p s c C s d | i | i f S( Ns TupleArg(%s, %s)( R Rt ( R
( ( s& /usr/lib/python2.6/compiler/pyassem.pyRQ s s c C s d | i S( Ns .%d( R ( R
( ( s& /usr/lib/python2.6/compiler/pyassem.pyR{ u s ( RH RI t __doc__R RQ R{ ( ( ( s& /usr/lib/python2.6/compiler/pyassem.pyRz n s c C sb t | } | oK xH | D]< } t | t o& t t i | i } | | } q q Wn | S( N( R! R" Rz R t flattenRt ( Rn Rp R` t numNames( ( s& /usr/lib/python2.6/compiler/pyassem.pyRo x s c C s$ t | t p t t | d S( s/ Convert an int argument into high and low bytesi ( R" t intR0 t divmod( t val( ( s& /usr/lib/python2.6/compiler/pyassem.pyR s R c B s; e Z d Z d Z d Z d Z d Z d Z RS( s( lnotab
This class builds the lnotab, which is documented in compile.c.
Here's a brief recap:
For each SET_LINENO instruction after the first one, two bytes are
added to lnotab. (In some cases, multiple two-byte entries are
added.) The first byte is the distance in bytes between the
instruction for the last SET_LINENO and the current SET_LINENO.
The second byte is offset in line numbers. If either offset is
greater than 255, multiple two-byte entries are added -- see
compile.c for the delicate details.
c C s: g | _ d | _ d | _ d | _ d | _ g | _ d S( Ni ( t codet
codeOffsetR t lastlinet lastoffR ( R
( ( s& /usr/lib/python2.6/compiler/pyassem.pyR s c G sA x$ | D] } | i i t | q W| i t | | _ d S( N( R R) t chrR R! ( R
Rn R` ( ( s& /usr/lib/python2.6/compiler/pyassem.pyR s c C s | i d j o | | _ | | _ n | i | i } | | i } | d j o | i i } x0 | d j o" | d | d | d 8} q_ Wx6 | d j o( | | | d | d 8} d } q W| d j p
| d j o | | | | n | | _ | i | _ n d S( Ni i ( R R R R R R) ( R
t linenot addrt linet push( ( s& /usr/lib/python2.6/compiler/pyassem.pyR s.
c C s d i | i S( NRK ( RT R ( R
( ( s& /usr/lib/python2.6/compiler/pyassem.pyR s c C s d i t t | i S( NRK ( RT RR R R ( R
( ( s& /usr/lib/python2.6/compiler/pyassem.pyR s ( RH RI R R R R R R ( ( ( s& /usr/lib/python2.6/compiler/pyassem.pyR s
t StackDepthTrackerc B s e Z d d Z h$ d d 6d d 6d d 6d d 6d d 6d d
6d d 6d d 6d d
6d d 6d d 6d d 6d d 6d d 6d d 6d d 6d d 6d d 6d d 6d d 6d d 6d d 6d d 6d d 6d d 6d d 6d d 6d d! 6d d" 6d d# 6d d$ 6d d% 6d& d' 6d& d( 6d d) 6d d* 6Z d8 d9 g Z d- Z d. Z d/ Z d0 Z d1 Z d2 Z
d3 Z d4 Z d5 Z
d6 Z d7 Z RS(: i c C s# d } d } x| D]} | d } | o | Gn | i i | d } | d j o | | } n xC | i D]8 \ } } | t | | j o | } | | } Pql ql W| d j o; t | | d }
|
d j o | |
| d } q n | | j o
| } n | o
| G| GHq q W| S( Ni i ( t effectR R t patternsR! t getattr( R
R; t debugR t maxDepthR3 R t deltat patt pat_deltat meth( ( s& /usr/lib/python2.6/compiler/pyassem.pyR s2
it POP_TOPi t DUP_TOPit LIST_APPENDs SLICE+1s SLICE+2s SLICE+3s
STORE_SLICE+0s
STORE_SLICE+1s
STORE_SLICE+2is
STORE_SLICE+3s DELETE_SLICE+0s DELETE_SLICE+1s DELETE_SLICE+2s DELETE_SLICE+3t STORE_SUBSCRt
DELETE_SUBSCRt
PRINT_ITEMR R t EXEC_STMTt BUILD_CLASSt
STORE_NAMEt
STORE_ATTRt DELETE_ATTRt STORE_GLOBALt BUILD_MAPt
COMPARE_OPt
STORE_FASTt IMPORT_STARt IMPORT_NAMEt IMPORT_FROMt LOAD_ATTRi t SETUP_EXCEPTt
SETUP_FINALLYt FOR_ITERt WITH_CLEANUPt BINARY_t LOAD_c C s | d S( Ni ( ( R
R ( ( s& /usr/lib/python2.6/compiler/pyassem.pyt UNPACK_SEQUENCE s c C s | d S( Ni ( ( R
R ( ( s& /usr/lib/python2.6/compiler/pyassem.pyt BUILD_TUPLE s c C s | d S( Ni ( ( R
R ( ( s& /usr/lib/python2.6/compiler/pyassem.pyt
BUILD_LIST s c C s" t | d \ } } | | d S( Ni i ( R ( R
t argcR R ( ( s& /usr/lib/python2.6/compiler/pyassem.pyt
CALL_FUNCTION s c C s | i | d S( Ni ( R ( R
R ( ( s& /usr/lib/python2.6/compiler/pyassem.pyt CALL_FUNCTION_VAR s c C s | i | d S( Ni ( R ( R
R ( ( s& /usr/lib/python2.6/compiler/pyassem.pyt CALL_FUNCTION_KW! s c C s | i | d S( Ni ( R ( R
R ( ( s& /usr/lib/python2.6/compiler/pyassem.pyt CALL_FUNCTION_VAR_KW# s c C s | S( N( ( R
R ( ( s& /usr/lib/python2.6/compiler/pyassem.pyt
MAKE_FUNCTION% s c C s | S( N( ( R
R ( ( s& /usr/lib/python2.6/compiler/pyassem.pyt MAKE_CLOSURE' s c C s( | d j o d S| d j o d Sd S( Ni ii i( ( R
R ( ( s& /usr/lib/python2.6/compiler/pyassem.pyt BUILD_SLICE* s
c C s | S( N( ( R
R ( ( s& /usr/lib/python2.6/compiler/pyassem.pyt DUP_TOPX/ s ( R i( R
i ( RH RI R R R R R R
R R R R R R R R ( ( ( s& /usr/lib/python2.6/compiler/pyassem.pyR sf
( R R R R t compilerR t compiler.constsR R R R R R& R Re Rf Rg Rh Ri R Rz Ro R R R R ( ( ( s& /usr/lib/python2.6/compiler/pyassem.pyt s* " Y 2
BjPK [[Ln&$ misc.pynu W+A
def flatten(tup):
elts = []
for elt in tup:
if isinstance(elt, tuple):
elts = elts + flatten(elt)
else:
elts.append(elt)
return elts
class Set:
def __init__(self):
self.elts = {}
def __len__(self):
return len(self.elts)
def __contains__(self, elt):
return elt in self.elts
def add(self, elt):
self.elts[elt] = elt
def elements(self):
return self.elts.keys()
def has_elt(self, elt):
return elt in self.elts
def remove(self, elt):
del self.elts[elt]
def copy(self):
c = Set()
c.elts.update(self.elts)
return c
class Stack:
def __init__(self):
self.stack = []
self.pop = self.stack.pop
def __len__(self):
return len(self.stack)
def push(self, elt):
self.stack.append(elt)
def top(self):
return self.stack[-1]
def __getitem__(self, index): # needed by visitContinue()
return self.stack[index]
MANGLE_LEN = 256 # magic constant from compile.c
def mangle(name, klass):
if not name.startswith('__'):
return name
if len(name) + 2 >= MANGLE_LEN:
return name
if name.endswith('__'):
return name
try:
i = 0
while klass[i] == '_':
i = i + 1
except IndexError:
return name
klass = klass[i:]
tlen = len(klass) + len(name)
if tlen > MANGLE_LEN:
klass = klass[:MANGLE_LEN-tlen]
return "_%s%s" % (klass, name)
def set_filename(filename, tree):
"""Set the filename attribute to filename on every node in tree"""
worklist = [tree]
while worklist:
node = worklist.pop(0)
node.filename = filename
worklist.extend(node.getChildNodes())
PK [[XB __init__.pycnu W+A
YMc @ si d Z d d k l Z e d d d [ d d k l Z l Z d d k l Z d d k l Z l
Z
d S(
s Package for parsing and compiling Python source code
There are several functions defined at the top level that are imported
from modules contained in the package.
parse(buf, mode="exec") -> AST
Converts a string containing Python source code to an abstract
syntax tree (AST). The AST is defined in compiler.ast.
parseFile(path) -> AST
The same as parse(open(path))
walk(ast, visitor, verbose=None)
Does a pre-order walk over the ast using the visitor instance.
See compiler.visitor for details.
compile(source, filename, mode, flags=None, dont_inherit=None)
Returns a code object. A replacement for the builtin compile() function.
compileFile(filename)
Generates a .pyc file by compiling filename.
i( t warnpy3ks3 the compiler package has been removed in Python 3.0t
stackleveli ( t parset parseFile( t walk( t compilet compileFileN( t __doc__t warningsR t compiler.transformerR R t compiler.visitorR t compiler.pycodegenR R ( ( ( s' /usr/lib/python2.6/compiler/__init__.pyt s PK [[G8ou transformer.pynu W+A """Parse tree transformation module.
Transforms Python source code into an abstract syntax tree (AST)
defined in the ast module.
The simplest ways to invoke this module are via parse and parseFile.
parse(buf) -> AST
parseFile(path) -> AST
"""
# Original version written by Greg Stein (gstein@lyra.org)
# and Bill Tutt (rassilon@lima.mudlib.org)
# February 1997.
#
# Modifications and improvements for Python 2.0 by Jeremy Hylton and
# Mark Hammond
#
# Some fixes to try to have correct line number on almost all nodes
# (except Module, Discard and Stmt) added by Sylvain Thenault
#
# Portions of this file are:
# Copyright (C) 1997-1998 Greg Stein. All Rights Reserved.
#
# This module is provided under a BSD-ish license. See
# http://www.opensource.org/licenses/bsd-license.html
# and replace OWNER, ORGANIZATION, and YEAR as appropriate.
from compiler.ast import *
import parser
import symbol
import token
class WalkerError(StandardError):
pass
from compiler.consts import CO_VARARGS, CO_VARKEYWORDS
from compiler.consts import OP_ASSIGN, OP_DELETE, OP_APPLY
def parseFile(path):
f = open(path, "U")
# XXX The parser API tolerates files without a trailing newline,
# but not strings without a trailing newline. Always add an extra
# newline to the file contents, since we're going through the string
# version of the API.
src = f.read() + "\n"
f.close()
return parse(src)
def parse(buf, mode="exec"):
if mode == "exec" or mode == "single":
return Transformer().parsesuite(buf)
elif mode == "eval":
return Transformer().parseexpr(buf)
else:
raise ValueError("compile() arg 3 must be"
" 'exec' or 'eval' or 'single'")
def asList(nodes):
l = []
for item in nodes:
if hasattr(item, "asList"):
l.append(item.asList())
else:
if type(item) is type( (None, None) ):
l.append(tuple(asList(item)))
elif type(item) is type( [] ):
l.append(asList(item))
else:
l.append(item)
return l
def extractLineNo(ast):
if not isinstance(ast[1], tuple):
# get a terminal node
return ast[2]
for child in ast[1:]:
if isinstance(child, tuple):
lineno = extractLineNo(child)
if lineno is not None:
return lineno
def Node(*args):
kind = args[0]
if kind in nodes:
try:
return nodes[kind](*args[1:])
except TypeError:
print nodes[kind], len(args), args
raise
else:
raise WalkerError, "Can't find appropriate Node type: %s" % str(args)
#return apply(ast.Node, args)
class Transformer:
"""Utility object for transforming Python parse trees.
Exposes the following methods:
tree = transform(ast_tree)
tree = parsesuite(text)
tree = parseexpr(text)
tree = parsefile(fileob | filename)
"""
def __init__(self):
self._dispatch = {}
for value, name in symbol.sym_name.items():
if hasattr(self, name):
self._dispatch[value] = getattr(self, name)
self._dispatch[token.NEWLINE] = self.com_NEWLINE
self._atom_dispatch = {token.LPAR: self.atom_lpar,
token.LSQB: self.atom_lsqb,
token.LBRACE: self.atom_lbrace,
token.BACKQUOTE: self.atom_backquote,
token.NUMBER: self.atom_number,
token.STRING: self.atom_string,
token.NAME: self.atom_name,
}
self.encoding = None
def transform(self, tree):
"""Transform an AST into a modified parse tree."""
if not (isinstance(tree, tuple) or isinstance(tree, list)):
tree = parser.st2tuple(tree, line_info=1)
return self.compile_node(tree)
def parsesuite(self, text):
"""Return a modified parse tree for the given suite text."""
return self.transform(parser.suite(text))
def parseexpr(self, text):
"""Return a modified parse tree for the given expression text."""
return self.transform(parser.expr(text))
def parsefile(self, file):
"""Return a modified parse tree for the contents of the given file."""
if type(file) == type(''):
file = open(file)
return self.parsesuite(file.read())
# --------------------------------------------------------------
#
# PRIVATE METHODS
#
def compile_node(self, node):
### emit a line-number node?
n = node[0]
if n == symbol.encoding_decl:
self.encoding = node[2]
node = node[1]
n = node[0]
if n == symbol.single_input:
return self.single_input(node[1:])
if n == symbol.file_input:
return self.file_input(node[1:])
if n == symbol.eval_input:
return self.eval_input(node[1:])
if n == symbol.lambdef:
return self.lambdef(node[1:])
if n == symbol.funcdef:
return self.funcdef(node[1:])
if n == symbol.classdef:
return self.classdef(node[1:])
raise WalkerError, ('unexpected node type', n)
def single_input(self, node):
### do we want to do anything about being "interactive" ?
# NEWLINE | simple_stmt | compound_stmt NEWLINE
n = node[0][0]
if n != token.NEWLINE:
return self.com_stmt(node[0])
return Pass()
def file_input(self, nodelist):
doc = self.get_docstring(nodelist, symbol.file_input)
if doc is not None:
i = 1
else:
i = 0
stmts = []
for node in nodelist[i:]:
if node[0] != token.ENDMARKER and node[0] != token.NEWLINE:
self.com_append_stmt(stmts, node)
return Module(doc, Stmt(stmts))
def eval_input(self, nodelist):
# from the built-in function input()
### is this sufficient?
return Expression(self.com_node(nodelist[0]))
def decorator_name(self, nodelist):
listlen = len(nodelist)
assert listlen >= 1 and listlen % 2 == 1
item = self.atom_name(nodelist)
i = 1
while i < listlen:
assert nodelist[i][0] == token.DOT
assert nodelist[i + 1][0] == token.NAME
item = Getattr(item, nodelist[i + 1][1])
i += 2
return item
def decorator(self, nodelist):
# '@' dotted_name [ '(' [arglist] ')' ]
assert len(nodelist) in (3, 5, 6)
assert nodelist[0][0] == token.AT
assert nodelist[-1][0] == token.NEWLINE
assert nodelist[1][0] == symbol.dotted_name
funcname = self.decorator_name(nodelist[1][1:])
if len(nodelist) > 3:
assert nodelist[2][0] == token.LPAR
expr = self.com_call_function(funcname, nodelist[3])
else:
expr = funcname
return expr
def decorators(self, nodelist):
# decorators: decorator ([NEWLINE] decorator)* NEWLINE
items = []
for dec_nodelist in nodelist:
assert dec_nodelist[0] == symbol.decorator
items.append(self.decorator(dec_nodelist[1:]))
return Decorators(items)
def decorated(self, nodelist):
assert nodelist[0][0] == symbol.decorators
if nodelist[1][0] == symbol.funcdef:
n = [nodelist[0]] + list(nodelist[1][1:])
return self.funcdef(n)
elif nodelist[1][0] == symbol.classdef:
decorators = self.decorators(nodelist[0][1:])
cls = self.classdef(nodelist[1][1:])
cls.decorators = decorators
return cls
raise WalkerError()
def funcdef(self, nodelist):
# -6 -5 -4 -3 -2 -1
# funcdef: [decorators] 'def' NAME parameters ':' suite
# parameters: '(' [varargslist] ')'
if len(nodelist) == 6:
assert nodelist[0][0] == symbol.decorators
decorators = self.decorators(nodelist[0][1:])
else:
assert len(nodelist) == 5
decorators = None
lineno = nodelist[-4][2]
name = nodelist[-4][1]
args = nodelist[-3][2]
if args[0] == symbol.varargslist:
names, defaults, flags = self.com_arglist(args[1:])
else:
names = defaults = ()
flags = 0
doc = self.get_docstring(nodelist[-1])
# code for function
code = self.com_node(nodelist[-1])
if doc is not None:
assert isinstance(code, Stmt)
assert isinstance(code.nodes[0], Discard)
del code.nodes[0]
return Function(decorators, name, names, defaults, flags, doc, code,
lineno=lineno)
def lambdef(self, nodelist):
# lambdef: 'lambda' [varargslist] ':' test
if nodelist[2][0] == symbol.varargslist:
names, defaults, flags = self.com_arglist(nodelist[2][1:])
else:
names = defaults = ()
flags = 0
# code for lambda
code = self.com_node(nodelist[-1])
return Lambda(names, defaults, flags, code, lineno=nodelist[1][2])
old_lambdef = lambdef
def classdef(self, nodelist):
# classdef: 'class' NAME ['(' [testlist] ')'] ':' suite
name = nodelist[1][1]
doc = self.get_docstring(nodelist[-1])
if nodelist[2][0] == token.COLON:
bases = []
elif nodelist[3][0] == token.RPAR:
bases = []
else:
bases = self.com_bases(nodelist[3])
# code for class
code = self.com_node(nodelist[-1])
if doc is not None:
assert isinstance(code, Stmt)
assert isinstance(code.nodes[0], Discard)
del code.nodes[0]
return Class(name, bases, doc, code, lineno=nodelist[1][2])
def stmt(self, nodelist):
return self.com_stmt(nodelist[0])
small_stmt = stmt
flow_stmt = stmt
compound_stmt = stmt
def simple_stmt(self, nodelist):
# small_stmt (';' small_stmt)* [';'] NEWLINE
stmts = []
for i in range(0, len(nodelist), 2):
self.com_append_stmt(stmts, nodelist[i])
return Stmt(stmts)
def parameters(self, nodelist):
raise WalkerError
def varargslist(self, nodelist):
raise WalkerError
def fpdef(self, nodelist):
raise WalkerError
def fplist(self, nodelist):
raise WalkerError
def dotted_name(self, nodelist):
raise WalkerError
def comp_op(self, nodelist):
raise WalkerError
def trailer(self, nodelist):
raise WalkerError
def sliceop(self, nodelist):
raise WalkerError
def argument(self, nodelist):
raise WalkerError
# --------------------------------------------------------------
#
# STATEMENT NODES (invoked by com_node())
#
def expr_stmt(self, nodelist):
# augassign testlist | testlist ('=' testlist)*
en = nodelist[-1]
exprNode = self.lookup_node(en)(en[1:])
if len(nodelist) == 1:
return Discard(exprNode, lineno=exprNode.lineno)
if nodelist[1][0] == token.EQUAL:
nodesl = []
for i in range(0, len(nodelist) - 2, 2):
nodesl.append(self.com_assign(nodelist[i], OP_ASSIGN))
return Assign(nodesl, exprNode, lineno=nodelist[1][2])
else:
lval = self.com_augassign(nodelist[0])
op = self.com_augassign_op(nodelist[1])
return AugAssign(lval, op[1], exprNode, lineno=op[2])
raise WalkerError, "can't get here"
def print_stmt(self, nodelist):
# print ([ test (',' test)* [','] ] | '>>' test [ (',' test)+ [','] ])
items = []
if len(nodelist) == 1:
start = 1
dest = None
elif nodelist[1][0] == token.RIGHTSHIFT:
assert len(nodelist) == 3 \
or nodelist[3][0] == token.COMMA
dest = self.com_node(nodelist[2])
start = 4
else:
dest = None
start = 1
for i in range(start, len(nodelist), 2):
items.append(self.com_node(nodelist[i]))
if nodelist[-1][0] == token.COMMA:
return Print(items, dest, lineno=nodelist[0][2])
return Printnl(items, dest, lineno=nodelist[0][2])
def del_stmt(self, nodelist):
return self.com_assign(nodelist[1], OP_DELETE)
def pass_stmt(self, nodelist):
return Pass(lineno=nodelist[0][2])
def break_stmt(self, nodelist):
return Break(lineno=nodelist[0][2])
def continue_stmt(self, nodelist):
return Continue(lineno=nodelist[0][2])
def return_stmt(self, nodelist):
# return: [testlist]
if len(nodelist) < 2:
return Return(Const(None), lineno=nodelist[0][2])
return Return(self.com_node(nodelist[1]), lineno=nodelist[0][2])
def yield_stmt(self, nodelist):
expr = self.com_node(nodelist[0])
return Discard(expr, lineno=expr.lineno)
def yield_expr(self, nodelist):
if len(nodelist) > 1:
value = self.com_node(nodelist[1])
else:
value = Const(None)
return Yield(value, lineno=nodelist[0][2])
def raise_stmt(self, nodelist):
# raise: [test [',' test [',' test]]]
if len(nodelist) > 5:
expr3 = self.com_node(nodelist[5])
else:
expr3 = None
if len(nodelist) > 3:
expr2 = self.com_node(nodelist[3])
else:
expr2 = None
if len(nodelist) > 1:
expr1 = self.com_node(nodelist[1])
else:
expr1 = None
return Raise(expr1, expr2, expr3, lineno=nodelist[0][2])
def import_stmt(self, nodelist):
# import_stmt: import_name | import_from
assert len(nodelist) == 1
return self.com_node(nodelist[0])
def import_name(self, nodelist):
# import_name: 'import' dotted_as_names
return Import(self.com_dotted_as_names(nodelist[1]),
lineno=nodelist[0][2])
def import_from(self, nodelist):
# import_from: 'from' ('.'* dotted_name | '.') 'import' ('*' |
# '(' import_as_names ')' | import_as_names)
assert nodelist[0][1] == 'from'
idx = 1
while nodelist[idx][1] == '.':
idx += 1
level = idx - 1
if nodelist[idx][0] == symbol.dotted_name:
fromname = self.com_dotted_name(nodelist[idx])
idx += 1
else:
fromname = ""
assert nodelist[idx][1] == 'import'
if nodelist[idx + 1][0] == token.STAR:
return From(fromname, [('*', None)], level,
lineno=nodelist[0][2])
else:
node = nodelist[idx + 1 + (nodelist[idx + 1][0] == token.LPAR)]
return From(fromname, self.com_import_as_names(node), level,
lineno=nodelist[0][2])
def global_stmt(self, nodelist):
# global: NAME (',' NAME)*
names = []
for i in range(1, len(nodelist), 2):
names.append(nodelist[i][1])
return Global(names, lineno=nodelist[0][2])
def exec_stmt(self, nodelist):
# exec_stmt: 'exec' expr ['in' expr [',' expr]]
expr1 = self.com_node(nodelist[1])
if len(nodelist) >= 4:
expr2 = self.com_node(nodelist[3])
if len(nodelist) >= 6:
expr3 = self.com_node(nodelist[5])
else:
expr3 = None
else:
expr2 = expr3 = None
return Exec(expr1, expr2, expr3, lineno=nodelist[0][2])
def assert_stmt(self, nodelist):
# 'assert': test, [',' test]
expr1 = self.com_node(nodelist[1])
if (len(nodelist) == 4):
expr2 = self.com_node(nodelist[3])
else:
expr2 = None
return Assert(expr1, expr2, lineno=nodelist[0][2])
def if_stmt(self, nodelist):
# if: test ':' suite ('elif' test ':' suite)* ['else' ':' suite]
tests = []
for i in range(0, len(nodelist) - 3, 4):
testNode = self.com_node(nodelist[i + 1])
suiteNode = self.com_node(nodelist[i + 3])
tests.append((testNode, suiteNode))
if len(nodelist) % 4 == 3:
elseNode = self.com_node(nodelist[-1])
## elseNode.lineno = nodelist[-1][1][2]
else:
elseNode = None
return If(tests, elseNode, lineno=nodelist[0][2])
def while_stmt(self, nodelist):
# 'while' test ':' suite ['else' ':' suite]
testNode = self.com_node(nodelist[1])
bodyNode = self.com_node(nodelist[3])
if len(nodelist) > 4:
elseNode = self.com_node(nodelist[6])
else:
elseNode = None
return While(testNode, bodyNode, elseNode, lineno=nodelist[0][2])
def for_stmt(self, nodelist):
# 'for' exprlist 'in' exprlist ':' suite ['else' ':' suite]
assignNode = self.com_assign(nodelist[1], OP_ASSIGN)
listNode = self.com_node(nodelist[3])
bodyNode = self.com_node(nodelist[5])
if len(nodelist) > 8:
elseNode = self.com_node(nodelist[8])
else:
elseNode = None
return For(assignNode, listNode, bodyNode, elseNode,
lineno=nodelist[0][2])
def try_stmt(self, nodelist):
return self.com_try_except_finally(nodelist)
def with_stmt(self, nodelist):
return self.com_with(nodelist)
def with_var(self, nodelist):
return self.com_with_var(nodelist)
def suite(self, nodelist):
# simple_stmt | NEWLINE INDENT NEWLINE* (stmt NEWLINE*)+ DEDENT
if len(nodelist) == 1:
return self.com_stmt(nodelist[0])
stmts = []
for node in nodelist:
if node[0] == symbol.stmt:
self.com_append_stmt(stmts, node)
return Stmt(stmts)
# --------------------------------------------------------------
#
# EXPRESSION NODES (invoked by com_node())
#
def testlist(self, nodelist):
# testlist: expr (',' expr)* [',']
# testlist_safe: test [(',' test)+ [',']]
# exprlist: expr (',' expr)* [',']
return self.com_binary(Tuple, nodelist)
testlist_safe = testlist # XXX
testlist1 = testlist
exprlist = testlist
def testlist_gexp(self, nodelist):
if len(nodelist) == 2 and nodelist[1][0] == symbol.gen_for:
test = self.com_node(nodelist[0])
return self.com_generator_expression(test, nodelist[1])
return self.testlist(nodelist)
def test(self, nodelist):
# or_test ['if' or_test 'else' test] | lambdef
if len(nodelist) == 1 and nodelist[0][0] == symbol.lambdef:
return self.lambdef(nodelist[0])
then = self.com_node(nodelist[0])
if len(nodelist) > 1:
assert len(nodelist) == 5
assert nodelist[1][1] == 'if'
assert nodelist[3][1] == 'else'
test = self.com_node(nodelist[2])
else_ = self.com_node(nodelist[4])
return IfExp(test, then, else_, lineno=nodelist[1][2])
return then
def or_test(self, nodelist):
# and_test ('or' and_test)* | lambdef
if len(nodelist) == 1 and nodelist[0][0] == symbol.lambdef:
return self.lambdef(nodelist[0])
return self.com_binary(Or, nodelist)
old_test = or_test
def and_test(self, nodelist):
# not_test ('and' not_test)*
return self.com_binary(And, nodelist)
def not_test(self, nodelist):
# 'not' not_test | comparison
result = self.com_node(nodelist[-1])
if len(nodelist) == 2:
return Not(result, lineno=nodelist[0][2])
return result
def comparison(self, nodelist):
# comparison: expr (comp_op expr)*
node = self.com_node(nodelist[0])
if len(nodelist) == 1:
return node
results = []
for i in range(2, len(nodelist), 2):
nl = nodelist[i-1]
# comp_op: '<' | '>' | '=' | '>=' | '<=' | '<>' | '!=' | '=='
# | 'in' | 'not' 'in' | 'is' | 'is' 'not'
n = nl[1]
if n[0] == token.NAME:
type = n[1]
if len(nl) == 3:
if type == 'not':
type = 'not in'
else:
type = 'is not'
else:
type = _cmp_types[n[0]]
lineno = nl[1][2]
results.append((type, self.com_node(nodelist[i])))
# we need a special "compare" node so that we can distinguish
# 3 < x < 5 from (3 < x) < 5
# the two have very different semantics and results (note that the
# latter form is always true)
return Compare(node, results, lineno=lineno)
def expr(self, nodelist):
# xor_expr ('|' xor_expr)*
return self.com_binary(Bitor, nodelist)
def xor_expr(self, nodelist):
# xor_expr ('^' xor_expr)*
return self.com_binary(Bitxor, nodelist)
def and_expr(self, nodelist):
# xor_expr ('&' xor_expr)*
return self.com_binary(Bitand, nodelist)
def shift_expr(self, nodelist):
# shift_expr ('<<'|'>>' shift_expr)*
node = self.com_node(nodelist[0])
for i in range(2, len(nodelist), 2):
right = self.com_node(nodelist[i])
if nodelist[i-1][0] == token.LEFTSHIFT:
node = LeftShift([node, right], lineno=nodelist[1][2])
elif nodelist[i-1][0] == token.RIGHTSHIFT:
node = RightShift([node, right], lineno=nodelist[1][2])
else:
raise ValueError, "unexpected token: %s" % nodelist[i-1][0]
return node
def arith_expr(self, nodelist):
node = self.com_node(nodelist[0])
for i in range(2, len(nodelist), 2):
right = self.com_node(nodelist[i])
if nodelist[i-1][0] == token.PLUS:
node = Add([node, right], lineno=nodelist[1][2])
elif nodelist[i-1][0] == token.MINUS:
node = Sub([node, right], lineno=nodelist[1][2])
else:
raise ValueError, "unexpected token: %s" % nodelist[i-1][0]
return node
def term(self, nodelist):
node = self.com_node(nodelist[0])
for i in range(2, len(nodelist), 2):
right = self.com_node(nodelist[i])
t = nodelist[i-1][0]
if t == token.STAR:
node = Mul([node, right])
elif t == token.SLASH:
node = Div([node, right])
elif t == token.PERCENT:
node = Mod([node, right])
elif t == token.DOUBLESLASH:
node = FloorDiv([node, right])
else:
raise ValueError, "unexpected token: %s" % t
node.lineno = nodelist[1][2]
return node
def factor(self, nodelist):
elt = nodelist[0]
t = elt[0]
node = self.lookup_node(nodelist[-1])(nodelist[-1][1:])
# need to handle (unary op)constant here...
if t == token.PLUS:
return UnaryAdd(node, lineno=elt[2])
elif t == token.MINUS:
return UnarySub(node, lineno=elt[2])
elif t == token.TILDE:
node = Invert(node, lineno=elt[2])
return node
def power(self, nodelist):
# power: atom trailer* ('**' factor)*
node = self.com_node(nodelist[0])
for i in range(1, len(nodelist)):
elt = nodelist[i]
if elt[0] == token.DOUBLESTAR:
return Power([node, self.com_node(nodelist[i+1])],
lineno=elt[2])
node = self.com_apply_trailer(node, elt)
return node
def atom(self, nodelist):
return self._atom_dispatch[nodelist[0][0]](nodelist)
def atom_lpar(self, nodelist):
if nodelist[1][0] == token.RPAR:
return Tuple((), lineno=nodelist[0][2])
return self.com_node(nodelist[1])
def atom_lsqb(self, nodelist):
if nodelist[1][0] == token.RSQB:
return List((), lineno=nodelist[0][2])
return self.com_list_constructor(nodelist[1])
def atom_lbrace(self, nodelist):
if nodelist[1][0] == token.RBRACE:
return Dict((), lineno=nodelist[0][2])
return self.com_dictmaker(nodelist[1])
def atom_backquote(self, nodelist):
return Backquote(self.com_node(nodelist[1]))
def atom_number(self, nodelist):
### need to verify this matches compile.c
k = eval(nodelist[0][1])
return Const(k, lineno=nodelist[0][2])
def decode_literal(self, lit):
if self.encoding:
# this is particularly fragile & a bit of a
# hack... changes in compile.c:parsestr and
# tokenizer.c must be reflected here.
if self.encoding not in ['utf-8', 'iso-8859-1']:
lit = unicode(lit, 'utf-8').encode(self.encoding)
return eval("# coding: %s\n%s" % (self.encoding, lit))
else:
return eval(lit)
def atom_string(self, nodelist):
k = ''
for node in nodelist:
k += self.decode_literal(node[1])
return Const(k, lineno=nodelist[0][2])
def atom_name(self, nodelist):
return Name(nodelist[0][1], lineno=nodelist[0][2])
# --------------------------------------------------------------
#
# INTERNAL PARSING UTILITIES
#
# The use of com_node() introduces a lot of extra stack frames,
# enough to cause a stack overflow compiling test.test_parser with
# the standard interpreter recursionlimit. The com_node() is a
# convenience function that hides the dispatch details, but comes
# at a very high cost. It is more efficient to dispatch directly
# in the callers. In these cases, use lookup_node() and call the
# dispatched node directly.
def lookup_node(self, node):
return self._dispatch[node[0]]
def com_node(self, node):
# Note: compile.c has handling in com_node for del_stmt, pass_stmt,
# break_stmt, stmt, small_stmt, flow_stmt, simple_stmt,
# and compound_stmt.
# We'll just dispatch them.
return self._dispatch[node[0]](node[1:])
def com_NEWLINE(self, *args):
# A ';' at the end of a line can make a NEWLINE token appear
# here, Render it harmless. (genc discards ('discard',
# ('const', xxxx)) Nodes)
return Discard(Const(None))
def com_arglist(self, nodelist):
# varargslist:
# (fpdef ['=' test] ',')* ('*' NAME [',' '**' NAME] | '**' NAME)
# | fpdef ['=' test] (',' fpdef ['=' test])* [',']
# fpdef: NAME | '(' fplist ')'
# fplist: fpdef (',' fpdef)* [',']
names = []
defaults = []
flags = 0
i = 0
while i < len(nodelist):
node = nodelist[i]
if node[0] == token.STAR or node[0] == token.DOUBLESTAR:
if node[0] == token.STAR:
node = nodelist[i+1]
if node[0] == token.NAME:
names.append(node[1])
flags = flags | CO_VARARGS
i = i + 3
if i < len(nodelist):
# should be DOUBLESTAR
t = nodelist[i][0]
if t == token.DOUBLESTAR:
node = nodelist[i+1]
else:
raise ValueError, "unexpected token: %s" % t
names.append(node[1])
flags = flags | CO_VARKEYWORDS
break
# fpdef: NAME | '(' fplist ')'
names.append(self.com_fpdef(node))
i = i + 1
if i < len(nodelist) and nodelist[i][0] == token.EQUAL:
defaults.append(self.com_node(nodelist[i + 1]))
i = i + 2
elif len(defaults):
# we have already seen an argument with default, but here
# came one without
raise SyntaxError, "non-default argument follows default argument"
# skip the comma
i = i + 1
return names, defaults, flags
def com_fpdef(self, node):
# fpdef: NAME | '(' fplist ')'
if node[1][0] == token.LPAR:
return self.com_fplist(node[2])
return node[1][1]
def com_fplist(self, node):
# fplist: fpdef (',' fpdef)* [',']
if len(node) == 2:
return self.com_fpdef(node[1])
list = []
for i in range(1, len(node), 2):
list.append(self.com_fpdef(node[i]))
return tuple(list)
def com_dotted_name(self, node):
# String together the dotted names and return the string
name = ""
for n in node:
if type(n) == type(()) and n[0] == 1:
name = name + n[1] + '.'
return name[:-1]
def com_dotted_as_name(self, node):
assert node[0] == symbol.dotted_as_name
node = node[1:]
dot = self.com_dotted_name(node[0][1:])
if len(node) == 1:
return dot, None
assert node[1][1] == 'as'
assert node[2][0] == token.NAME
return dot, node[2][1]
def com_dotted_as_names(self, node):
assert node[0] == symbol.dotted_as_names
node = node[1:]
names = [self.com_dotted_as_name(node[0])]
for i in range(2, len(node), 2):
names.append(self.com_dotted_as_name(node[i]))
return names
def com_import_as_name(self, node):
assert node[0] == symbol.import_as_name
node = node[1:]
assert node[0][0] == token.NAME
if len(node) == 1:
return node[0][1], None
assert node[1][1] == 'as', node
assert node[2][0] == token.NAME
return node[0][1], node[2][1]
def com_import_as_names(self, node):
assert node[0] == symbol.import_as_names
node = node[1:]
names = [self.com_import_as_name(node[0])]
for i in range(2, len(node), 2):
names.append(self.com_import_as_name(node[i]))
return names
def com_bases(self, node):
bases = []
for i in range(1, len(node), 2):
bases.append(self.com_node(node[i]))
return bases
def com_try_except_finally(self, nodelist):
# ('try' ':' suite
# ((except_clause ':' suite)+ ['else' ':' suite] ['finally' ':' suite]
# | 'finally' ':' suite))
if nodelist[3][0] == token.NAME:
# first clause is a finally clause: only try-finally
return TryFinally(self.com_node(nodelist[2]),
self.com_node(nodelist[5]),
lineno=nodelist[0][2])
#tryexcept: [TryNode, [except_clauses], elseNode)]
clauses = []
elseNode = None
finallyNode = None
for i in range(3, len(nodelist), 3):
node = nodelist[i]
if node[0] == symbol.except_clause:
# except_clause: 'except' [expr [(',' | 'as') expr]] */
if len(node) > 2:
expr1 = self.com_node(node[2])
if len(node) > 4:
expr2 = self.com_assign(node[4], OP_ASSIGN)
else:
expr2 = None
else:
expr1 = expr2 = None
clauses.append((expr1, expr2, self.com_node(nodelist[i+2])))
if node[0] == token.NAME:
if node[1] == 'else':
elseNode = self.com_node(nodelist[i+2])
elif node[1] == 'finally':
finallyNode = self.com_node(nodelist[i+2])
try_except = TryExcept(self.com_node(nodelist[2]), clauses, elseNode,
lineno=nodelist[0][2])
if finallyNode:
return TryFinally(try_except, finallyNode, lineno=nodelist[0][2])
else:
return try_except
def com_with(self, nodelist):
# with_stmt: 'with' expr [with_var] ':' suite
expr = self.com_node(nodelist[1])
body = self.com_node(nodelist[-1])
if nodelist[2][0] == token.COLON:
var = None
else:
var = self.com_assign(nodelist[2][2], OP_ASSIGN)
return With(expr, var, body, lineno=nodelist[0][2])
def com_with_var(self, nodelist):
# with_var: 'as' expr
return self.com_node(nodelist[1])
def com_augassign_op(self, node):
assert node[0] == symbol.augassign
return node[1]
def com_augassign(self, node):
"""Return node suitable for lvalue of augmented assignment
Names, slices, and attributes are the only allowable nodes.
"""
l = self.com_node(node)
if l.__class__ in (Name, Slice, Subscript, Getattr):
return l
raise SyntaxError, "can't assign to %s" % l.__class__.__name__
def com_assign(self, node, assigning):
# return a node suitable for use as an "lvalue"
# loop to avoid trivial recursion
while 1:
t = node[0]
if t in (symbol.exprlist, symbol.testlist, symbol.testlist_safe, symbol.testlist_gexp):
if len(node) > 2:
return self.com_assign_tuple(node, assigning)
node = node[1]
elif t in _assign_types:
if len(node) > 2:
raise SyntaxError, "can't assign to operator"
node = node[1]
elif t == symbol.power:
if node[1][0] != symbol.atom:
raise SyntaxError, "can't assign to operator"
if len(node) > 2:
primary = self.com_node(node[1])
for i in range(2, len(node)-1):
ch = node[i]
if ch[0] == token.DOUBLESTAR:
raise SyntaxError, "can't assign to operator"
primary = self.com_apply_trailer(primary, ch)
return self.com_assign_trailer(primary, node[-1],
assigning)
node = node[1]
elif t == symbol.atom:
t = node[1][0]
if t == token.LPAR:
node = node[2]
if node[0] == token.RPAR:
raise SyntaxError, "can't assign to ()"
elif t == token.LSQB:
node = node[2]
if node[0] == token.RSQB:
raise SyntaxError, "can't assign to []"
return self.com_assign_list(node, assigning)
elif t == token.NAME:
return self.com_assign_name(node[1], assigning)
else:
raise SyntaxError, "can't assign to literal"
else:
raise SyntaxError, "bad assignment (%s)" % t
def com_assign_tuple(self, node, assigning):
assigns = []
for i in range(1, len(node), 2):
assigns.append(self.com_assign(node[i], assigning))
return AssTuple(assigns, lineno=extractLineNo(node))
def com_assign_list(self, node, assigning):
assigns = []
for i in range(1, len(node), 2):
if i + 1 < len(node):
if node[i + 1][0] == symbol.list_for:
raise SyntaxError, "can't assign to list comprehension"
assert node[i + 1][0] == token.COMMA, node[i + 1]
assigns.append(self.com_assign(node[i], assigning))
return AssList(assigns, lineno=extractLineNo(node))
def com_assign_name(self, node, assigning):
return AssName(node[1], assigning, lineno=node[2])
def com_assign_trailer(self, primary, node, assigning):
t = node[1][0]
if t == token.DOT:
return self.com_assign_attr(primary, node[2], assigning)
if t == token.LSQB:
return self.com_subscriptlist(primary, node[2], assigning)
if t == token.LPAR:
raise SyntaxError, "can't assign to function call"
raise SyntaxError, "unknown trailer type: %s" % t
def com_assign_attr(self, primary, node, assigning):
return AssAttr(primary, node[1], assigning, lineno=node[-1])
def com_binary(self, constructor, nodelist):
"Compile 'NODE (OP NODE)*' into (type, [ node1, ..., nodeN ])."
l = len(nodelist)
if l == 1:
n = nodelist[0]
return self.lookup_node(n)(n[1:])
items = []
for i in range(0, l, 2):
n = nodelist[i]
items.append(self.lookup_node(n)(n[1:]))
return constructor(items, lineno=extractLineNo(nodelist))
def com_stmt(self, node):
result = self.lookup_node(node)(node[1:])
assert result is not None
if isinstance(result, Stmt):
return result
return Stmt([result])
def com_append_stmt(self, stmts, node):
result = self.lookup_node(node)(node[1:])
assert result is not None
if isinstance(result, Stmt):
stmts.extend(result.nodes)
else:
stmts.append(result)
if hasattr(symbol, 'list_for'):
def com_list_constructor(self, nodelist):
# listmaker: test ( list_for | (',' test)* [','] )
values = []
for i in range(1, len(nodelist)):
if nodelist[i][0] == symbol.list_for:
assert len(nodelist[i:]) == 1
return self.com_list_comprehension(values[0],
nodelist[i])
elif nodelist[i][0] == token.COMMA:
continue
values.append(self.com_node(nodelist[i]))
return List(values, lineno=values[0].lineno)
def com_list_comprehension(self, expr, node):
# list_iter: list_for | list_if
# list_for: 'for' exprlist 'in' testlist [list_iter]
# list_if: 'if' test [list_iter]
# XXX should raise SyntaxError for assignment
lineno = node[1][2]
fors = []
while node:
t = node[1][1]
if t == 'for':
assignNode = self.com_assign(node[2], OP_ASSIGN)
listNode = self.com_node(node[4])
newfor = ListCompFor(assignNode, listNode, [])
newfor.lineno = node[1][2]
fors.append(newfor)
if len(node) == 5:
node = None
else:
node = self.com_list_iter(node[5])
elif t == 'if':
test = self.com_node(node[2])
newif = ListCompIf(test, lineno=node[1][2])
newfor.ifs.append(newif)
if len(node) == 3:
node = None
else:
node = self.com_list_iter(node[3])
else:
raise SyntaxError, \
("unexpected list comprehension element: %s %d"
% (node, lineno))
return ListComp(expr, fors, lineno=lineno)
def com_list_iter(self, node):
assert node[0] == symbol.list_iter
return node[1]
else:
def com_list_constructor(self, nodelist):
values = []
for i in range(1, len(nodelist), 2):
values.append(self.com_node(nodelist[i]))
return List(values, lineno=values[0].lineno)
if hasattr(symbol, 'gen_for'):
def com_generator_expression(self, expr, node):
# gen_iter: gen_for | gen_if
# gen_for: 'for' exprlist 'in' test [gen_iter]
# gen_if: 'if' test [gen_iter]
lineno = node[1][2]
fors = []
while node:
t = node[1][1]
if t == 'for':
assignNode = self.com_assign(node[2], OP_ASSIGN)
genNode = self.com_node(node[4])
newfor = GenExprFor(assignNode, genNode, [],
lineno=node[1][2])
fors.append(newfor)
if (len(node)) == 5:
node = None
else:
node = self.com_gen_iter(node[5])
elif t == 'if':
test = self.com_node(node[2])
newif = GenExprIf(test, lineno=node[1][2])
newfor.ifs.append(newif)
if len(node) == 3:
node = None
else:
node = self.com_gen_iter(node[3])
else:
raise SyntaxError, \
("unexpected generator expression element: %s %d"
% (node, lineno))
fors[0].is_outmost = True
return GenExpr(GenExprInner(expr, fors), lineno=lineno)
def com_gen_iter(self, node):
assert node[0] == symbol.gen_iter
return node[1]
def com_dictmaker(self, nodelist):
# dictmaker: test ':' test (',' test ':' value)* [',']
items = []
for i in range(1, len(nodelist), 4):
items.append((self.com_node(nodelist[i]),
self.com_node(nodelist[i+2])))
return Dict(items, lineno=items[0][0].lineno)
def com_apply_trailer(self, primaryNode, nodelist):
t = nodelist[1][0]
if t == token.LPAR:
return self.com_call_function(primaryNode, nodelist[2])
if t == token.DOT:
return self.com_select_member(primaryNode, nodelist[2])
if t == token.LSQB:
return self.com_subscriptlist(primaryNode, nodelist[2], OP_APPLY)
raise SyntaxError, 'unknown node type: %s' % t
def com_select_member(self, primaryNode, nodelist):
if nodelist[0] != token.NAME:
raise SyntaxError, "member must be a name"
return Getattr(primaryNode, nodelist[1], lineno=nodelist[2])
def com_call_function(self, primaryNode, nodelist):
if nodelist[0] == token.RPAR:
return CallFunc(primaryNode, [], lineno=extractLineNo(nodelist))
args = []
kw = 0
star_node = dstar_node = None
len_nodelist = len(nodelist)
i = 1
while i < len_nodelist:
node = nodelist[i]
if node[0]==token.STAR:
if star_node is not None:
raise SyntaxError, 'already have the varargs indentifier'
star_node = self.com_node(nodelist[i+1])
i = i + 3
continue
elif node[0]==token.DOUBLESTAR:
if dstar_node is not None:
raise SyntaxError, 'already have the kwargs indentifier'
dstar_node = self.com_node(nodelist[i+1])
i = i + 3
continue
# positional or named parameters
kw, result = self.com_argument(node, kw, star_node)
if len_nodelist != 2 and isinstance(result, GenExpr) \
and len(node) == 3 and node[2][0] == symbol.gen_for:
# allow f(x for x in y), but reject f(x for x in y, 1)
# should use f((x for x in y), 1) instead of f(x for x in y, 1)
raise SyntaxError, 'generator expression needs parenthesis'
args.append(result)
i = i + 2
return CallFunc(primaryNode, args, star_node, dstar_node,
lineno=extractLineNo(nodelist))
def com_argument(self, nodelist, kw, star_node):
if len(nodelist) == 3 and nodelist[2][0] == symbol.gen_for:
test = self.com_node(nodelist[1])
return 0, self.com_generator_expression(test, nodelist[2])
if len(nodelist) == 2:
if kw:
raise SyntaxError, "non-keyword arg after keyword arg"
if star_node:
raise SyntaxError, "only named arguments may follow *expression"
return 0, self.com_node(nodelist[1])
result = self.com_node(nodelist[3])
n = nodelist[1]
while len(n) == 2 and n[0] != token.NAME:
n = n[1]
if n[0] != token.NAME:
raise SyntaxError, "keyword can't be an expression (%s)"%n[0]
node = Keyword(n[1], result, lineno=n[2])
return 1, node
def com_subscriptlist(self, primary, nodelist, assigning):
# slicing: simple_slicing | extended_slicing
# simple_slicing: primary "[" short_slice "]"
# extended_slicing: primary "[" slice_list "]"
# slice_list: slice_item ("," slice_item)* [","]
# backwards compat slice for '[i:j]'
if len(nodelist) == 2:
sub = nodelist[1]
if (sub[1][0] == token.COLON or \
(len(sub) > 2 and sub[2][0] == token.COLON)) and \
sub[-1][0] != symbol.sliceop:
return self.com_slice(primary, sub, assigning)
subscripts = []
for i in range(1, len(nodelist), 2):
subscripts.append(self.com_subscript(nodelist[i]))
return Subscript(primary, assigning, subscripts,
lineno=extractLineNo(nodelist))
def com_subscript(self, node):
# slice_item: expression | proper_slice | ellipsis
ch = node[1]
t = ch[0]
if t == token.DOT and node[2][0] == token.DOT:
return Ellipsis()
if t == token.COLON or len(node) > 2:
return self.com_sliceobj(node)
return self.com_node(ch)
def com_sliceobj(self, node):
# proper_slice: short_slice | long_slice
# short_slice: [lower_bound] ":" [upper_bound]
# long_slice: short_slice ":" [stride]
# lower_bound: expression
# upper_bound: expression
# stride: expression
#
# Note: a stride may be further slicing...
items = []
if node[1][0] == token.COLON:
items.append(Const(None))
i = 2
else:
items.append(self.com_node(node[1]))
# i == 2 is a COLON
i = 3
if i < len(node) and node[i][0] == symbol.test:
items.append(self.com_node(node[i]))
i = i + 1
else:
items.append(Const(None))
# a short_slice has been built. look for long_slice now by looking
# for strides...
for j in range(i, len(node)):
ch = node[j]
if len(ch) == 2:
items.append(Const(None))
else:
items.append(self.com_node(ch[2]))
return Sliceobj(items, lineno=extractLineNo(node))
def com_slice(self, primary, node, assigning):
# short_slice: [lower_bound] ":" [upper_bound]
lower = upper = None
if len(node) == 3:
if node[1][0] == token.COLON:
upper = self.com_node(node[2])
else:
lower = self.com_node(node[1])
elif len(node) == 4:
lower = self.com_node(node[1])
upper = self.com_node(node[3])
return Slice(primary, assigning, lower, upper,
lineno=extractLineNo(node))
def get_docstring(self, node, n=None):
if n is None:
n = node[0]
node = node[1:]
if n == symbol.suite:
if len(node) == 1:
return self.get_docstring(node[0])
for sub in node:
if sub[0] == symbol.stmt:
return self.get_docstring(sub)
return None
if n == symbol.file_input:
for sub in node:
if sub[0] == symbol.stmt:
return self.get_docstring(sub)
return None
if n == symbol.atom:
if node[0][0] == token.STRING:
s = ''
for t in node:
s = s + eval(t[1])
return s
return None
if n == symbol.stmt or n == symbol.simple_stmt \
or n == symbol.small_stmt:
return self.get_docstring(node[0])
if n in _doc_nodes and len(node) == 1:
return self.get_docstring(node[0])
return None
_doc_nodes = [
symbol.expr_stmt,
symbol.testlist,
symbol.testlist_safe,
symbol.test,
symbol.or_test,
symbol.and_test,
symbol.not_test,
symbol.comparison,
symbol.expr,
symbol.xor_expr,
symbol.and_expr,
symbol.shift_expr,
symbol.arith_expr,
symbol.term,
symbol.factor,
symbol.power,
]
# comp_op: '<' | '>' | '=' | '>=' | '<=' | '<>' | '!=' | '=='
# | 'in' | 'not' 'in' | 'is' | 'is' 'not'
_cmp_types = {
token.LESS : '<',
token.GREATER : '>',
token.EQEQUAL : '==',
token.EQUAL : '==',
token.LESSEQUAL : '<=',
token.GREATEREQUAL : '>=',
token.NOTEQUAL : '!=',
}
_legal_node_types = [
symbol.funcdef,
symbol.classdef,
symbol.stmt,
symbol.small_stmt,
symbol.flow_stmt,
symbol.simple_stmt,
symbol.compound_stmt,
symbol.expr_stmt,
symbol.print_stmt,
symbol.del_stmt,
symbol.pass_stmt,
symbol.break_stmt,
symbol.continue_stmt,
symbol.return_stmt,
symbol.raise_stmt,
symbol.import_stmt,
symbol.global_stmt,
symbol.exec_stmt,
symbol.assert_stmt,
symbol.if_stmt,
symbol.while_stmt,
symbol.for_stmt,
symbol.try_stmt,
symbol.with_stmt,
symbol.suite,
symbol.testlist,
symbol.testlist_safe,
symbol.test,
symbol.and_test,
symbol.not_test,
symbol.comparison,
symbol.exprlist,
symbol.expr,
symbol.xor_expr,
symbol.and_expr,
symbol.shift_expr,
symbol.arith_expr,
symbol.term,
symbol.factor,
symbol.power,
symbol.atom,
]
if hasattr(symbol, 'yield_stmt'):
_legal_node_types.append(symbol.yield_stmt)
if hasattr(symbol, 'yield_expr'):
_legal_node_types.append(symbol.yield_expr)
_assign_types = [
symbol.test,
symbol.or_test,
symbol.and_test,
symbol.not_test,
symbol.comparison,
symbol.expr,
symbol.xor_expr,
symbol.and_expr,
symbol.shift_expr,
symbol.arith_expr,
symbol.term,
symbol.factor,
]
_names = {}
for k, v in symbol.sym_name.items():
_names[k] = v
for k, v in token.tok_name.items():
_names[k] = v
def debug_tree(tree):
l = []
for elt in tree:
if isinstance(elt, int):
l.append(_names.get(elt, elt))
elif isinstance(elt, str):
l.append(elt)
else:
l.append(debug_tree(elt))
return l
PK [[KԪc c visitor.pycnu W+A
YMc @ s[ d d k l Z d d d YZ d e f d YZ e Z d d d Z d Z d S(
i( t astt
ASTVisitorc B s8 e Z d Z d Z d Z d Z d Z d Z RS( s Performs a depth-first walk of the AST
The ASTVisitor will walk the AST, performing either a preorder or
postorder traversal depending on which method is called.
methods:
preorder(tree, visitor)
postorder(tree, visitor)
tree: an instance of ast.Node
visitor: an instance with visitXXX methods
The ASTVisitor is responsible for walking over the tree in the
correct order. For each node, it checks the visitor argument for
a method named 'visitNodeType' where NodeType is the name of the
node's class, e.g. Class. If the method exists, it is called
with the node as its sole argument.
The visitor method for a particular node type can control how
child nodes are visited during a preorder walk. (It can't control
the order during a postorder walk, because it is called _after_
the walk has occurred.) The ASTVisitor modifies the visitor
argument by adding a visit method to the visitor; this method can
be used to visit a child node of arbitrary type.
i c C s d | _ h | _ d S( N( t Nonet nodet _cache( t self( ( s& /usr/lib/python2.6/compiler/visitor.pyt __init__" s c G s+ x$ | i D] } | i | | q
Wd S( N( t
getChildNodest dispatch( R R t argst child( ( s& /usr/lib/python2.6/compiler/visitor.pyt default& s
c G sw | | _ | i } | i i | d } | d j o6 | i } t | i d | | i } | | i | s
;#PK [[@
consts.pycnu W+A
YMc @ sv d Z d Z d Z d Z d Z d Z d Z d Z d Z d Z d Z
d Z d Z d
Z
d Z d Z d
Z d Z d Z d S( t OP_ASSIGNt OP_DELETEt OP_APPLYi i i i i i i i i i i @ i i N( R R R t SC_LOCALt SC_GLOBALt SC_FREEt SC_CELLt
SC_UNKNOWNt CO_OPTIMIZEDt CO_NEWLOCALSt
CO_VARARGSt CO_VARKEYWORDSt CO_NESTEDt CO_GENERATORt CO_GENERATOR_ALLOWEDt CO_FUTURE_DIVISIONt CO_FUTURE_ABSIMPORTt CO_FUTURE_WITH_STATEMENTt CO_FUTURE_PRINT_FUNCTION( ( ( s% /usr/lib/python2.6/compiler/consts.pyt s$ PK [[Z
pycodegen.pycnu W+A
YMc @ s d d k Z d d k Z d d k Z d d k Z d d k Z d d k l Z d d k l Z l Z l
Z
l Z d d k l Z l
Z
l Z l Z d d k l Z l Z l Z l Z d d k l Z l Z l Z l Z l Z l Z l Z l Z l Z d d k l Z y e i d Z! Wn e" j
o
d Z! n Xh d
d d f 6d d d f 6d d d f 6d
d d f 6Z# d Z$ d Z% d Z& d Z' d d Z( e) e) d Z* d f d YZ+ d e+ f d YZ, d e+ f d YZ- d e+ f d YZ. d f d YZ/ d Z0 d f d YZ1 d f d! YZ2 d" e2 e1 f d# YZ3 d$ e2 e1 f d% YZ4 d& e2 e1 f d' YZ5 d( f d) YZ6 d* e2 e6 e1 f d+ YZ7 d, e2 e6 e1 f d- YZ8 d. f d/ YZ9 d0 e2 e9 e1 f d1 YZ: d2 Z; d3 Z< d4 f d5 YZ= d6 f d7 YZ> d8 e> f d9 YZ? d: e> f d; YZ@ d< e> f d= YZA d> e> f d? YZB h e? e iC 6e@ e iD 6eA e iE 6eB e iF 6ZG d@ ZH eI dA j o& x e iJ d D] ZK e( eK qWn d S(B iN( t StringIO( t astt parset walkt syntax( t pyassemt misct futuret symbols( t SC_LOCALt SC_GLOBALt SC_FREEt SC_CELL( t
CO_VARARGSt CO_VARKEYWORDSt CO_NEWLOCALSt CO_NESTEDt CO_GENERATORt CO_FUTURE_DIVISIONt CO_FUTURE_ABSIMPORTt CO_FUTURE_WITH_STATEMENTt CO_FUTURE_PRINT_FUNCTION( t TupleArgi i t
CALL_FUNCTIONt CALL_FUNCTION_VARt CALL_FUNCTION_KWt CALL_FUNCTION_VAR_KWi i i c C s t | d } | i } | i t | | } y | i | Wn t j
o
n, Xt | d d } | i | | i d S( Nt Ut ct wb( t opent readt closet Modulet compilet SyntaxErrort dump( t filenamet displayt ft buft mod( ( s( /usr/lib/python2.6/compiler/pycodegen.pyt compileFile$ s
c C s | d j p
| d j o
t d n | d j o t | | } nM | d j o t | | } n- | d j o t | | } n
t d | i | i S( s* Replacement for builtin compile() functions not implemented yett singlet exect evals6 compile() 3rd arg must be 'exec' or 'eval' or 'single'N( t Nonet RuntimeErrort InteractiveR! t
Expressiont
ValueErrorR" t code( t sourceR% t modet flagst dont_inheritt gen( ( s( /usr/lib/python2.6/compiler/pycodegen.pyR" 2 s
t AbstractCompileModec B s2 e Z d Z d Z d Z d Z d Z RS( c C s | | _ | | _ d | _ d S( N( R4 R% R. R3 ( t selfR4 R% ( ( s( /usr/lib/python2.6/compiler/pycodegen.pyt __init__G s c C s9 t | i | i } t i | i | t i | | S( N( R R4 R5 R t set_filenameR% R t check( R: t tree( ( s( /usr/lib/python2.6/compiler/pycodegen.pyt _get_treeL s
c C s d S( N( ( R: ( ( s( /usr/lib/python2.6/compiler/pycodegen.pyR" R s c C s | i S( N( R3 ( R: ( ( s( /usr/lib/python2.6/compiler/pycodegen.pyt getCodeU s N( t __name__t
__module__R. R5 R; R? R" R@ ( ( ( s( /usr/lib/python2.6/compiler/pycodegen.pyR9 C s
R1 c B s e Z d Z d Z RS( R- c C s+ | i } t | } | i | _ d S( N( R? t ExpressionCodeGeneratorR@ R3 ( R: R> R8 ( ( s( /usr/lib/python2.6/compiler/pycodegen.pyR" \ s ( RA RB R5 R" ( ( ( s( /usr/lib/python2.6/compiler/pycodegen.pyR1 X s R0 c B s e Z d Z d Z RS( R+ c C s+ | i } t | } | i | _ d S( N( R? t InteractiveCodeGeneratorR@ R3 ( R: R> R8 ( ( s( /usr/lib/python2.6/compiler/pycodegen.pyR" e s ( RA RB R5 R" ( ( ( s( /usr/lib/python2.6/compiler/pycodegen.pyR0 a s R! c B s8 e Z d Z d d Z d Z e i Z d Z RS( R, i c C sP | i } t | } | o d d k } | i | GHn | i | _ d S( Ni( R? t ModuleCodeGeneratort pprintR@ R3 ( R: R& R> R8 RF ( ( s( /usr/lib/python2.6/compiler/pycodegen.pyR" n s c C s* | i | i t i | i | d S( N( t writet getPycHeadert marshalR$ R3 ( R: R' ( ( s( /usr/lib/python2.6/compiler/pycodegen.pyR$ v s c C s2 t i i | i } t i d | } | i | S( Ns | i i D]- } | i i | o | i i | q q W| i S( N( RV t elementsRU t has_eltt remove( R: t elt( ( s( /usr/lib/python2.6/compiler/pycodegen.pyt getLocals s
c C s d S( N( ( R: t node( ( s( /usr/lib/python2.6/compiler/pycodegen.pyt visitDict s c C s( x! | i D] } | i i | q
Wd S( N( RU RV RW ( R: R^ RX ( ( s( /usr/lib/python2.6/compiler/pycodegen.pyt visitGlobal s
c C s | i i | i d S( N( RU RW RX ( R: R^ ( ( s( /usr/lib/python2.6/compiler/pycodegen.pyt
visitFunction s c C s d S( N( ( R: R^ ( ( s( /usr/lib/python2.6/compiler/pycodegen.pyt visitLambda s c C s5 x. | i D]# \ } } | i i | p | q
Wd S( N( RU RW ( R: R^ RX t alias( ( s( /usr/lib/python2.6/compiler/pycodegen.pyt visitImport s
c C s5 x. | i D]# \ } } | i i | p | q
Wd S( N( RU RW ( R: R^ RX Rc ( ( s( /usr/lib/python2.6/compiler/pycodegen.pyt visitFrom s
c C s | i i | i d S( N( RU RW RX ( R: R^ ( ( s( /usr/lib/python2.6/compiler/pycodegen.pyt
visitClass s c C s | i i | i d S( N( RU RW RX ( R: R^ ( ( s( /usr/lib/python2.6/compiler/pycodegen.pyt visitAssName s ( (
RA RB t __doc__R; R] R_ R` Ra Rb Rd Re Rf Rg ( ( ( s( /usr/lib/python2.6/compiler/pycodegen.pyRS s c C s* t | t i o | i p d Sn d S( Ni i ( t
isinstanceR t Constt value( R^ ( ( s( /usr/lib/python2.6/compiler/pycodegen.pyt is_constant_false s
t
CodeGeneratorc B sB e Z d Z d Z d Z d Z d Z d Z d Z d Z
d Z d Z d Z
d Z d
Z d Z d Z d
Z d Z d Z e d Z e Z d Z d Z d Z d Z d Z d Z d d Z d Z d Z! d Z" d Z# d Z$ d Z% d Z& d Z' d Z( d Z) d Z* d Z+ d! Z, d" Z- d# Z. d$ Z/ d% Z0 d& Z1 d' Z2 d( Z3 d) Z4 d* Z5 d+ Z6 d, Z7 d Z8 d- Z9 d. Z: d/ Z; d0 Z< d1 Z= d2 Z> d3 Z? d4 Z@ d5 ZA d6 ZB d7 ZC d8 ZD d9 ZE d: ZF d; d< ZG eH d= j o eG ZI eG ZJ n d> ZI d? ZJ d@ ZK h dA dB 6dC dD 6dE dF 6dG dH 6dI dJ 6dK dL 6dM dN 6dO dP 6dQ dR 6dS dT 6dU dV 6dW dX 6ZL dY ZM dZ ZN d[ ZO d\ ZP d] ZQ d^ ZR d d_ ZS d` ZT da ZU db ZV d dc ZW d dd ZX de ZY df ZZ dg Z[ dh Z\ di Z] dj Z^ dk Z_ dl Z` dm Za dn Zb do Zc dp Zd dq Ze dr Zf ds Zg dt Zh du Zi dv Zj dw Zk dx Zl dy Zm dz Zn d{ Zo d| Zp d} Zq d~ Zr RS( s Defines basic code generator for Python bytecode
This class is an abstract base class. Concrete subclasses must
define an __init__() that defines self.graph and then calls the
__init__() defined in this class.
The concrete class must also define the class attributes
NameFinder, FunctionGen, and ClassGen. These attributes can be
defined in the initClass() method, which is a hook for
initializing these methods after all the classes have been
defined.
i c C s | i d j o | i d | i _ n | i t i | _ t i | _ d | _ | i
d | _ | i i
} x | D] } | d j o | i i t d | _ q | d j o | i i t q | d j o | i i t q | d j o | i i t q q Wd S( Ni t
BINARY_DIVIDEt divisiont BINARY_TRUE_DIVIDEt absolute_importt with_statementt print_function( t _CodeGenerator__initializedR. t initClasst __class__t
checkClassR t Stackt localst setupst last_linenot _setupGraphDelegationt _div_opt
get_modulet futurest grapht setFlagR R R R ( R: R t feature( ( s( /usr/lib/python2.6/compiler/pycodegen.pyR; s*
c C s d S( s) This method is called once for each classN( ( R: ( ( s( /usr/lib/python2.6/compiler/pycodegen.pyRu s c C s y` t | d p t t | d p t t | d p t t | d p t Wn. t j
o" } d | i i } t | n Xd S( s* Verify that class is constructed correctlyR t
NameFindert FunctionGent ClassGens Bad class construction for %sN( t hasattrt AssertionErrort getattrRv RA ( R: t msgt intro( ( s( /usr/lib/python2.6/compiler/pycodegen.pyRw s c C sO | i i | _ | i i | _ | i i | _ | i i | _ | i i | _ d S( N( R t emitt newBlockt
startBlockt nextBlockt setDocstring( R: ( ( s( /usr/lib/python2.6/compiler/pycodegen.pyR| s
c C s
| i i S( s Return a code object( R R@ ( R: ( ( s( /usr/lib/python2.6/compiler/pycodegen.pyR@ s c C s, | i d j o t i | | i S| Sd S( N( t
class_nameR. R t mangle( R: RX ( ( s( /usr/lib/python2.6/compiler/pycodegen.pyR s c C s t i } t | | | i S( N( R t
SymbolVisitorR t scopes( R: R> t s( ( s( /usr/lib/python2.6/compiler/pycodegen.pyt parseSymbols s
c C s
t d d S( Ns# should be implemented by subclasses( R/ ( R: ( ( s( /usr/lib/python2.6/compiler/pycodegen.pyR~ s c C s | i i i | S( N( Ry t topRZ ( R: RX ( ( s( /usr/lib/python2.6/compiler/pycodegen.pyt isLocalName s c C s | i d | d S( Nt STORE( t _nameOp( R: RX ( ( s( /usr/lib/python2.6/compiler/pycodegen.pyt storeName s c C s | i d | d S( Nt LOAD( R ( R: RX ( ( s( /usr/lib/python2.6/compiler/pycodegen.pyt loadName s c C s | i d | d S( Nt DELETE( R ( R: RX ( ( s( /usr/lib/python2.6/compiler/pycodegen.pyt delName s c C s | i | } | i i | } | t j o: | i p | i | d | q | i | d | n | t j o: | i p | i | d | q | i | d | nF | t j p
| t j o | i | d | n t d | | f d S( Nt _NAMEt _FASTt _GLOBALt _DEREFs unsupported scope for var %s: %d(
R t scopet
check_nameR t optimizedR R
R R R/ ( R: t prefixRX R ( ( s( /usr/lib/python2.6/compiler/pycodegen.pyR s
c C s: | i o | i | d | n | i | d | d S( s Emit name ops for names generated implicitly by for loops
The interpreter generates names that start with a period or
dollar sign. The symbol table ignores these names because
they aren't present in the program text.
R R N( R R ( R: R RX ( ( s( /usr/lib/python2.6/compiler/pycodegen.pyt _implicitNameOp( s
c C sX t | d d } | d j o5 | | i j p | o | i d | | | _ t St S( s Emit SET_LINENO if necessary.
The instruction is considered necessary if the node has a
lineno attribute and it is different than the last lineno
emitted.
Returns true if SET_LINENO was emitted.
There are no rules for when an AST node should have a lineno
attribute. The transformer and AST code need to be reviewed
and a consistent policy implemented and documented. Until
then, this method works around missing line numbers.
t linenot
SET_LINENON( R R. R{ R t Truet False( R: R^ t forceR ( ( s( /usr/lib/python2.6/compiler/pycodegen.pyt
set_lineno9 s c C s | i | | _ | i | | _ | i d d | i o$ | i d | i | i d n t | i | i d d } | i i
| i | i | i | i d d | i d d S( NR i t
LOAD_CONSTRh t verboset RETURN_VALUE( R R R R t docR R R^ R Ry t pushR] t visitR. ( R: R^ t lnf( ( s( /usr/lib/python2.6/compiler/pycodegen.pyt visitModuleW s
c C sP | i | | i | | _ | i | | _ | i | i | i d d S( NR ( R R R R R R^ R ( R: R^ ( ( s( /usr/lib/python2.6/compiler/pycodegen.pyt visitExpressiond s
c C sE | i | d d | i o | i | i n | i | i d S( Nt isLambdai ( t _visitFuncOrLambdaR R R RX ( R: R^ ( ( s( /usr/lib/python2.6/compiler/pycodegen.pyRa k s
c C s | i | d d d S( NR i ( R ( R: R^ ( ( s( /usr/lib/python2.6/compiler/pycodegen.pyRb q s c C s | oD | i o: x! | i i D] } | i | q Wt | i i } n d } | i | | i | | i | i } t | i | | i
| i | x | i D] } | i | q W| i
| t | i x$ t | D] } | i d d q Wd S( Ni R i ( t
decoratorst nodesR t lenR R R R~ R R3 t finishR t defaultst _makeClosuret rangeR ( R: R^ R t decoratort ndecoratorsR8 t defaultt i( ( s( /usr/lib/python2.6/compiler/pycodegen.pyR t s$
c C s | i | | i | i } t | i | | i | i | | i d | i x | i D] } | i
| qb W| i d t | i | i | d | i d d | i d | i
| i d S( NR t BUILD_TUPLEi R t BUILD_CLASS( R R R~ R R3 R R R RX t basesR R R R ( R: R^ R8 t base( ( s( /usr/lib/python2.6/compiler/pycodegen.pyRf s
c C s | i } t | i } x t | D] } | i | \ } } t | o q( n | i | | i | | i } | i d | | i | i d | i | | i d | | i | | i d q( W| i
o | i | i
n | i | d S( Nt
JUMP_IF_FALSEt POP_TOPt JUMP_FORWARD( R R t testsR Rl R R R R R t else_( R: R^ t endt numtestsR t testt suitet nextTest( ( s( /usr/lib/python2.6/compiler/pycodegen.pyt visitIf s(
c C s8 | i | | i } | i } | i } | i d | | i | | i i t | f | i | d t | i | i | i d | p | | i | i d | i | i
| i d | | i | | i d | i d | i i | i
o | i | i
n | i | d S( Nt
SETUP_LOOPR R R t
JUMP_ABSOLUTEt POP_BLOCK( R R R R Rz R t LOOPR R R t bodyR t popR ( R: R^ t loopR t after( ( s( /usr/lib/python2.6/compiler/pycodegen.pyt
visitWhile s*
c C s* | i } | i } | i } | i i t | f | i | | i d | | i | i | i d | i | | i | d d | i d | | i | i | i | i
| i d | | i | | i d | i i | i o | i | i n | i | d S( NR t GET_ITERR i t FOR_ITERR R (
R Rz R R R R R t listR t assignR R R ( R: R^ t startt anchorR ( ( s( /usr/lib/python2.6/compiler/pycodegen.pyt visitFor s(
c C sE | i p t d | i | i f n | i | | i d d S( Ns 'break' outside loop (%s, %d)t
BREAK_LOOP( Rz R# R% R R R ( R: R^ ( ( s( /usr/lib/python2.6/compiler/pycodegen.pyt
visitBreak s
c C sj | i p t d | i | i f n | i i \ } } | t j o+ | i | | i d | | i n | t j p
| t
j o | i | t | i } xA | d j o3 | d } | i | \ } } | t j o Pq q W| t j o t d | i | i f n | i d | | i n1 | t j o# d } t | | i | i f n d S( Ns 'continue' outside loop (%s, %d)R i i t
CONTINUE_LOOPs7 'continue' not allowed inside 'finally' clause (%s, %d)(
Rz R# R% R R R R R R t EXCEPTt TRY_FINALLYR t END_FINALLY( R: R^ t kindt blockR t
loop_blockR ( ( s( /usr/lib/python2.6/compiler/pycodegen.pyt
visitContinue s2
c C s} | i } xI | i d D]: } | i | | i | | | i | i d q W| i | i d | i | d S( NiR ( R R R R R ( R: R^ t jumpR t child( ( s( /usr/lib/python2.6/compiler/pycodegen.pyt visitTest s
c C s | i | d d S( NR ( R ( R: R^ ( ( s( /usr/lib/python2.6/compiler/pycodegen.pyt visitAnd s c C s | i | d d S( Nt JUMP_IF_TRUE( R ( R: R^ ( ( s( /usr/lib/python2.6/compiler/pycodegen.pyt visitOr s c C s | i } | i } | i | i | i d | | i d | i | i | i d | | i | | i d | i | i | i | d S( NR R R ( R R R R t thenR R ( R: R^ t endblockt elseblock( ( s( /usr/lib/python2.6/compiler/pycodegen.pyt
visitIfExp s
c C sD | i | i | i } xy | i d D]j \ } } | i | | i d | i d | i d | | i d | | i | i d q* W| i o4 | i d \ } } | i | | i d | n t | i d j oT | i } | i d | | i | | i d | i d | i | n d S(
Nit DUP_TOPt ROT_THREEt
COMPARE_OPR R i R t ROT_TWO( R t exprR t opsR R R R ( R: R^ t cleanupt opR3 R ( ( s( /usr/lib/python2.6/compiler/pycodegen.pyt visitCompare$ s,
c C s | i | d | i } | i d | _ | i d d | i d | i d | g } x t t t | i | i D] \ } } | i | \ } } d } x> | i
D]3 } | d j o | i } n | i | | q W| i d | | | f q W| i d | | i | i
| i d x | D]z \ } } } | oG | i }
| i d |
| i | | i d
| i |
n | i d | | i | q8W| i d | | i d | _ d S(
Ns $list%di t
BUILD_LISTi R R R t LIST_APPENDR R R R ( R t _CodeGenerator__list_countR R t zipR R t qualsR R. t ifsR t insertR R R ( R: R^ t tmpnamet stackR t for_R R t contt if_t skip_one( ( s( /usr/lib/python2.6/compiler/pycodegen.pyt
visitListComp? s@
"
c C s | i } | i } | i | i | i d | i | | i | d t | i d | | i | i | i | | f S( NR R R ( R R R R R R R R ( R: R^ R R ( ( s( /usr/lib/python2.6/compiler/pycodegen.pyt visitListCompForc s
c C sN | i | d t | i | i | i d | | i | i d d S( NR R R ( R R R R R R ( R: R^ t branch( ( s( /usr/lib/python2.6/compiler/pycodegen.pyt visitListCompIfp s
c C s | i i } | o[ x | D] } | i d | q W| i d t | | i d | | i d | n! | i d | | i d | d S( Nt LOAD_CLOSURER R t MAKE_CLOSUREt
MAKE_FUNCTION( R t
get_free_varsR R ( R: R8 t argst freesRX ( ( s( /usr/lib/python2.6/compiler/pycodegen.pyR w s c C s t | | i | i | i } t | i | | i | i | | i | d | i | i i
d i | i d | i d d d S( Ni R R i (
t GenExprCodeGeneratorR R R~ R R3 R R R R R t iterR ( R: R^ R8 ( ( s( /usr/lib/python2.6/compiler/pycodegen.pyt visitGenExpr s
c C s | i | g } x t t t | i | i D] \ } } | i | \ } } } d } x> | i D]3 } | d j o | i } n | i | | qi W| i d | | | | f q5 W| i | i
| i d | i d x | D] \ } } } } | oG | i }
| i d |
| i | | i d | i
|
n | i d | | i | | i d | i i | i | q W| i d d d S( Ni t YIELD_VALUER R R R R ( R R R R R R R. R R R R R R R Rz R ( R: R^ R R R R R R R
R R ( ( s( /usr/lib/python2.6/compiler/pycodegen.pyt visitGenExprInner s:
"
c C s | i } | i } | i } | i i t | f | i d | | i o | i d n | i | i | i d | i | | i
| d t | i d | | i | i | i | | | f S( NR s .0R R R (
R Rz R R R t
is_outmostR R R R R R R ( R: R^ R R R ( ( s( /usr/lib/python2.6/compiler/pycodegen.pyt visitGenExprFor s
c C sN | i | d t | i | i | i d | | i | i d d S( NR R R ( R R R R R R ( R: R^ R ( ( s( /usr/lib/python2.6/compiler/pycodegen.pyt visitGenExprIf s
c C s | i } | i | | i | i | i | i d | | i | i d | i d d | i o$ | i | i | i d d n | i d d | i | | i d d S( NR R t LOAD_GLOBALR t
RAISE_VARARGSi i ( R R R R R R t fail( R: R^ R ( ( s( /usr/lib/python2.6/compiler/pycodegen.pyt visitAssert s
c C s | i | d } | i o | i | i | d } n | i o | i | i | d } n | i o | i | i | d } n | i d | d S( Ni i R ( R t expr1R t expr2t expr3R ( R: R^ t n( ( s( /usr/lib/python2.6/compiler/pycodegen.pyt
visitRaise s
c C sh | i } | i } | i } | i o | i } n | } | i | | i d | | i | | i i t | f | i | i | i d | i i
| i d | | i | t | i
d } x>t t | i
D]'} | i
| \ } } } | i | | oa | i d | i | | i d d | i }
| i d |
| i | i d n | i d | o | i | n | i d | i d | i | | i d | | o | i |
n | i | o | i d q q W| i d
| i o! | i | | i | i n | i | d S( Nt SETUP_EXCEPTR R i R R s exception matchR R R ( R R R R R Rz R R R R R R R t handlersR ( R: R^ R R) R t lElset lastR R t targett next( ( s( /usr/lib/python2.6/compiler/pycodegen.pyt visitTryExcept sZ
c C s | i } | i } | i | | i d | | i | | i i t | f | i | i | i d | i i | i d d | i | | i i t | f | i | i | i d | i i d S( Nt
SETUP_FINALLYR R R (
R R R R Rz R R R R R R. R t final( R: R^ R R0 ( ( s( /usr/lib/python2.6/compiler/pycodegen.pyt visitTryFinally% s
c C s | i } | i } d | i } | i d 7_ | i | | i | i | i d | i d d | i d | i d d | i d d | i d j o | i d
n | i d | | i d | | i | | i
i t | f | i d j o4 | i d
| | i d | | i | i n | i | i
| i d | i
i | i d d | i | | i
i t | f | i d | i d | i
i | i d 8_ d S( Ns $value%di R t LOAD_ATTRt __exit__R t __enter__R i R R R/ R R R R t WITH_CLEANUPR ( R t _CodeGenerator__with_countR R R R t varsR. R R Rz R R R R R ( R: R^ R R0 t valuevar( ( s( /usr/lib/python2.6/compiler/pycodegen.pyt visitWith8 s>
c C s. | i | | i | i | i d d S( NR ( R R R R ( R: R^ ( ( s( /usr/lib/python2.6/compiler/pycodegen.pyt visitDiscard\ s
c C s | i d | i d S( NR ( R Rk ( R: R^ ( ( s( /usr/lib/python2.6/compiler/pycodegen.pyt
visitConsta s c C s' | i d | i | i | i d S( NR ( R RX R R ( R: R^ ( ( s( /usr/lib/python2.6/compiler/pycodegen.pyt visitKeywordd s c C s d S( N( ( R: R^ ( ( s( /usr/lib/python2.6/compiler/pycodegen.pyR` h s c C s! | i | | i | i d S( N( R R RX ( R: R^ ( ( s( /usr/lib/python2.6/compiler/pycodegen.pyt visitNamel s
c C s | i | d S( N( R ( R: R^ ( ( s( /usr/lib/python2.6/compiler/pycodegen.pyt visitPassp s c C s | i | | i i t o d n d } x | i D] \ } } t d j o$ | i d | | i d d n | i d | | i d d } | o | i | | i
| q7 | i
| q7 Wd S( Ni ii R t IMPORT_NAMEt .( R R t checkFlagR RU t VERSIONR R. t splitt _resolveDotsR ( R: R^ t levelRX Rc R) ( ( s( /usr/lib/python2.6/compiler/pycodegen.pyRd s s
c C s` | i | | i } | d j o | i i t o
d } n t d | i D } t d j o$ | i d | | i d | n | i d | i x | i D] \ } } t d j oz | d j o8 d | _
| i d t | i d j p t d S| i d | | i
| | i | p | q | i d | q W| i d
d S( Ni ic s s x | ] \ } } | Vq Wd S( N( ( t .0RX Rc ( ( s( /usr/lib/python2.6/compiler/pycodegen.pys s i R R? t *t IMPORT_STARt IMPORT_FROMR ( R RE R RA R t tupleRU RB R t modnamet namespaceR R RD R ( R: R^ RE t fromlistRX Rc ( ( s( /usr/lib/python2.6/compiler/pycodegen.pyRe s,
!
c C sP | i d } t | d j o d Sx" | d D] } | i d | q2 Wd S( NR@ i R2 ( RC R R ( R: RX t eltsR\ ( ( s( /usr/lib/python2.6/compiler/pycodegen.pyRD s c C s0 | i | i | i d | i | i d S( NR2 ( R R R R t attrname( R: R^ ( ( s( /usr/lib/python2.6/compiler/pycodegen.pyt visitGetattr s c C s | i | | i | i t | i d } xl t t | i D]U } | i | } | | j o | i d n t | t i o | i | qF qF Wd S( Ni R (
R R R R R R R Ri R t Node( R: R^ t dupsR R\ ( ( s( /usr/lib/python2.6/compiler/pycodegen.pyt visitAssign s
c C se | i d j o | i | i n> | i d j o! | i | | i | i n
d G| i GHd S( Nt OP_ASSIGNt OP_DELETEt oops( R6 R RX R R ( R: R^ ( ( s( /usr/lib/python2.6/compiler/pycodegen.pyRg s
c C s | i | i | i d j o | i d | i | i nB | i d j o | i d | i | i n d G| i GH| GHd S( NRT t
STORE_ATTRRU t DELETE_ATTRs warning: unexpected flags:( R R R6 R R RO ( R: R^ ( ( s( /usr/lib/python2.6/compiler/pycodegen.pyt visitAssAttr s t UNPACK_SEQUENCEc C sU t | d j o | i | t | i n x | i D] } | i | q: Wd S( NRU ( t findOpR R R R ( R: R^ R R ( ( s( /usr/lib/python2.6/compiler/pycodegen.pyt _visitAssSequence s
i c C s | i | d d S( Nt UNPACK_TUPLE( R\ ( R: R^ ( ( s( /usr/lib/python2.6/compiler/pycodegen.pyt
visitAssTuple s c C s | i | d d S( Nt UNPACK_LIST( R\ ( R: R^ ( ( s( /usr/lib/python2.6/compiler/pycodegen.pyt visitAssList s c C sg | i | t | i } | i | d | i | i | i | i | i | i | d d S( Nt loadt store( R t wrap_augR^ R R R t _augmented_opcodeR ( R: R^ t aug_node( ( s( /usr/lib/python2.6/compiler/pycodegen.pyt visitAugAssign s
t INPLACE_ADDs +=t INPLACE_SUBTRACTs -=t INPLACE_MULTIPLYs *=t INPLACE_DIVIDEs /=t INPLACE_FLOOR_DIVIDEs //=t INPLACE_MODULOs %=t
INPLACE_POWERs **=t INPLACE_RSHIFTs >>=t INPLACE_LSHIFTs <<=t INPLACE_ANDs &=t INPLACE_XORs ^=t
INPLACE_ORs |=c C sF | d j o | i | i n" | d j o | i | i n d S( NRa Rb ( R RX R ( R: R^ R5 ( ( s( /usr/lib/python2.6/compiler/pycodegen.pyt visitAugName s
c C s | d j o= | i | i | i d | i d | i | i n; | d j o- | i d | i d | i | i n d S( NRa R R2 Rb R RW ( R R R R RO ( R: R^ R5 ( ( s( /usr/lib/python2.6/compiler/pycodegen.pyt visitAugGetattr s
c C s | d j o | i | d n | d j o d } | i o | d B} n | i o | d B} n | d j o | i d n, | d j o | i d n | i d | i d
| n d S( NRa i Rb i i R i t ROT_FOURR s STORE_SLICE+%d( t
visitSlicet lowert upperR ( R: R^ R5 t slice( ( s( /usr/lib/python2.6/compiler/pycodegen.pyt
visitAugSlice s
c C sP | d j o | i | d n, | d j o | i d | i d n d S( NRa i Rb R t STORE_SUBSCR( t visitSubscriptR ( R: R^ R5 ( ( s( /usr/lib/python2.6/compiler/pycodegen.pyt visitAugSubscript s
c C s | i | i | i d j o | i d d n | i | i | i d j o | i d n | i | i | i d d S( NR R t EXEC_STMT( R R Ry R. R RV ( R: R^ ( ( s( /usr/lib/python2.6/compiler/pycodegen.pyt visitExec s c C s d } d } | i | | i | i xI | i D]> } | i | t | t i o | d } q3 | d } q3 W| i d j o | i | i n | i d j o | i | i n | i d j } | i d j } t
| | f } | i | | d >| B d S( Ni i i ( R R R^ R Ri R t Keywordt star_argsR. t
dstar_argst callfunc_opcode_infoR ( R: R^ t post kwt argt have_start
have_dstart opcode( ( s( /usr/lib/python2.6/compiler/pycodegen.pyt
visitCallFunc# s$
c C s | i | | i o | i | i n xn | i D]c } | i o | i d n | i | | i o | i d | i d q5 | i d q5 W| i o | o | i d n d S( NR R t
PRINT_ITEM_TOt
PRINT_ITEMR ( R t destR R R ( R: R^ t newlineR ( ( s( /usr/lib/python2.6/compiler/pycodegen.pyt
visitPrint7 s
c C s? | i | d d | i o | i d n | i d d S( NR i t PRINT_NEWLINE_TOt
PRINT_NEWLINE( R R R ( R: R^ ( ( s( /usr/lib/python2.6/compiler/pycodegen.pyt visitPrintnlG s
c C s. | i | | i | i | i d d S( NR ( R R Rk R ( R: R^ ( ( s( /usr/lib/python2.6/compiler/pycodegen.pyt visitReturnN s
c C s. | i | | i | i | i d d S( NR ( R R Rk R ( R: R^ ( ( s( /usr/lib/python2.6/compiler/pycodegen.pyt
visitYieldS s
c C sB | i | i d } | i o | i | i | d B} n | i o | i | i | d B} n | oS | d j o | i d q | d j o | i d d q | i d d n | i d j o | i d | nZ | i d j o | i d
| n5 | i d j o | i d | n d
G| i GH d S( Ni i i R i t DUP_TOPXt OP_APPLYs SLICE+%dRT s STORE_SLICE+%dRU s DELETE_SLICE+%ds weird slice( R R Rw Rx R R6 ( R: R^ t aug_flagRy ( ( s( /usr/lib/python2.6/compiler/pycodegen.pyRv Z s,
c C s | i | i x | i D] } | i | q Wt | i d j o | i d t | i n | o | i d d n | i d j o | i d nC | i d j o | i d n" | i d j o | i d
n d S( Ni R R i R t
BINARY_SUBSCRRT R{ RU t
DELETE_SUBSCR( R R t subsR R R6 ( R: R^ R t sub( ( s( /usr/lib/python2.6/compiler/pycodegen.pyR| u s
c C s1 | i | i | i | i | i | d S( N( R t leftt rightR ( R: R^ R ( ( s( /usr/lib/python2.6/compiler/pycodegen.pyt binaryOp s c C s | i | d S( Nt
BINARY_ADD( R ( R: R^ ( ( s( /usr/lib/python2.6/compiler/pycodegen.pyt visitAdd s c C s | i | d S( Nt BINARY_SUBTRACT( R ( R: R^ ( ( s( /usr/lib/python2.6/compiler/pycodegen.pyt visitSub s c C s | i | d S( Nt BINARY_MULTIPLY( R ( R: R^ ( ( s( /usr/lib/python2.6/compiler/pycodegen.pyt visitMul s c C s | i | | i S( N( R R} ( R: R^ ( ( s( /usr/lib/python2.6/compiler/pycodegen.pyt visitDiv s c C s | i | d S( Nt BINARY_FLOOR_DIVIDE( R ( R: R^ ( ( s( /usr/lib/python2.6/compiler/pycodegen.pyt
visitFloorDiv s c C s | i | d S( Nt
BINARY_MODULO( R ( R: R^ ( ( s( /usr/lib/python2.6/compiler/pycodegen.pyt visitMod s c C s | i | d S( Nt BINARY_POWER( R ( R: R^ ( ( s( /usr/lib/python2.6/compiler/pycodegen.pyt
visitPower s c C s | i | d S( Nt
BINARY_LSHIFT( R ( R: R^ ( ( s( /usr/lib/python2.6/compiler/pycodegen.pyt visitLeftShift s c C s | i | d S( Nt
BINARY_RSHIFT( R ( R: R^ ( ( s( /usr/lib/python2.6/compiler/pycodegen.pyt visitRightShift s c C s! | i | i | i | d S( N( R R R ( R: R^ R ( ( s( /usr/lib/python2.6/compiler/pycodegen.pyt unaryOp s c C s | i | d S( Nt UNARY_INVERT( R ( R: R^ ( ( s( /usr/lib/python2.6/compiler/pycodegen.pyt visitInvert s c C s | i | d S( Nt UNARY_NEGATIVE( R ( R: R^ ( ( s( /usr/lib/python2.6/compiler/pycodegen.pyt
visitUnarySub s c C s | i | d S( Nt UNARY_POSITIVE( R ( R: R^ ( ( s( /usr/lib/python2.6/compiler/pycodegen.pyt
visitUnaryAdd s c C s | i | d S( NR ( R ( R: R^ ( ( s( /usr/lib/python2.6/compiler/pycodegen.pyt visitUnaryInvert s c C s | i | d S( Nt UNARY_NOT( R ( R: R^ ( ( s( /usr/lib/python2.6/compiler/pycodegen.pyt visitNot s c C s | i | d S( Nt
UNARY_CONVERT( R ( R: R^ ( ( s( /usr/lib/python2.6/compiler/pycodegen.pyt visitBackquote s c C sD | i | d x, | d D] } | i | | i | q Wd S( Ni i ( R R ( R: R R R^ ( ( s( /usr/lib/python2.6/compiler/pycodegen.pyt bitOp s
c C s | i | i d S( Nt
BINARY_AND( R R ( R: R^ ( ( s( /usr/lib/python2.6/compiler/pycodegen.pyt visitBitand s c C s | i | i d S( Nt BINARY_OR( R R ( R: R^ ( ( s( /usr/lib/python2.6/compiler/pycodegen.pyt
visitBitor s c C s | i | i d S( Nt
BINARY_XOR( R R ( R: R^ ( ( s( /usr/lib/python2.6/compiler/pycodegen.pyt visitBitxor s c C s | i d t d S( NR ( R t Ellipsis( R: R^ ( ( s( /usr/lib/python2.6/compiler/pycodegen.pyt
visitEllipsis s c C sK | i | x | i D] } | i | q W| i d t | i d S( NR ( R R R R R ( R: R^ R\ ( ( s( /usr/lib/python2.6/compiler/pycodegen.pyt
visitTuple s
c C sK | i | x | i D] } | i | q W| i d t | i d S( NR ( R R R R R ( R: R^ R\ ( ( s( /usr/lib/python2.6/compiler/pycodegen.pyt visitList s
c C s> x | i D] } | i | q
W| i d t | i d S( Nt BUILD_SLICE( R R R R ( R: R^ R ( ( s( /usr/lib/python2.6/compiler/pycodegen.pyt
visitSliceobj s
c C s| | i | | i d d xX | i D]M \ } } | i d | i | | i | | i d | i d q' Wd S( Nt BUILD_MAPi R R R{ ( R R t itemsR ( R: R^ t kt v( ( s( /usr/lib/python2.6/compiler/pycodegen.pyR_ s
N(s RA RB Rh R R. Rt R R; Ru Rw R| R@ R R R~ R R R R R R R R RS R R R R R Ra Rb R Rf R R R R R R R R R R R R
R R R R R R R R" R' R. R1 R6 R9 R: R; R< R` R= R> Rd Re RD RP RS Rg RY R\ RB R^ R` Rf Rd Rs Rt Rz R} R R R R R R Rv R| R R R R R R R R R R R R R R R R R R R R R R R R R R_ ( ( ( s( /usr/lib/python2.6/compiler/pycodegen.pyRm s
$
! 2 $
t NestedScopeMixinc B s e Z d Z d Z RS( s> Defines initClass() for nested scoping (Python 2.2-compatible)c C s( t | i _ t | i _ t | i _ d S( N( RS Rv R t FunctionCodeGeneratorR t ClassCodeGeneratorR ( R: ( ( s( /usr/lib/python2.6/compiler/pycodegen.pyRu s ( RA RB Rh Ru ( ( ( s( /usr/lib/python2.6/compiler/pycodegen.pyR s RE c B s) e Z e i Z d Z d Z d Z RS( c C sE t i d | i | _ t i | | _ | i t | | d S( Ns ( R t PyFlowGraphR% R R t find_futuresR t _ModuleCodeGenerator__super_initR ( R: R> ( ( s( /usr/lib/python2.6/compiler/pycodegen.pyR; s
c C s | S( N( ( R: ( ( s( /usr/lib/python2.6/compiler/pycodegen.pyR~ s N( RA RB Rm R; R R. R R~ ( ( ( s( /usr/lib/python2.6/compiler/pycodegen.pyRE s RC c B s/ e Z e i Z d Z d Z d Z d Z RS( c C s3 t i d | i | _ | i t | | d S( Ns ( R R R% R t$ _ExpressionCodeGenerator__super_initR ( R: R> ( ( s( /usr/lib/python2.6/compiler/pycodegen.pyR;
s
c C s | S( N( ( R: ( ( s( /usr/lib/python2.6/compiler/pycodegen.pyR~ s N( ( RA RB Rm R; R R. R R R~ ( ( ( s( /usr/lib/python2.6/compiler/pycodegen.pyRC s
RD c B s8 e Z e i Z d Z d Z d Z d Z d Z RS( c C sM t i d | i | _ | i | i | t | | | i d d S( Ns
R ( R R R% R t% _InteractiveCodeGenerator__super_initR R R ( R: R> ( ( s( /usr/lib/python2.6/compiler/pycodegen.pyR; s
c C s | S( N( ( R: ( ( s( /usr/lib/python2.6/compiler/pycodegen.pyR~ s c C s! | i | i | i d d S( Nt
PRINT_EXPR( R R R ( R: R^ ( ( s( /usr/lib/python2.6/compiler/pycodegen.pyR: # s N( (
RA RB Rm R; R R. R R R~ R: ( ( ( s( /usr/lib/python2.6/compiler/pycodegen.pyRD s t AbstractFunctionCodec B sG e Z d Z d Z d Z d Z d Z d Z d Z e Z RS( i i c C sW | | _ | | _ | o' t } d | i } | i d | _ n
| i } t | i \ } } t i | | i | d d | _
| | _ | i | o | i
o | i | i
n t | i | i | d d }
| i i |
i | i o | i
i t n | i o | i
i t n | i | | o | i | i n d S( Ns i R R i ( R t moduleR t lambdaCountRX t generateArgListt argnamesR R R% R R t
super_initR R R R3 R Ry R R] t varargsR R
t kwargsR R t generateArgUnpack( R: t funcR R R R) t klassRX R t hasTupleArgR ( ( s( /usr/lib/python2.6/compiler/pycodegen.pyR; - s.
!
c C s | i S( N( R ( R: ( ( s( /usr/lib/python2.6/compiler/pycodegen.pyR~ J s c C s< | i i | i p | i d d n | i d d S( NR R ( R t startExitBlockR R R. ( R: ( ( s( /usr/lib/python2.6/compiler/pycodegen.pyR M s
c C sd x] t t | D]I } | | } t | t o) | i d d | d | i | q q Wd S( Nt LOAD_FASTs .%di ( R R Ri RJ R t unpackSequence( R: R R R ( ( s( /usr/lib/python2.6/compiler/pycodegen.pyR S s
c C s t d j o | i d t | n | i d t | x? | D]7 } t | t o | i | qD | i d | qD Wd S( Ni RZ R] R ( RB R R Ri RJ R R ( R: t tupR\ ( ( s( /usr/lib/python2.6/compiler/pycodegen.pyR Z s
(
RA RB R R R; R~ R R R t unpackTuple( ( ( s( /usr/lib/python2.6/compiler/pycodegen.pyR ) s R c B s) e Z e i Z d Z e i Z d Z RS( c C s | | _ | | | _ | i | | | | | | i i | i i | i i | i i | i i d j o | i i
t n d S( N( R R t" _FunctionCodeGenerator__super_initR t setFreeVarsR t setCellVarst
get_cell_varst generatorR. R R ( R: R R R R R) ( ( s( /usr/lib/python2.6/compiler/pycodegen.pyR; n s
N( RA RB Rm R; R R. R R R ( ( ( s( /usr/lib/python2.6/compiler/pycodegen.pyR g s R c B s) e Z e i Z d Z e i Z d Z RS( c C su | | _ | | | _ | i | | d | | | i i | i i | i i | i i | i i t d S( Ni (
R R t! _GenExprCodeGenerator__super_initR R R R R R R ( R: t gexpR R R) ( ( s( /usr/lib/python2.6/compiler/pycodegen.pyR; ~ s
N( RA RB Rm R; R R. R R R ( ( ( s( /usr/lib/python2.6/compiler/pycodegen.pyR w s t AbstractClassCodec B s# e Z d Z d Z d Z RS( c C s | i | _ | | _ t i | i | i d d d d | _ | i t | i | i
d d } | i i | i
| i i t | i o | i | i n d S( NR i R i R ( RX R R R R R% R R R R3 R Ry R R] R R R R ( R: R R R R ( ( s( /usr/lib/python2.6/compiler/pycodegen.pyR; s
c C s | i S( N( R ( R: ( ( s( /usr/lib/python2.6/compiler/pycodegen.pyR~ s c C s+ | i i | i d | i d d S( Nt LOAD_LOCALSR ( R R R ( R: ( ( s( /usr/lib/python2.6/compiler/pycodegen.pyR s
( RA RB R; R~ R ( ( ( s( /usr/lib/python2.6/compiler/pycodegen.pyR s R c B s) e Z e i Z d Z e i Z d Z RS( c C s | | _ | | | _ | i | | | | i i | i i | i i | i i | i | | i d d | i
d | i o$ | i d | i | i
d n d S( NR RA RB R Rh ( R R t _ClassCodeGenerator__super_initR R R R R R R R R ( R: R R R ( ( s( /usr/lib/python2.6/compiler/pycodegen.pyR; s
N( RA RB Rm R; R R. R R R ( ( ( s( /usr/lib/python2.6/compiler/pycodegen.pyR s c C s g } g } d } x t t | D] } | | } t | t o | i | q% t | t o> | i t | d | | i t i | | d } q% t
d | q% W| | | f S( s& Generate an arg list marking TupleArgsi i i s unexpect argument type:( R R Ri t strt appendRJ R t extendR t flattenR2 ( t arglistR t extrat countR R\ ( ( s( /usr/lib/python2.6/compiler/pycodegen.pyR s
c C s# t } t | | d d | i S( s5 Find the op (DELETE, LOAD, STORE) in an AssTuple treeR i ( t OpFinderR R ( R^ R ( ( s( /usr/lib/python2.6/compiler/pycodegen.pyR[ s R c B s& e Z d Z d Z e Z e Z RS( c C s
d | _ d S( N( R. R ( R: ( ( s( /usr/lib/python2.6/compiler/pycodegen.pyR; s c C sD | i d j o | i | _ n! | i | i j o
t d n d S( Ns mixed ops in stmt( R R. R6 R2 ( R: R^ ( ( s( /usr/lib/python2.6/compiler/pycodegen.pyRg s ( RA RB R; Rg RY R| ( ( ( s( /usr/lib/python2.6/compiler/pycodegen.pyR s t Delegatorc B s e Z d Z d Z d Z RS( s Base class to support delegation for augmented assignment nodes
To generator code for augmented assignments, we use the following
wrapper classes. In visitAugAssign, the left-hand expression node
is visited twice. The first time the visit uses the normal method
for that node . The second time the visit uses a different method
that generates the appropriate code to perform the assignment.
These delegator classes wrap the original AST nodes in order to
support the variant visit methods.
c C s
| | _ d S( N( t obj( R: R ( ( s( /usr/lib/python2.6/compiler/pycodegen.pyR; s c C s t | i | S( N( R R ( R: t attr( ( s( /usr/lib/python2.6/compiler/pycodegen.pyt __getattr__ s ( RA RB Rh R; R ( ( ( s( /usr/lib/python2.6/compiler/pycodegen.pyR s
t
AugGetattrc B s e Z RS( ( RA RB ( ( ( s( /usr/lib/python2.6/compiler/pycodegen.pyR s t AugNamec B s e Z RS( ( RA RB ( ( ( s( /usr/lib/python2.6/compiler/pycodegen.pyR s t AugSlicec B s e Z RS( ( RA RB ( ( ( s( /usr/lib/python2.6/compiler/pycodegen.pyR s t AugSubscriptc B s e Z RS( ( RA RB ( ( ( s( /usr/lib/python2.6/compiler/pycodegen.pyR s c C s t | i | S( N( t wrapperRv ( R^ ( ( s( /usr/lib/python2.6/compiler/pycodegen.pyRc s t __main__(L RQ RJ RI RM t syst cStringIOR t compilerR R R R R R R R t compiler.constsR R
R R R
R R R R R R R R t compiler.pyassemR t version_infoRB t AttributeErrorR R R R R R* R. R" R9 R1 R0 R! RS Rl Rm R RE RC RD R R R R R R R[ R R R R R R t Getattrt Namet Slicet SubscriptR Rc RA t argvt file( ( ( s( /usr/lib/python2.6/compiler/pycodegen.pyt s """@
+ =>
PK [[9N
future.pycnu W+A
YMc @ s d Z d d k l Z l Z d Z d d
d YZ d d d YZ d Z e d j on d d
k Z d d k l
Z
l Z xI e i d D]6 Z e GHe
e Z
e Z e e
e e i GHHq Wn d
S( s Parser for future statements
i( t astt walkc C s5 t | t i p d S| i d j o d Sd Sd S( s: Return true if statement is a well-formed future statementi t
__future__i N( t
isinstanceR t Fromt modname( t stmt( ( s% /usr/lib/python2.6/compiler/future.pyt is_future s
t FutureParserc B s2 e Z d Z d Z d Z d Z d
Z RS( t
nested_scopest
generatorst divisiont absolute_importt with_statementt print_functiont unicode_literalsc C s
h | _ d S( N( t found( t self( ( s% /usr/lib/python2.6/compiler/future.pyt __init__ s c C s6 | i } x& | i D] } | i | p Pq q Wd S( N( t nodet nodest
check_stmt( R R R t s( ( s% /usr/lib/python2.6/compiler/future.pyt visitModule s
c C sg t | oV xE | i D]: \ } } | | i j o d | i | s
PK [[F pycodegen.pynu W+A import imp
import os
import marshal
import struct
import sys
from cStringIO import StringIO
from compiler import ast, parse, walk, syntax
from compiler import pyassem, misc, future, symbols
from compiler.consts import SC_LOCAL, SC_GLOBAL, SC_FREE, SC_CELL
from compiler.consts import (CO_VARARGS, CO_VARKEYWORDS, CO_NEWLOCALS,
CO_NESTED, CO_GENERATOR, CO_FUTURE_DIVISION,
CO_FUTURE_ABSIMPORT, CO_FUTURE_WITH_STATEMENT, CO_FUTURE_PRINT_FUNCTION)
from compiler.pyassem import TupleArg
# XXX The version-specific code can go, since this code only works with 2.x.
# Do we have Python 1.x or Python 2.x?
try:
VERSION = sys.version_info[0]
except AttributeError:
VERSION = 1
callfunc_opcode_info = {
# (Have *args, Have **args) : opcode
(0,0) : "CALL_FUNCTION",
(1,0) : "CALL_FUNCTION_VAR",
(0,1) : "CALL_FUNCTION_KW",
(1,1) : "CALL_FUNCTION_VAR_KW",
}
LOOP = 1
EXCEPT = 2
TRY_FINALLY = 3
END_FINALLY = 4
def compileFile(filename, display=0):
f = open(filename, 'U')
buf = f.read()
f.close()
mod = Module(buf, filename)
try:
mod.compile(display)
except SyntaxError:
raise
else:
f = open(filename + "c", "wb")
mod.dump(f)
f.close()
def compile(source, filename, mode, flags=None, dont_inherit=None):
"""Replacement for builtin compile() function"""
if flags is not None or dont_inherit is not None:
raise RuntimeError, "not implemented yet"
if mode == "single":
gen = Interactive(source, filename)
elif mode == "exec":
gen = Module(source, filename)
elif mode == "eval":
gen = Expression(source, filename)
else:
raise ValueError("compile() 3rd arg must be 'exec' or "
"'eval' or 'single'")
gen.compile()
return gen.code
class AbstractCompileMode:
mode = None # defined by subclass
def __init__(self, source, filename):
self.source = source
self.filename = filename
self.code = None
def _get_tree(self):
tree = parse(self.source, self.mode)
misc.set_filename(self.filename, tree)
syntax.check(tree)
return tree
def compile(self):
pass # implemented by subclass
def getCode(self):
return self.code
class Expression(AbstractCompileMode):
mode = "eval"
def compile(self):
tree = self._get_tree()
gen = ExpressionCodeGenerator(tree)
self.code = gen.getCode()
class Interactive(AbstractCompileMode):
mode = "single"
def compile(self):
tree = self._get_tree()
gen = InteractiveCodeGenerator(tree)
self.code = gen.getCode()
class Module(AbstractCompileMode):
mode = "exec"
def compile(self, display=0):
tree = self._get_tree()
gen = ModuleCodeGenerator(tree)
if display:
import pprint
print pprint.pprint(tree)
self.code = gen.getCode()
def dump(self, f):
f.write(self.getPycHeader())
marshal.dump(self.code, f)
MAGIC = imp.get_magic()
def getPycHeader(self):
# compile.c uses marshal to write a long directly, with
# calling the interface that would also generate a 1-byte code
# to indicate the type of the value. simplest way to get the
# same effect is to call marshal and then skip the code.
mtime = os.path.getmtime(self.filename)
mtime = struct.pack(' 0:
top = top - 1
kind, loop_block = self.setups[top]
if kind == LOOP:
break
if kind != LOOP:
raise SyntaxError, "'continue' outside loop (%s, %d)" % \
(node.filename, node.lineno)
self.emit('CONTINUE_LOOP', loop_block)
self.nextBlock()
elif kind == END_FINALLY:
msg = "'continue' not allowed inside 'finally' clause (%s, %d)"
raise SyntaxError, msg % (node.filename, node.lineno)
def visitTest(self, node, jump):
end = self.newBlock()
for child in node.nodes[:-1]:
self.visit(child)
self.emit(jump, end)
self.nextBlock()
self.emit('POP_TOP')
self.visit(node.nodes[-1])
self.nextBlock(end)
def visitAnd(self, node):
self.visitTest(node, 'JUMP_IF_FALSE')
def visitOr(self, node):
self.visitTest(node, 'JUMP_IF_TRUE')
def visitIfExp(self, node):
endblock = self.newBlock()
elseblock = self.newBlock()
self.visit(node.test)
self.emit('JUMP_IF_FALSE', elseblock)
self.emit('POP_TOP')
self.visit(node.then)
self.emit('JUMP_FORWARD', endblock)
self.nextBlock(elseblock)
self.emit('POP_TOP')
self.visit(node.else_)
self.nextBlock(endblock)
def visitCompare(self, node):
self.visit(node.expr)
cleanup = self.newBlock()
for op, code in node.ops[:-1]:
self.visit(code)
self.emit('DUP_TOP')
self.emit('ROT_THREE')
self.emit('COMPARE_OP', op)
self.emit('JUMP_IF_FALSE', cleanup)
self.nextBlock()
self.emit('POP_TOP')
# now do the last comparison
if node.ops:
op, code = node.ops[-1]
self.visit(code)
self.emit('COMPARE_OP', op)
if len(node.ops) > 1:
end = self.newBlock()
self.emit('JUMP_FORWARD', end)
self.startBlock(cleanup)
self.emit('ROT_TWO')
self.emit('POP_TOP')
self.nextBlock(end)
# list comprehensions
__list_count = 0
def visitListComp(self, node):
self.set_lineno(node)
# setup list
tmpname = "$list%d" % self.__list_count
self.__list_count = self.__list_count + 1
self.emit('BUILD_LIST', 0)
self.emit('DUP_TOP')
self._implicitNameOp('STORE', tmpname)
stack = []
for i, for_ in zip(range(len(node.quals)), node.quals):
start, anchor = self.visit(for_)
cont = None
for if_ in for_.ifs:
if cont is None:
cont = self.newBlock()
self.visit(if_, cont)
stack.insert(0, (start, cont, anchor))
self._implicitNameOp('LOAD', tmpname)
self.visit(node.expr)
self.emit('LIST_APPEND')
for start, cont, anchor in stack:
if cont:
skip_one = self.newBlock()
self.emit('JUMP_FORWARD', skip_one)
self.startBlock(cont)
self.emit('POP_TOP')
self.nextBlock(skip_one)
self.emit('JUMP_ABSOLUTE', start)
self.startBlock(anchor)
self._implicitNameOp('DELETE', tmpname)
self.__list_count = self.__list_count - 1
def visitListCompFor(self, node):
start = self.newBlock()
anchor = self.newBlock()
self.visit(node.list)
self.emit('GET_ITER')
self.nextBlock(start)
self.set_lineno(node, force=True)
self.emit('FOR_ITER', anchor)
self.nextBlock()
self.visit(node.assign)
return start, anchor
def visitListCompIf(self, node, branch):
self.set_lineno(node, force=True)
self.visit(node.test)
self.emit('JUMP_IF_FALSE', branch)
self.newBlock()
self.emit('POP_TOP')
def _makeClosure(self, gen, args):
frees = gen.scope.get_free_vars()
if frees:
for name in frees:
self.emit('LOAD_CLOSURE', name)
self.emit('BUILD_TUPLE', len(frees))
self.emit('LOAD_CONST', gen)
self.emit('MAKE_CLOSURE', args)
else:
self.emit('LOAD_CONST', gen)
self.emit('MAKE_FUNCTION', args)
def visitGenExpr(self, node):
gen = GenExprCodeGenerator(node, self.scopes, self.class_name,
self.get_module())
walk(node.code, gen)
gen.finish()
self.set_lineno(node)
self._makeClosure(gen, 0)
# precomputation of outmost iterable
self.visit(node.code.quals[0].iter)
self.emit('GET_ITER')
self.emit('CALL_FUNCTION', 1)
def visitGenExprInner(self, node):
self.set_lineno(node)
# setup list
stack = []
for i, for_ in zip(range(len(node.quals)), node.quals):
start, anchor, end = self.visit(for_)
cont = None
for if_ in for_.ifs:
if cont is None:
cont = self.newBlock()
self.visit(if_, cont)
stack.insert(0, (start, cont, anchor, end))
self.visit(node.expr)
self.emit('YIELD_VALUE')
self.emit('POP_TOP')
for start, cont, anchor, end in stack:
if cont:
skip_one = self.newBlock()
self.emit('JUMP_FORWARD', skip_one)
self.startBlock(cont)
self.emit('POP_TOP')
self.nextBlock(skip_one)
self.emit('JUMP_ABSOLUTE', start)
self.startBlock(anchor)
self.emit('POP_BLOCK')
self.setups.pop()
self.startBlock(end)
self.emit('LOAD_CONST', None)
def visitGenExprFor(self, node):
start = self.newBlock()
anchor = self.newBlock()
end = self.newBlock()
self.setups.push((LOOP, start))
self.emit('SETUP_LOOP', end)
if node.is_outmost:
self.loadName('.0')
else:
self.visit(node.iter)
self.emit('GET_ITER')
self.nextBlock(start)
self.set_lineno(node, force=True)
self.emit('FOR_ITER', anchor)
self.nextBlock()
self.visit(node.assign)
return start, anchor, end
def visitGenExprIf(self, node, branch):
self.set_lineno(node, force=True)
self.visit(node.test)
self.emit('JUMP_IF_FALSE', branch)
self.newBlock()
self.emit('POP_TOP')
# exception related
def visitAssert(self, node):
# XXX would be interesting to implement this via a
# transformation of the AST before this stage
if __debug__:
end = self.newBlock()
self.set_lineno(node)
# XXX AssertionError appears to be special case -- it is always
# loaded as a global even if there is a local name. I guess this
# is a sort of renaming op.
self.nextBlock()
self.visit(node.test)
self.emit('JUMP_IF_TRUE', end)
self.nextBlock()
self.emit('POP_TOP')
self.emit('LOAD_GLOBAL', 'AssertionError')
if node.fail:
self.visit(node.fail)
self.emit('RAISE_VARARGS', 2)
else:
self.emit('RAISE_VARARGS', 1)
self.nextBlock(end)
self.emit('POP_TOP')
def visitRaise(self, node):
self.set_lineno(node)
n = 0
if node.expr1:
self.visit(node.expr1)
n = n + 1
if node.expr2:
self.visit(node.expr2)
n = n + 1
if node.expr3:
self.visit(node.expr3)
n = n + 1
self.emit('RAISE_VARARGS', n)
def visitTryExcept(self, node):
body = self.newBlock()
handlers = self.newBlock()
end = self.newBlock()
if node.else_:
lElse = self.newBlock()
else:
lElse = end
self.set_lineno(node)
self.emit('SETUP_EXCEPT', handlers)
self.nextBlock(body)
self.setups.push((EXCEPT, body))
self.visit(node.body)
self.emit('POP_BLOCK')
self.setups.pop()
self.emit('JUMP_FORWARD', lElse)
self.startBlock(handlers)
last = len(node.handlers) - 1
for i in range(len(node.handlers)):
expr, target, body = node.handlers[i]
self.set_lineno(expr)
if expr:
self.emit('DUP_TOP')
self.visit(expr)
self.emit('COMPARE_OP', 'exception match')
next = self.newBlock()
self.emit('JUMP_IF_FALSE', next)
self.nextBlock()
self.emit('POP_TOP')
self.emit('POP_TOP')
if target:
self.visit(target)
else:
self.emit('POP_TOP')
self.emit('POP_TOP')
self.visit(body)
self.emit('JUMP_FORWARD', end)
if expr:
self.nextBlock(next)
else:
self.nextBlock()
if expr: # XXX
self.emit('POP_TOP')
self.emit('END_FINALLY')
if node.else_:
self.nextBlock(lElse)
self.visit(node.else_)
self.nextBlock(end)
def visitTryFinally(self, node):
body = self.newBlock()
final = self.newBlock()
self.set_lineno(node)
self.emit('SETUP_FINALLY', final)
self.nextBlock(body)
self.setups.push((TRY_FINALLY, body))
self.visit(node.body)
self.emit('POP_BLOCK')
self.setups.pop()
self.emit('LOAD_CONST', None)
self.nextBlock(final)
self.setups.push((END_FINALLY, final))
self.visit(node.final)
self.emit('END_FINALLY')
self.setups.pop()
__with_count = 0
def visitWith(self, node):
body = self.newBlock()
final = self.newBlock()
valuevar = "$value%d" % self.__with_count
self.__with_count += 1
self.set_lineno(node)
self.visit(node.expr)
self.emit('DUP_TOP')
self.emit('LOAD_ATTR', '__exit__')
self.emit('ROT_TWO')
self.emit('LOAD_ATTR', '__enter__')
self.emit('CALL_FUNCTION', 0)
if node.vars is None:
self.emit('POP_TOP')
else:
self._implicitNameOp('STORE', valuevar)
self.emit('SETUP_FINALLY', final)
self.nextBlock(body)
self.setups.push((TRY_FINALLY, body))
if node.vars is not None:
self._implicitNameOp('LOAD', valuevar)
self._implicitNameOp('DELETE', valuevar)
self.visit(node.vars)
self.visit(node.body)
self.emit('POP_BLOCK')
self.setups.pop()
self.emit('LOAD_CONST', None)
self.nextBlock(final)
self.setups.push((END_FINALLY, final))
self.emit('WITH_CLEANUP')
self.emit('END_FINALLY')
self.setups.pop()
self.__with_count -= 1
# misc
def visitDiscard(self, node):
self.set_lineno(node)
self.visit(node.expr)
self.emit('POP_TOP')
def visitConst(self, node):
self.emit('LOAD_CONST', node.value)
def visitKeyword(self, node):
self.emit('LOAD_CONST', node.name)
self.visit(node.expr)
def visitGlobal(self, node):
# no code to generate
pass
def visitName(self, node):
self.set_lineno(node)
self.loadName(node.name)
def visitPass(self, node):
self.set_lineno(node)
def visitImport(self, node):
self.set_lineno(node)
level = 0 if self.graph.checkFlag(CO_FUTURE_ABSIMPORT) else -1
for name, alias in node.names:
if VERSION > 1:
self.emit('LOAD_CONST', level)
self.emit('LOAD_CONST', None)
self.emit('IMPORT_NAME', name)
mod = name.split(".")[0]
if alias:
self._resolveDots(name)
self.storeName(alias)
else:
self.storeName(mod)
def visitFrom(self, node):
self.set_lineno(node)
level = node.level
if level == 0 and not self.graph.checkFlag(CO_FUTURE_ABSIMPORT):
level = -1
fromlist = tuple(name for (name, alias) in node.names)
if VERSION > 1:
self.emit('LOAD_CONST', level)
self.emit('LOAD_CONST', fromlist)
self.emit('IMPORT_NAME', node.modname)
for name, alias in node.names:
if VERSION > 1:
if name == '*':
self.namespace = 0
self.emit('IMPORT_STAR')
# There can only be one name w/ from ... import *
assert len(node.names) == 1
return
else:
self.emit('IMPORT_FROM', name)
self._resolveDots(name)
self.storeName(alias or name)
else:
self.emit('IMPORT_FROM', name)
self.emit('POP_TOP')
def _resolveDots(self, name):
elts = name.split(".")
if len(elts) == 1:
return
for elt in elts[1:]:
self.emit('LOAD_ATTR', elt)
def visitGetattr(self, node):
self.visit(node.expr)
self.emit('LOAD_ATTR', self.mangle(node.attrname))
# next five implement assignments
def visitAssign(self, node):
self.set_lineno(node)
self.visit(node.expr)
dups = len(node.nodes) - 1
for i in range(len(node.nodes)):
elt = node.nodes[i]
if i < dups:
self.emit('DUP_TOP')
if isinstance(elt, ast.Node):
self.visit(elt)
def visitAssName(self, node):
if node.flags == 'OP_ASSIGN':
self.storeName(node.name)
elif node.flags == 'OP_DELETE':
self.set_lineno(node)
self.delName(node.name)
else:
print "oops", node.flags
def visitAssAttr(self, node):
self.visit(node.expr)
if node.flags == 'OP_ASSIGN':
self.emit('STORE_ATTR', self.mangle(node.attrname))
elif node.flags == 'OP_DELETE':
self.emit('DELETE_ATTR', self.mangle(node.attrname))
else:
print "warning: unexpected flags:", node.flags
print node
def _visitAssSequence(self, node, op='UNPACK_SEQUENCE'):
if findOp(node) != 'OP_DELETE':
self.emit(op, len(node.nodes))
for child in node.nodes:
self.visit(child)
if VERSION > 1:
visitAssTuple = _visitAssSequence
visitAssList = _visitAssSequence
else:
def visitAssTuple(self, node):
self._visitAssSequence(node, 'UNPACK_TUPLE')
def visitAssList(self, node):
self._visitAssSequence(node, 'UNPACK_LIST')
# augmented assignment
def visitAugAssign(self, node):
self.set_lineno(node)
aug_node = wrap_aug(node.node)
self.visit(aug_node, "load")
self.visit(node.expr)
self.emit(self._augmented_opcode[node.op])
self.visit(aug_node, "store")
_augmented_opcode = {
'+=' : 'INPLACE_ADD',
'-=' : 'INPLACE_SUBTRACT',
'*=' : 'INPLACE_MULTIPLY',
'/=' : 'INPLACE_DIVIDE',
'//=': 'INPLACE_FLOOR_DIVIDE',
'%=' : 'INPLACE_MODULO',
'**=': 'INPLACE_POWER',
'>>=': 'INPLACE_RSHIFT',
'<<=': 'INPLACE_LSHIFT',
'&=' : 'INPLACE_AND',
'^=' : 'INPLACE_XOR',
'|=' : 'INPLACE_OR',
}
def visitAugName(self, node, mode):
if mode == "load":
self.loadName(node.name)
elif mode == "store":
self.storeName(node.name)
def visitAugGetattr(self, node, mode):
if mode == "load":
self.visit(node.expr)
self.emit('DUP_TOP')
self.emit('LOAD_ATTR', self.mangle(node.attrname))
elif mode == "store":
self.emit('ROT_TWO')
self.emit('STORE_ATTR', self.mangle(node.attrname))
def visitAugSlice(self, node, mode):
if mode == "load":
self.visitSlice(node, 1)
elif mode == "store":
slice = 0
if node.lower:
slice = slice | 1
if node.upper:
slice = slice | 2
if slice == 0:
self.emit('ROT_TWO')
elif slice == 3:
self.emit('ROT_FOUR')
else:
self.emit('ROT_THREE')
self.emit('STORE_SLICE+%d' % slice)
def visitAugSubscript(self, node, mode):
if mode == "load":
self.visitSubscript(node, 1)
elif mode == "store":
self.emit('ROT_THREE')
self.emit('STORE_SUBSCR')
def visitExec(self, node):
self.visit(node.expr)
if node.locals is None:
self.emit('LOAD_CONST', None)
else:
self.visit(node.locals)
if node.globals is None:
self.emit('DUP_TOP')
else:
self.visit(node.globals)
self.emit('EXEC_STMT')
def visitCallFunc(self, node):
pos = 0
kw = 0
self.set_lineno(node)
self.visit(node.node)
for arg in node.args:
self.visit(arg)
if isinstance(arg, ast.Keyword):
kw = kw + 1
else:
pos = pos + 1
if node.star_args is not None:
self.visit(node.star_args)
if node.dstar_args is not None:
self.visit(node.dstar_args)
have_star = node.star_args is not None
have_dstar = node.dstar_args is not None
opcode = callfunc_opcode_info[have_star, have_dstar]
self.emit(opcode, kw << 8 | pos)
def visitPrint(self, node, newline=0):
self.set_lineno(node)
if node.dest:
self.visit(node.dest)
for child in node.nodes:
if node.dest:
self.emit('DUP_TOP')
self.visit(child)
if node.dest:
self.emit('ROT_TWO')
self.emit('PRINT_ITEM_TO')
else:
self.emit('PRINT_ITEM')
if node.dest and not newline:
self.emit('POP_TOP')
def visitPrintnl(self, node):
self.visitPrint(node, newline=1)
if node.dest:
self.emit('PRINT_NEWLINE_TO')
else:
self.emit('PRINT_NEWLINE')
def visitReturn(self, node):
self.set_lineno(node)
self.visit(node.value)
self.emit('RETURN_VALUE')
def visitYield(self, node):
self.set_lineno(node)
self.visit(node.value)
self.emit('YIELD_VALUE')
# slice and subscript stuff
def visitSlice(self, node, aug_flag=None):
# aug_flag is used by visitAugSlice
self.visit(node.expr)
slice = 0
if node.lower:
self.visit(node.lower)
slice = slice | 1
if node.upper:
self.visit(node.upper)
slice = slice | 2
if aug_flag:
if slice == 0:
self.emit('DUP_TOP')
elif slice == 3:
self.emit('DUP_TOPX', 3)
else:
self.emit('DUP_TOPX', 2)
if node.flags == 'OP_APPLY':
self.emit('SLICE+%d' % slice)
elif node.flags == 'OP_ASSIGN':
self.emit('STORE_SLICE+%d' % slice)
elif node.flags == 'OP_DELETE':
self.emit('DELETE_SLICE+%d' % slice)
else:
print "weird slice", node.flags
raise
def visitSubscript(self, node, aug_flag=None):
self.visit(node.expr)
for sub in node.subs:
self.visit(sub)
if len(node.subs) > 1:
self.emit('BUILD_TUPLE', len(node.subs))
if aug_flag:
self.emit('DUP_TOPX', 2)
if node.flags == 'OP_APPLY':
self.emit('BINARY_SUBSCR')
elif node.flags == 'OP_ASSIGN':
self.emit('STORE_SUBSCR')
elif node.flags == 'OP_DELETE':
self.emit('DELETE_SUBSCR')
# binary ops
def binaryOp(self, node, op):
self.visit(node.left)
self.visit(node.right)
self.emit(op)
def visitAdd(self, node):
return self.binaryOp(node, 'BINARY_ADD')
def visitSub(self, node):
return self.binaryOp(node, 'BINARY_SUBTRACT')
def visitMul(self, node):
return self.binaryOp(node, 'BINARY_MULTIPLY')
def visitDiv(self, node):
return self.binaryOp(node, self._div_op)
def visitFloorDiv(self, node):
return self.binaryOp(node, 'BINARY_FLOOR_DIVIDE')
def visitMod(self, node):
return self.binaryOp(node, 'BINARY_MODULO')
def visitPower(self, node):
return self.binaryOp(node, 'BINARY_POWER')
def visitLeftShift(self, node):
return self.binaryOp(node, 'BINARY_LSHIFT')
def visitRightShift(self, node):
return self.binaryOp(node, 'BINARY_RSHIFT')
# unary ops
def unaryOp(self, node, op):
self.visit(node.expr)
self.emit(op)
def visitInvert(self, node):
return self.unaryOp(node, 'UNARY_INVERT')
def visitUnarySub(self, node):
return self.unaryOp(node, 'UNARY_NEGATIVE')
def visitUnaryAdd(self, node):
return self.unaryOp(node, 'UNARY_POSITIVE')
def visitUnaryInvert(self, node):
return self.unaryOp(node, 'UNARY_INVERT')
def visitNot(self, node):
return self.unaryOp(node, 'UNARY_NOT')
def visitBackquote(self, node):
return self.unaryOp(node, 'UNARY_CONVERT')
# bit ops
def bitOp(self, nodes, op):
self.visit(nodes[0])
for node in nodes[1:]:
self.visit(node)
self.emit(op)
def visitBitand(self, node):
return self.bitOp(node.nodes, 'BINARY_AND')
def visitBitor(self, node):
return self.bitOp(node.nodes, 'BINARY_OR')
def visitBitxor(self, node):
return self.bitOp(node.nodes, 'BINARY_XOR')
# object constructors
def visitEllipsis(self, node):
self.emit('LOAD_CONST', Ellipsis)
def visitTuple(self, node):
self.set_lineno(node)
for elt in node.nodes:
self.visit(elt)
self.emit('BUILD_TUPLE', len(node.nodes))
def visitList(self, node):
self.set_lineno(node)
for elt in node.nodes:
self.visit(elt)
self.emit('BUILD_LIST', len(node.nodes))
def visitSliceobj(self, node):
for child in node.nodes:
self.visit(child)
self.emit('BUILD_SLICE', len(node.nodes))
def visitDict(self, node):
self.set_lineno(node)
self.emit('BUILD_MAP', 0)
for k, v in node.items:
self.emit('DUP_TOP')
self.visit(k)
self.visit(v)
self.emit('ROT_THREE')
self.emit('STORE_SUBSCR')
class NestedScopeMixin:
"""Defines initClass() for nested scoping (Python 2.2-compatible)"""
def initClass(self):
self.__class__.NameFinder = LocalNameFinder
self.__class__.FunctionGen = FunctionCodeGenerator
self.__class__.ClassGen = ClassCodeGenerator
class ModuleCodeGenerator(NestedScopeMixin, CodeGenerator):
__super_init = CodeGenerator.__init__
scopes = None
def __init__(self, tree):
self.graph = pyassem.PyFlowGraph("", tree.filename)
self.futures = future.find_futures(tree)
self.__super_init()
walk(tree, self)
def get_module(self):
return self
class ExpressionCodeGenerator(NestedScopeMixin, CodeGenerator):
__super_init = CodeGenerator.__init__
scopes = None
futures = ()
def __init__(self, tree):
self.graph = pyassem.PyFlowGraph("", tree.filename)
self.__super_init()
walk(tree, self)
def get_module(self):
return self
class InteractiveCodeGenerator(NestedScopeMixin, CodeGenerator):
__super_init = CodeGenerator.__init__
scopes = None
futures = ()
def __init__(self, tree):
self.graph = pyassem.PyFlowGraph("", tree.filename)
self.__super_init()
self.set_lineno(tree)
walk(tree, self)
self.emit('RETURN_VALUE')
def get_module(self):
return self
def visitDiscard(self, node):
# XXX Discard means it's an expression. Perhaps this is a bad
# name.
self.visit(node.expr)
self.emit('PRINT_EXPR')
class AbstractFunctionCode:
optimized = 1
lambdaCount = 0
def __init__(self, func, scopes, isLambda, class_name, mod):
self.class_name = class_name
self.module = mod
if isLambda:
klass = FunctionCodeGenerator
name = "" % klass.lambdaCount
klass.lambdaCount = klass.lambdaCount + 1
else:
name = func.name
args, hasTupleArg = generateArgList(func.argnames)
self.graph = pyassem.PyFlowGraph(name, func.filename, args,
optimized=1)
self.isLambda = isLambda
self.super_init()
if not isLambda and func.doc:
self.setDocstring(func.doc)
lnf = walk(func.code, self.NameFinder(args), verbose=0)
self.locals.push(lnf.getLocals())
if func.varargs:
self.graph.setFlag(CO_VARARGS)
if func.kwargs:
self.graph.setFlag(CO_VARKEYWORDS)
self.set_lineno(func)
if hasTupleArg:
self.generateArgUnpack(func.argnames)
def get_module(self):
return self.module
def finish(self):
self.graph.startExitBlock()
if not self.isLambda:
self.emit('LOAD_CONST', None)
self.emit('RETURN_VALUE')
def generateArgUnpack(self, args):
for i in range(len(args)):
arg = args[i]
if isinstance(arg, tuple):
self.emit('LOAD_FAST', '.%d' % (i * 2))
self.unpackSequence(arg)
def unpackSequence(self, tup):
if VERSION > 1:
self.emit('UNPACK_SEQUENCE', len(tup))
else:
self.emit('UNPACK_TUPLE', len(tup))
for elt in tup:
if isinstance(elt, tuple):
self.unpackSequence(elt)
else:
self._nameOp('STORE', elt)
unpackTuple = unpackSequence
class FunctionCodeGenerator(NestedScopeMixin, AbstractFunctionCode,
CodeGenerator):
super_init = CodeGenerator.__init__ # call be other init
scopes = None
__super_init = AbstractFunctionCode.__init__
def __init__(self, func, scopes, isLambda, class_name, mod):
self.scopes = scopes
self.scope = scopes[func]
self.__super_init(func, scopes, isLambda, class_name, mod)
self.graph.setFreeVars(self.scope.get_free_vars())
self.graph.setCellVars(self.scope.get_cell_vars())
if self.scope.generator is not None:
self.graph.setFlag(CO_GENERATOR)
class GenExprCodeGenerator(NestedScopeMixin, AbstractFunctionCode,
CodeGenerator):
super_init = CodeGenerator.__init__ # call be other init
scopes = None
__super_init = AbstractFunctionCode.__init__
def __init__(self, gexp, scopes, class_name, mod):
self.scopes = scopes
self.scope = scopes[gexp]
self.__super_init(gexp, scopes, 1, class_name, mod)
self.graph.setFreeVars(self.scope.get_free_vars())
self.graph.setCellVars(self.scope.get_cell_vars())
self.graph.setFlag(CO_GENERATOR)
class AbstractClassCode:
def __init__(self, klass, scopes, module):
self.class_name = klass.name
self.module = module
self.graph = pyassem.PyFlowGraph(klass.name, klass.filename,
optimized=0, klass=1)
self.super_init()
lnf = walk(klass.code, self.NameFinder(), verbose=0)
self.locals.push(lnf.getLocals())
self.graph.setFlag(CO_NEWLOCALS)
if klass.doc:
self.setDocstring(klass.doc)
def get_module(self):
return self.module
def finish(self):
self.graph.startExitBlock()
self.emit('LOAD_LOCALS')
self.emit('RETURN_VALUE')
class ClassCodeGenerator(NestedScopeMixin, AbstractClassCode, CodeGenerator):
super_init = CodeGenerator.__init__
scopes = None
__super_init = AbstractClassCode.__init__
def __init__(self, klass, scopes, module):
self.scopes = scopes
self.scope = scopes[klass]
self.__super_init(klass, scopes, module)
self.graph.setFreeVars(self.scope.get_free_vars())
self.graph.setCellVars(self.scope.get_cell_vars())
self.set_lineno(klass)
self.emit("LOAD_GLOBAL", "__name__")
self.storeName("__module__")
if klass.doc:
self.emit("LOAD_CONST", klass.doc)
self.storeName('__doc__')
def generateArgList(arglist):
"""Generate an arg list marking TupleArgs"""
args = []
extra = []
count = 0
for i in range(len(arglist)):
elt = arglist[i]
if isinstance(elt, str):
args.append(elt)
elif isinstance(elt, tuple):
args.append(TupleArg(i * 2, elt))
extra.extend(misc.flatten(elt))
count = count + 1
else:
raise ValueError, "unexpect argument type:", elt
return args + extra, count
def findOp(node):
"""Find the op (DELETE, LOAD, STORE) in an AssTuple tree"""
v = OpFinder()
walk(node, v, verbose=0)
return v.op
class OpFinder:
def __init__(self):
self.op = None
def visitAssName(self, node):
if self.op is None:
self.op = node.flags
elif self.op != node.flags:
raise ValueError, "mixed ops in stmt"
visitAssAttr = visitAssName
visitSubscript = visitAssName
class Delegator:
"""Base class to support delegation for augmented assignment nodes
To generator code for augmented assignments, we use the following
wrapper classes. In visitAugAssign, the left-hand expression node
is visited twice. The first time the visit uses the normal method
for that node . The second time the visit uses a different method
that generates the appropriate code to perform the assignment.
These delegator classes wrap the original AST nodes in order to
support the variant visit methods.
"""
def __init__(self, obj):
self.obj = obj
def __getattr__(self, attr):
return getattr(self.obj, attr)
class AugGetattr(Delegator):
pass
class AugName(Delegator):
pass
class AugSlice(Delegator):
pass
class AugSubscript(Delegator):
pass
wrapper = {
ast.Getattr: AugGetattr,
ast.Name: AugName,
ast.Slice: AugSlice,
ast.Subscript: AugSubscript,
}
def wrap_aug(node):
return wrapper[node.__class__](node)
if __name__ == "__main__":
for file in sys.argv[1:]:
compileFile(file)
PK [[] ast.pycnu W+A
YMc @ s d Z d d k l Z l Z d Z d Z h Z d d d YZ d e f d YZ d e f d
YZ d e f d YZ
d
e f d YZ d e f d YZ d e f d YZ
d e f d YZ d e f d YZ d e f d YZ d e f d YZ d e f d YZ d e f d YZ d e f d YZ d! e f d" YZ d# e f d$ YZ d% e f d& YZ d' e f d( YZ d) e f d* YZ d+ e f d, YZ d- e f d. YZ d/ e f d0 YZ d1 e f d2 YZ d3 e f d4 YZ d5 e f d6 YZ d7 e f d8 YZ d9 e f d: YZ! d; e f d< YZ" d= e f d> YZ# d? e f d@ YZ$ dA e f dB YZ% dC e f dD YZ& dE e f dF YZ' dG e f dH YZ( dI e f dJ YZ) dK e f dL YZ* dM e f dN YZ+ dO e f dP YZ, dQ e f dR YZ- dS e f dT YZ. dU e f dV YZ/ dW e f dX YZ0 dY e f dZ YZ1 d[ e f d\ YZ2 d] e f d^ YZ3 d_ e f d` YZ4 da e f db YZ5 dc e f dd YZ6 de e f df YZ7 dg e f dh YZ8 di e f dj YZ9 dk e f dl YZ: dm e f dn YZ; do e f dp YZ< dq e f dr YZ= ds e f dt YZ> du e f dv YZ? dw e f dx YZ@ dy e f dz YZA d{ e f d| YZB d} e f d~ YZC d e f d YZD d e f d YZE d e f d YZF d e f d YZG d e f d YZH d e f d YZI d e f d YZJ d e f d YZK d e f d YZL d e f d YZM d e f d YZN d e f d YZO d e f d YZP d e f d YZQ xQ eR iS D]@ \ ZT ZU eV eU eW o$ eX eU e o eU e eT iY s c C s d t | i t | i f S( Ns
Add((%s, %s))( R R" R# ( R ( ( s" /usr/lib/python2.6/compiler/ast.pyR A s N( R R t NoneR R R R ( ( ( s" /usr/lib/python2.6/compiler/ast.pyR! 5 s t Andc B s/ e Z d d Z d Z d Z d Z RS( c C s | | _ | | _ d S( N( R R$ ( R R R$ ( ( s" /usr/lib/python2.6/compiler/ast.pyR E s c C s t t | i S( N( R R R ( R ( ( s" /usr/lib/python2.6/compiler/ast.pyR I s c C s& g } | i t | i t | S( N( t extendR R R ( R t nodelist( ( s" /usr/lib/python2.6/compiler/ast.pyR L s c C s d t | i f S( Ns And(%s)( R R ( R ( ( s" /usr/lib/python2.6/compiler/ast.pyR Q s N( R R R& R R R R ( ( ( s" /usr/lib/python2.6/compiler/ast.pyR' D s t AssAttrc B s/ e Z d d Z d Z d Z d Z RS( c C s( | | _ | | _ | | _ | | _ d S( N( t exprt attrnamet flagsR$ ( R R+ R, R- R$ ( ( s" /usr/lib/python2.6/compiler/ast.pyR U s c C s | i | i | i f S( N( R+ R, R- ( R ( ( s" /usr/lib/python2.6/compiler/ast.pyR [ s c C s
| i f S( N( R+ ( R ( ( s" /usr/lib/python2.6/compiler/ast.pyR ^ s c C s, d t | i t | i t | i f S( Ns AssAttr(%s, %s, %s)( R R+ R, R- ( R ( ( s" /usr/lib/python2.6/compiler/ast.pyR a s N( R R R& R R R R ( ( ( s" /usr/lib/python2.6/compiler/ast.pyR* T s t AssListc B s/ e Z d d Z d Z d Z d Z RS( c C s | | _ | | _ d S( N( R R$ ( R R R$ ( ( s" /usr/lib/python2.6/compiler/ast.pyR e s c C s t t | i S( N( R R R ( R ( ( s" /usr/lib/python2.6/compiler/ast.pyR i s c C s& g } | i t | i t | S( N( R( R R R ( R R) ( ( s" /usr/lib/python2.6/compiler/ast.pyR l s c C s d t | i f S( Ns AssList(%s)( R R ( R ( ( s" /usr/lib/python2.6/compiler/ast.pyR q s N( R R R& R R R R ( ( ( s" /usr/lib/python2.6/compiler/ast.pyR. d s t AssNamec B s/ e Z d d Z d Z d Z d Z RS( c C s | | _ | | _ | | _ d S( N( t nameR- R$ ( R R0 R- R$ ( ( s" /usr/lib/python2.6/compiler/ast.pyR u s c C s | i | i f S( N( R0 R- ( R ( ( s" /usr/lib/python2.6/compiler/ast.pyR z s c C s d S( N( ( ( R ( ( s" /usr/lib/python2.6/compiler/ast.pyR } s c C s d t | i t | i f S( Ns AssName(%s, %s)( R R0 R- ( R ( ( s" /usr/lib/python2.6/compiler/ast.pyR s N( R R R& R R R R ( ( ( s" /usr/lib/python2.6/compiler/ast.pyR/ t s t AssTuplec B s/ e Z d d Z d Z d Z d Z RS( c C s | | _ | | _ d S( N( R R$ ( R R R$ ( ( s" /usr/lib/python2.6/compiler/ast.pyR s c C s t t | i S( N( R R R ( R ( ( s" /usr/lib/python2.6/compiler/ast.pyR s c C s& g } | i t | i t | S( N( R( R R R ( R R) ( ( s" /usr/lib/python2.6/compiler/ast.pyR s c C s d t | i f S( Ns AssTuple(%s)( R R ( R ( ( s" /usr/lib/python2.6/compiler/ast.pyR s N( R R R& R R R R ( ( ( s" /usr/lib/python2.6/compiler/ast.pyR1 s t Assertc B s/ e Z d d Z d Z d Z d Z RS( c C s | | _ | | _ | | _ d S( N( t testt failR$ ( R R3 R4 R$ ( ( s" /usr/lib/python2.6/compiler/ast.pyR s c C s0 g } | i | i | i | i t | S( N( R R3 R4 R ( R t children( ( s" /usr/lib/python2.6/compiler/ast.pyR s c C sD g } | i | i | i d j o | i | i n t | S( N( R R3 R4 R& R ( R R) ( ( s" /usr/lib/python2.6/compiler/ast.pyR s
c C s d t | i t | i f S( Ns Assert(%s, %s)( R R3 R4 ( R ( ( s" /usr/lib/python2.6/compiler/ast.pyR s N( R R R& R R R R ( ( ( s" /usr/lib/python2.6/compiler/ast.pyR2 s t Assignc B s/ e Z d d Z d Z d Z d Z RS( c C s | | _ | | _ | | _ d S( N( R R+ R$ ( R R R+ R$ ( ( s" /usr/lib/python2.6/compiler/ast.pyR s c C s6 g } | i t | i | i | i t | S( N( R( R R R R+ R ( R R5 ( ( s" /usr/lib/python2.6/compiler/ast.pyR s c C s6 g } | i t | i | i | i t | S( N( R( R R R R+ R ( R R) ( ( s" /usr/lib/python2.6/compiler/ast.pyR s c C s d t | i t | i f S( Ns Assign(%s, %s)( R R R+ ( R ( ( s" /usr/lib/python2.6/compiler/ast.pyR s N( R R R& R R R R ( ( ( s" /usr/lib/python2.6/compiler/ast.pyR6 s t AugAssignc B s/ e Z d d Z d Z d Z d Z RS( c C s( | | _ | | _ | | _ | | _ d S( N( R t opR+ R$ ( R R R8 R+ R$ ( ( s" /usr/lib/python2.6/compiler/ast.pyR s c C s | i | i | i f S( N( R R8 R+ ( R ( ( s" /usr/lib/python2.6/compiler/ast.pyR s c C s | i | i f S( N( R R+ ( R ( ( s" /usr/lib/python2.6/compiler/ast.pyR s c C s, d t | i t | i t | i f S( Ns AugAssign(%s, %s, %s)( R R R8 R+ ( R ( ( s" /usr/lib/python2.6/compiler/ast.pyR s N( R R R& R R R R ( ( ( s" /usr/lib/python2.6/compiler/ast.pyR7 s t Backquotec B s/ e Z d d Z d Z d Z d Z RS( c C s | | _ | | _ d S( N( R+ R$ ( R R+ R$ ( ( s" /usr/lib/python2.6/compiler/ast.pyR s c C s
| i f S( N( R+ ( R ( ( s" /usr/lib/python2.6/compiler/ast.pyR s c C s
| i f S( N( R+ ( R ( ( s" /usr/lib/python2.6/compiler/ast.pyR s c C s d t | i f S( Ns
Backquote(%s)( R R+ ( R ( ( s" /usr/lib/python2.6/compiler/ast.pyR s N( R R R& R R R R ( ( ( s" /usr/lib/python2.6/compiler/ast.pyR9 s t Bitandc B s/ e Z d d Z d Z d Z d Z RS( c C s | | _ | | _ d S( N( R R$ ( R R R$ ( ( s" /usr/lib/python2.6/compiler/ast.pyR s c C s t t | i S( N( R R R ( R ( ( s" /usr/lib/python2.6/compiler/ast.pyR s c C s& g } | i t | i t | S( N( R( R R R ( R R) ( ( s" /usr/lib/python2.6/compiler/ast.pyR s c C s d t | i f S( Ns
Bitand(%s)( R R ( R ( ( s" /usr/lib/python2.6/compiler/ast.pyR s N( R R R& R R R R ( ( ( s" /usr/lib/python2.6/compiler/ast.pyR: s t Bitorc B s/ e Z d d Z d Z d Z d Z RS( c C s | | _ | | _ d S( N( R R$ ( R R R$ ( ( s" /usr/lib/python2.6/compiler/ast.pyR s c C s t t | i S( N( R R R ( R ( ( s" /usr/lib/python2.6/compiler/ast.pyR s c C s& g } | i t | i t | S( N( R( R R R ( R R) ( ( s" /usr/lib/python2.6/compiler/ast.pyR s c C s d t | i f S( Ns Bitor(%s)( R R ( R ( ( s" /usr/lib/python2.6/compiler/ast.pyR s N( R R R& R R R R ( ( ( s" /usr/lib/python2.6/compiler/ast.pyR; s t Bitxorc B s/ e Z d d Z d Z d Z d Z RS( c C s | | _ | | _ d S( N( R R$ ( R R R$ ( ( s" /usr/lib/python2.6/compiler/ast.pyR s c C s t t | i S( N( R R R ( R ( ( s" /usr/lib/python2.6/compiler/ast.pyR s c C s& g } | i t | i t | S( N( R( R R R ( R R) ( ( s" /usr/lib/python2.6/compiler/ast.pyR s c C s d t | i f S( Ns
Bitxor(%s)( R R ( R ( ( s" /usr/lib/python2.6/compiler/ast.pyR s N( R R R& R R R R ( ( ( s" /usr/lib/python2.6/compiler/ast.pyR< s t Breakc B s/ e Z d d Z d Z d Z d Z RS( c C s
| | _ d S( N( R$ ( R R$ ( ( s" /usr/lib/python2.6/compiler/ast.pyR
s c C s d S( N( ( ( R ( ( s" /usr/lib/python2.6/compiler/ast.pyR s c C s d S( N( ( ( R ( ( s" /usr/lib/python2.6/compiler/ast.pyR s c C s d S( Ns Break()( ( R ( ( s" /usr/lib/python2.6/compiler/ast.pyR s N( R R R& R R R R ( ( ( s" /usr/lib/python2.6/compiler/ast.pyR= s t CallFuncc B s5 e Z d d d d Z d Z d Z d Z RS( c C s1 | | _ | | _ | | _ | | _ | | _ d S( N( R t argst star_argst
dstar_argsR$ ( R R R? R@ RA R$ ( ( s" /usr/lib/python2.6/compiler/ast.pyR s
c C sV g } | i | i | i t | i | i | i | i | i t | S( N( R R R( R R? R@ RA R ( R R5 ( ( s" /usr/lib/python2.6/compiler/ast.pyR ! s c C s~ g } | i | i | i t | i | i d j o | i | i n | i d j o | i | i n t | S( N( R R R( R R? R@ R& RA R ( R R) ( ( s" /usr/lib/python2.6/compiler/ast.pyR ) s c C s8 d t | i t | i t | i t | i f S( Ns CallFunc(%s, %s, %s, %s)( R R R? R@ RA ( R ( ( s" /usr/lib/python2.6/compiler/ast.pyR 3 s N( R R R& R R R R ( ( ( s" /usr/lib/python2.6/compiler/ast.pyR> s
t Classc B s2 e Z d d d Z d Z d Z d Z RS( c C s: | | _ | | _ | | _ | | _ | | _ | | _ d S( N( R0 t basest doct codet
decoratorsR$ ( R R0 RC RD RE RF R$ ( ( s" /usr/lib/python2.6/compiler/ast.pyR 7 s c C sf g } | i | i | i t | i | i | i | i | i | i | i t | S( N( R R0 R( R RC RD RE RF R ( R R5 ( ( s" /usr/lib/python2.6/compiler/ast.pyR ? s c C sZ g } | i t | i | i | i | i d j o | i | i n t | S( N( R( R RC R RE RF R& R ( R R) ( ( s" /usr/lib/python2.6/compiler/ast.pyR H s c C sD d t | i t | i t | i t | i t | i f S( Ns Class(%s, %s, %s, %s, %s)( R R0 RC RD RE RF ( R ( ( s" /usr/lib/python2.6/compiler/ast.pyR P s N( R R R& R R R R ( ( ( s" /usr/lib/python2.6/compiler/ast.pyRB 6 s t Comparec B s/ e Z d d Z d Z d Z d Z RS( c C s | | _ | | _ | | _ d S( N( R+ t opsR$ ( R R+ RH R$ ( ( s" /usr/lib/python2.6/compiler/ast.pyR T s c C s6 g } | i | i | i t | i t | S( N( R R+ R( R RH R ( R R5 ( ( s" /usr/lib/python2.6/compiler/ast.pyR Y s c C s6 g } | i | i | i t | i t | S( N( R R+ R( R RH R ( R R) ( ( s" /usr/lib/python2.6/compiler/ast.pyR _ s c C s d t | i t | i f S( Ns Compare(%s, %s)( R R+ RH ( R ( ( s" /usr/lib/python2.6/compiler/ast.pyR e s N( R R R& R R R R ( ( ( s" /usr/lib/python2.6/compiler/ast.pyRG S s t Constc B s/ e Z d d Z d Z d Z d Z RS( c C s | | _ | | _ d S( N( t valueR$ ( R RJ R$ ( ( s" /usr/lib/python2.6/compiler/ast.pyR i s c C s
| i f S( N( RJ ( R ( ( s" /usr/lib/python2.6/compiler/ast.pyR m s c C s d S( N( ( ( R ( ( s" /usr/lib/python2.6/compiler/ast.pyR p s c C s d t | i f S( Ns Const(%s)( R RJ ( R ( ( s" /usr/lib/python2.6/compiler/ast.pyR s s N( R R R& R R R R ( ( ( s" /usr/lib/python2.6/compiler/ast.pyRI h s t Continuec B s/ e Z d d Z d Z d Z d Z RS( c C s
| | _ d S( N( R$ ( R R$ ( ( s" /usr/lib/python2.6/compiler/ast.pyR w s c C s d S( N( ( ( R ( ( s" /usr/lib/python2.6/compiler/ast.pyR z s c C s d S( N( ( ( R ( ( s" /usr/lib/python2.6/compiler/ast.pyR } s c C s d S( Ns
Continue()( ( R ( ( s" /usr/lib/python2.6/compiler/ast.pyR s N( R R R& R R R R ( ( ( s" /usr/lib/python2.6/compiler/ast.pyRK v s t
Decoratorsc B s/ e Z d d Z d Z d Z d Z RS( c C s | | _ | | _ d S( N( R R$ ( R R R$ ( ( s" /usr/lib/python2.6/compiler/ast.pyR s c C s t t | i S( N( R R R ( R ( ( s" /usr/lib/python2.6/compiler/ast.pyR s c C s& g } | i t | i t | S( N( R( R R R ( R R) ( ( s" /usr/lib/python2.6/compiler/ast.pyR s c C s d t | i f S( Ns Decorators(%s)( R R ( R ( ( s" /usr/lib/python2.6/compiler/ast.pyR s N( R R R& R R R R ( ( ( s" /usr/lib/python2.6/compiler/ast.pyRL s t Dictc B s/ e Z d d Z d Z d Z d Z RS( c C s | | _ | | _ d S( N( t itemsR$ ( R RN R$ ( ( s" /usr/lib/python2.6/compiler/ast.pyR s c C s t t | i S( N( R R RN ( R ( ( s" /usr/lib/python2.6/compiler/ast.pyR s c C s& g } | i t | i t | S( N( R( R RN R ( R R) ( ( s" /usr/lib/python2.6/compiler/ast.pyR s c C s d t | i f S( Ns Dict(%s)( R RN ( R ( ( s" /usr/lib/python2.6/compiler/ast.pyR s N( R R R& R R R R ( ( ( s" /usr/lib/python2.6/compiler/ast.pyRM s t Discardc B s/ e Z d d Z d Z d Z d Z RS( c C s | | _ | | _ d S( N( R+ R$ ( R R+ R$ ( ( s" /usr/lib/python2.6/compiler/ast.pyR s c C s
| i f S( N( R+ ( R ( ( s" /usr/lib/python2.6/compiler/ast.pyR s c C s
| i f S( N( R+ ( R ( ( s" /usr/lib/python2.6/compiler/ast.pyR s c C s d t | i f S( Ns Discard(%s)( R R+ ( R ( ( s" /usr/lib/python2.6/compiler/ast.pyR s N( R R R& R R R R ( ( ( s" /usr/lib/python2.6/compiler/ast.pyRO s t Divc B s/ e Z d d Z d Z d Z d Z RS( c C s' | d | _ | d | _ | | _ d S( Ni i ( R" R# R$ ( R R% R$ ( ( s" /usr/lib/python2.6/compiler/ast.pyR s
c C s | i | i f S( N( R" R# ( R ( ( s" /usr/lib/python2.6/compiler/ast.pyR s c C s | i | i f S( N( R" R# ( R ( ( s" /usr/lib/python2.6/compiler/ast.pyR s c C s d t | i t | i f S( Ns
Div((%s, %s))( R R" R# ( R ( ( s" /usr/lib/python2.6/compiler/ast.pyR s N( R R R& R R R R ( ( ( s" /usr/lib/python2.6/compiler/ast.pyRP s t Ellipsisc B s/ e Z d d Z d Z d Z d Z RS( c C s
| | _ d S( N( R$ ( R R$ ( ( s" /usr/lib/python2.6/compiler/ast.pyR s c C s d S( N( ( ( R ( ( s" /usr/lib/python2.6/compiler/ast.pyR s c C s d S( N( ( ( R ( ( s" /usr/lib/python2.6/compiler/ast.pyR s c C s d S( Ns
Ellipsis()( ( R ( ( s" /usr/lib/python2.6/compiler/ast.pyR s N( R R R& R R R R ( ( ( s" /usr/lib/python2.6/compiler/ast.pyRQ s t Execc B s/ e Z d d Z d Z d Z d Z RS( c C s( | | _ | | _ | | _ | | _ d S( N( R+ t localst globalsR$ ( R R+ RS RT R$ ( ( s" /usr/lib/python2.6/compiler/ast.pyR s c C s@ g } | i | i | i | i | i | i t | S( N( R R+ RS RT R ( R R5 ( ( s" /usr/lib/python2.6/compiler/ast.pyR s
c C sh g } | i | i | i d j o | i | i n | i d j o | i | i n t | S( N( R R+ RS R& RT R ( R R) ( ( s" /usr/lib/python2.6/compiler/ast.pyR s c C s, d t | i t | i t | i f S( Ns Exec(%s, %s, %s)( R R+ RS RT ( R ( ( s" /usr/lib/python2.6/compiler/ast.pyR s N( R R R& R R R R ( ( ( s" /usr/lib/python2.6/compiler/ast.pyRR s t FloorDivc B s/ e Z d d Z d Z d Z d Z RS( c C s' | d | _ | d | _ | | _ d S( Ni i ( R" R# R$ ( R R% R$ ( ( s" /usr/lib/python2.6/compiler/ast.pyR s
c C s | i | i f S( N( R" R# ( R ( ( s" /usr/lib/python2.6/compiler/ast.pyR s c C s | i | i f S( N( R" R# ( R ( ( s" /usr/lib/python2.6/compiler/ast.pyR s c C s d t | i t | i f S( Ns FloorDiv((%s, %s))( R R" R# ( R ( ( s" /usr/lib/python2.6/compiler/ast.pyR s N( R R R& R R R R ( ( ( s" /usr/lib/python2.6/compiler/ast.pyRU s t Forc B s/ e Z d d Z d Z d Z d Z RS( c C s1 | | _ | | _ | | _ | | _ | | _ d S( N( t assignR t bodyt else_R$ ( R RW R RX RY R$ ( ( s" /usr/lib/python2.6/compiler/ast.pyR s
c C sP g } | i | i | i | i | i | i | i | i t | S( N( R RW R RX RY R ( R R5 ( ( s" /usr/lib/python2.6/compiler/ast.pyR s c C sd g } | i | i | i | i | i | i | i d j o | i | i n t | S( N( R RW R RX RY R& R ( R R) ( ( s" /usr/lib/python2.6/compiler/ast.pyR s c C s8 d t | i t | i t | i t | i f S( Ns For(%s, %s, %s, %s)( R RW R RX RY ( R ( ( s" /usr/lib/python2.6/compiler/ast.pyR s N( R R R& R R R R ( ( ( s" /usr/lib/python2.6/compiler/ast.pyRV s t Fromc B s/ e Z d d Z d Z d Z d Z RS( c C s( | | _ | | _ | | _ | | _ d S( N( t modnamet namest levelR$ ( R R[ R\ R] R$ ( ( s" /usr/lib/python2.6/compiler/ast.pyR s c C s | i | i | i f S( N( R[ R\ R] ( R ( ( s" /usr/lib/python2.6/compiler/ast.pyR s c C s d S( N( ( ( R ( ( s" /usr/lib/python2.6/compiler/ast.pyR s c C s, d t | i t | i t | i f S( Ns From(%s, %s, %s)( R R[ R\ R] ( R ( ( s" /usr/lib/python2.6/compiler/ast.pyR s N( R R R& R R R R ( ( ( s" /usr/lib/python2.6/compiler/ast.pyRZ s t Functionc B s/ e Z d d Z d Z d Z d Z RS( c C s | | _ | | _ | | _ | | _ | | _ | | _ | | _ | | _ d | _ | _
| t @o
d | _ n | t @o
d | _
n d S( Ni (
RF R0 t argnamest defaultsR- RD RE R$ R& t varargst kwargsR R ( R RF R0 R_ R` R- RD RE R$ ( ( s" /usr/lib/python2.6/compiler/ast.pyR # s
c C s g } | i | i | i | i | i | i | i t | i | i | i | i | i | i | i t
| S( N( R RF R0 R_ R( R R` R- RD RE R ( R R5 ( ( s" /usr/lib/python2.6/compiler/ast.pyR 3 s c C sZ g } | i d j o | i | i n | i t | i | i | i t | S( N( RF R& R R( R R` RE R ( R R) ( ( s" /usr/lib/python2.6/compiler/ast.pyR > s c C s\ d t | i t | i t | i t | i t | i t | i t | i f S( Ns$ Function(%s, %s, %s, %s, %s, %s, %s)( R RF R0 R_ R` R- RD RE ( R ( ( s" /usr/lib/python2.6/compiler/ast.pyR F s N( R R R& R R R R ( ( ( s" /usr/lib/python2.6/compiler/ast.pyR^ " s t GenExprc B s/ e Z d d Z d Z d Z d Z RS( c C s2 | | _ | | _ d g | _ d | _ | _ d S( Ns .0( RE R$ R_ R& Ra Rb ( R RE R$ ( ( s" /usr/lib/python2.6/compiler/ast.pyR J s c C s
| i f S( N( RE ( R ( ( s" /usr/lib/python2.6/compiler/ast.pyR Q s c C s
| i f S( N( RE ( R ( ( s" /usr/lib/python2.6/compiler/ast.pyR T s c C s d t | i f S( Ns GenExpr(%s)( R RE ( R ( ( s" /usr/lib/python2.6/compiler/ast.pyR W s N( R R R& R R R R ( ( ( s" /usr/lib/python2.6/compiler/ast.pyRc I s t
GenExprForc B s/ e Z d d Z d Z d Z d Z RS( c C s1 | | _ | | _ | | _ | | _ t | _ d S( N( RW t itert ifsR$ t Falset
is_outmost( R RW Re Rf R$ ( ( s" /usr/lib/python2.6/compiler/ast.pyR [ s
c C sF g } | i | i | i | i | i t | i t | S( N( R RW Re R( R Rf R ( R R5 ( ( s" /usr/lib/python2.6/compiler/ast.pyR b s
c C sF g } | i | i | i | i | i t | i t | S( N( R RW Re R( R Rf R ( R R) ( ( s" /usr/lib/python2.6/compiler/ast.pyR i s
c C s, d t | i t | i t | i f S( Ns GenExprFor(%s, %s, %s)( R RW Re Rf ( R ( ( s" /usr/lib/python2.6/compiler/ast.pyR p s N( R R R& R R R R ( ( ( s" /usr/lib/python2.6/compiler/ast.pyRd Z s t GenExprIfc B s/ e Z d d Z d Z d Z d Z RS( c C s | | _ | | _ d S( N( R3 R$ ( R R3 R$ ( ( s" /usr/lib/python2.6/compiler/ast.pyR t s c C s
| i f S( N( R3 ( R ( ( s" /usr/lib/python2.6/compiler/ast.pyR x s c C s
| i f S( N( R3 ( R ( ( s" /usr/lib/python2.6/compiler/ast.pyR { s c C s d t | i f S( Ns
GenExprIf(%s)( R R3 ( R ( ( s" /usr/lib/python2.6/compiler/ast.pyR ~ s N( R R R& R R R R ( ( ( s" /usr/lib/python2.6/compiler/ast.pyRi s s t GenExprInnerc B s/ e Z d d Z d Z d Z d Z RS( c C s | | _ | | _ | | _ d S( N( R+ t qualsR$ ( R R+ Rk R$ ( ( s" /usr/lib/python2.6/compiler/ast.pyR s c C s6 g } | i | i | i t | i t | S( N( R R+ R( R Rk R ( R R5 ( ( s" /usr/lib/python2.6/compiler/ast.pyR s c C s6 g } | i | i | i t | i t | S( N( R R+ R( R Rk R ( R R) ( ( s" /usr/lib/python2.6/compiler/ast.pyR s c C s d t | i t | i f S( Ns GenExprInner(%s, %s)( R R+ Rk ( R ( ( s" /usr/lib/python2.6/compiler/ast.pyR s N( R R R& R R R R ( ( ( s" /usr/lib/python2.6/compiler/ast.pyRj s t Getattrc B s/ e Z d d Z d Z d Z d Z RS( c C s | | _ | | _ | | _ d S( N( R+ R, R$ ( R R+ R, R$ ( ( s" /usr/lib/python2.6/compiler/ast.pyR s c C s | i | i f S( N( R+ R, ( R ( ( s" /usr/lib/python2.6/compiler/ast.pyR s c C s
| i f S( N( R+ ( R ( ( s" /usr/lib/python2.6/compiler/ast.pyR s c C s d t | i t | i f S( Ns Getattr(%s, %s)( R R+ R, ( R ( ( s" /usr/lib/python2.6/compiler/ast.pyR s N( R R R& R R R R ( ( ( s" /usr/lib/python2.6/compiler/ast.pyRl s t Globalc B s/ e Z d d Z d Z d Z d Z RS( c C s | | _ | | _ d S( N( R\ R$ ( R R\ R$ ( ( s" /usr/lib/python2.6/compiler/ast.pyR s c C s
| i f S( N( R\ ( R ( ( s" /usr/lib/python2.6/compiler/ast.pyR s c C s d S( N( ( ( R ( ( s" /usr/lib/python2.6/compiler/ast.pyR s c C s d t | i f S( Ns
Global(%s)( R R\ ( R ( ( s" /usr/lib/python2.6/compiler/ast.pyR s N( R R R& R R R R ( ( ( s" /usr/lib/python2.6/compiler/ast.pyRm s t Ifc B s/ e Z d d Z d Z d Z d Z RS( c C s | | _ | | _ | | _ d S( N( t testsRY R$ ( R Ro RY R$ ( ( s" /usr/lib/python2.6/compiler/ast.pyR s c C s6 g } | i t | i | i | i t | S( N( R( R Ro R RY R ( R R5 ( ( s" /usr/lib/python2.6/compiler/ast.pyR s c C sJ g } | i t | i | i d j o | i | i n t | S( N( R( R Ro RY R& R R ( R R) ( ( s" /usr/lib/python2.6/compiler/ast.pyR s
c C s d t | i t | i f S( Ns
If(%s, %s)( R Ro RY ( R ( ( s" /usr/lib/python2.6/compiler/ast.pyR s N( R R R& R R R R ( ( ( s" /usr/lib/python2.6/compiler/ast.pyRn s t IfExpc B s/ e Z d d Z d Z d Z d Z RS( c C s( | | _ | | _ | | _ | | _ d S( N( R3 t thenRY R$ ( R R3 Rq RY R$ ( ( s" /usr/lib/python2.6/compiler/ast.pyR s c C s | i | i | i f S( N( R3 Rq RY ( R ( ( s" /usr/lib/python2.6/compiler/ast.pyR s c C s | i | i | i f S( N( R3 Rq RY ( R ( ( s" /usr/lib/python2.6/compiler/ast.pyR s c C s, d t | i t | i t | i f S( Ns IfExp(%s, %s, %s)( R R3 Rq RY ( R ( ( s" /usr/lib/python2.6/compiler/ast.pyR s N( R R R& R R R R ( ( ( s" /usr/lib/python2.6/compiler/ast.pyRp s t Importc B s/ e Z d d Z d Z d Z d Z RS( c C s | | _ | | _ d S( N( R\ R$ ( R R\ R$ ( ( s" /usr/lib/python2.6/compiler/ast.pyR s c C s
| i f S( N( R\ ( R ( ( s" /usr/lib/python2.6/compiler/ast.pyR s c C s d S( N( ( ( R ( ( s" /usr/lib/python2.6/compiler/ast.pyR s c C s d t | i f S( Ns
Import(%s)( R R\ ( R ( ( s" /usr/lib/python2.6/compiler/ast.pyR s N( R R R& R R R R ( ( ( s" /usr/lib/python2.6/compiler/ast.pyRr s t Invertc B s/ e Z d d Z d Z d Z d Z RS( c C s | | _ | | _ d S( N( R+ R$ ( R R+ R$ ( ( s" /usr/lib/python2.6/compiler/ast.pyR s c C s
| i f S( N( R+ ( R ( ( s" /usr/lib/python2.6/compiler/ast.pyR s c C s
| i f S( N( R+ ( R ( ( s" /usr/lib/python2.6/compiler/ast.pyR s c C s d t | i f S( Ns
Invert(%s)( R R+ ( R ( ( s" /usr/lib/python2.6/compiler/ast.pyR s N( R R R& R R R R ( ( ( s" /usr/lib/python2.6/compiler/ast.pyRs s t Keywordc B s/ e Z d d Z d Z d Z d Z RS( c C s | | _ | | _ | | _ d S( N( R0 R+ R$ ( R R0 R+ R$ ( ( s" /usr/lib/python2.6/compiler/ast.pyR s c C s | i | i f S( N( R0 R+ ( R ( ( s" /usr/lib/python2.6/compiler/ast.pyR s c C s
| i f S( N( R+ ( R ( ( s" /usr/lib/python2.6/compiler/ast.pyR s c C s d t | i t | i f S( Ns Keyword(%s, %s)( R R0 R+ ( R ( ( s" /usr/lib/python2.6/compiler/ast.pyR s N( R R R& R R R R ( ( ( s" /usr/lib/python2.6/compiler/ast.pyRt s t Lambdac B s/ e Z d d Z d Z d Z d Z RS( c C sq | | _ | | _ | | _ | | _ | | _ d | _ | _ | t @o
d | _ n | t @o
d | _ n d S( Ni (
R_ R` R- RE R$ R& Ra Rb R R ( R R_ R` R- RE R$ ( ( s" /usr/lib/python2.6/compiler/ast.pyR s
c C sV g } | i | i | i t | i | i | i | i | i t | S( N( R R_ R( R R` R- RE R ( R R5 ( ( s" /usr/lib/python2.6/compiler/ast.pyR s c C s6 g } | i t | i | i | i t | S( N( R( R R` R RE R ( R R) ( ( s" /usr/lib/python2.6/compiler/ast.pyR s c C s8 d t | i t | i t | i t | i f S( Ns Lambda(%s, %s, %s, %s)( R R_ R` R- RE ( R ( ( s" /usr/lib/python2.6/compiler/ast.pyR s N( R R R& R R R R ( ( ( s" /usr/lib/python2.6/compiler/ast.pyRu s
t LeftShiftc B s/ e Z d d Z d Z d Z d Z RS( c C s' | d | _ | d | _ | | _ d S( Ni i ( R" R# R$ ( R R% R$ ( ( s" /usr/lib/python2.6/compiler/ast.pyR $ s
c C s | i | i f S( N( R" R# ( R ( ( s" /usr/lib/python2.6/compiler/ast.pyR ) s c C s | i | i f S( N( R" R# ( R ( ( s" /usr/lib/python2.6/compiler/ast.pyR , s c C s d t | i t | i f S( Ns LeftShift((%s, %s))( R R" R# ( R ( ( s" /usr/lib/python2.6/compiler/ast.pyR / s N( R R R& R R R R ( ( ( s" /usr/lib/python2.6/compiler/ast.pyRv # s t Listc B s/ e Z d d Z d Z d Z d Z RS( c C s | | _ | | _ d S( N( R R$ ( R R R$ ( ( s" /usr/lib/python2.6/compiler/ast.pyR 3 s c C s t t | i S( N( R R R ( R ( ( s" /usr/lib/python2.6/compiler/ast.pyR 7 s c C s& g } | i t | i t | S( N( R( R R R ( R R) ( ( s" /usr/lib/python2.6/compiler/ast.pyR : s c C s d t | i f S( Ns List(%s)( R R ( R ( ( s" /usr/lib/python2.6/compiler/ast.pyR ? s N( R R R& R R R R ( ( ( s" /usr/lib/python2.6/compiler/ast.pyRw 2 s t ListCompc B s/ e Z d d Z d Z d Z d Z RS( c C s | | _ | | _ | | _ d S( N( R+ Rk R$ ( R R+ Rk R$ ( ( s" /usr/lib/python2.6/compiler/ast.pyR C s c C s6 g } | i | i | i t | i t | S( N( R R+ R( R Rk R ( R R5 ( ( s" /usr/lib/python2.6/compiler/ast.pyR H s c C s6 g } | i | i | i t | i t | S( N( R R+ R( R Rk R ( R R) ( ( s" /usr/lib/python2.6/compiler/ast.pyR N s c C s d t | i t | i f S( Ns ListComp(%s, %s)( R R+ Rk ( R ( ( s" /usr/lib/python2.6/compiler/ast.pyR T s N( R R R& R R R R ( ( ( s" /usr/lib/python2.6/compiler/ast.pyRx B s t ListCompForc B s/ e Z d d Z d Z d Z d Z RS( c C s( | | _ | | _ | | _ | | _ d S( N( RW R Rf R$ ( R RW R Rf R$ ( ( s" /usr/lib/python2.6/compiler/ast.pyR X s c C sF g } | i | i | i | i | i t | i t | S( N( R RW R R( R Rf R ( R R5 ( ( s" /usr/lib/python2.6/compiler/ast.pyR ^ s
c C sF g } | i | i | i | i | i t | i t | S( N( R RW R R( R Rf R ( R R) ( ( s" /usr/lib/python2.6/compiler/ast.pyR e s
c C s, d t | i t | i t | i f S( Ns ListCompFor(%s, %s, %s)( R RW R Rf ( R ( ( s" /usr/lib/python2.6/compiler/ast.pyR l s N( R R R& R R R R ( ( ( s" /usr/lib/python2.6/compiler/ast.pyRy W s t
ListCompIfc B s/ e Z d d Z d Z d Z d Z RS( c C s | | _ | | _ d S( N( R3 R$ ( R R3 R$ ( ( s" /usr/lib/python2.6/compiler/ast.pyR p s c C s
| i f S( N( R3 ( R ( ( s" /usr/lib/python2.6/compiler/ast.pyR t s c C s
| i f S( N( R3 ( R ( ( s" /usr/lib/python2.6/compiler/ast.pyR w s c C s d t | i f S( Ns ListCompIf(%s)( R R3 ( R ( ( s" /usr/lib/python2.6/compiler/ast.pyR z s N( R R R& R R R R ( ( ( s" /usr/lib/python2.6/compiler/ast.pyRz o s t Modc B s/ e Z d d Z d Z d Z d Z RS( c C s' | d | _ | d | _ | | _ d S( Ni i ( R" R# R$ ( R R% R$ ( ( s" /usr/lib/python2.6/compiler/ast.pyR ~ s
c C s | i | i f S( N( R" R# ( R ( ( s" /usr/lib/python2.6/compiler/ast.pyR s c C s | i | i f S( N( R" R# ( R ( ( s" /usr/lib/python2.6/compiler/ast.pyR s c C s d t | i t | i f S( Ns
Mod((%s, %s))( R R" R# ( R ( ( s" /usr/lib/python2.6/compiler/ast.pyR s N( R R R& R R R R ( ( ( s" /usr/lib/python2.6/compiler/ast.pyR{ } s t Modulec B s/ e Z d d Z d Z d Z d Z RS( c C s | | _ | | _ | | _ d S( N( RD R R$ ( R RD R R$ ( ( s" /usr/lib/python2.6/compiler/ast.pyR s c C s | i | i f S( N( RD R ( R ( ( s" /usr/lib/python2.6/compiler/ast.pyR s c C s
| i f S( N( R ( R ( ( s" /usr/lib/python2.6/compiler/ast.pyR s c C s d t | i t | i f S( Ns Module(%s, %s)( R RD R ( R ( ( s" /usr/lib/python2.6/compiler/ast.pyR s N( R R R& R R R R ( ( ( s" /usr/lib/python2.6/compiler/ast.pyR| s t Mulc B s/ e Z d d Z d Z d Z d Z RS( c C s' | d | _ | d | _ | | _ d S( Ni i ( R" R# R$ ( R R% R$ ( ( s" /usr/lib/python2.6/compiler/ast.pyR s
c C s | i | i f S( N( R" R# ( R ( ( s" /usr/lib/python2.6/compiler/ast.pyR s c C s | i | i f S( N( R" R# ( R ( ( s" /usr/lib/python2.6/compiler/ast.pyR s c C s d t | i t | i f S( Ns
Mul((%s, %s))( R R" R# ( R ( ( s" /usr/lib/python2.6/compiler/ast.pyR s N( R R R& R R R R ( ( ( s" /usr/lib/python2.6/compiler/ast.pyR} s t Namec B s/ e Z d d Z d Z d Z d Z RS( c C s | | _ | | _ d S( N( R0 R$ ( R R0 R$ ( ( s" /usr/lib/python2.6/compiler/ast.pyR s c C s
| i f S( N( R0 ( R ( ( s" /usr/lib/python2.6/compiler/ast.pyR s c C s d S( N( ( ( R ( ( s" /usr/lib/python2.6/compiler/ast.pyR s c C s d t | i f S( Ns Name(%s)( R R0 ( R ( ( s" /usr/lib/python2.6/compiler/ast.pyR s N( R R R& R R R R ( ( ( s" /usr/lib/python2.6/compiler/ast.pyR~ s t Notc B s/ e Z d d Z d Z d Z d Z RS( c C s | | _ | | _ d S( N( R+ R$ ( R R+ R$ ( ( s" /usr/lib/python2.6/compiler/ast.pyR s c C s
| i f S( N( R+ ( R ( ( s" /usr/lib/python2.6/compiler/ast.pyR s c C s
| i f S( N( R+ ( R ( ( s" /usr/lib/python2.6/compiler/ast.pyR s c C s d t | i f S( Ns Not(%s)( R R+ ( R ( ( s" /usr/lib/python2.6/compiler/ast.pyR s N( R R R& R R R R ( ( ( s" /usr/lib/python2.6/compiler/ast.pyR s t Orc B s/ e Z d d Z d Z d Z d Z RS( c C s | | _ | | _ d S( N( R R$ ( R R R$ ( ( s" /usr/lib/python2.6/compiler/ast.pyR s c C s t t | i S( N( R R R ( R ( ( s" /usr/lib/python2.6/compiler/ast.pyR s c C s& g } | i t | i t | S( N( R( R R R ( R R) ( ( s" /usr/lib/python2.6/compiler/ast.pyR s c C s d t | i f S( Ns Or(%s)( R R ( R ( ( s" /usr/lib/python2.6/compiler/ast.pyR s N( R R R& R R R R ( ( ( s" /usr/lib/python2.6/compiler/ast.pyR s t Passc B s/ e Z d d Z d Z d Z d Z RS( c C s
| | _ d S( N( R$ ( R R$ ( ( s" /usr/lib/python2.6/compiler/ast.pyR s c C s d S( N( ( ( R ( ( s" /usr/lib/python2.6/compiler/ast.pyR s c C s d S( N( ( ( R ( ( s" /usr/lib/python2.6/compiler/ast.pyR s c C s d S( Ns Pass()( ( R ( ( s" /usr/lib/python2.6/compiler/ast.pyR s N( R R R& R R R R ( ( ( s" /usr/lib/python2.6/compiler/ast.pyR s t Powerc B s/ e Z d d Z d Z d Z d Z RS( c C s' | d | _ | d | _ | | _ d S( Ni i ( R" R# R$ ( R R% R$ ( ( s" /usr/lib/python2.6/compiler/ast.pyR s
c C s | i | i f S( N( R" R# ( R ( ( s" /usr/lib/python2.6/compiler/ast.pyR s c C s | i | i f S( N( R" R# ( R ( ( s" /usr/lib/python2.6/compiler/ast.pyR s c C s d t | i t | i f S( Ns Power((%s, %s))( R R" R# ( R ( ( s" /usr/lib/python2.6/compiler/ast.pyR s N( R R R& R R R R ( ( ( s" /usr/lib/python2.6/compiler/ast.pyR s t Printc B s/ e Z d d Z d Z d Z d Z RS( c C s | | _ | | _ | | _ d S( N( R t destR$ ( R R R R$ ( ( s" /usr/lib/python2.6/compiler/ast.pyR s c C s6 g } | i t | i | i | i t | S( N( R( R R R R R ( R R5 ( ( s" /usr/lib/python2.6/compiler/ast.pyR s c C sJ g } | i t | i | i d j o | i | i n t | S( N( R( R R R R& R R ( R R) ( ( s" /usr/lib/python2.6/compiler/ast.pyR s
c C s d t | i t | i f S( Ns
Print(%s, %s)( R R R ( R ( ( s" /usr/lib/python2.6/compiler/ast.pyR s N( R R R& R R R R ( ( ( s" /usr/lib/python2.6/compiler/ast.pyR s t Printnlc B s/ e Z d d Z d Z d Z d Z RS( c C s | | _ | | _ | | _ d S( N( R R R$ ( R R R R$ ( ( s" /usr/lib/python2.6/compiler/ast.pyR s c C s6 g } | i t | i | i | i t | S( N( R( R R R R R ( R R5 ( ( s" /usr/lib/python2.6/compiler/ast.pyR s c C sJ g } | i t | i | i d j o | i | i n t | S( N( R( R R R R& R R ( R R) ( ( s" /usr/lib/python2.6/compiler/ast.pyR s
c C s d t | i t | i f S( Ns Printnl(%s, %s)( R R R ( R ( ( s" /usr/lib/python2.6/compiler/ast.pyR s N( R R R& R R R R ( ( ( s" /usr/lib/python2.6/compiler/ast.pyR s t Raisec B s/ e Z d d Z d Z d Z d Z RS( c C s( | | _ | | _ | | _ | | _ d S( N( t expr1t expr2t expr3R$ ( R R R R R$ ( ( s" /usr/lib/python2.6/compiler/ast.pyR s c C s@ g } | i | i | i | i | i | i t | S( N( R R R R R ( R R5 ( ( s" /usr/lib/python2.6/compiler/ast.pyR % s
c C s| g } | i d j o | i | i n | i d j o | i | i n | i d j o | i | i n t | S( N( R R& R R R R ( R R) ( ( s" /usr/lib/python2.6/compiler/ast.pyR , s c C s, d t | i t | i t | i f S( Ns Raise(%s, %s, %s)( R R R R ( R ( ( s" /usr/lib/python2.6/compiler/ast.pyR 6 s N( R R R& R R R R ( ( ( s" /usr/lib/python2.6/compiler/ast.pyR s
t Returnc B s/ e Z d d Z d Z d Z d Z RS( c C s | | _ | | _ d S( N( RJ R$ ( R RJ R$ ( ( s" /usr/lib/python2.6/compiler/ast.pyR : s c C s
| i f S( N( RJ ( R ( ( s" /usr/lib/python2.6/compiler/ast.pyR > s c C s
| i f S( N( RJ ( R ( ( s" /usr/lib/python2.6/compiler/ast.pyR A s c C s d t | i f S( Ns
Return(%s)( R RJ ( R ( ( s" /usr/lib/python2.6/compiler/ast.pyR D s N( R R R& R R R R ( ( ( s" /usr/lib/python2.6/compiler/ast.pyR 9 s t
RightShiftc B s/ e Z d d Z d Z d Z d Z RS( c C s' | d | _ | d | _ | | _ d S( Ni i ( R" R# R$ ( R R% R$ ( ( s" /usr/lib/python2.6/compiler/ast.pyR H s
c C s | i | i f S( N( R" R# ( R ( ( s" /usr/lib/python2.6/compiler/ast.pyR M s c C s | i | i f S( N( R" R# ( R ( ( s" /usr/lib/python2.6/compiler/ast.pyR P s c C s d t | i t | i f S( Ns RightShift((%s, %s))( R R" R# ( R ( ( s" /usr/lib/python2.6/compiler/ast.pyR S s N( R R R& R R R R ( ( ( s" /usr/lib/python2.6/compiler/ast.pyR G s t Slicec B s/ e Z d d Z d Z d Z d Z RS( c C s1 | | _ | | _ | | _ | | _ | | _ d S( N( R+ R- t lowert upperR$ ( R R+ R- R R R$ ( ( s" /usr/lib/python2.6/compiler/ast.pyR W s
c C sP g } | i | i | i | i | i | i | i | i t | S( N( R R+ R- R R R ( R R5 ( ( s" /usr/lib/python2.6/compiler/ast.pyR ^ s c C sh g } | i | i | i d j o | i | i n | i d j o | i | i n t | S( N( R R+ R R& R R ( R R) ( ( s" /usr/lib/python2.6/compiler/ast.pyR f s c C s8 d t | i t | i t | i t | i f S( Ns Slice(%s, %s, %s, %s)( R R+ R- R R ( R ( ( s" /usr/lib/python2.6/compiler/ast.pyR o s N( R R R& R R R R ( ( ( s" /usr/lib/python2.6/compiler/ast.pyR V s t Sliceobjc B s/ e Z d d Z d Z d Z d Z RS( c C s | | _ | | _ d S( N( R R$ ( R R R$ ( ( s" /usr/lib/python2.6/compiler/ast.pyR s s c C s t t | i S( N( R R R ( R ( ( s" /usr/lib/python2.6/compiler/ast.pyR w s c C s& g } | i t | i t | S( N( R( R R R ( R R) ( ( s" /usr/lib/python2.6/compiler/ast.pyR z s c C s d t | i f S( Ns Sliceobj(%s)( R R ( R ( ( s" /usr/lib/python2.6/compiler/ast.pyR s N( R R R& R R R R ( ( ( s" /usr/lib/python2.6/compiler/ast.pyR r s t Stmtc B s/ e Z d d Z d Z d Z d Z RS( c C s | | _ | | _ d S( N( R R$ ( R R R$ ( ( s" /usr/lib/python2.6/compiler/ast.pyR s c C s t t | i S( N( R R R ( R ( ( s" /usr/lib/python2.6/compiler/ast.pyR s c C s& g } | i t | i t | S( N( R( R R R ( R R) ( ( s" /usr/lib/python2.6/compiler/ast.pyR s c C s d t | i f S( Ns Stmt(%s)( R R ( R ( ( s" /usr/lib/python2.6/compiler/ast.pyR s N( R R R& R R R R ( ( ( s" /usr/lib/python2.6/compiler/ast.pyR s t Subc B s/ e Z d d Z d Z d Z d Z RS( c C s' | d | _ | d | _ | | _ d S( Ni i ( R" R# R$ ( R R% R$ ( ( s" /usr/lib/python2.6/compiler/ast.pyR s
c C s | i | i f S( N( R" R# ( R ( ( s" /usr/lib/python2.6/compiler/ast.pyR s c C s | i | i f S( N( R" R# ( R ( ( s" /usr/lib/python2.6/compiler/ast.pyR s c C s d t | i t | i f S( Ns
Sub((%s, %s))( R R" R# ( R ( ( s" /usr/lib/python2.6/compiler/ast.pyR s N( R R R& R R R R ( ( ( s" /usr/lib/python2.6/compiler/ast.pyR s t Subscriptc B s/ e Z d d Z d Z d Z d Z RS( c C s( | | _ | | _ | | _ | | _ d S( N( R+ R- t subsR$ ( R R+ R- R R$ ( ( s" /usr/lib/python2.6/compiler/ast.pyR s c C sF g } | i | i | i | i | i t | i t | S( N( R R+ R- R( R R R ( R R5 ( ( s" /usr/lib/python2.6/compiler/ast.pyR s
c C s6 g } | i | i | i t | i t | S( N( R R+ R( R R R ( R R) ( ( s" /usr/lib/python2.6/compiler/ast.pyR s c C s, d t | i t | i t | i f S( Ns Subscript(%s, %s, %s)( R R+ R- R ( R ( ( s" /usr/lib/python2.6/compiler/ast.pyR s N( R R R& R R R R ( ( ( s" /usr/lib/python2.6/compiler/ast.pyR s t TryExceptc B s/ e Z d d Z d Z d Z d Z RS( c C s( | | _ | | _ | | _ | | _ d S( N( RX t handlersRY R$ ( R RX R RY R$ ( ( s" /usr/lib/python2.6/compiler/ast.pyR s c C sF g } | i | i | i t | i | i | i t | S( N( R RX R( R R RY R ( R R5 ( ( s" /usr/lib/python2.6/compiler/ast.pyR s
c C sZ g } | i | i | i t | i | i d j o | i | i n t | S( N( R RX R( R R RY R& R ( R R) ( ( s" /usr/lib/python2.6/compiler/ast.pyR s c C s, d t | i t | i t | i f S( Ns TryExcept(%s, %s, %s)( R RX R RY ( R ( ( s" /usr/lib/python2.6/compiler/ast.pyR s N( R R R& R R R R ( ( ( s" /usr/lib/python2.6/compiler/ast.pyR s t
TryFinallyc B s/ e Z d d Z d Z d Z d Z RS( c C s | | _ | | _ | | _ d S( N( RX t finalR$ ( R RX R R$ ( ( s" /usr/lib/python2.6/compiler/ast.pyR s c C s | i | i f S( N( RX R ( R ( ( s" /usr/lib/python2.6/compiler/ast.pyR s c C s | i | i f S( N( RX R ( R ( ( s" /usr/lib/python2.6/compiler/ast.pyR s c C s d t | i t | i f S( Ns TryFinally(%s, %s)( R RX R ( R ( ( s" /usr/lib/python2.6/compiler/ast.pyR s N( R R R& R R R R ( ( ( s" /usr/lib/python2.6/compiler/ast.pyR s t Tuplec B s/ e Z d d Z d Z d Z d Z RS( c C s | | _ | | _ d S( N( R R$ ( R R R$ ( ( s" /usr/lib/python2.6/compiler/ast.pyR s c C s t t | i S( N( R R R ( R ( ( s" /usr/lib/python2.6/compiler/ast.pyR s c C s& g } | i t | i t | S( N( R( R R R ( R R) ( ( s" /usr/lib/python2.6/compiler/ast.pyR s c C s d t | i f S( Ns Tuple(%s)( R R ( R ( ( s" /usr/lib/python2.6/compiler/ast.pyR s N( R R R& R R R R ( ( ( s" /usr/lib/python2.6/compiler/ast.pyR s t UnaryAddc B s/ e Z d d Z d Z d Z d Z RS( c C s | | _ | | _ d S( N( R+ R$ ( R R+ R$ ( ( s" /usr/lib/python2.6/compiler/ast.pyR s c C s
| i f S( N( R+ ( R ( ( s" /usr/lib/python2.6/compiler/ast.pyR s c C s
| i f S( N( R+ ( R ( ( s" /usr/lib/python2.6/compiler/ast.pyR s c C s d t | i f S( Ns UnaryAdd(%s)( R R+ ( R ( ( s" /usr/lib/python2.6/compiler/ast.pyR s N( R R R& R R R R ( ( ( s" /usr/lib/python2.6/compiler/ast.pyR s t UnarySubc B s/ e Z d d Z d Z d Z d Z RS( c C s | | _ | | _ d S( N( R+ R$ ( R R+ R$ ( ( s" /usr/lib/python2.6/compiler/ast.pyR s c C s
| i f S( N( R+ ( R ( ( s" /usr/lib/python2.6/compiler/ast.pyR s c C s
| i f S( N( R+ ( R ( ( s" /usr/lib/python2.6/compiler/ast.pyR s c C s d t | i f S( Ns UnarySub(%s)( R R+ ( R ( ( s" /usr/lib/python2.6/compiler/ast.pyR s N( R R R& R R R R ( ( ( s" /usr/lib/python2.6/compiler/ast.pyR s t Whilec B s/ e Z d d Z d Z d Z d Z RS( c C s( | | _ | | _ | | _ | | _ d S( N( R3 RX RY R$ ( R R3 RX RY R$ ( ( s" /usr/lib/python2.6/compiler/ast.pyR
s c C s@ g } | i | i | i | i | i | i t | S( N( R R3 RX RY R ( R R5 ( ( s" /usr/lib/python2.6/compiler/ast.pyR s
c C sT g } | i | i | i | i | i d j o | i | i n t | S( N( R R3 RX RY R& R ( R R) ( ( s" /usr/lib/python2.6/compiler/ast.pyR s c C s, d t | i t | i t | i f S( Ns While(%s, %s, %s)( R R3 RX RY ( R ( ( s" /usr/lib/python2.6/compiler/ast.pyR " s N( R R R& R R R R ( ( ( s" /usr/lib/python2.6/compiler/ast.pyR s t Withc B s/ e Z d d Z d Z d Z d Z RS( c C s( | | _ | | _ | | _ | | _ d S( N( R+ t varsRX R$ ( R R+ R RX R$ ( ( s" /usr/lib/python2.6/compiler/ast.pyR & s c C s@ g } | i | i | i | i | i | i t | S( N( R R+ R RX R ( R R5 ( ( s" /usr/lib/python2.6/compiler/ast.pyR , s
c C sT g } | i | i | i d j o | i | i n | i | i t | S( N( R R+ R R& RX R ( R R) ( ( s" /usr/lib/python2.6/compiler/ast.pyR 3 s c C s, d t | i t | i t | i f S( Ns With(%s, %s, %s)( R R+ R RX ( R ( ( s" /usr/lib/python2.6/compiler/ast.pyR ; s N( R R R& R R R R ( ( ( s" /usr/lib/python2.6/compiler/ast.pyR % s t Yieldc B s/ e Z d d Z d Z d Z d Z RS( c C s | | _ | | _ d S( N( RJ R$ ( R RJ R$ ( ( s" /usr/lib/python2.6/compiler/ast.pyR ? s c C s
| i f S( N( RJ ( R ( ( s" /usr/lib/python2.6/compiler/ast.pyR C s c C s
| i f S( N( RJ ( R ( ( s" /usr/lib/python2.6/compiler/ast.pyR F s c C s d t | i f S( Ns Yield(%s)( R RJ ( R ( ( s" /usr/lib/python2.6/compiler/ast.pyR I s N( R R R& R R R R ( ( ( s" /usr/lib/python2.6/compiler/ast.pyR > s N( (Z R t compiler.constsR R R R R R
R R R! R' R* R. R/ R1 R2 R6 R7 R9 R: R; R< R= R> RB RG RI RK RL RM RO RP RQ RR RU RV RZ R^ Rc Rd Ri Rj Rl Rm Rn Rp Rr Rs Rt Ru Rv Rw Rx Ry Rz R{ R| R} R~ R R R R R R R R R R R R R R R R R R R R R R RT RN R0 t objR R t
issubclassR ( ( ( s" /usr/lib/python2.6/compiler/ast.pyt s
'
PK [[) ast.pynu W+A """Python abstract syntax node definitions
This file is automatically generated by Tools/compiler/astgen.py
"""
from compiler.consts import CO_VARARGS, CO_VARKEYWORDS
def flatten(seq):
l = []
for elt in seq:
t = type(elt)
if t is tuple or t is list:
for elt2 in flatten(elt):
l.append(elt2)
else:
l.append(elt)
return l
def flatten_nodes(seq):
return [n for n in flatten(seq) if isinstance(n, Node)]
nodes = {}
class Node:
"""Abstract base class for ast nodes."""
def getChildren(self):
pass # implemented by subclasses
def __iter__(self):
for n in self.getChildren():
yield n
def asList(self): # for backwards compatibility
return self.getChildren()
def getChildNodes(self):
pass # implemented by subclasses
class EmptyNode(Node):
pass
class Expression(Node):
# Expression is an artificial node class to support "eval"
nodes["expression"] = "Expression"
def __init__(self, node):
self.node = node
def getChildren(self):
return self.node,
def getChildNodes(self):
return self.node,
def __repr__(self):
return "Expression(%s)" % (repr(self.node))
class Add(Node):
def __init__(self, leftright, lineno=None):
self.left = leftright[0]
self.right = leftright[1]
self.lineno = lineno
def getChildren(self):
return self.left, self.right
def getChildNodes(self):
return self.left, self.right
def __repr__(self):
return "Add((%s, %s))" % (repr(self.left), repr(self.right))
class And(Node):
def __init__(self, nodes, lineno=None):
self.nodes = nodes
self.lineno = lineno
def getChildren(self):
return tuple(flatten(self.nodes))
def getChildNodes(self):
nodelist = []
nodelist.extend(flatten_nodes(self.nodes))
return tuple(nodelist)
def __repr__(self):
return "And(%s)" % (repr(self.nodes),)
class AssAttr(Node):
def __init__(self, expr, attrname, flags, lineno=None):
self.expr = expr
self.attrname = attrname
self.flags = flags
self.lineno = lineno
def getChildren(self):
return self.expr, self.attrname, self.flags
def getChildNodes(self):
return self.expr,
def __repr__(self):
return "AssAttr(%s, %s, %s)" % (repr(self.expr), repr(self.attrname), repr(self.flags))
class AssList(Node):
def __init__(self, nodes, lineno=None):
self.nodes = nodes
self.lineno = lineno
def getChildren(self):
return tuple(flatten(self.nodes))
def getChildNodes(self):
nodelist = []
nodelist.extend(flatten_nodes(self.nodes))
return tuple(nodelist)
def __repr__(self):
return "AssList(%s)" % (repr(self.nodes),)
class AssName(Node):
def __init__(self, name, flags, lineno=None):
self.name = name
self.flags = flags
self.lineno = lineno
def getChildren(self):
return self.name, self.flags
def getChildNodes(self):
return ()
def __repr__(self):
return "AssName(%s, %s)" % (repr(self.name), repr(self.flags))
class AssTuple(Node):
def __init__(self, nodes, lineno=None):
self.nodes = nodes
self.lineno = lineno
def getChildren(self):
return tuple(flatten(self.nodes))
def getChildNodes(self):
nodelist = []
nodelist.extend(flatten_nodes(self.nodes))
return tuple(nodelist)
def __repr__(self):
return "AssTuple(%s)" % (repr(self.nodes),)
class Assert(Node):
def __init__(self, test, fail, lineno=None):
self.test = test
self.fail = fail
self.lineno = lineno
def getChildren(self):
children = []
children.append(self.test)
children.append(self.fail)
return tuple(children)
def getChildNodes(self):
nodelist = []
nodelist.append(self.test)
if self.fail is not None:
nodelist.append(self.fail)
return tuple(nodelist)
def __repr__(self):
return "Assert(%s, %s)" % (repr(self.test), repr(self.fail))
class Assign(Node):
def __init__(self, nodes, expr, lineno=None):
self.nodes = nodes
self.expr = expr
self.lineno = lineno
def getChildren(self):
children = []
children.extend(flatten(self.nodes))
children.append(self.expr)
return tuple(children)
def getChildNodes(self):
nodelist = []
nodelist.extend(flatten_nodes(self.nodes))
nodelist.append(self.expr)
return tuple(nodelist)
def __repr__(self):
return "Assign(%s, %s)" % (repr(self.nodes), repr(self.expr))
class AugAssign(Node):
def __init__(self, node, op, expr, lineno=None):
self.node = node
self.op = op
self.expr = expr
self.lineno = lineno
def getChildren(self):
return self.node, self.op, self.expr
def getChildNodes(self):
return self.node, self.expr
def __repr__(self):
return "AugAssign(%s, %s, %s)" % (repr(self.node), repr(self.op), repr(self.expr))
class Backquote(Node):
def __init__(self, expr, lineno=None):
self.expr = expr
self.lineno = lineno
def getChildren(self):
return self.expr,
def getChildNodes(self):
return self.expr,
def __repr__(self):
return "Backquote(%s)" % (repr(self.expr),)
class Bitand(Node):
def __init__(self, nodes, lineno=None):
self.nodes = nodes
self.lineno = lineno
def getChildren(self):
return tuple(flatten(self.nodes))
def getChildNodes(self):
nodelist = []
nodelist.extend(flatten_nodes(self.nodes))
return tuple(nodelist)
def __repr__(self):
return "Bitand(%s)" % (repr(self.nodes),)
class Bitor(Node):
def __init__(self, nodes, lineno=None):
self.nodes = nodes
self.lineno = lineno
def getChildren(self):
return tuple(flatten(self.nodes))
def getChildNodes(self):
nodelist = []
nodelist.extend(flatten_nodes(self.nodes))
return tuple(nodelist)
def __repr__(self):
return "Bitor(%s)" % (repr(self.nodes),)
class Bitxor(Node):
def __init__(self, nodes, lineno=None):
self.nodes = nodes
self.lineno = lineno
def getChildren(self):
return tuple(flatten(self.nodes))
def getChildNodes(self):
nodelist = []
nodelist.extend(flatten_nodes(self.nodes))
return tuple(nodelist)
def __repr__(self):
return "Bitxor(%s)" % (repr(self.nodes),)
class Break(Node):
def __init__(self, lineno=None):
self.lineno = lineno
def getChildren(self):
return ()
def getChildNodes(self):
return ()
def __repr__(self):
return "Break()"
class CallFunc(Node):
def __init__(self, node, args, star_args = None, dstar_args = None, lineno=None):
self.node = node
self.args = args
self.star_args = star_args
self.dstar_args = dstar_args
self.lineno = lineno
def getChildren(self):
children = []
children.append(self.node)
children.extend(flatten(self.args))
children.append(self.star_args)
children.append(self.dstar_args)
return tuple(children)
def getChildNodes(self):
nodelist = []
nodelist.append(self.node)
nodelist.extend(flatten_nodes(self.args))
if self.star_args is not None:
nodelist.append(self.star_args)
if self.dstar_args is not None:
nodelist.append(self.dstar_args)
return tuple(nodelist)
def __repr__(self):
return "CallFunc(%s, %s, %s, %s)" % (repr(self.node), repr(self.args), repr(self.star_args), repr(self.dstar_args))
class Class(Node):
def __init__(self, name, bases, doc, code, decorators = None, lineno=None):
self.name = name
self.bases = bases
self.doc = doc
self.code = code
self.decorators = decorators
self.lineno = lineno
def getChildren(self):
children = []
children.append(self.name)
children.extend(flatten(self.bases))
children.append(self.doc)
children.append(self.code)
children.append(self.decorators)
return tuple(children)
def getChildNodes(self):
nodelist = []
nodelist.extend(flatten_nodes(self.bases))
nodelist.append(self.code)
if self.decorators is not None:
nodelist.append(self.decorators)
return tuple(nodelist)
def __repr__(self):
return "Class(%s, %s, %s, %s, %s)" % (repr(self.name), repr(self.bases), repr(self.doc), repr(self.code), repr(self.decorators))
class Compare(Node):
def __init__(self, expr, ops, lineno=None):
self.expr = expr
self.ops = ops
self.lineno = lineno
def getChildren(self):
children = []
children.append(self.expr)
children.extend(flatten(self.ops))
return tuple(children)
def getChildNodes(self):
nodelist = []
nodelist.append(self.expr)
nodelist.extend(flatten_nodes(self.ops))
return tuple(nodelist)
def __repr__(self):
return "Compare(%s, %s)" % (repr(self.expr), repr(self.ops))
class Const(Node):
def __init__(self, value, lineno=None):
self.value = value
self.lineno = lineno
def getChildren(self):
return self.value,
def getChildNodes(self):
return ()
def __repr__(self):
return "Const(%s)" % (repr(self.value),)
class Continue(Node):
def __init__(self, lineno=None):
self.lineno = lineno
def getChildren(self):
return ()
def getChildNodes(self):
return ()
def __repr__(self):
return "Continue()"
class Decorators(Node):
def __init__(self, nodes, lineno=None):
self.nodes = nodes
self.lineno = lineno
def getChildren(self):
return tuple(flatten(self.nodes))
def getChildNodes(self):
nodelist = []
nodelist.extend(flatten_nodes(self.nodes))
return tuple(nodelist)
def __repr__(self):
return "Decorators(%s)" % (repr(self.nodes),)
class Dict(Node):
def __init__(self, items, lineno=None):
self.items = items
self.lineno = lineno
def getChildren(self):
return tuple(flatten(self.items))
def getChildNodes(self):
nodelist = []
nodelist.extend(flatten_nodes(self.items))
return tuple(nodelist)
def __repr__(self):
return "Dict(%s)" % (repr(self.items),)
class Discard(Node):
def __init__(self, expr, lineno=None):
self.expr = expr
self.lineno = lineno
def getChildren(self):
return self.expr,
def getChildNodes(self):
return self.expr,
def __repr__(self):
return "Discard(%s)" % (repr(self.expr),)
class Div(Node):
def __init__(self, leftright, lineno=None):
self.left = leftright[0]
self.right = leftright[1]
self.lineno = lineno
def getChildren(self):
return self.left, self.right
def getChildNodes(self):
return self.left, self.right
def __repr__(self):
return "Div((%s, %s))" % (repr(self.left), repr(self.right))
class Ellipsis(Node):
def __init__(self, lineno=None):
self.lineno = lineno
def getChildren(self):
return ()
def getChildNodes(self):
return ()
def __repr__(self):
return "Ellipsis()"
class Exec(Node):
def __init__(self, expr, locals, globals, lineno=None):
self.expr = expr
self.locals = locals
self.globals = globals
self.lineno = lineno
def getChildren(self):
children = []
children.append(self.expr)
children.append(self.locals)
children.append(self.globals)
return tuple(children)
def getChildNodes(self):
nodelist = []
nodelist.append(self.expr)
if self.locals is not None:
nodelist.append(self.locals)
if self.globals is not None:
nodelist.append(self.globals)
return tuple(nodelist)
def __repr__(self):
return "Exec(%s, %s, %s)" % (repr(self.expr), repr(self.locals), repr(self.globals))
class FloorDiv(Node):
def __init__(self, leftright, lineno=None):
self.left = leftright[0]
self.right = leftright[1]
self.lineno = lineno
def getChildren(self):
return self.left, self.right
def getChildNodes(self):
return self.left, self.right
def __repr__(self):
return "FloorDiv((%s, %s))" % (repr(self.left), repr(self.right))
class For(Node):
def __init__(self, assign, list, body, else_, lineno=None):
self.assign = assign
self.list = list
self.body = body
self.else_ = else_
self.lineno = lineno
def getChildren(self):
children = []
children.append(self.assign)
children.append(self.list)
children.append(self.body)
children.append(self.else_)
return tuple(children)
def getChildNodes(self):
nodelist = []
nodelist.append(self.assign)
nodelist.append(self.list)
nodelist.append(self.body)
if self.else_ is not None:
nodelist.append(self.else_)
return tuple(nodelist)
def __repr__(self):
return "For(%s, %s, %s, %s)" % (repr(self.assign), repr(self.list), repr(self.body), repr(self.else_))
class From(Node):
def __init__(self, modname, names, level, lineno=None):
self.modname = modname
self.names = names
self.level = level
self.lineno = lineno
def getChildren(self):
return self.modname, self.names, self.level
def getChildNodes(self):
return ()
def __repr__(self):
return "From(%s, %s, %s)" % (repr(self.modname), repr(self.names), repr(self.level))
class Function(Node):
def __init__(self, decorators, name, argnames, defaults, flags, doc, code, lineno=None):
self.decorators = decorators
self.name = name
self.argnames = argnames
self.defaults = defaults
self.flags = flags
self.doc = doc
self.code = code
self.lineno = lineno
self.varargs = self.kwargs = None
if flags & CO_VARARGS:
self.varargs = 1
if flags & CO_VARKEYWORDS:
self.kwargs = 1
def getChildren(self):
children = []
children.append(self.decorators)
children.append(self.name)
children.append(self.argnames)
children.extend(flatten(self.defaults))
children.append(self.flags)
children.append(self.doc)
children.append(self.code)
return tuple(children)
def getChildNodes(self):
nodelist = []
if self.decorators is not None:
nodelist.append(self.decorators)
nodelist.extend(flatten_nodes(self.defaults))
nodelist.append(self.code)
return tuple(nodelist)
def __repr__(self):
return "Function(%s, %s, %s, %s, %s, %s, %s)" % (repr(self.decorators), repr(self.name), repr(self.argnames), repr(self.defaults), repr(self.flags), repr(self.doc), repr(self.code))
class GenExpr(Node):
def __init__(self, code, lineno=None):
self.code = code
self.lineno = lineno
self.argnames = ['.0']
self.varargs = self.kwargs = None
def getChildren(self):
return self.code,
def getChildNodes(self):
return self.code,
def __repr__(self):
return "GenExpr(%s)" % (repr(self.code),)
class GenExprFor(Node):
def __init__(self, assign, iter, ifs, lineno=None):
self.assign = assign
self.iter = iter
self.ifs = ifs
self.lineno = lineno
self.is_outmost = False
def getChildren(self):
children = []
children.append(self.assign)
children.append(self.iter)
children.extend(flatten(self.ifs))
return tuple(children)
def getChildNodes(self):
nodelist = []
nodelist.append(self.assign)
nodelist.append(self.iter)
nodelist.extend(flatten_nodes(self.ifs))
return tuple(nodelist)
def __repr__(self):
return "GenExprFor(%s, %s, %s)" % (repr(self.assign), repr(self.iter), repr(self.ifs))
class GenExprIf(Node):
def __init__(self, test, lineno=None):
self.test = test
self.lineno = lineno
def getChildren(self):
return self.test,
def getChildNodes(self):
return self.test,
def __repr__(self):
return "GenExprIf(%s)" % (repr(self.test),)
class GenExprInner(Node):
def __init__(self, expr, quals, lineno=None):
self.expr = expr
self.quals = quals
self.lineno = lineno
def getChildren(self):
children = []
children.append(self.expr)
children.extend(flatten(self.quals))
return tuple(children)
def getChildNodes(self):
nodelist = []
nodelist.append(self.expr)
nodelist.extend(flatten_nodes(self.quals))
return tuple(nodelist)
def __repr__(self):
return "GenExprInner(%s, %s)" % (repr(self.expr), repr(self.quals))
class Getattr(Node):
def __init__(self, expr, attrname, lineno=None):
self.expr = expr
self.attrname = attrname
self.lineno = lineno
def getChildren(self):
return self.expr, self.attrname
def getChildNodes(self):
return self.expr,
def __repr__(self):
return "Getattr(%s, %s)" % (repr(self.expr), repr(self.attrname))
class Global(Node):
def __init__(self, names, lineno=None):
self.names = names
self.lineno = lineno
def getChildren(self):
return self.names,
def getChildNodes(self):
return ()
def __repr__(self):
return "Global(%s)" % (repr(self.names),)
class If(Node):
def __init__(self, tests, else_, lineno=None):
self.tests = tests
self.else_ = else_
self.lineno = lineno
def getChildren(self):
children = []
children.extend(flatten(self.tests))
children.append(self.else_)
return tuple(children)
def getChildNodes(self):
nodelist = []
nodelist.extend(flatten_nodes(self.tests))
if self.else_ is not None:
nodelist.append(self.else_)
return tuple(nodelist)
def __repr__(self):
return "If(%s, %s)" % (repr(self.tests), repr(self.else_))
class IfExp(Node):
def __init__(self, test, then, else_, lineno=None):
self.test = test
self.then = then
self.else_ = else_
self.lineno = lineno
def getChildren(self):
return self.test, self.then, self.else_
def getChildNodes(self):
return self.test, self.then, self.else_
def __repr__(self):
return "IfExp(%s, %s, %s)" % (repr(self.test), repr(self.then), repr(self.else_))
class Import(Node):
def __init__(self, names, lineno=None):
self.names = names
self.lineno = lineno
def getChildren(self):
return self.names,
def getChildNodes(self):
return ()
def __repr__(self):
return "Import(%s)" % (repr(self.names),)
class Invert(Node):
def __init__(self, expr, lineno=None):
self.expr = expr
self.lineno = lineno
def getChildren(self):
return self.expr,
def getChildNodes(self):
return self.expr,
def __repr__(self):
return "Invert(%s)" % (repr(self.expr),)
class Keyword(Node):
def __init__(self, name, expr, lineno=None):
self.name = name
self.expr = expr
self.lineno = lineno
def getChildren(self):
return self.name, self.expr
def getChildNodes(self):
return self.expr,
def __repr__(self):
return "Keyword(%s, %s)" % (repr(self.name), repr(self.expr))
class Lambda(Node):
def __init__(self, argnames, defaults, flags, code, lineno=None):
self.argnames = argnames
self.defaults = defaults
self.flags = flags
self.code = code
self.lineno = lineno
self.varargs = self.kwargs = None
if flags & CO_VARARGS:
self.varargs = 1
if flags & CO_VARKEYWORDS:
self.kwargs = 1
def getChildren(self):
children = []
children.append(self.argnames)
children.extend(flatten(self.defaults))
children.append(self.flags)
children.append(self.code)
return tuple(children)
def getChildNodes(self):
nodelist = []
nodelist.extend(flatten_nodes(self.defaults))
nodelist.append(self.code)
return tuple(nodelist)
def __repr__(self):
return "Lambda(%s, %s, %s, %s)" % (repr(self.argnames), repr(self.defaults), repr(self.flags), repr(self.code))
class LeftShift(Node):
def __init__(self, leftright, lineno=None):
self.left = leftright[0]
self.right = leftright[1]
self.lineno = lineno
def getChildren(self):
return self.left, self.right
def getChildNodes(self):
return self.left, self.right
def __repr__(self):
return "LeftShift((%s, %s))" % (repr(self.left), repr(self.right))
class List(Node):
def __init__(self, nodes, lineno=None):
self.nodes = nodes
self.lineno = lineno
def getChildren(self):
return tuple(flatten(self.nodes))
def getChildNodes(self):
nodelist = []
nodelist.extend(flatten_nodes(self.nodes))
return tuple(nodelist)
def __repr__(self):
return "List(%s)" % (repr(self.nodes),)
class ListComp(Node):
def __init__(self, expr, quals, lineno=None):
self.expr = expr
self.quals = quals
self.lineno = lineno
def getChildren(self):
children = []
children.append(self.expr)
children.extend(flatten(self.quals))
return tuple(children)
def getChildNodes(self):
nodelist = []
nodelist.append(self.expr)
nodelist.extend(flatten_nodes(self.quals))
return tuple(nodelist)
def __repr__(self):
return "ListComp(%s, %s)" % (repr(self.expr), repr(self.quals))
class ListCompFor(Node):
def __init__(self, assign, list, ifs, lineno=None):
self.assign = assign
self.list = list
self.ifs = ifs
self.lineno = lineno
def getChildren(self):
children = []
children.append(self.assign)
children.append(self.list)
children.extend(flatten(self.ifs))
return tuple(children)
def getChildNodes(self):
nodelist = []
nodelist.append(self.assign)
nodelist.append(self.list)
nodelist.extend(flatten_nodes(self.ifs))
return tuple(nodelist)
def __repr__(self):
return "ListCompFor(%s, %s, %s)" % (repr(self.assign), repr(self.list), repr(self.ifs))
class ListCompIf(Node):
def __init__(self, test, lineno=None):
self.test = test
self.lineno = lineno
def getChildren(self):
return self.test,
def getChildNodes(self):
return self.test,
def __repr__(self):
return "ListCompIf(%s)" % (repr(self.test),)
class Mod(Node):
def __init__(self, leftright, lineno=None):
self.left = leftright[0]
self.right = leftright[1]
self.lineno = lineno
def getChildren(self):
return self.left, self.right
def getChildNodes(self):
return self.left, self.right
def __repr__(self):
return "Mod((%s, %s))" % (repr(self.left), repr(self.right))
class Module(Node):
def __init__(self, doc, node, lineno=None):
self.doc = doc
self.node = node
self.lineno = lineno
def getChildren(self):
return self.doc, self.node
def getChildNodes(self):
return self.node,
def __repr__(self):
return "Module(%s, %s)" % (repr(self.doc), repr(self.node))
class Mul(Node):
def __init__(self, leftright, lineno=None):
self.left = leftright[0]
self.right = leftright[1]
self.lineno = lineno
def getChildren(self):
return self.left, self.right
def getChildNodes(self):
return self.left, self.right
def __repr__(self):
return "Mul((%s, %s))" % (repr(self.left), repr(self.right))
class Name(Node):
def __init__(self, name, lineno=None):
self.name = name
self.lineno = lineno
def getChildren(self):
return self.name,
def getChildNodes(self):
return ()
def __repr__(self):
return "Name(%s)" % (repr(self.name),)
class Not(Node):
def __init__(self, expr, lineno=None):
self.expr = expr
self.lineno = lineno
def getChildren(self):
return self.expr,
def getChildNodes(self):
return self.expr,
def __repr__(self):
return "Not(%s)" % (repr(self.expr),)
class Or(Node):
def __init__(self, nodes, lineno=None):
self.nodes = nodes
self.lineno = lineno
def getChildren(self):
return tuple(flatten(self.nodes))
def getChildNodes(self):
nodelist = []
nodelist.extend(flatten_nodes(self.nodes))
return tuple(nodelist)
def __repr__(self):
return "Or(%s)" % (repr(self.nodes),)
class Pass(Node):
def __init__(self, lineno=None):
self.lineno = lineno
def getChildren(self):
return ()
def getChildNodes(self):
return ()
def __repr__(self):
return "Pass()"
class Power(Node):
def __init__(self, leftright, lineno=None):
self.left = leftright[0]
self.right = leftright[1]
self.lineno = lineno
def getChildren(self):
return self.left, self.right
def getChildNodes(self):
return self.left, self.right
def __repr__(self):
return "Power((%s, %s))" % (repr(self.left), repr(self.right))
class Print(Node):
def __init__(self, nodes, dest, lineno=None):
self.nodes = nodes
self.dest = dest
self.lineno = lineno
def getChildren(self):
children = []
children.extend(flatten(self.nodes))
children.append(self.dest)
return tuple(children)
def getChildNodes(self):
nodelist = []
nodelist.extend(flatten_nodes(self.nodes))
if self.dest is not None:
nodelist.append(self.dest)
return tuple(nodelist)
def __repr__(self):
return "Print(%s, %s)" % (repr(self.nodes), repr(self.dest))
class Printnl(Node):
def __init__(self, nodes, dest, lineno=None):
self.nodes = nodes
self.dest = dest
self.lineno = lineno
def getChildren(self):
children = []
children.extend(flatten(self.nodes))
children.append(self.dest)
return tuple(children)
def getChildNodes(self):
nodelist = []
nodelist.extend(flatten_nodes(self.nodes))
if self.dest is not None:
nodelist.append(self.dest)
return tuple(nodelist)
def __repr__(self):
return "Printnl(%s, %s)" % (repr(self.nodes), repr(self.dest))
class Raise(Node):
def __init__(self, expr1, expr2, expr3, lineno=None):
self.expr1 = expr1
self.expr2 = expr2
self.expr3 = expr3
self.lineno = lineno
def getChildren(self):
children = []
children.append(self.expr1)
children.append(self.expr2)
children.append(self.expr3)
return tuple(children)
def getChildNodes(self):
nodelist = []
if self.expr1 is not None:
nodelist.append(self.expr1)
if self.expr2 is not None:
nodelist.append(self.expr2)
if self.expr3 is not None:
nodelist.append(self.expr3)
return tuple(nodelist)
def __repr__(self):
return "Raise(%s, %s, %s)" % (repr(self.expr1), repr(self.expr2), repr(self.expr3))
class Return(Node):
def __init__(self, value, lineno=None):
self.value = value
self.lineno = lineno
def getChildren(self):
return self.value,
def getChildNodes(self):
return self.value,
def __repr__(self):
return "Return(%s)" % (repr(self.value),)
class RightShift(Node):
def __init__(self, leftright, lineno=None):
self.left = leftright[0]
self.right = leftright[1]
self.lineno = lineno
def getChildren(self):
return self.left, self.right
def getChildNodes(self):
return self.left, self.right
def __repr__(self):
return "RightShift((%s, %s))" % (repr(self.left), repr(self.right))
class Slice(Node):
def __init__(self, expr, flags, lower, upper, lineno=None):
self.expr = expr
self.flags = flags
self.lower = lower
self.upper = upper
self.lineno = lineno
def getChildren(self):
children = []
children.append(self.expr)
children.append(self.flags)
children.append(self.lower)
children.append(self.upper)
return tuple(children)
def getChildNodes(self):
nodelist = []
nodelist.append(self.expr)
if self.lower is not None:
nodelist.append(self.lower)
if self.upper is not None:
nodelist.append(self.upper)
return tuple(nodelist)
def __repr__(self):
return "Slice(%s, %s, %s, %s)" % (repr(self.expr), repr(self.flags), repr(self.lower), repr(self.upper))
class Sliceobj(Node):
def __init__(self, nodes, lineno=None):
self.nodes = nodes
self.lineno = lineno
def getChildren(self):
return tuple(flatten(self.nodes))
def getChildNodes(self):
nodelist = []
nodelist.extend(flatten_nodes(self.nodes))
return tuple(nodelist)
def __repr__(self):
return "Sliceobj(%s)" % (repr(self.nodes),)
class Stmt(Node):
def __init__(self, nodes, lineno=None):
self.nodes = nodes
self.lineno = lineno
def getChildren(self):
return tuple(flatten(self.nodes))
def getChildNodes(self):
nodelist = []
nodelist.extend(flatten_nodes(self.nodes))
return tuple(nodelist)
def __repr__(self):
return "Stmt(%s)" % (repr(self.nodes),)
class Sub(Node):
def __init__(self, leftright, lineno=None):
self.left = leftright[0]
self.right = leftright[1]
self.lineno = lineno
def getChildren(self):
return self.left, self.right
def getChildNodes(self):
return self.left, self.right
def __repr__(self):
return "Sub((%s, %s))" % (repr(self.left), repr(self.right))
class Subscript(Node):
def __init__(self, expr, flags, subs, lineno=None):
self.expr = expr
self.flags = flags
self.subs = subs
self.lineno = lineno
def getChildren(self):
children = []
children.append(self.expr)
children.append(self.flags)
children.extend(flatten(self.subs))
return tuple(children)
def getChildNodes(self):
nodelist = []
nodelist.append(self.expr)
nodelist.extend(flatten_nodes(self.subs))
return tuple(nodelist)
def __repr__(self):
return "Subscript(%s, %s, %s)" % (repr(self.expr), repr(self.flags), repr(self.subs))
class TryExcept(Node):
def __init__(self, body, handlers, else_, lineno=None):
self.body = body
self.handlers = handlers
self.else_ = else_
self.lineno = lineno
def getChildren(self):
children = []
children.append(self.body)
children.extend(flatten(self.handlers))
children.append(self.else_)
return tuple(children)
def getChildNodes(self):
nodelist = []
nodelist.append(self.body)
nodelist.extend(flatten_nodes(self.handlers))
if self.else_ is not None:
nodelist.append(self.else_)
return tuple(nodelist)
def __repr__(self):
return "TryExcept(%s, %s, %s)" % (repr(self.body), repr(self.handlers), repr(self.else_))
class TryFinally(Node):
def __init__(self, body, final, lineno=None):
self.body = body
self.final = final
self.lineno = lineno
def getChildren(self):
return self.body, self.final
def getChildNodes(self):
return self.body, self.final
def __repr__(self):
return "TryFinally(%s, %s)" % (repr(self.body), repr(self.final))
class Tuple(Node):
def __init__(self, nodes, lineno=None):
self.nodes = nodes
self.lineno = lineno
def getChildren(self):
return tuple(flatten(self.nodes))
def getChildNodes(self):
nodelist = []
nodelist.extend(flatten_nodes(self.nodes))
return tuple(nodelist)
def __repr__(self):
return "Tuple(%s)" % (repr(self.nodes),)
class UnaryAdd(Node):
def __init__(self, expr, lineno=None):
self.expr = expr
self.lineno = lineno
def getChildren(self):
return self.expr,
def getChildNodes(self):
return self.expr,
def __repr__(self):
return "UnaryAdd(%s)" % (repr(self.expr),)
class UnarySub(Node):
def __init__(self, expr, lineno=None):
self.expr = expr
self.lineno = lineno
def getChildren(self):
return self.expr,
def getChildNodes(self):
return self.expr,
def __repr__(self):
return "UnarySub(%s)" % (repr(self.expr),)
class While(Node):
def __init__(self, test, body, else_, lineno=None):
self.test = test
self.body = body
self.else_ = else_
self.lineno = lineno
def getChildren(self):
children = []
children.append(self.test)
children.append(self.body)
children.append(self.else_)
return tuple(children)
def getChildNodes(self):
nodelist = []
nodelist.append(self.test)
nodelist.append(self.body)
if self.else_ is not None:
nodelist.append(self.else_)
return tuple(nodelist)
def __repr__(self):
return "While(%s, %s, %s)" % (repr(self.test), repr(self.body), repr(self.else_))
class With(Node):
def __init__(self, expr, vars, body, lineno=None):
self.expr = expr
self.vars = vars
self.body = body
self.lineno = lineno
def getChildren(self):
children = []
children.append(self.expr)
children.append(self.vars)
children.append(self.body)
return tuple(children)
def getChildNodes(self):
nodelist = []
nodelist.append(self.expr)
if self.vars is not None:
nodelist.append(self.vars)
nodelist.append(self.body)
return tuple(nodelist)
def __repr__(self):
return "With(%s, %s, %s)" % (repr(self.expr), repr(self.vars), repr(self.body))
class Yield(Node):
def __init__(self, value, lineno=None):
self.value = value
self.lineno = lineno
def getChildren(self):
return self.value,
def getChildNodes(self):
return self.value,
def __repr__(self):
return "Yield(%s)" % (repr(self.value),)
for name, obj in globals().items():
if isinstance(obj, type) and issubclass(obj, Node):
nodes[name.lower()] = obj
PK [[0~F8 8
visitor.pynu W+A PK [[@ r syntax.pynu W+A PK [[ O consts.pynu W+A PK [[iM9E 9E < symbols.pycnu W+A PK [[]7[8 [8
\ symbols.pynu W+A PK [[Q E misc.pycnu W+A PK [[2e e future.pynu W+A PK [[,P P
syntax.pycnu W+A PK [[&6b)f )f
* pyassem.pynu W+A PK [[ __init__.pynu W+A PK [[=W transformer.pycnu W+A PK [[l l pyassem.pycnu W+A PK [[Ln&$ B misc.pynu W+A PK [[XB I __init__.pycnu W+A PK [[G8ou O transformer.pynu W+A PK [[KԪc c visitor.pycnu W+A PK [[@
) consts.pycnu W+A PK [[Z
x, pycodegen.pycnu W+A PK [[9N
5 future.pycnu W+A PK [[F pycodegen.pynu W+A PK [[] 6 ast.pycnu W+A PK [[) ast.pynu W+A PK a @a