PK„Ñ47SäBEGG-INFO/namespace_packages.txtpeak peak.util PK„Ñ4?Ç<® ® EGG-INFO/PKG-INFOMetadata-Version: 1.0 Name: BytecodeAssembler Version: 0.1 Summary: Generate Python code objects by "assembling" bytecode Home-page: http://peak.telecommunity.com/DevCenter/BytecodeAssembler Author: Phillip J. Eby Author-email: peak@eby-sarna.com License: PSF or ZPL Description: ``peak.util.assembler`` is a simple bytecode assembler module that handles most low-level bytecode generation details like jump offsets, stack size tracking, line number table generation, constant and variable name index tracking, etc. That way, you can focus your attention on the desired semantics of your bytecode instead of on these mechanical issues. In addition to a low-level opcode-oriented API for directly generating specific bytecodes, this module also offers an extensible mini-AST framework for generating code from high-level specifications. This framework does most of the work needed to transform tree-like structures into linear bytecode instructions, and includes the ability to do compile-time constant folding. Changes since version 0.0.1: * Added massive quantities of new documentation and examples * Full block, loop, and closure support * High-level functional code generation from trees, with smart labels and blocks, constant folding, extensibility, smart local variable names, etc. * The ``.label()`` method was renamed to ``.here()`` to distinguish it from the new smart ``Label`` objects. * Docs and tests were moved to README.txt instead of assembler.txt * Added a demo that implements a "switch"-like statement template that shows how to extend the code generation system and how to abuse ``END_FINALLY`` to implement a "computed goto" in bytecode. * Various bug fixes There are a few features that aren't tested yet, and not all opcodes may be fully supported. Notably, the following features are still NOT reliably supported yet: * Wide jump addressing (for generated bytecode>64K in size) * The ``dis()`` module in Python 2.3 has a bug that makes it show incorrect line numbers when the difference between two adjacent line numbers is greater than 255. This causes two shallow failures in the current test suite when it's run under Python 2.3. If you find any other issues, please let me know. Please also keep in mind that this is a work in progress, and the API may change if I come up with a better way to do something. Questions and discussion regarding this software should be directed to the `PEAK Mailing List `_. Platform: UNKNOWN PK„Ñ4„‚)Ð??EGG-INFO/SOURCES.txtREADME.txt setup.py test_assembler.py BytecodeAssembler.egg-info/PKG-INFO BytecodeAssembler.egg-info/SOURCES.txt BytecodeAssembler.egg-info/namespace_packages.txt BytecodeAssembler.egg-info/top_level.txt ez_setup/README.txt ez_setup/__init__.py peak/__init__.py peak/util/__init__.py peak/util/assembler.py PK„Ñ4†êÁEGG-INFO/top_level.txtpeak PK…Ñ4EGG-INFO/zip-safePK/ ·4‰kÔ<99peak/__init__.py__import__('pkg_resources').declare_namespace(__name__) PK…Ñ4ºÑgéÍÍpeak/__init__.pyc;ò ™rDc@sedƒieƒdS(s pkg_resourcesN(s __import__sdeclare_namespaces__name__(((s&build\bdist.win32\egg\peak\__init__.pys?sPKÍÑ4å@hRµIµIpeak/util/assembler.pyfrom array import array from dis import * from new import code, instancemethod from types import CodeType __all__ = [ 'Code', 'Const', 'Return', 'Global', 'Local', 'Call', 'nil', 'ast_curry', 'const_value', 'NotAConstant', 'Label', ] opcode = {} for op in range(256): name=opname[op] if name.startswith('<'): continue if name.endswith('+0'): opcode[name[:-2]]=op opcode[name]=op globals().update(opcode) # opcodes are now importable at will # Flags from code.h CO_OPTIMIZED = 0x0001 # use LOAD/STORE_FAST instead of _NAME CO_NEWLOCALS = 0x0002 # only cleared for module/exec code CO_VARARGS = 0x0004 CO_VARKEYWORDS = 0x0008 CO_NESTED = 0x0010 # ??? CO_GENERATOR = 0x0020 CO_NOFREE = 0x0040 # set if no free or cell vars CO_GENERATOR_ALLOWED = 0x1000 # unused CO_FUTURE_DIVISION = 0x2000 CO_FUTURE_ABSOLUTE_IMPORT = 0x4000 # Python 2.5+ only CO_FUTURE_WITH_STATEMENT = 0x8000 # Python 2.5+ only __all__.extend([k for k in globals().keys() if k.startswith('CO_')]) class _nil(object): """Pseudo-None object used to work around ast_currying limitations""" __slots__ = () def __nonzero__(self): return False def __call__(self,code): code.LOAD_CONST(None) def __repr__(self): return 'nil' nil = _nil() def ast_curry(f,*args): for arg in args: if arg is None: arg = nil f = instancemethod(f,arg,type(arg)) return f def Const(value, code=None): if code is None: return ast_curry(Const, value) code.LOAD_CONST(value) def Global(name, code=None): if code is None: return ast_curry(Global, name) code.LOAD_GLOBAL(name) def Local(name, code=None): if code is None: return ast_curry(Local, name) if name in code.co_cellvars or name in code.co_freevars: return code.LOAD_DEREF(name) elif code.co_flags & CO_OPTIMIZED: return code.LOAD_FAST(name) else: return code.LOAD_NAME(name) def Return(value=None, code=None): if code is None: return ast_curry(Return, value) return code(value, Code.RETURN_VALUE) def Call(func, args=(),kwargs=(), star=None,dstar=None, fold=True, code=None): if code is None: if fold and (args or kwargs or star or dstar): cv = const_value try: ffunc = cv(func) fargs = map(cv,args) fkw = dict([(cv(k),cv(v)) for k,v in kwargs]) if star: fargs.extend(cv(star)) if dstar: fkw.update(cv(dstar)) except NotAConstant: pass else: return Const(ffunc(*fargs, **fkw)) return ast_curry( Call, func, tuple(args), tuple(kwargs), star, dstar, fold ) code(func, *args) for k,v in kwargs: code(k,v) argc = len(args) kwargc = len(kwargs) if star: if dstar: code(star, dstar) return code.CALL_FUNCTION_VAR_KW(argc, kwargc) else: code(star) return code.CALL_FUNCTION_VAR(argc, kwargc) else: if dstar: code(dstar) return code.CALL_FUNCTION_KW(argc, kwargc) else: return code.CALL_FUNCTION(argc, kwargc) class Label(object): """A forward-referenceable location in a ``Code`` object""" __slots__ = 'backpatches', 'resolution' def __init__(self): self.backpatches = [] self.resolution = None def SETUP_EXCEPT(self, code): return self.backpatches.append(code.setup_block(SETUP_EXCEPT)) def SETUP_FINALLY(self, code): return self.backpatches.append(code.setup_block(SETUP_FINALLY)) def SETUP_LOOP(self, code): return self.backpatches.append(code.setup_block(SETUP_LOOP)) def POP_BLOCK(self, code): self.backpatches[0] = code.POP_BLOCK() for op in hasjrel+hasjabs: if opname[op] not in locals(): def do_jump(self, code, op=op): code.stackchange(stack_effects[op]) method = getattr(code, opname[op]) if self.resolution is None: return self.backpatches.append(method()) else: return method(self.resolution) locals()[opname[op]] = do_jump del do_jump def __call__(self, code): if self.resolution is not None: raise AssertionError("Label previously defined") self.resolution = resolution = len(code.co_code) for p in self.backpatches: if p: p() class Code: co_argcount = 0 co_stacksize = 0 co_flags = CO_OPTIMIZED | CO_NEWLOCALS # typical usage co_filename = '' co_name = '' co_firstlineno = 0 co_freevars = () co_cellvars = () _last_lineofs = 0 stack_size = 0 def __init__(self): self.co_code = array('B') self.co_consts = [None] self.co_names = [] self.co_varnames = [] self.co_lnotab = array('B') self.emit = self.co_code.append self.blocks = [] def emit_arg(self, op, arg): emit = self.emit if arg>0xFFFF: emit(EXTENDED_ARG) emit((arg>>16)&255) emit((arg>>24)&255) emit(op) emit(arg&255) emit((arg>>8)&255) def set_lineno(self, lno): if not self.co_firstlineno: self.co_firstlineno = self._last_line = lno return append = self.co_lnotab.append incr_line = lno - self._last_line incr_addr = len(self.co_code) - self._last_lineofs if not incr_line: return assert incr_addr>=0 and incr_line>=0 while incr_addr>255: append(255) append(0) incr_addr -= 255 while incr_line>255: append(incr_addr) append(255) incr_line -= 255 incr_addr = 0 if incr_addr or incr_line: append(incr_addr) append(incr_line) self._last_line = lno self._last_lineofs = len(self.co_code) def stackchange(self, (inputs,outputs)): assert inputs<=self.stack_size, "Stack underflow" if inputs or outputs: ss = self.stack_size = self.stack_size + outputs - inputs if outputs>inputs and ss>self.co_stacksize: self.co_stacksize = ss def LOAD_CONST(self, const): self.stackchange((0,1)) try: arg = self.co_consts.index(const) except ValueError: arg = len(self.co_consts) self.co_consts.append(const) self.emit_arg(LOAD_CONST, arg) def CALL_FUNCTION(self, argc=0, kwargc=0, op=CALL_FUNCTION): self.stackchange((1+argc+2*kwargc,1)) emit = self.emit emit(op); emit(argc); emit(kwargc) def CALL_FUNCTION_VAR(self, argc=0, kwargc=0): self.stackchange((1,0)) # extra for *args self.CALL_FUNCTION(argc,kwargc,CALL_FUNCTION_VAR) def CALL_FUNCTION_KW(self, argc=0, kwargc=0): self.stackchange((1,0)) # extra for **kw self.CALL_FUNCTION(argc,kwargc,CALL_FUNCTION_KW) def CALL_FUNCTION_VAR_KW(self, argc=0, kwargc=0): self.stackchange((2,0)) # extra for *args, **kw self.CALL_FUNCTION(argc,kwargc,CALL_FUNCTION_VAR_KW) def BUILD_TUPLE(self, count): self.stackchange((count,1)) self.emit_arg(BUILD_TUPLE,count) def BUILD_LIST(self, count): self.stackchange((count,1)) self.emit_arg(BUILD_LIST,count) def UNPACK_SEQUENCE(self, count): self.stackchange((1,count)) self.emit_arg(UNPACK_SEQUENCE,count) def BUILD_SLICE(self, count): assert count in (2,3), "Invalid number of arguments for BUILD_SLICE" self.stackchange((count,1)) self.emit_arg(BUILD_SLICE,count) def DUP_TOPX(self, count): self.stackchange((count,count*2)) self.emit_arg(DUP_TOPX,count) def RAISE_VARARGS(self, argc): assert 0<=argc<=3, "Invalid number of arguments for RAISE_VARARGS" self.stackchange((argc,0)) self.emit_arg(RAISE_VARARGS,argc) def MAKE_FUNCTION(self, ndefaults): self.stackchange((1+ndefaults,1)) self.emit_arg(MAKE_FUNCTION, ndefaults) def MAKE_CLOSURE(self, ndefaults, freevars): self.stackchange((1+freevars+ndefaults,1)) self.emit_arg(MAKE_CLOSURE, ndefaults) def here(self): return len(self.co_code) def jump(self, op, arg=None): def backpatch(target): if op not in hasjabs: target = target - posn assert target>=0, "Relative jumps can't go backwards" self.co_code[posn-2] = target & 255 self.co_code[posn-1] = (target>>8) & 255 def lbl(code=None): backpatch(self.here()) self.emit_arg(op,0) posn = self.here() if arg is not None: backpatch(arg) else: return lbl def setup_block(self, op): jmp = self.jump(op) self.blocks.append((op,self.stack_size,jmp)) return jmp def SETUP_EXCEPT(self): self.setup_block(SETUP_EXCEPT) def SETUP_FINALLY(self): self.setup_block(SETUP_FINALLY) def SETUP_LOOP(self): self.setup_block(SETUP_LOOP) def raw_pop(self, stacksize): if stacksize != self.stack_size: raise AssertionError( "Stack level mismatch: actual=%d expected=%d" % (self.stack_size, stacksize) ) self.emit(POP_BLOCK) def POP_BLOCK(self): if not self.blocks: raise AssertionError("Not currently in a block") why, level, fwd = self.blocks.pop() self.raw_pop(level) if why!=SETUP_LOOP: self.stackchange((0,3)) if why==SETUP_FINALLY: self.stackchange((3,0)) self.LOAD_CONST(None) fwd() else: else_ = self.JUMP_FORWARD() fwd() return else_ else: return fwd def assert_loop(self): for why,level,fwd in self.blocks: if why==SETUP_LOOP: return raise AssertionError("Not inside a loop") def BREAK_LOOP(self): self.assert_loop() self.emit(BREAK_LOOP) def CONTINUE_LOOP(self, label): self.assert_loop() if self.blocks[-1][0]==SETUP_LOOP: op = JUMP_ABSOLUTE # more efficient if not in a nested block else: op = CONTINUE_LOOP return self.jump(op, label) def __call__(self, *args): last = None for ob in args: if callable(ob): last = ob(self) else: try: f = generate_types[type(ob)] except KeyError: raise TypeError("Can't generate", ob) else: last = f(self, ob) return last def return_(self, ob=None): return self(ob, Code.RETURN_VALUE) def from_function(cls, function, copy_lineno=False): code = cls.from_code(function.func_code, copy_lineno) return code from_function = classmethod(from_function) def from_code(cls, code, copy_lineno=False): self = cls() if copy_lineno: self.set_lineno(code.co_firstlineno) import inspect args, var, kw = inspect.getargs(code) self.co_varnames.extend(args) if var: self.co_varnames.append(var) self.co_flags |= CO_VARARGS if kw: self.co_varnames.append(kw) self.co_flags |= CO_VARKEYWORDS def tuple_arg(args): self.UNPACK_SEQUENCE(len(args)) for arg in args: if isinstance(arg, list): tuple_arg(arg) else: self.STORE_FAST(arg) for narg, arg in enumerate(args): if isinstance(arg,list): dummy_name = '.'+str(narg) self.co_varnames[narg] = dummy_name self.LOAD_FAST(dummy_name) tuple_arg(arg) self.co_argcount = code.co_argcount self.co_name = code.co_name self.co_freevars = code.co_freevars return self from_code = classmethod(from_code) def code(self): if self.blocks: raise AssertionError("%d unclosed block(s)" % len(self.blocks)) flags = self.co_flags & ~CO_NOFREE if not self.co_freevars and not self.co_cellvars: flags |= CO_NOFREE return code( self.co_argcount, len(self.co_varnames), self.co_stacksize, flags, self.co_code.tostring(), tuple(self.co_consts), tuple(self.co_names), tuple(self.co_varnames), self.co_filename, self.co_name, self.co_firstlineno, self.co_lnotab.tostring(), self.co_freevars, self.co_cellvars ) for op in hasfree: if not hasattr(Code, opname[op]): def do_free(self, varname, op=op): self.stackchange(stack_effects[op]) try: arg = list(self.co_cellvars+self.co_freevars).index(varname) except ValueError: raise NameError("Undefined free or cell var", varname) self.emit_arg(op, arg) setattr(Code, opname[op], do_free) for op in hasname: if not hasattr(Code, opname[op]): def do_name(self, name, op=op): self.stackchange(stack_effects[op]) try: arg = self.co_names.index(name) except ValueError: arg = len(self.co_names) self.co_names.append(name) self.emit_arg(op, arg) if op in (LOAD_NAME, STORE_NAME, DELETE_NAME): # Can't use optimized local vars, so reset flags self.co_flags &= ~CO_OPTIMIZED setattr(Code, opname[op], do_name) for op in haslocal: if not hasattr(Code, opname[op]): def do_local(self, varname, op=op): if not self.co_flags & CO_OPTIMIZED: raise AssertionError( "co_flags must include CO_OPTIMIZED to use fast locals" ) self.stackchange(stack_effects[op]) try: arg = self.co_varnames.index(varname) except ValueError: arg = len(self.co_varnames) self.co_varnames.append(varname) self.emit_arg(op, arg) setattr(Code, opname[op], do_local) for op in hasjrel+hasjabs: if not hasattr(Code, opname[op]): def do_jump(self, address=None, op=op): self.stackchange(stack_effects[op]) return self.jump(op, address) setattr(Code, opname[op], do_jump) def gen_map(code, ob): code.BUILD_MAP(0) for k,v in ob.items(): code.DUP_TOP() code(k, v) code.ROT_THREE() code.STORE_SUBSCR() def gen_tuple(code, ob): code(*ob) return code.BUILD_TUPLE(len(ob)) def gen_list(code, ob): code(*ob) return code.BUILD_LIST(len(ob)) generate_types = { int: Code.LOAD_CONST, long: Code.LOAD_CONST, bool: Code.LOAD_CONST, CodeType: Code.LOAD_CONST, str: Code.LOAD_CONST, unicode: Code.LOAD_CONST, complex: Code.LOAD_CONST, float: Code.LOAD_CONST, type(None): Code.LOAD_CONST, tuple: gen_tuple, list: gen_list, dict: gen_map, } class NotAConstant(Exception): """The supplied value is not a constant expression tree""" def const_value(value): """Return the constant value -- if any -- of an expression tree Raises NotAConstant if the value or any child of the value are not constants. """ t = type(value) if t is instancemethod: if value.im_func is Const: value = value.im_self else: raise NotAConstant(value) elif t is tuple: t = tuple(map(const_value,value)) if t==value: return value return t elif generate_types.get(t) != Code.LOAD_CONST: raise NotAConstant(value) if value is nil: value = None return value class _se: """Quick way of defining static stack effects of opcodes""" POP_TOP = END_FINALLY = 1,0 ROT_TWO = 2,2 ROT_THREE = 3,3 ROT_FOUR = 4,4 DUP_TOP = 1,2 UNARY_POSITIVE = UNARY_NEGATIVE = UNARY_NOT = UNARY_CONVERT = \ UNARY_INVERT = GET_ITER = LOAD_ATTR = IMPORT_FROM = 1,1 BINARY_POWER = BINARY_MULTIPLY = BINARY_DIVIDE = BINARY_FLOOR_DIVIDE = \ BINARY_TRUE_DIVIDE = BINARY_MODULO = BINARY_ADD = BINARY_SUBTRACT = \ BINARY_SUBSCR = BINARY_LSHIFT = BINARY_RSHIFT = BINARY_AND = \ BINARY_XOR = BINARY_OR = COMPARE_OP = 2,1 INPLACE_POWER = INPLACE_MULTIPLY = INPLACE_DIVIDE = \ INPLACE_FLOOR_DIVIDE = INPLACE_TRUE_DIVIDE = INPLACE_MODULO = \ INPLACE_ADD = INPLACE_SUBTRACT = INPLACE_LSHIFT = INPLACE_RSHIFT = \ INPLACE_AND = INPLACE_XOR = INPLACE_OR = 2,1 SLICE_0, SLICE_1, SLICE_2, SLICE_3 = \ (1,1),(2,1),(2,1),(3,1) STORE_SLICE_0, STORE_SLICE_1, STORE_SLICE_2, STORE_SLICE_3 = \ (2,0),(3,0),(3,0),(4,0) DELETE_SLICE_0, DELETE_SLICE_1, DELETE_SLICE_2, DELETE_SLICE_3 = \ (1,0),(2,0),(2,0),(3,0) STORE_SUBSCR = 3,0 DELETE_SUBSCR = STORE_ATTR = 2,0 DELETE_ATTR = STORE_DEREF = 1,0 PRINT_EXPR = PRINT_ITEM = PRINT_NEWLINE_TO = IMPORT_STAR = 1,0 RETURN_VALUE = YIELD_VALUE = STORE_NAME = STORE_GLOBAL = STORE_FAST = 1,0 PRINT_ITEM_TO = LIST_APPEND = 2,0 LOAD_LOCALS = LOAD_CONST = LOAD_NAME = LOAD_GLOBAL = LOAD_FAST = \ LOAD_CLOSURE = LOAD_DEREF = IMPORT_NAME = BUILD_MAP = 0,1 EXEC_STMT = BUILD_CLASS = 3,0 stack_effects = [(0,0)]*256 for name in opcode: op = opcode[name] name = name.replace('+','_') if hasattr(_se,name): # update stack effects table from the _se class stack_effects[op] = getattr(_se,name) if not hasattr(Code,name): # Create default method for Code class if op>=HAVE_ARGUMENT: def do_op(self,arg,op=op,se=stack_effects[op]): self.stackchange(se); self.emit_arg(op,arg) else: def do_op(self,op=op,se=stack_effects[op]): self.stackchange(se); self.emit(op) setattr(Code, name, do_op) PK…Ñ4„·9¬ÀtÀtpeak/util/assembler.pyc;ò ⛓Dc @s×dklZdkTdklZlZdklZdddddd d d d d dg ZhZxae dƒD]SZ e e Z e i dƒoqnne idƒoe ee d e-i=<e?e-i=<ee-i=<e@e-i=<eAe-i=<eBe-i=<eCe-i=<eDe%ƒe-i=<eEe:<eFe;<eGe9 # E,       cBstZdZddfZd„Zd„Zd„Zd„Zd„ZxGe e D];Z e e e ƒjo!e d„Zee ƒe e scCsXtdƒ|_tg|_g|_g|_tdƒ|_|ii|_ g|_ dS(NsB( sarraysselfsco_codesNones co_constssco_namess co_varnamess co_lnotabsappendsemitsblocks(sself((s,build\bdist.win32\egg\peak\util\assembler.pys__init__±s   cCsv|i}|djo2|tƒ||d?d@ƒ||d?d@ƒn||ƒ||d@ƒ||d?d@ƒdS(Niÿÿiiÿii(sselfsemitsargs EXTENDED_ARGsop(sselfsopsargsemit((s,build\bdist.win32\egg\peak\util\assembler.pysemit_argºs    cCs4|i o||_|_dSn|ii}||i}t|iƒ|i }| odSn|djo |djpt ‚x0|djo"|dƒ|dƒ|d8}q†Wx6|djo(||ƒ|dƒ|d8}d}q¹W|p|o||ƒ||ƒn||_t|iƒ|_ dS(Niiÿ( sselfsco_firstlinenoslnos _last_lines co_lnotabsappends incr_lineslensco_codes _last_lineofss incr_addrsAssertionError(sselfslnos incr_addrs incr_linesappend((s,build\bdist.win32\egg\peak\util\assembler.pys set_linenoÎs2   !          cCs~|\}}||ijp td‚|p|oF|i||}|_||jo ||ijo ||_qzndS(NsStack underflow(sinputssoutputssselfs stack_sizesAssertionErrorssss co_stacksize(sselfs.2sinputssoutputssss((s,build\bdist.win32\egg\peak\util\assembler.pys stackchangeís cCsr|iddfƒy|ii|ƒ}Wn2tj o&t|iƒ}|ii|ƒnX|i t |ƒdS(Nii( sselfs stackchanges co_constssindexsconstsargs ValueErrorslensappendsemit_args LOAD_CONST(sselfsconstsarg((s,build\bdist.win32\egg\peak\util\assembler.pys LOAD_CONST÷scCsJ|id|d|dfƒ|i}||ƒ||ƒ||ƒdS(Nii(sselfs stackchangesargcskwargcsemitsop(sselfsargcskwargcsopsemit((s,build\bdist.win32\egg\peak\util\assembler.pys CALL_FUNCTIONs cCs*|iddfƒ|i||tƒdS(Nii(sselfs stackchanges CALL_FUNCTIONsargcskwargcsCALL_FUNCTION_VAR(sselfsargcskwargc((s,build\bdist.win32\egg\peak\util\assembler.pysCALL_FUNCTION_VARscCs*|iddfƒ|i||tƒdS(Nii(sselfs stackchanges CALL_FUNCTIONsargcskwargcsCALL_FUNCTION_KW(sselfsargcskwargc((s,build\bdist.win32\egg\peak\util\assembler.pysCALL_FUNCTION_KW scCs*|iddfƒ|i||tƒdS(Nii(sselfs stackchanges CALL_FUNCTIONsargcskwargcsCALL_FUNCTION_VAR_KW(sselfsargcskwargc((s,build\bdist.win32\egg\peak\util\assembler.pysCALL_FUNCTION_VAR_KWscCs'|i|dfƒ|it|ƒdS(Ni(sselfs stackchangescountsemit_args BUILD_TUPLE(sselfscount((s,build\bdist.win32\egg\peak\util\assembler.pys BUILD_TUPLEscCs'|i|dfƒ|it|ƒdS(Ni(sselfs stackchangescountsemit_args BUILD_LIST(sselfscount((s,build\bdist.win32\egg\peak\util\assembler.pys BUILD_LISTscCs'|id|fƒ|it|ƒdS(Ni(sselfs stackchangescountsemit_argsUNPACK_SEQUENCE(sselfscount((s,build\bdist.win32\egg\peak\util\assembler.pysUNPACK_SEQUENCEscCsD|ddfjp td‚|i|dfƒ|it|ƒdS(Niis+Invalid number of arguments for BUILD_SLICEi(scountsAssertionErrorsselfs stackchangesemit_args BUILD_SLICE(sselfscount((s,build\bdist.win32\egg\peak\util\assembler.pys BUILD_SLICE scCs+|i||dfƒ|it|ƒdS(Ni(sselfs stackchangescountsemit_argsDUP_TOPX(sselfscount((s,build\bdist.win32\egg\peak\util\assembler.pysDUP_TOPX%scCsOd|jo djnp td‚|i|dfƒ|it|ƒdS(Niis-Invalid number of arguments for RAISE_VARARGS(sargcsAssertionErrorsselfs stackchangesemit_args RAISE_VARARGS(sselfsargc((s,build\bdist.win32\egg\peak\util\assembler.pys RAISE_VARARGS)s(cCs+|id|dfƒ|it|ƒdS(Ni(sselfs stackchanges ndefaultssemit_args MAKE_FUNCTION(sselfs ndefaults((s,build\bdist.win32\egg\peak\util\assembler.pys MAKE_FUNCTION.scCs/|id||dfƒ|it|ƒdS(Ni(sselfs stackchangesfreevarss ndefaultssemit_args MAKE_CLOSURE(sselfs ndefaultssfreevars((s,build\bdist.win32\egg\peak\util\assembler.pys MAKE_CLOSURE2scCst|iƒSdS(N(slensselfsco_code(sself((s,build\bdist.win32\egg\peak\util\assembler.pyshere6scsc‡‡‡d†‰t‡‡d†}ˆiˆdƒˆiƒ‰|tj oˆ|ƒn|SdS(Ncsdˆtjo%|ˆ}|djp td‚n|d@ˆiˆd<|d?d@ˆiˆd||ijotd|i|fƒ‚n|itƒdS(Ns+Stack level mismatch: actual=%d expected=%d(s stacksizesselfs stack_sizesAssertionErrorsemits POP_BLOCK(sselfs stacksize((s,build\bdist.win32\egg\peak\util\assembler.pysraw_popWscCs»|i otdƒ‚n|iiƒ\}}}|i|ƒ|tjof|i ddfƒ|t jo+|i ddfƒ|i t ƒ|ƒq·|i ƒ}|ƒ|Sn|SdS(NsNot currently in a blockii(sselfsblockssAssertionErrorspopswhyslevelsfwdsraw_pops SETUP_LOOPs stackchanges SETUP_FINALLYs LOAD_CONSTsNones JUMP_FORWARDselse_(sselfslevelsfwdselse_swhy((s,build\bdist.win32\egg\peak\util\assembler.pys POP_BLOCK_s       cCsBx/|iD]$\}}}|tjodSq q Wtdƒ‚dS(NsNot inside a loop(sselfsblocksswhyslevelsfwds SETUP_LOOPsAssertionError(sselfslevelsfwdswhy((s,build\bdist.win32\egg\peak\util\assembler.pys assert_looprs    cCs|iƒ|itƒdS(N(sselfs assert_loopsemits BREAK_LOOP(sself((s,build\bdist.win32\egg\peak\util\assembler.pys BREAK_LOOPxs cCsF|iƒ|iddtjo t}nt}|i||ƒSdS(Niÿÿÿÿi( sselfs assert_loopsblockss SETUP_LOOPs JUMP_ABSOLUTEsops CONTINUE_LOOPsjumpslabel(sselfslabelsop((s,build\bdist.win32\egg\peak\util\assembler.pys CONTINUE_LOOP|s   cGs„t}xs|D]k}t|ƒo||ƒ}q ytt|ƒ}Wn"t j ot d|ƒ‚q X|||ƒ}q W|SdS(NsCan't generate( sNoneslastsargssobscallablesselfsgenerate_typesstypesfsKeyErrors TypeError(sselfsargsslastsfsob((s,build\bdist.win32\egg\peak\util\assembler.pys__call__„s cCs||tiƒSdS(N(sselfsobsCodes RETURN_VALUE(sselfsob((s,build\bdist.win32\egg\peak\util\assembler.pysreturn_’scCs|i|i|ƒ}|SdS(N(sclss from_codesfunctions func_codes copy_linenoscode(sclssfunctions copy_linenoscode((s,build\bdist.win32\egg\peak\util\assembler.pys from_function•sc sI|ƒ‰|oˆi|iƒndk}|i|ƒ\}} }ˆi i |ƒ| o#ˆi i | ƒˆitO_n|o#ˆi i |ƒˆitO_n‡‡d†‰xbt|ƒD]T\} } t| tƒo8dt| ƒ}|ˆi | <ˆi|ƒˆ| ƒqÅqÅW|iˆ_|iˆ_|iˆ_ˆSdS(NcsSˆit|ƒƒx9|D]1}t|tƒoˆ|ƒqˆi|ƒqWdS(N( sselfsUNPACK_SEQUENCEslensargssargs isinstanceslists tuple_args STORE_FAST(sargssarg(sselfs tuple_arg(s,build\bdist.win32\egg\peak\util\assembler.pys tuple_argªs s.(sclssselfs copy_linenos set_linenoscodesco_firstlinenosinspectsgetargssargssvarskws co_varnamessextendsappendsco_flagss CO_VARARGSsCO_VARKEYWORDSs tuple_args enumeratesnargsargs isinstanceslistsstrs dummy_names LOAD_FASTs co_argcountsco_names co_freevars( sclsscodes copy_linenosinspects dummy_namesselfsargsskws tuple_argsargsvarsnarg((sselfs tuple_args,build\bdist.win32\egg\peak\util\assembler.pys from_code›s0        cCsÙ|iotdt|iƒƒ‚n|it@}|i o|i o|tO}nt |i t|i ƒ|i ||i iƒt|iƒt|iƒt|i ƒ|i|i|i|iiƒ|i|iƒSdS(Ns%d unclosed block(s)(sselfsblockssAssertionErrorslensco_flagss CO_NOFREEsflagss co_freevarss co_cellvarsscodes co_argcounts co_varnamess co_stacksizesco_codestostringstuples co_constssco_namess co_filenamesco_namesco_firstlinenos co_lnotab(sselfsflags((s,build\bdist.win32\egg\peak\util\assembler.pyscodeÄs  (2s__name__s __module__s co_argcounts co_stacksizes CO_OPTIMIZEDs CO_NEWLOCALSsco_flagss co_filenamesco_namesco_firstlinenos co_freevarss co_cellvarss _last_lineofss stack_sizes__init__semit_args set_linenos stackchanges LOAD_CONSTs CALL_FUNCTIONsCALL_FUNCTION_VARsCALL_FUNCTION_KWsCALL_FUNCTION_VAR_KWs BUILD_TUPLEs BUILD_LISTsUNPACK_SEQUENCEs BUILD_SLICEsDUP_TOPXs RAISE_VARARGSs MAKE_FUNCTIONs MAKE_CLOSUREsheresNonesjumps setup_blocks SETUP_EXCEPTs SETUP_FINALLYs SETUP_LOOPsraw_pops POP_BLOCKs assert_loops BREAK_LOOPs CONTINUE_LOOPs__call__sreturn_sFalses from_functions classmethods from_codescode(((s,build\bdist.win32\egg\peak\util\assembler.pysCode¥sZ                            # cCsm|it|ƒy#t|i|iƒi|ƒ}Wn"t j ot d|ƒ‚nX|i ||ƒdS(NsUndefined free or cell var( sselfs stackchanges stack_effectssopslists co_cellvarss co_freevarssindexsvarnamesargs ValueErrors NameErrorsemit_arg(sselfsvarnamesopsarg((s,build\bdist.win32\egg\peak\util\assembler.pysdo_freeÙs #cCsš|it|ƒy|ii|ƒ}Wn2tj o&t |iƒ}|ii |ƒnX|i ||ƒ|t t tfjo|itM_ndS(N(sselfs stackchanges stack_effectssopsco_namessindexsnamesargs ValueErrorslensappendsemit_args LOAD_NAMEs STORE_NAMEs DELETE_NAMEsco_flagss CO_OPTIMIZED(sselfsnamesopsarg((s,build\bdist.win32\egg\peak\util\assembler.pysdo_nameïscCs|it@ otdƒ‚n|it|ƒy|ii|ƒ}Wn2t j o&t |iƒ}|ii |ƒnX|i||ƒdS(Ns5co_flags must include CO_OPTIMIZED to use fast locals(sselfsco_flagss CO_OPTIMIZEDsAssertionErrors stackchanges stack_effectssops co_varnamessindexsvarnamesargs ValueErrorslensappendsemit_arg(sselfsvarnamesopsarg((s,build\bdist.win32\egg\peak\util\assembler.pysdo_localþscCs%|it|ƒ|i||ƒSdS(N(sselfs stackchanges stack_effectssopsjumpsaddress(sselfsaddresssop((s,build\bdist.win32\egg\peak\util\assembler.pysdo_jumpscCsY|idƒxE|iƒD]7\}}|iƒ|||ƒ|iƒ|iƒqWdS(Ni( scodes BUILD_MAPsobsitemssksvsDUP_TOPs ROT_THREEs STORE_SUBSCR(scodesobsksv((s,build\bdist.win32\egg\peak\util\assembler.pysgen_maps     cCs!||Œ|it|ƒƒSdS(N(scodesobs BUILD_TUPLEslen(scodesob((s,build\bdist.win32\egg\peak\util\assembler.pys gen_tuples cCs!||Œ|it|ƒƒSdS(N(scodesobs BUILD_LISTslen(scodesob((s,build\bdist.win32\egg\peak\util\assembler.pysgen_list"s cBstZdZRS(s4The supplied value is not a constant expression tree(s__name__s __module__s__doc__(((s,build\bdist.win32\egg\peak\util\assembler.pys NotAConstant?s cCsÍt|ƒ}|tjo-|itjo |i}q®t|ƒ‚ni|tjo2tt t |ƒƒ}||jo|Sn|Sn*t i |ƒt ijot|ƒ‚n|tjo t}n|SdS(s˜Return the constant value -- if any -- of an expression tree Raises NotAConstant if the value or any child of the value are not constants. N(stypesvaluestsinstancemethodsim_funcsConstsim_selfs NotAConstantstuplesmaps const_valuesgenerate_typessgetsCodes LOAD_CONSTsnilsNone(svaluest((s,build\bdist.win32\egg\peak\util\assembler.pys const_valueBs        s_secBsDtZdZddfZZddfZddfZddfZddfZddfZ Z Z Z Z ZZZddfZZZZZZZZZZZZZZZddfZ Z!Z"Z#Z$Z%Z&Z'Z(Z)Z*Z+Z,ddfddfddfddff\Z-Z.Z/Z0ddfddfddfddff\Z1Z2Z3Z4ddfddfddfddff\Z5Z6Z7Z8ddfZ9ddfZ:Z;ddfZ<Z=ddfZ>Z?Z@ZAddfZBZCZDZEZFddfZGZHddfZIZJZKZLZMZNZOZPZQddfZRZSRS(s5Quick way of defining static stack effects of opcodesiiiii(Ts__name__s __module__s__doc__sPOP_TOPs END_FINALLYsROT_TWOs ROT_THREEsROT_FOURsDUP_TOPsUNARY_POSITIVEsUNARY_NEGATIVEs UNARY_NOTs UNARY_CONVERTs UNARY_INVERTsGET_ITERs LOAD_ATTRs IMPORT_FROMs BINARY_POWERsBINARY_MULTIPLYs BINARY_DIVIDEsBINARY_FLOOR_DIVIDEsBINARY_TRUE_DIVIDEs BINARY_MODULOs BINARY_ADDsBINARY_SUBTRACTs BINARY_SUBSCRs BINARY_LSHIFTs BINARY_RSHIFTs BINARY_ANDs BINARY_XORs BINARY_ORs COMPARE_OPs INPLACE_POWERsINPLACE_MULTIPLYsINPLACE_DIVIDEsINPLACE_FLOOR_DIVIDEsINPLACE_TRUE_DIVIDEsINPLACE_MODULOs INPLACE_ADDsINPLACE_SUBTRACTsINPLACE_LSHIFTsINPLACE_RSHIFTs INPLACE_ANDs INPLACE_XORs INPLACE_ORsSLICE_0sSLICE_1sSLICE_2sSLICE_3s STORE_SLICE_0s STORE_SLICE_1s STORE_SLICE_2s STORE_SLICE_3sDELETE_SLICE_0sDELETE_SLICE_1sDELETE_SLICE_2sDELETE_SLICE_3s STORE_SUBSCRs DELETE_SUBSCRs STORE_ATTRs DELETE_ATTRs STORE_DEREFs PRINT_EXPRs PRINT_ITEMsPRINT_NEWLINE_TOs IMPORT_STARs RETURN_VALUEs YIELD_VALUEs STORE_NAMEs STORE_GLOBALs STORE_FASTs PRINT_ITEM_TOs LIST_APPENDs LOAD_LOCALSs LOAD_CONSTs LOAD_NAMEs LOAD_GLOBALs LOAD_FASTs LOAD_CLOSUREs LOAD_DEREFs IMPORT_NAMEs BUILD_MAPs EXEC_STMTs BUILD_CLASS(((s,build\bdist.win32\egg\peak\util\assembler.pys_sehs(     (D<666 ,is+s_cCs!|i|ƒ|i||ƒdS(N(sselfs stackchangessesemit_argsopsarg(sselfsargsopsse((s,build\bdist.win32\egg\peak\util\assembler.pysdo_opžscCs|i|ƒ|i|ƒdS(N(sselfs stackchangessesemitsop(sselfsopsse((s,build\bdist.win32\egg\peak\util\assembler.pysdo_op¡sN(RsarraysdissnewscodesinstancemethodstypessCodeTypes__all__sopcodesrangesopsopnamesnames startswithsendswithsglobalssupdates CO_OPTIMIZEDs CO_NEWLOCALSs CO_VARARGSsCO_VARKEYWORDSs CO_NESTEDs CO_GENERATORs CO_NOFREEsCO_GENERATOR_ALLOWEDsCO_FUTURE_DIVISIONsCO_FUTURE_ABSOLUTE_IMPORTsCO_FUTURE_WITH_STATEMENTsextendsappends_[1]skeyssksobjects_nilsnils ast_currysNonesConstsGlobalsLocalsReturnsTruesCallsLabelsCodeshasfreeshasattrsdo_freessetattrshasnamesdo_nameshaslocalsdo_localshasjrelshasjabssdo_jumpsgen_maps gen_tuplesgen_listsints LOAD_CONSTslongsboolsstrsunicodescomplexsfloatstypestupleslistsdictsgenerate_typess Exceptions NotAConstants const_values_ses stack_effectssreplacesgetattrs HAVE_ARGUMENTsdo_op(,s ast_curryscodesConsts_sesLabelsCalls CO_NESTEDsCodeTypes CO_NEWLOCALSsarraysLocals CO_OPTIMIZEDs NotAConstantsReturns__all__sdo_jumpsCO_VARKEYWORDSsdo_localsdo_ops CO_VARARGSsgenerate_typessCO_FUTURE_DIVISIONsCO_GENERATOR_ALLOWEDs const_values CO_NOFREEsCO_FUTURE_ABSOLUTE_IMPORTsnilsgen_listsinstancemethodsdo_names stack_effectssdo_frees CO_GENERATORsgen_mapsCodes gen_tuplesnamesksGlobals_[1]sopcodes_nilsCO_FUTURE_WITH_STATEMENTsop((s,build\bdist.win32\egg\peak\util\assembler.pys?s˜  '  K      ))ÿ3        “ &)  PK2 ·4(åØ88peak/util/__init__.py__import__('pkg_resources').declare_namespace(__name__) PK…Ñ4™}µ7ÒÒpeak/util/__init__.pyc;ò ™rDc@sedƒieƒdS(s pkg_resourcesN(s __import__sdeclare_namespaces__name__(((s+build\bdist.win32\egg\peak\util\__init__.pys?sPK„Ñ47SäB¶EGG-INFO/namespace_packages.txtPK„Ñ4?Ç<® ® ¶LEGG-INFO/PKG-INFOPK„Ñ4„‚)Ð??¶) EGG-INFO/SOURCES.txtPK„Ñ4†êÁ¶š EGG-INFO/top_level.txtPK…Ñ4¶Ó EGG-INFO/zip-safePK/ ·4‰kÔ<99¶peak/__init__.pyPK…Ñ4ºÑgéÍͶipeak/__init__.pycPKÍÑ4å@hRµIµI¶epeak/util/assembler.pyPK…Ñ4„·9¬ÀtÀt¶NYpeak/util/assembler.pycPK2 ·4(åØ88¶CÎpeak/util/__init__.pyPK…Ñ4™}µ7ÒÒ¶®Îpeak/util/__init__.pycPK Þ´Ï