3 /*^@sdZddlZddlmZddlmZmZmZddlm Z m Z m Z m Z m Z mZmZmZmZmZddlmZddlmZddlmZGd d d eZGd d d eZGd ddeeZddZedkrddlZeej dS)ah A spark grammar for Python 3.x. However instead of terminal symbols being the usual ASCII text, e.g. 5, myvariable, "for", etc. they are CPython Bytecode tokens, e.g. "LOAD_CONST 5", "STORE NAME myvariable", "SETUP_LOOP", etc. If we succeed in creating a parse tree, then we have a Python program that a later phase can turn into a sequence of ASCII text. N)Token) PythonParserPythonParserSinglenop_func) and_checkexcept_handler_else ifelsestmtifstmt iflaststmtor_checktesttrue tryelsestmtl3 tryexcept while1stmt) SyntaxTree) DEFAULT_DEBUG)PYTHON3cseZdZeffdd ZddZddZddZd d Zd d Z d dZ ddZ ddZ ddZ ddZddZeddZddZddZdd Zd!d"Zd#d$ZZS)% Python3Parsercs*t|_tt|jtd|dt|_dS)NZstmts)debug)setZ added_rulessuperr__init__rZ new_rules)selfZ debug_parser) __class__V/home/psgendb/BIRCHDEV/python/lib/python3.6/site-packages/uncompyle6/parsers/parse3.pyr2szPython3Parser.__init__cCsdS)a # Python3 scanner adds LOAD_LISTCOMP. Python3 does list comprehension like # other comprehensions (set, dictionary). # Our "continue" heuristic - in two successive JUMP_BACKS, the first # one may be a continue - sometimes classifies a JUMP_BACK # as a CONTINUE. The two are kind of the same in a comprehension. comp_for ::= expr for_iter store comp_iter CONTINUE comp_for ::= expr for_iter store comp_iter JUMP_BACK list_comp ::= BUILD_LIST_0 list_iter lc_body ::= expr LIST_APPEND list_for ::= expr FOR_ITER store list_iter jb_or_c # This is seen in PyPy, but possibly it appears on other Python 3? list_if ::= expr jmp_false list_iter COME_FROM list_if_not ::= expr jmp_true list_iter COME_FROM jb_or_c ::= JUMP_BACK jb_or_c ::= CONTINUE jb_cfs ::= JUMP_BACK _come_froms stmt ::= set_comp_func set_comp_func ::= BUILD_SET_0 LOAD_FAST FOR_ITER store comp_iter JUMP_BACK RETURN_VALUE RETURN_LAST set_comp_func ::= BUILD_SET_0 LOAD_FAST FOR_ITER store comp_iter COME_FROM JUMP_BACK RETURN_VALUE RETURN_LAST comp_body ::= dict_comp_body comp_body ::= set_comp_body dict_comp_body ::= expr expr MAP_ADD set_comp_body ::= expr SET_ADD # See also common Python p_list_comprehension Nr)rargsrrrp_comprehension37szPython3Parser.p_comprehension3cCsdS)a&" expr ::= dict_comp stmt ::= dict_comp_func dict_comp_func ::= BUILD_MAP_0 LOAD_FAST FOR_ITER store comp_iter JUMP_BACK RETURN_VALUE RETURN_LAST comp_iter ::= comp_if_not comp_if_not ::= expr jmp_true comp_iter Nr)rrrrr p_dict_comp3_szPython3Parser.p_dict_comp3cCsdS)a sstmt ::= stmt stmt ::= ifelsestmtr sstmt ::= return RETURN_LAST return_if_stmts ::= return_if_stmt come_from_opt return_if_stmts ::= _stmts return_if_stmt _come_froms return_if_stmt ::= ret_expr RETURN_END_IF returns ::= _stmts return_if_stmt stmt ::= break break ::= BREAK_LOOP stmt ::= continue continue ::= CONTINUE continues ::= _stmts lastl_stmt continue continues ::= lastl_stmt continue continues ::= continue kwarg ::= LOAD_STR expr kwargs ::= kwarg+ classdef ::= build_class store # FIXME: we need to add these because don't detect this properly # in custom rules. Specifically if one of the exprs is CALL_FUNCTION # then we'll mistake that for the final CALL_FUNCTION. # We can fix by triggering on the CALL_FUNCTION op # Python3 introduced LOAD_BUILD_CLASS # Other definitions are in a custom rule build_class ::= LOAD_BUILD_CLASS mkfunc expr call CALL_FUNCTION_3 build_class ::= LOAD_BUILD_CLASS mkfunc expr call expr CALL_FUNCTION_4 stmt ::= classdefdeco classdefdeco ::= classdefdeco1 store expr ::= LOAD_ASSERT assert ::= assert_expr jmp_true LOAD_ASSERT RAISE_VARARGS_1 COME_FROM stmt ::= assert2 assert2 ::= assert_expr jmp_true LOAD_ASSERT expr CALL_FUNCTION_1 RAISE_VARARGS_1 COME_FROM assert_expr ::= expr assert_expr ::= assert_expr_or assert_expr ::= assert_expr_and assert_expr_or ::= assert_expr jmp_true expr assert_expr_and ::= assert_expr jmp_false expr ifstmt ::= testexpr _ifstmts_jump testexpr ::= testfalse testexpr ::= testtrue testfalse ::= expr jmp_false testtrue ::= expr jmp_true _ifstmts_jump ::= return_if_stmts _ifstmts_jump ::= stmts _come_froms _ifstmts_jumpl ::= c_stmts_opt come_froms iflaststmt ::= testexpr stmts_opt JUMP_ABSOLUTE iflaststmt ::= testexpr _ifstmts_jumpl # ifstmts where we are in a loop _ifstmts_jumpl ::= _ifstmts_jump iflaststmtl ::= testexpr c_stmts_opt JUMP_BACK iflaststmtl ::= testexpr _ifstmts_jumpl # These are used to keep parse tree indices the same jump_forward_else ::= JUMP_FORWARD ELSE jump_absolute_else ::= JUMP_ABSOLUTE ELSE # Note: in if/else kinds of statements, we err on the side # of missing "else" clauses. Therefore we include grammar # rules with and without ELSE. ifelsestmt ::= testexpr stmts_opt JUMP_FORWARD else_suite opt_come_from_except ifelsestmt ::= testexpr stmts_opt jump_forward_else else_suite _come_froms # ifelsestmt ::= testexpr c_stmts_opt jump_forward_else # pass _come_froms # FIXME: remove this stmt ::= ifelsestmtc c_stmts ::= ifelsestmtc ifelsestmtc ::= testexpr c_stmts_opt JUMP_ABSOLUTE else_suitec ifelsestmtc ::= testexpr c_stmts_opt jump_absolute_else else_suitec ifelsestmtc ::= testexpr c_stmts_opt jump_forward_else else_suitec _come_froms # "if"/"else" statement that ends in a RETURN ifelsestmtr ::= testexpr return_if_stmts returns ifelsestmtl ::= testexpr c_stmts_opt JUMP_BACK else_suitel ifelsestmtl ::= testexpr c_stmts_opt cf_jump_back else_suitel ifelsestmtl ::= testexpr c_stmts_opt continue else_suitel cf_jump_back ::= COME_FROM JUMP_BACK # FIXME: this feels like a hack. Is it just 1 or two # COME_FROMs? the parsed tree for this and even with just the # one COME_FROM for Python 2.7 seems to associate the # COME_FROM targets from the wrong places # this is nested inside a try_except tryfinallystmt ::= SETUP_FINALLY suite_stmts_opt POP_BLOCK LOAD_CONST COME_FROM_FINALLY suite_stmts_opt END_FINALLY except_handler_else ::= except_handler except_handler ::= jmp_abs COME_FROM except_stmts END_FINALLY except_handler ::= jmp_abs COME_FROM_EXCEPT except_stmts END_FINALLY # FIXME: remove this except_handler ::= JUMP_FORWARD COME_FROM except_stmts END_FINALLY COME_FROM except_handler ::= JUMP_FORWARD COME_FROM except_stmts END_FINALLY COME_FROM_EXCEPT except_stmts ::= except_stmt+ except_stmt ::= except_cond1 except_suite except_stmt ::= except_cond2 except_suite except_stmt ::= except_cond2 except_suite_finalize except_stmt ::= except ## FIXME: what's except_pop_except? except_stmt ::= except_pop_except # Python3 introduced POP_EXCEPT except_suite ::= c_stmts_opt POP_EXCEPT jump_except jump_except ::= JUMP_ABSOLUTE jump_except ::= JUMP_BACK jump_except ::= JUMP_FORWARD jump_except ::= CONTINUE # This is used in Python 3 in # "except ... as e" to remove 'e' after the c_stmts_opt finishes except_suite_finalize ::= SETUP_FINALLY c_stmts_opt except_var_finalize END_FINALLY _jump except_var_finalize ::= POP_BLOCK POP_EXCEPT LOAD_CONST COME_FROM_FINALLY LOAD_CONST store del_stmt except_suite ::= returns except_cond1 ::= DUP_TOP expr COMPARE_OP jmp_false POP_TOP POP_TOP POP_TOP except_cond2 ::= DUP_TOP expr COMPARE_OP jmp_false POP_TOP store POP_TOP except ::= POP_TOP POP_TOP POP_TOP c_stmts_opt POP_EXCEPT _jump except ::= POP_TOP POP_TOP POP_TOP returns jmp_abs ::= JUMP_ABSOLUTE jmp_abs ::= JUMP_BACK with ::= expr SETUP_WITH POP_TOP suite_stmts_opt POP_BLOCK LOAD_CONST COME_FROM_WITH WITH_CLEANUP END_FINALLY withasstmt ::= expr SETUP_WITH store suite_stmts_opt POP_BLOCK LOAD_CONST COME_FROM_WITH WITH_CLEANUP END_FINALLY expr_jt ::= expr jmp_true expr_jitop ::= expr JUMP_IF_TRUE_OR_POP ## FIXME: Right now we have erroneous jump targets ## This below is probably not correct when the COME_FROM is put in the right place and ::= expr jmp_false expr COME_FROM or ::= expr_jt expr COME_FROM or ::= expr_jt expr or ::= expr_jitop expr COME_FROM and ::= expr JUMP_IF_FALSE_OR_POP expr COME_FROM # # something like the below is needed when the jump targets are fixed ## or ::= expr JUMP_IF_TRUE_OR_POP COME_FROM expr ## and ::= expr JUMP_IF_FALSE_OR_POP COME_FROM expr Nr)rrrrr p_grammarjszPython3Parser.p_grammarcCsdS)a except_handler ::= JUMP_FORWARD COME_FROM_EXCEPT except_stmts END_FINALLY COME_FROM except_handler ::= JUMP_FORWARD COME_FROM_EXCEPT except_stmts END_FINALLY COME_FROM_EXCEPT_CLAUSE for_block ::= l_stmts_opt COME_FROM_LOOP JUMP_BACK for_block ::= l_stmts iflaststmtl ::= testexpr c_stmts_opt Nr)rrrrrp_misc3)szPython3Parser.p_misc3cCsdS)a7 # Annotated functions stmt ::= function_def_annotate function_def_annotate ::= mkfunc_annotate store mkfuncdeco0 ::= mkfunc_annotate # This has the annotation value. # LOAD_NAME is used in an annotation type like # int, float, str annotate_arg ::= LOAD_NAME # LOAD_CONST is used in an annotation string annotate_arg ::= expr # This stores the tuple of parameter names # that have been annotated annotate_tuple ::= LOAD_CONST Nr)rrrrrp_def_annotations35sz Python3Parser.p_def_annotations3cCsdS)z opt_come_from_except ::= COME_FROM_EXCEPT opt_come_from_except ::= _come_froms opt_come_from_except ::= come_from_except_clauses come_from_except_clauses ::= COME_FROM_EXCEPT_CLAUSE+ Nr)rrrrr p_come_from3IszPython3Parser.p_come_from3cCsdS)a jmp_false ::= POP_JUMP_IF_FALSE jmp_true ::= POP_JUMP_IF_TRUE # FIXME: Common with 2.7 ret_and ::= expr JUMP_IF_FALSE_OR_POP ret_expr_or_cond COME_FROM ret_or ::= expr JUMP_IF_TRUE_OR_POP ret_expr_or_cond COME_FROM if_exp_ret ::= expr POP_JUMP_IF_FALSE expr RETURN_END_IF COME_FROM ret_expr_or_cond # compare_chained1 is used exclusively in chained_compare compare_chained1 ::= expr DUP_TOP ROT_THREE COMPARE_OP JUMP_IF_FALSE_OR_POP compare_chained1 COME_FROM compare_chained1 ::= expr DUP_TOP ROT_THREE COMPARE_OP JUMP_IF_FALSE_OR_POP compare_chained2 COME_FROM Nr)rrrrrp_jump3RszPython3Parser.p_jump3cCsdS)a7 stmt ::= if_exp_lambda stmt ::= if_exp_not_lambda if_exp_lambda ::= expr jmp_false expr return_if_lambda return_stmt_lambda LAMBDA_MARKER if_exp_not_lambda ::= expr jmp_true expr return_if_lambda return_stmt_lambda LAMBDA_MARKER return_stmt_lambda ::= ret_expr RETURN_VALUE_LAMBDA return_if_lambda ::= RETURN_END_IF_LAMBDA stmt ::= return_closure return_closure ::= LOAD_CLOSURE RETURN_VALUE RETURN_LAST stmt ::= whileTruestmt ifelsestmt ::= testexpr c_stmts_opt JUMP_FORWARD else_suite _come_froms # FIXME: go over this _stmts ::= _stmts last_stmt stmts ::= last_stmt stmts_opt ::= stmts last_stmt ::= iflaststmt last_stmt ::= forelselaststmt iflaststmt ::= testexpr last_stmt JUMP_ABSOLUTE iflaststmt ::= testexpr stmts JUMP_ABSOLUTE _iflaststmts_jump ::= stmts last_stmt _ifstmts_jump ::= stmts_opt JUMP_FORWARD _come_froms iflaststmt ::= testexpr _iflaststmts_jump ifelsestmt ::= testexpr stmts_opt jump_absolute_else else_suite ifelsestmt ::= testexpr stmts_opt jump_forward_else else_suite _come_froms else_suite ::= stmts else_suitel ::= stmts # FIXME: remove this _ifstmts_jump ::= c_stmts_opt JUMP_FORWARD _come_froms # statements with continue and break c_stmts ::= _stmts c_stmts ::= _stmts lastc_stmt c_stmts ::= lastc_stmt c_stmts ::= continues lastc_stmt ::= iflaststmtl lastc_stmt ::= forelselaststmt lastc_stmt ::= ifelsestmtc # Statements in a loop lstmt ::= stmt l_stmts ::= lstmt+ Nr)rrrrrp_stmt3dszPython3Parser.p_stmt3cCsdS)aw stmt ::= whileelsestmt2 for ::= SETUP_LOOP expr for_iter store for_block POP_BLOCK COME_FROM_LOOP forelsestmt ::= SETUP_LOOP expr for_iter store for_block POP_BLOCK else_suite COME_FROM_LOOP forelselaststmt ::= SETUP_LOOP expr for_iter store for_block POP_BLOCK else_suitec COME_FROM_LOOP forelselaststmtl ::= SETUP_LOOP expr for_iter store for_block POP_BLOCK else_suitel COME_FROM_LOOP whilestmt ::= SETUP_LOOP testexpr l_stmts_opt COME_FROM JUMP_BACK POP_BLOCK COME_FROM_LOOP whilestmt ::= SETUP_LOOP testexpr l_stmts_opt JUMP_BACK POP_BLOCK JUMP_BACK COME_FROM_LOOP whilestmt ::= SETUP_LOOP testexpr l_stmts_opt JUMP_BACK POP_BLOCK COME_FROM_LOOP whilestmt ::= SETUP_LOOP testexpr returns POP_BLOCK COME_FROM_LOOP while1elsestmt ::= SETUP_LOOP l_stmts JUMP_BACK else_suitel whileelsestmt ::= SETUP_LOOP testexpr l_stmts_opt jb_cfs POP_BLOCK else_suitel COME_FROM_LOOP whileelsestmt2 ::= SETUP_LOOP testexpr l_stmts_opt JUMP_BACK POP_BLOCK else_suitel JUMP_BACK COME_FROM_LOOP whileTruestmt ::= SETUP_LOOP l_stmts_opt JUMP_BACK POP_BLOCK COME_FROM_LOOP # FIXME: Python 3.? starts adding branch optimization? Put this starting there. while1stmt ::= SETUP_LOOP l_stmts COME_FROM_LOOP while1stmt ::= SETUP_LOOP l_stmts COME_FROM JUMP_BACK COME_FROM_LOOP while1elsestmt ::= SETUP_LOOP l_stmts JUMP_BACK else_suite COME_FROM_LOOP # FIXME: investigate - can code really produce a NOP? whileTruestmt ::= SETUP_LOOP l_stmts_opt JUMP_BACK NOP COME_FROM_LOOP whileTruestmt ::= SETUP_LOOP l_stmts_opt JUMP_BACK POP_BLOCK NOP COME_FROM_LOOP for ::= SETUP_LOOP expr for_iter store for_block POP_BLOCK NOP COME_FROM_LOOP Nr)rrrrr p_loop_stmt3szPython3Parser.p_loop_stmt3cCsdS)zl load_genexpr ::= LOAD_GENEXPR load_genexpr ::= BUILD_TUPLE_1 LOAD_GENEXPR LOAD_STR Nr)rrrrrp_generator_exp3szPython3Parser.p_generator_exp3cCsdS)a expr ::= LOAD_STR expr ::= if_exp_not if_exp_not ::= expr jmp_true expr jump_forward_else expr COME_FROM # a JUMP_FORWARD to another JUMP_FORWARD can get turned into # a JUMP_ABSOLUTE with no COME_FROM if_exp ::= expr jmp_false expr jump_absolute_else expr # if_exp_true are for conditions which always evaluate true # There is dead or non-optional remnants of the condition code though, # and we use that to match on to reconstruct the source more accurately expr ::= if_exp_true if_exp_true ::= expr JUMP_FORWARD expr COME_FROM Nr)rrrrrp_expr3szPython3Parser.p_expr3cCs(|jdk rd|j|jfSd|jSdS)zACustomize CALL_FUNCTION to add the number of positional argumentsNz%s_%iz%s_0)attrkind)tokenrrr call_fn_names zPython3Parser.call_fn_namec Csx@t|dt|D]*}||jjdr,Pq||jjdrPqW|t|ksVtd||djdksptdd}x0t|t|D]}||jjdr||}PqW|std ||jd kr|j|}|j|\} } d d | dd | |f} n|j}|jdr\|j dt |rD|j|\} } dd | dd | |f} ndd |j d|f} n |j|}d d |j d|f} |j | t dS)a # Should the first rule be somehow folded into the 2nd one? build_class ::= LOAD_BUILD_CLASS mkfunc LOAD_CLASSNAME {expr}^n-1 CALL_FUNCTION_n LOAD_CONST CALL_FUNCTION_n build_class ::= LOAD_BUILD_CLASS mkfunc expr call CALL_FUNCTION_3  MAKE_FUNCTION MAKE_CLOSUREz7build_class needs to find MAKE_FUNCTION or MAKE_CLOSURELOAD_STRzr@rAnakZ uniq_paramrBrrrcustom_classfunc_rule<s"   "  z#Python3Parser.custom_classfunc_rulecCsJ|jdkr.ts|j rd}nd}||d}n|d}|j||||dS)ztPython 3.3 added a an addtional LOAD_STR before MAKE_FUNCTION and this has an effect on many rules. gffffff @z LOAD_STR z LOAD_CONST r,rN)r7rr>rF)rrBr:r(r=load_opZnew_rulerrradd_make_function_ruleps  z$Python3Parser.add_make_function_rulec!Cs>d|_tdփ}td׃}tdd|D|_tdd|jD|_d|krZd|_|jdtt|}d}xBt|D]6\}}|dkrp||dkrp|j ||ddkrpd}qpWxxt|D]j\}}|j } | d| j d|ks| |krq| d| j d} | dkr(d|j } d| | f} |j| tq| jd rh|j } d!d| | f} |j| td"} |j| tq| dkrd%|j } | d&krd'} |j| d(d|d)} d*} |j| d)d+|d,} |j| d)d|d-} n|jd.krb| jd/s| jd$r.d0|jkrd1d2|j | f} |j| td3d|j | f} n2d4| d|j d| f} |j| | |j |d5| } n0| d6d7|j } |j| | |j |d8| | f} |j| | |j |q| jd9r|j } d:d| | f} |j| tq| jdr|j } d;d| | f} |j| tq| dkrP|j } d}| d>krd}x0t| D]$}|||dj d@kr2d}Pq2W|rdAdB| | f} |j| | |j || s| d+kr|j }|dC}|dDdD}|d+krdEdFdD} |j| | |||d+kr|jdGdHdD| ||| | j dddj}dI|dJ|dK|d|dD| } |jdL|| g|qqq| dMkr|j dkrx|jdNdOg|n(|j dPkstdQ| |jdRdSg|q| tdڃks| jdYr| dTkr|j dkrdZ} |j| t|j| ||||d|jq| d[kr`|j|\}}t| td[dP}d\d]|d^|d|| } |j| | |j |q| dkr|jd_t|j| q| d`kr|jdat|j| q| dbkr|jdct|j| q| ddkr|jdet|j| q| dfkr |jdgt|j| q| dkr,|jdht|j| q| dikrT|j } |jdjt|j| q| dkkrv|j| |||||jq| dlkr|jdmt|j| q| dnkr|jdot|j| q| d0kr|rdp}|j|| |j ||j| q| dqkr|jdrt|j| q| dskr6|jdt| |j ||j| q| dukrt|rh|jdvtdw}|j|| |j ||j| q| dxkr|jdyt|j| q| jdz r| d{krd0|jkrd|} |j| t|j \}}}|jd}krd}nd}|js||kr0|||d~kr0dd]|| f}|j|| |j || r,dd]|| f}|j|| |j || r,|js||kr|||dskrdd]|| f}|j|| |j ||js||kr|||dukrdd]|| f}|j|| |j ||j s||k r,|||d0k r,|jdd]|| f| |j ||d+k rsz9Python3Parser.customize_grammar_rules..cSsg|]}|d|jdqS)N_)rfind)r\r:rrrr^sPyPyTaW stmt ::= assign3_pypy stmt ::= assign2_pypy assign3_pypy ::= expr expr expr store store store assign2_pypy ::= expr expr store store stmt ::= if_exp_lambda stmt ::= if_exp_not_lambda if_expr_lambda ::= expr jmp_false expr return_if_lambda return_lambda LAMBDA_MARKER if_exp_not_lambda ::= expr jmp_true expr return_if_lambda return_lambda LAMBDA_MARKER GET_ITERr,ZCALL_FUNCTION_1Nr_BUILD_CONST_KEY_MAPzexpr zdict ::= %sLOAD_CONST %sBUILD_LIST_UNPACKzbuild_list_unpack ::= %s%szexpr ::= build_list_unpack BUILD_MAPBUILD_MAP_UNPACKz kvlist_%sZ BUILD_MAP_nzddict_comp_func ::= BUILD_MAP_n LOAD_FAST FOR_ITER store comp_iter JUMP_BACK RETURN_VALUE RETURN_LASTZdict_comp_funckvlist_nzkvlist_n ::= kvlist_n kv3rz kvlist_n ::=zdict ::= BUILD_MAP_n kvlist_ng @ZBUILD_MAP_WITH_CALLZ LOAD_DICTCOMPz dict ::= %s%sz dict_comp z expr ::= unmap_dict unmap_dict ::= %s%s z %s ::= %s %sz dict ::= %sz ::= zexpr expr STORE_MAP zdict ::= %s %sBUILD_MAP_UNPACK_WITH_CALLz#build_map_unpack_with_call ::= %s%szstarred ::= %s %s BUILD_LIST BUILD_SET BUILD_TUPLEBUILD_TUPLE_UNPACK LOAD_CLOSUREzload_closure ::= %s%sz LOAD_CLOSURE i z expr32 ::=%sz exprzexpr1024 ::=%sz expr32z%s ::= z expr1024 zexpr32 z expr ::= %s BUILD_SLICEzexpr ::= build_slice2z(build_slice2 ::= expr expr BUILD_SLICE_2rDz'BUILD_SLICE value must be 2 or 3; is %szexpr ::= build_slice3z-build_slice3 ::= expr expr expr BUILD_SLICE_3r0CALL_FUNCTION_EXCALL_FUNCTION_EX_KWCALL_FUNCTION_VARCALL_FUNCTION_VAR_KWr1a8 dict_comp ::= LOAD_DICTCOMP LOAD_STR MAKE_FUNCTION_0 expr GET_ITER CALL_FUNCTION_1 classdefdeco1 ::= expr classdefdeco2 CALL_FUNCTION_1 classdefdeco1 ::= expr classdefdeco1 CALL_FUNCTION_1 Z CALL_METHODzcall ::= expr zpos_arg zkwarg zcontinue ::= CONTINUE CONTINUE_LOOPzcontinue ::= CONTINUE_LOOP DELETE_ATTRzdel_stmt ::= expr DELETE_ATTR DELETE_DEREFz| stmt ::= del_deref_stmt del_deref_stmt ::= DELETE_DEREF DELETE_SUBSCRz del_stmt ::= delete_subscript delete_subscript ::= expr expr DELETE_SUBSCR zo expr ::= get_iter get_iter ::= expr GET_ITER ZJUMP_IF_NOT_DEBUGa stmt ::= assert_pypy stmt ::= assert_not_pypy stmt ::= assert2_pypy stmt ::= assert2_not_pypy assert_pypy ::= JUMP_IF_NOT_DEBUG assert_expr jmp_true LOAD_ASSERT RAISE_VARARGS_1 COME_FROM assert_not_pypy ::= JUMP_IF_NOT_DEBUG assert_expr jmp_false LOAD_ASSERT RAISE_VARARGS_1 COME_FROM assert2_pypy ::= JUMP_IF_NOT_DEBUG assert_expr jmp_true LOAD_ASSERT expr CALL_FUNCTION_1 RAISE_VARARGS_1 COME_FROM assert2_pypy ::= JUMP_IF_NOT_DEBUG assert_expr jmp_true LOAD_ASSERT expr CALL_FUNCTION_1 RAISE_VARARGS_1 COME_FROM assert2_not_pypy ::= JUMP_IF_NOT_DEBUG assert_expr jmp_false LOAD_ASSERT expr CALL_FUNCTION_1 RAISE_VARARGS_1 COME_FROM rELOAD_CLASSDEREFzexpr ::= LOAD_CLASSDEREFZLOAD_CLASSNAMEzexpr ::= LOAD_CLASSNAMEzKdict_comp ::= LOAD_DICTCOMP %sMAKE_FUNCTION_0 expr GET_ITER CALL_FUNCTION_1 LOAD_ATTRzl expr ::= attribute attribute ::= expr LOAD_ATTR Z LOAD_LISTCOMPzexpr ::= listcompZ LOAD_SETCOMPzexpr ::= set_compzIset_comp ::= LOAD_SETCOMP %sMAKE_FUNCTION_0 expr GET_ITER CALL_FUNCTION_1Z LOOKUP_METHODz expr ::= attribute attribute ::= expr LOOKUP_METHOD r.ZMAKE_CLOSURE_0z dict_comp ::= load_closure LOAD_DICTCOMP LOAD_STR MAKE_CLOSURE_0 expr GET_ITER CALL_FUNCTION_1 gffffff @Z LOAD_LAMBDAz-mklambda ::= %sload_closure LOAD_LAMBDA %%s%szQgenerator_exp ::= %sload_closure load_genexpr %%s%s expr GET_ITER CALL_FUNCTION_1zMlistcomp ::= %sload_closure LOAD_LISTCOMP %%s%s expr GET_ITER CALL_FUNCTION_1zLset_comp ::= %sload_closure LOAD_SETCOMP %%s%s expr GET_ITER CALL_FUNCTION_1zKdict_comp ::= %sload_closure LOAD_DICTCOMP %s expr GET_ITER CALL_FUNCTION_1zkwargs rJg @zBmkfunc_annotate ::= %s%s%sannotate_tuple load_closure LOAD_CODE %sz annotate_arg z(mkfunc ::= %s%sload_closure LOAD_CODE %szKmkfunc_annotate ::= %s%s%sannotate_tuple load_closure LOAD_CODE LOAD_STR %sz1mkfunc ::= %s%sload_closure LOAD_CODE LOAD_STR %sg333333 @r/ LOAD_CONSTz;mkfunc_annotate ::= %s%s%sannotate_tuple load_closure %s %sz,mkfunc ::= %s%s load_closure LOAD_CODE %s %sz)mkfunc ::= %sload_closure load_genexpr %sz&mkfunc ::= %sload_closure LOAD_CODE %sr-g @zmklambda ::= %s%s%s%sz load_closure z#BUILD_TUPLE_1 LOAD_LAMBDA LOAD_STR zmklambda ::= %s%s%szLOAD_LAMBDA LOAD_STR z&mklambda ::= %sLOAD_LAMBDA LOAD_STR %szmkfunc ::= %s%s%s%szLOAD_CODE LOAD_STR zLOAD_CODE LOAD_CONST zDgenerator_exp ::= %sload_genexpr %%s%s expr GET_ITER CALL_FUNCTION_1zKlistcomp ::= load_closure LOAD_LISTCOMP %%s%s expr GET_ITER CALL_FUNCTION_1z@listcomp ::= %sLOAD_LISTCOMP %%s%s expr GET_ITER CALL_FUNCTION_1z"mklambda ::= %s%sLOAD_LAMBDA %%s%sZ no_kwargsz no_kwargs ::=kwargszmkfunc ::= %s %s%s%sz LOAD_CODE zmkfunc ::= %s%s%szmkfunc ::= %s%s %s%szmkfunc ::= %s%sexpr %sz^MAKE_FUNCTION.*_Az frozensetrrGZseen_op_basenamesr9rr3 enumerater+r)findr`r(r4rFr7r2lowerZadd_unique_rulesr5rIr8addrCrLrresearchrr rr r r rreduce_check_tablerZ check_reducer )!rr<r=Zcustomize_instruction_basenamesZcustom_ops_processednZhas_get_iter_call_function1r;r*r:Z opname_baserhrBvZis_LOAD_CLOSUREjZ build_countZ thousandsZ thirty32sZ collectionr@rArHZrule_patZ annotate_argsZ kwargs_strrKclosureZ stack_countr|Z pos_kw_tupleZ before_countZ after_countrrrcustomize_grammar_ruless,                             (                                               $$                          $$                                                           z%Python3Parser.customize_grammar_rulesc Cs|d}t|}t||d}|jj|d}|rJ|||||||||rJdS|d"krf|dddkrfdS|dkrt||jt S|dkr||j} t| tpt| t S|d#kr|j d krt ||||||||S|d%kr|j dks||dkrdSt ||||||||rdS|dj } | j j dr|t|dt|d} | j j drl| | krl| j| jkS||dkr||j| jkrdS| j| jkSdS|d'krdS|dkr2|dddkr2t|t|d}||jd(kr|d8}|d} ||j| djko,||jkSS|dkrt||||||||rXdS|j dkrhdSd|kot|knr||d)kr|d7}x.|t|krt||jtr|d7}qW|t|kr ||j} ||dkst| ||jkr dSdS|dkrt|}||kr4|d8}||dkrL|d8}n||ddkrf|d8}||d*krxdS|d7}x*||krt||jtr|d7}qW||krdS|j dko||j||jkS|d,kr|d-}t|ts ||j|d.jkSdSdS)/Nrr,Trrrrrr rg @r testexpr _ifstmts_jumpg@Z RETURN_END_IFFZ POP_JUMP_IFZ COME_FROM\e__ifstmts_jumprrcjump_forward_elserCOME_FROM_LOOP JUMP_BACK SETUP_LOOPrrOgffffff@ c_stmts_opt else_suite _come_froms)rr)r rrr)r rrr)r r)rr)rrOrrrrr)rrrr)r3minrget isinstancer(tuplestrunicoder7r Z last_childr)r4Zoff2introffsetr5r)rrBastr<firstlastlhsrfnargZcondition_jumpZcondition_jump2rrZ come_fromsrrrreduce_is_invalid-s    "    &"       zPython3Parser.reduce_is_invalid)__name__ __module__ __qualname__PARSER_DEFAULT_DEBUGrrrrr r!r"r#r$r%r&r' staticmethodr+rCrIrLrr __classcell__rr)rrr1s4( @  89 H45rc@seZdZddZdS)Python30ParsercCsdS)z jmp_true ::= JUMP_IF_TRUE_OR_POP POP_TOP _ifstmts_jump ::= c_stmts_opt JUMP_FORWARD POP_TOP COME_FROM Nr)rrrrrp_30szPython30Parser.p_30N)rrrrrrrrrsrc@s eZdZdS)Python3ParserSingleN)rrrrrrrrsrcCst}t|dkr||d}|dkr6ddlm}|}nF|dkrRddlm}|}n*|dkrnddlm}|}n|dkr|t}|j tt j d krt j d d krt d d |j dS) Nrz3.5)Python35Parserz3.3)Python33Parserz3.2)Python32Parserz3.0r,dump-2)rr3Zuncompyle6.parser.parse35rZuncompyle6.parser.parse33rZuncompyle6.parser.parse32rrZ check_grammarsysargvprintZ dump_grammar)rprrrrrrrinfos$     r__main__)!__doc__rZuncompyle6.scanners.tokrZuncompyle6.parserrrrZuncompyle6.parsers.reducecheckrrrr r r r r rrZuncompyle6.parsers.treenoderZ spark_parserrrZxdisrrrrrrrrrrrrs6 0