def __init__(self, debug_parser=PARSER_DEFAULT_DEBUG):

self.added_rules = set()

super(Python3Parser, self).__init__(AST, 'stmts', debug=debug_parser)

self.new_rules = set()

def p_comprehension3(self, args):

"""

def p_dictcomp3(self, args):

""""

def p_grammar(self, args):

'''

def p_misc3(self, args):

"""

def p_def_annotations3(self, args):

"""

def p_come_from3(self, args):

"""

def p_jump3(self, args):

"""

def p_stmt3(self, args):

"""

def p_loop_stmt3(self, args):

"""

def p_genexpr3(self, args):

'''

def p_expr3(self, args):

"""

@staticmethod

def call_fn_name(token):

"""Customize CALL_FUNCTION to add the number of positional arguments"""

return '%s_%i' % (token.type, token.attr)

def custom_build_class_rule(self, opname, i, token, tokens, customize):

'''

# FIXME: I bet this can be simplified

# look for next MAKE_FUNCTION

for i in range(i+1, len(tokens)):

if tokens[i].type.startswith('MAKE_FUNCTION'):

break

elif tokens[i].type.startswith('MAKE_CLOSURE'):

break

pass

assert i < len(tokens), "build_class needs to find MAKE_FUNCTION or MAKE_CLOSURE"

assert tokens[i+1].type == 'LOAD_CONST', \

"build_class expecting CONST after MAKE_FUNCTION/MAKE_CLOSURE"

for i in range(i, len(tokens)):

if tokens[i].type == 'CALL_FUNCTION':

call_fn_tok = tokens[i]

break

assert call_fn_tok, "build_class custom rule needs to find CALL_FUNCTION"

# customize build_class rule

# FIXME: What's the deal with the two rules? Different Python versions?

# Different situations? Note that the above rule is based on the CALL_FUNCTION

# token found, while this one doesn't.

call_function = self.call_fn_name(call_fn_tok)

args_pos = call_fn_tok.attr & 0xff

args_kw = (call_fn_tok.attr >> 8) & 0xff

rule = ("build_class ::= LOAD_BUILD_CLASS mkfunc %s"

"%s" % (('expr ' * (args_pos - 1) + ('kwarg ' * args_kw)),

call_function))

self.add_unique_rule(rule, opname, token.attr, customize)

return

def custom_classfunc_rule(self, opname, token, customize):

"""

# Low byte indicates number of positional paramters,

# high byte number of positional parameters

args_pos = token.attr & 0xff

args_kw = (token.attr >> 8) & 0xff

nak = ( len(opname)-len('CALL_FUNCTION') ) // 3

token.type = self.call_fn_name(token)

rule = ('call_function ::= expr ' +

('pos_arg ' * args_pos) +

('kwarg ' * args_kw) +

'expr ' * nak + token.type)

self.add_unique_rule(rule, token.type, args_pos, customize)

if self.version >= 3.5:

rule = ('async_call_function ::= expr ' +

('pos_arg ' * args_pos) +

('kwarg ' * args_kw) +

'expr ' * nak + token.type +

' GET_AWAITABLE LOAD_CONST YIELD_FROM')

self.add_unique_rule(rule, token.type, args_pos, customize)

self.add_unique_rule('expr ::= async_call_function', token.type, args_pos, customize)

rule = ('classdefdeco2 ::= LOAD_BUILD_CLASS mkfunc %s%s_%d'

% (('expr ' * (args_pos-1)), opname, args_pos))

self.add_unique_rule(rule, token.type, args_pos, customize)

def add_make_function_rule(self, rule, opname, attr, customize):

"""Python 3.3 added a an addtional LOAD_CONST before MAKE_FUNCTION and

new_rule = rule % (('LOAD_CONST ') * (1 if self.version >= 3.3 else 0))

self.add_unique_rule(new_rule, opname, attr, customize)

def add_custom_rules(self, tokens, customize):

"""

for i, token in enumerate(tokens):

opname = token.type

opname_base = opname[:opname.rfind('_')]

if opname == 'PyPy':

self.addRule("""

""", nop_func)

continue

elif opname in ('CALL_FUNCTION', 'CALL_FUNCTION_VAR',

'CALL_FUNCTION_VAR_KW', 'CALL_FUNCTION_KW'):

self.custom_classfunc_rule(opname, token, customize)

