3 /*^n@sdZddlmZddlmZmZmZddlmZm Z m Z ddl m Z ddl mZGdddeZGd d d ee Zed kreZejd S) ae Base grammar for Python 2.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. )print_function)except_handler_else ifelsestmt tryelsestmt) PythonParserPythonParserSinglenop_func) SyntaxTree) DEFAULT_DEBUGcsheZdZeffdd ZddZddZddZd d Zd d Z d dZ ddZ ddZ ddZ ZS) Python2Parsercs"tt|jtd|dt|_dS)NZstmts)debug)superr __init__r setZ new_rules)selfZ debug_parser) __class__V/home/psgendb/BIRCHDEV/python/lib/python3.6/site-packages/uncompyle6/parsers/parse2.pyr%szPython2Parser.__init__cCsdS)a stmt ::= print_items_stmt stmt ::= print_nl stmt ::= print_items_nl_stmt print_items_stmt ::= expr PRINT_ITEM print_items_opt print_items_nl_stmt ::= expr PRINT_ITEM print_items_opt PRINT_NEWLINE_CONT print_items_opt ::= print_items? print_items ::= print_item+ print_item ::= expr PRINT_ITEM_CONT print_nl ::= PRINT_NEWLINE Nr)rargsrrrp_print2)szPython2Parser.p_print2cCsdS)a stmt ::= print_to stmt ::= print_to_nl stmt ::= print_nl_to print_to ::= expr print_to_items POP_TOP print_to_nl ::= expr print_to_items PRINT_NEWLINE_TO print_nl_to ::= expr PRINT_NEWLINE_TO print_to_items ::= print_to_items print_to_item print_to_items ::= print_to_item print_to_item ::= DUP_TOP expr ROT_TWO PRINT_ITEM_TO Nr)rrrrr p_print_to7szPython2Parser.p_print_tocCsdS)a sstmt ::= stmt sstmt ::= return RETURN_LAST return_if_stmts ::= return_if_stmt return_if_stmts ::= _stmts return_if_stmt return_if_stmt ::= ret_expr RETURN_END_IF return_stmt_lambda ::= ret_expr RETURN_VALUE_LAMBDA stmt ::= break break ::= BREAK_LOOP stmt ::= continue continue ::= CONTINUE continues ::= _stmts lastl_stmt continue continues ::= lastl_stmt continue continues ::= continue stmt ::= assert2 stmt ::= raise_stmt0 stmt ::= raise_stmt1 stmt ::= raise_stmt2 stmt ::= raise_stmt3 raise_stmt0 ::= RAISE_VARARGS_0 raise_stmt1 ::= expr RAISE_VARARGS_1 raise_stmt2 ::= expr expr RAISE_VARARGS_2 raise_stmt3 ::= expr expr expr RAISE_VARARGS_3 for ::= SETUP_LOOP expr for_iter store for_block POP_BLOCK _come_froms del_stmt ::= delete_subscript delete_subscript ::= expr expr DELETE_SUBSCR del_stmt ::= expr DELETE_ATTR _mklambda ::= load_closure mklambda kwarg ::= LOAD_CONST expr kv3 ::= expr expr STORE_MAP classdef ::= buildclass store buildclass ::= LOAD_CONST expr mkfunc CALL_FUNCTION_0 BUILD_CLASS # Class decorators starting in 2.6 stmt ::= classdefdeco classdefdeco ::= classdefdeco1 store classdefdeco1 ::= expr classdefdeco1 CALL_FUNCTION_1 classdefdeco1 ::= expr classdefdeco2 CALL_FUNCTION_1 classdefdeco2 ::= LOAD_CONST expr mkfunc CALL_FUNCTION_0 BUILD_CLASS 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 iflaststmt ::= testexpr c_stmts_opt JUMP_ABSOLUTE iflaststmtl ::= testexpr c_stmts_opt JUMP_BACK # this is nested inside a try_except tryfinallystmt ::= SETUP_FINALLY suite_stmts_opt POP_BLOCK LOAD_CONST COME_FROM suite_stmts_opt END_FINALLY lastc_stmt ::= tryelsestmtc # Move to 2.7? 2.6 may use come_froms tryelsestmtc ::= SETUP_EXCEPT suite_stmts_opt POP_BLOCK except_handler_else else_suitec COME_FROM tryelsestmtl ::= SETUP_EXCEPT suite_stmts_opt POP_BLOCK except_handler_else else_suitel COME_FROM try_except ::= SETUP_EXCEPT suite_stmts_opt POP_BLOCK except_handler COME_FROM # Note: except_stmts may have many jumps after END_FINALLY except_handler ::= JUMP_FORWARD COME_FROM except_stmts END_FINALLY come_froms except_handler ::= jmp_abs COME_FROM except_stmts END_FINALLY except_handler_else ::= except_handler except_stmts ::= except_stmt+ except_stmt ::= except_cond1 except_suite except_stmt ::= except except_suite ::= c_stmts_opt JUMP_FORWARD except_suite ::= c_stmts_opt jmp_abs except_suite ::= returns except ::= POP_TOP POP_TOP POP_TOP c_stmts_opt _jump except ::= POP_TOP POP_TOP POP_TOP returns jmp_abs ::= JUMP_ABSOLUTE jmp_abs ::= JUMP_BACK jmp_abs ::= CONTINUE Nr)rrrrr p_grammarDszPython2Parser.p_grammarcCsdS)z^ generator_exp ::= LOAD_GENEXPR MAKE_FUNCTION_0 expr GET_ITER CALL_FUNCTION_1 Nr)rrrrrp_generator_exp2szPython2Parser.p_generator_exp2cCsdS)a expr ::= LOAD_LOCALS expr ::= LOAD_ASSERT expr ::= slice0 expr ::= slice1 expr ::= slice2 expr ::= slice3 expr ::= unary_convert expr_jt ::= expr jmp_true or ::= expr_jt expr come_from_opt and ::= expr jmp_false expr come_from_opt unary_convert ::= expr UNARY_CONVERT # In Python 3, DUP_TOPX_2 is DUP_TOP_TWO subscript2 ::= expr expr DUP_TOPX_2 BINARY_SUBSCR Nr)rrrrrp_expr2szPython2Parser.p_expr2cCsdS)a store ::= expr STORE_SLICE+0 store ::= expr expr STORE_SLICE+1 store ::= expr expr STORE_SLICE+2 store ::= expr expr expr STORE_SLICE+3 aug_assign1 ::= expr expr inplace_op ROT_FOUR STORE_SLICE+3 aug_assign1 ::= expr expr inplace_op ROT_THREE STORE_SLICE+1 aug_assign1 ::= expr expr inplace_op ROT_THREE STORE_SLICE+2 aug_assign1 ::= expr expr inplace_op ROT_TWO STORE_SLICE+0 slice0 ::= expr SLICE+0 slice0 ::= expr DUP_TOP SLICE+0 slice1 ::= expr expr SLICE+1 slice1 ::= expr expr DUP_TOPX_2 SLICE+1 slice2 ::= expr expr SLICE+2 slice2 ::= expr expr DUP_TOPX_2 SLICE+2 slice3 ::= expr expr expr SLICE+3 slice3 ::= expr expr expr DUP_TOPX_3 SLICE+3 Nr)rrrrrp_slice2szPython2Parser.p_slice2cCsdS)zZ inplace_op ::= INPLACE_DIVIDE binary_operator ::= BINARY_DIVIDE Nr)rrrrrp_op2szPython2Parser.p_op2cCsd|kr|jdttd~}t}xpt|D]b\}}|j}|d|jd|ks.||kr^q.|d|jd}|dkr4|j} | d} | dd} | dkrddd} |j | || || dkr|j ddd|| |||jdddj } d| d| d | d!| d|} |j d"| | g|q.nR|d#kr|d$krx|j d%d&d'g||j d(kr|j d)d*d|q.d+|j}d,||f} |j| tq.n|d-kr|j}|d.kr|j d/d0g|q.|d1kst d2||j d3d4g|q.n|dkrH|j|\}}t|td5d1}d9d!|d:|d!||} n>|d;kr|j|\}}t|td;d1}d9d!|d:|d!||} n|dkr|jd?t|j|q.n|jd@r|jdAt|j|dB|jdC<q.np|dDkr<|jdEt|j|q.nJ|dFkrl|jdGtdB|jdH<|j|q.n|dIkr|jdJt|j|q.n|dkrq.n|dMkr|jdNtq.n|dOkr|jdPtq.n|dQkr|jdRt|j|q.n|dSkr&|jdTt|j|q.n`|dUkrP|j dVdWg||j|q.n6|dXkrv|jdYt|j|q.n|dZkr|dkr||dd[kr|jd\d]|j|ftd^d!|j|f} n|d_kr|dkr ||dd[kr |jd`d!|j|ft|dkrH||d}|dakrH|j dbd!|j|fg||j dcd!|j|fg||j d(kr.|dkr.||d}|ddkr|j ded!|j|fg|q.|dUkr.|j dVdfd!|j|fg|q.n|dgkrd|kr|j dhdidjg||j|q.n~|dkkr6d|kr(|jdlt|j|q.nP|dkr^|j|do|dp|j} n(|dqkr.|j|dr|dp|j} nq.|j| tq.Wttttds|_dB|jdt<du|jdv<du|jdw<dB|jdx<dB|jdy<dB|jdz<dB|jd{<dB|jd|<du|jd}<dS)aThe base grammar we start out for a Python version even with the subclassing is, well, is pretty base. And we want it that way: lean and mean so that parsing will go faster. Here, we add additional grammar rules based on specific instructions that are in the instruction/token stream. In classes that inherit from from here and other versions, grammar rules may also be removed. For example if we see a pretty rare JUMP_IF_NOT_DEBUG instruction we'll add the grammar for that. More importantly, here we add grammar rules for instructions that may access a variable number of stack items. CALL_FUNCTION, BUILD_LIST and so on are like this. Without custom rules, there can be an super-exponential number of derivations. See the deparsing paper for an elaboration of this. PyPya stmt ::= assign3_pypy stmt ::= assign2_pypy assign3_pypy ::= expr expr expr store store store assign2_pypy ::= expr expr store store list_comp ::= expr BUILD_LIST_FROM_ARG for_iter store list_iter JUMP_BACK BUILDCALLCONTINUEDELETEDUPEXECGETJUMPLOADLOOKUPMAKESETUPRAISEUNPACKN_ BUILD_LIST BUILD_SET BUILD_TUPLEi rz expr32 ::=%sz exprzexpr1024 ::=%sz expr32z%s ::= z expr1024 zexpr32 zexpr z expr ::= %s BUILD_MAPZ BUILD_MAP_nzkvlist_n ::= kvlist_n kv3z kvlist_n ::=zdict ::= BUILD_MAP_n kvlist_ng@zddict_comp_func ::= BUILD_MAP_n LOAD_FAST FOR_ITER store comp_iter JUMP_BACK RETURN_VALUE RETURN_LASTZdict_comp_funcz kv3z dict ::= %s%s BUILD_SLICEzexpr ::= build_slice2z(build_slice2 ::= expr expr BUILD_SLICE_2z'BUILD_SLICE value must be 2 or 3; is %szexpr ::= build_slice3z-build_slice3 ::= expr expr expr BUILD_SLICE_3 CALL_FUNCTIONCALL_FUNCTION_VARCALL_FUNCTION_VAR_KWCALL_FUNCTION_KWzcall ::= expr zkwarg Z CALL_METHOD CONTINUE_LOOPzcontinue ::= CONTINUE_LOOP DELETE_ATTRzdel_stmt ::= expr DELETE_ATTRZ DELETE_SLICEa+ del_expr ::= expr del_stmt ::= del_expr DELETE_SLICE+0 del_stmt ::= del_expr del_expr DELETE_SLICE+1 del_stmt ::= del_expr del_expr DELETE_SLICE+2 del_stmt ::= del_expr del_expr del_expr DELETE_SLICE+3 ASTdel_expr DELETE_DEREFz| stmt ::= del_deref_stmt del_deref_stmt ::= DELETE_DEREF DELETE_SUBSCRz del_stmt ::= delete_subscript delete_subscript ::= expr expr DELETE_SUBSCR delete_subscriptGET_ITERzp expr ::= get_iter attribute ::= expr GET_ITER DUP_TOPX RAISE_VARARGSZ EXEC_STMTz stmt ::= exec_stmt exec_stmt ::= expr exprlist DUP_TOP EXEC_STMT exec_stmt ::= expr exprlist EXEC_STMT exprlist ::= expr+ ZJUMP_IF_NOT_DEBUGaN jmp_true_false ::= POP_JUMP_IF_TRUE jmp_true_false ::= POP_JUMP_IF_FALSE stmt ::= assert_pypy stmt ::= assert2_pypy assert_pypy ::= JUMP_IF_NOT_DEBUG assert_expr jmp_true_false LOAD_ASSERT RAISE_VARARGS_1 COME_FROM assert2_pypy ::= JUMP_IF_NOT_DEBUG assert_expr jmp_true_false LOAD_ASSERT expr CALL_FUNCTION_1 RAISE_VARARGS_1 COME_FROM LOAD_ATTRzl expr ::= attribute attribute ::= expr LOAD_ATTR Z LOAD_LISTCOMPzexpr ::= listcompZ LOAD_SETCOMPzexpr ::= set_compzGset_comp ::= LOAD_SETCOMP MAKE_FUNCTION_0 expr GET_ITER CALL_FUNCTION_1Z LOOKUP_METHODz expr ::= attribute attribute ::= expr LOOKUP_METHOD MAKE_FUNCTIONZ LOAD_LAMBDAzmklambda ::= %s LOAD_LAMBDA %szpos_arg zmkfunc ::= %s LOAD_CODE %sZ MAKE_CLOSUREz+mklambda ::= %s load_closure LOAD_LAMBDA %sZ LOAD_GENEXPRzOgenerator_exp ::= %s load_closure LOAD_GENEXPR %s expr GET_ITER CALL_FUNCTION_1z'mkfunc ::= %s load_closure LOAD_CODE %sZ LOAD_DICTCOMPzLdict_comp ::= %s load_closure LOAD_DICTCOMP %s expr GET_ITER CALL_FUNCTION_1zJset_comp ::= %s load_closure LOAD_SETCOMP %s expr GET_ITER CALL_FUNCTION_1 SETUP_EXCEPTzstmt ::= try_except_pypyzDtry_except_pypy ::= SETUP_EXCEPT suite_stmts_opt except_handler_pypyzDexcept_handler_pypy ::= COME_FROM except_stmts END_FINALLY COME_FROM SETUP_FINALLYz stmt ::= tryfinallystmt_pypy tryfinallystmt_pypy ::= SETUP_FINALLY suite_stmts_opt COME_FROM_FINALLY suite_stmts_opt END_FINALLY UNPACK_TUPLEUNPACK_SEQUENCEz unpack ::= z storeZ UNPACK_LISTzunpack_list ::= )rrr tryelsestmtlandtokensr raise_stmt1assert_expr_andrrI aug_assign2orZifstmt)rrrr r!r"r#r$r%r&r'r(r)r*)r,r-r.)r5r6r7r8)rArB)rGrH)ZaddRuler frozensetr enumeratekindfindrfindattrZadd_unique_rulelowerZadd_unique_rulesversionAssertionErrorZ get_pos_kwlenadd startswithZ check_reducerrrreduce_check_table)rrKZ customizeZcustomize_instruction_basenamesZcustom_seen_opsitokenopnameZ opname_baseZ build_countZ thousandsZ thirty32sruleZ collectionZkvlist_nZ slice_numZargs_posZargs_kwZnakZprev_tokrrrcustomize_grammar_ruless     (          $ $                                                         z%Python2Parser.customize_grammar_rulesc Cs|dkr dS|d}t|}|jj|d}|rH|||||||||rHdS|dkr||dkr`dS|d } | dd krx$||krt||jtr|d 8}qvW| dj||jkrdS|d d} | j| jd } | ||jkp||j| jk S|dkr|dr|dddkrdS|dkrD|d } | dj} | ||jkS|dkrh||dkof|t|kS|dkr|d} | dko| ddkS|dkr|dd} | j dkSdS)NFrTrJexpr jmp_false\e_come_from_opt YIELD_VALUEr0POP_JUMP_IF_FALSEr4 aug_assign1rNrOrMrLZ LOAD_ASSERTjmp_truer3r?r<rbrcrbrd)rJri)rgrN)rJrO)rLrbrhrbrd)rOrj)r?r<)rJrO) rYr\get isinstanceoffsetstrrUZpattrZoff2intrR)rr`astrKfirstlastlhsnfnrcZ jmp_targetZ jump_targetZexpr2oprrrreduce_is_invalidsL             zPython2Parser.reduce_is_invalid)__name__ __module__ __qualname__PARSER_DEFAULT_DEBUGrrrrrrrrrarv __classcell__rr)rrr $s t1r c@s eZdZdS)Python2ParserSingleN)rwrxryrrrrr|sr|__main__N)__doc__ __future__rZuncompyle6.parsers.reducecheckrrrZuncompyle6.parserrrrZuncompyle6.parsers.treenoder Z spark_parserr rzr r|rwpZ check_grammarrrrrs   9