elif opname == 'LOAD_DICTCOMP':

rule_pat = ("dictcomp ::= LOAD_DICTCOMP %sMAKE_FUNCTION_0 expr "

"GET_ITER CALL_FUNCTION_1")

self.add_make_function_rule(rule_pat, opname, token.attr, customize)

elif opname == 'LOAD_SETCOMP':

# Should this be generalized and put under MAKE_FUNCTION?

rule_pat = ("setcomp ::= LOAD_SETCOMP %sMAKE_FUNCTION_0 expr "

"GET_ITER CALL_FUNCTION_1")

self.add_make_function_rule(rule_pat, opname, token.attr, customize)

elif opname == 'LOAD_BUILD_CLASS':

self.custom_build_class_rule(opname, i, token, tokens, customize)

elif opname_base in ('BUILD_LIST', 'BUILD_TUPLE', 'BUILD_SET'):

v = token.attr

rule = ('build_list ::= ' + 'expr1024 ' * int(v//1024) +

'expr32 ' * int((v//32) % 32) +

'expr ' * (v % 32) + opname)

self.add_unique_rule(rule, opname, token.attr, customize)

if opname_base == 'BUILD_TUPLE':

rule = ('load_closure ::= %s%s' % (('LOAD_CLOSURE ' * v), opname))

self.add_unique_rule(rule, opname, token.attr, customize)

elif opname == 'LOOKUP_METHOD':

# A PyPy speciality - DRY with parse2

self.add_unique_rule("load_attr ::= expr LOOKUP_METHOD",

opname, token.attr, customize)

continue

elif opname == 'JUMP_IF_NOT_DEBUG':

self.add_unique_rule(

"stmt ::= assert_pypy", opname, v, customize)

self.add_unique_rule(

"stmt ::= assert2_pypy", opname_base, v, customize)

self.add_unique_rule(

"assert_pypy ::= JUMP_IF_NOT_DEBUG assert_expr jmp_true "

"LOAD_ASSERT RAISE_VARARGS_1 COME_FROM",

opname, token.attr, customize)

self.add_unique_rule(

"assert2_pypy ::= JUMP_IF_NOT_DEBUG assert_expr jmp_true "

"LOAD_ASSERT expr CALL_FUNCTION_1 RAISE_VARARGS_1 COME_FROM",

opname_base, v, customize)

continue

elif opname_base == 'BUILD_MAP':

kvlist_n = "kvlist_%s" % token.attr

if opname == 'BUILD_MAP_n':

# PyPy sometimes has no count. Sigh.

rule = ('dictcomp_func ::= BUILD_MAP_n LOAD_FAST FOR_ITER designator '

'comp_iter JUMP_BACK RETURN_VALUE RETURN_LAST')

self.add_unique_rule(rule, 'dictomp_func', 1, customize)

kvlist_n = 'kvlist_n'

rule = 'kvlist_n ::= kvlist_n kv3'

self.add_unique_rule(rule, 'kvlist_n', 0, customize)

rule = 'kvlist_n ::='

self.add_unique_rule(rule, 'kvlist_n', 1, customize)

rule = "mapexpr ::= BUILD_MAP_n kvlist_n"

elif self.version >= 3.5:

if opname != 'BUILD_MAP_WITH_CALL':

rule = kvlist_n + ' ::= ' + 'expr ' * (token.attr*2)

self.add_unique_rule(rule, opname, token.attr, customize)

rule = "mapexpr ::= %s %s" % (kvlist_n, opname)

else:

rule = kvlist_n + ' ::= ' + 'expr expr STORE_MAP ' * token.attr

self.add_unique_rule(rule, opname, token.attr, customize)

rule = "mapexpr ::= %s %s" % (opname, kvlist_n)

self.add_unique_rule(rule, opname, token.attr, customize)

elif opname_base == 'BUILD_CONST_KEY_MAP':

# This is in 3.6+

kvlist_n = 'expr ' * (token.attr)

rule = "mapexpr ::= %sLOAD_CONST %s" % (kvlist_n, opname)

self.add_unique_rule(rule, opname, token.attr, customize)

elif opname_base in ('UNPACK_EX',):

before_count, after_count = token.attr

rule = 'unpack ::= ' + opname + ' designator' * (before_count + after_count + 1)

self.add_unique_rule(rule, opname, token.attr, customize)

elif opname_base in ('UNPACK_TUPLE', 'UNPACK_SEQUENCE'):

rule = 'unpack ::= ' + opname + ' designator' * token.attr

self.add_unique_rule(rule, opname, token.attr, customize)

elif opname_base == 'UNPACK_LIST':

rule = 'unpack_list ::= ' + opname + ' designator' * token.attr

elif opname_base.startswith('MAKE_FUNCTION'):

# DRY with MAKE_CLOSURE

args_pos, args_kw, annotate_args = token.attr

rule_pat = ("genexpr ::= %sload_genexpr %%s%s expr "

"GET_ITER CALL_FUNCTION_1" % ('pos_arg '* args_pos, opname))

self.add_make_function_rule(rule_pat, opname, token.attr, customize)

rule_pat = ('mklambda ::= %sLOAD_LAMBDA %%s%s' % ('pos_arg '* args_pos, opname))

self.add_make_function_rule(rule_pat, opname, token.attr, customize)

rule_pat = ("listcomp ::= %sLOAD_LISTCOMP %%s%s expr "

"GET_ITER CALL_FUNCTION_1" % ('expr ' * args_pos, opname))

self.add_make_function_rule(rule_pat, opname, token.attr, customize)

if self.version == 3.3:

# positional args after keyword args

rule = ('mkfunc ::= kwargs %s%s %s' %

('pos_arg ' * args_pos, 'LOAD_CONST '*2,

opname))

elif self.version > 3.3:

# positional args before keyword args

rule = ('mkfunc ::= %skwargs %s %s' %

('pos_arg ' * args_pos, 'LOAD_CONST '*2,

opname))

else:

rule = ('mkfunc ::= kwargs %sexpr %s' %

('pos_arg ' * args_pos, opname))

self.add_unique_rule(rule, opname, token.attr, customize)

if opname.startswith('MAKE_FUNCTION_A'):

# rule = ('mkfunc2 ::= %s%sEXTENDED_ARG %s' %

# ('pos_arg ' * (args_pos), 'kwargs ' * (annotate_args-1), opname))

self.add_unique_rule(rule, opname, token.attr, customize)

if self.version >= 3.3:

rule = ('mkfunc_annotate ::= %s%sannotate_tuple LOAD_CONST LOAD_CONST EXTENDED_ARG %s' %

(('pos_arg ' * (args_pos)),

('call_function ' * (annotate_args-1)), opname))

self.add_unique_rule(rule, opname, token.attr, customize)

rule = ('mkfunc_annotate ::= %s%sannotate_tuple LOAD_CONST LOAD_CONST EXTENDED_ARG %s' %

(('pos_arg ' * (args_pos)),

('annotate_arg ' * (annotate_args-1)), opname))

else:

rule = ('mkfunc_annotate ::= %s%sannotate_tuple LOAD_CONST EXTENDED_ARG %s' %

(('pos_arg ' * (args_pos)),

('annotate_arg ' * (annotate_args-1)), opname))

self.add_unique_rule(rule, opname, token.attr, customize)

rule = ('mkfunc_annotate ::= %s%sannotate_tuple LOAD_CONST EXTENDED_ARG %s' %

(('pos_arg ' * (args_pos)),

('call_function ' * (annotate_args-1)), opname))

self.add_unique_rule(rule, opname, token.attr, customize)

elif opname_base == 'CALL_METHOD':

# PyPy only - DRY with parse2

# FIXME: The below argument parsing will be wrong when PyPy gets to 3.6

args_pos = (token.attr & 0xff) # positional parameters

args_kw = (token.attr >> 8) & 0xff # keyword parameters

# number of apply equiv arguments:

nak = ( len(opname_base)-len('CALL_METHOD') ) // 3

rule = ('call_function ::= expr ' +

('pos_arg ' * args_pos) +

('kwarg ' * args_kw) +

'expr ' * nak + opname)

self.add_unique_rule(rule, opname, token.attr, customize)

elif opname.startswith('MAKE_CLOSURE'):

# DRY with MAKE_FUNCTION

# Note: this probably doesn't handle kwargs proprerly

args_pos, args_kw, annotate_args = token.attr

rule_pat = ("genexpr ::= %sload_closure load_genexpr %%s%s expr "

"GET_ITER CALL_FUNCTION_1" % ('pos_arg '* args_pos, opname))

self.add_make_function_rule(rule_pat, opname, token.attr, customize)

rule_pat = ('mklambda ::= %sload_closure LOAD_LAMBDA %%s%s' %

('pos_arg '* args_pos, opname))

self.add_make_function_rule(rule_pat, opname, token.attr, customize)

rule_pat = ('listcomp ::= %sload_closure LOAD_LISTCOMP %%s%s expr '

'GET_ITER CALL_FUNCTION_1' % ('pos_arg ' * args_pos, opname))

self.add_make_function_rule(rule_pat, opname, token.attr, customize)

rule_pat = ('setcomp ::= %sload_closure LOAD_SETCOMP %%s%s expr '

'GET_ITER CALL_FUNCTION_1' % ('pos_arg ' * args_pos, opname))

self.add_make_function_rule(rule_pat, opname, token.attr, customize)

self.add_unique_rule('dictcomp ::= %sload_closure LOAD_DICTCOMP %s '

'expr GET_ITER CALL_FUNCTION_1' %

('pos_arg '* args_pos, opname),

opname, token.attr, customize)

# FIXME: kwarg processing is missing here.

# Note order of kwargs and pos args changed between 3.3-3.4

if self.version <= 3.2:

rule = ('mkfunc ::= kwargs %sload_closure LOAD_CONST kwargs %s'

% ('expr ' * args_pos, opname))

elif self.version == 3.3:

rule = ('mkfunc ::= kwargs %sload_closure LOAD_CONST LOAD_CONST %s'

% ('expr ' * args_pos, opname))

elif self.version >= 3.4:

rule = ('mkfunc ::= %skwargs load_closure LOAD_CONST LOAD_CONST %s'

% ('expr ' * args_pos, opname))

self.add_unique_rule(rule, opname, token.attr, customize)

rule = ('mkfunc ::= %sload_closure load_genexpr %s'

% ('pos_arg ' * args_pos, opname))

self.add_unique_rule(rule, opname, token.attr, customize)

rule = ('mkfunc ::= %sload_closure LOAD_CONST %s'

% ('expr ' * args_pos, opname))

self.add_unique_rule(rule, opname, token.attr, customize)

pass

self.check_reduce['augassign1'] = 'AST'

self.check_reduce['augassign2'] = 'AST'

self.check_reduce['while1stmt'] = 'noAST'

self.check_reduce['annotate_tuple'] = 'noAST'

self.check_reduce['kwarg'] = 'noAST'

# FIXME: remove parser errors caused by the below

# self.check_reduce['while1elsestmt'] = 'noAST'

return

def reduce_is_invalid(self, rule, ast, tokens, first, last):

lhs = rule[0]

if lhs in ('augassign1', 'augassign2') and ast[0][0] == 'and':

return True

elif lhs == 'annotate_tuple':

return not isinstance(tokens[first].attr, tuple)

elif lhs == 'kwarg':

return not isinstance(tokens[first].attr, str)

elif lhs == 'while1elsestmt':

# if SETUP_LOOP target spans the else part, then this is

# not while1else. Also do for whileTrue?

last += 1

while isinstance(tokens[last].offset, str):

last += 1

return tokens[first].attr == tokens[last].offset

elif lhs == 'while1stmt':

if tokens[last] in ('COME_FROM_LOOP', 'JUMP_BACK'):

# jump_back should be right afer SETUP_LOOP. Test?

last += 1

while last < len(tokens) and isinstance(tokens[last].offset, str):

last += 1

if last < len(tokens):

offset = tokens[last].offset

assert tokens[first] == 'SETUP_LOOP'

if offset != tokens[first].attr:

return True

return False

def p_30(self, args):

"""

# Check grammar

p = Python3Parser()

if len(args) > 0:

arg = args[0]

if arg == '3.5':

from uncompyle6.parser.parse35 import Python35Parser

p = Python35Parser()

elif arg == '3.3':

from uncompyle6.parser.parse33 import Python33Parser

p = Python33Parser()

elif arg == '3.2':

from uncompyle6.parser.parse32 import Python32Parser

p = Python32Parser()

elif arg == '3.0':

p = Python30Parser()

p.checkGrammar()

if len(sys.argv) > 1 and sys.argv[1] == 'dump':

print('-' * 50)