if loc is None:

def decorator(rule):

rule.expected = expected

return rule

else:

def decorator(inner_rule):

if cases == 1:

def rule(*args, **kwargs):

result = inner_rule(*args, **kwargs)

if result is not unmatched:

rule.covered[0] = True

return result

else:

rule = inner_rule

rule.loc, rule.expected, rule.covered = \

loc, expected, [False] * cases

_all_rules.append(rule)

return rule

"""

def decorator(mapper):

@llrule(loc, inner_rule.expected)

def outer_rule(parser):

result = inner_rule(parser)

if result is unmatched:

return result

if isinstance(result, tuple):

return mapper(parser, *result)

else:

return mapper(parser, result)

return outer_rule

"""A rule that accepts no tokens (epsilon) and returns ``value``."""

@llrule(loc, lambda parser: [])

def rule(parser):

return value

"""A rule that accepts a token of kind ``kind`` and returns it, or returns None."""

@llrule(loc, lambda parser: [kind])

def rule(parser):

return parser._accept(kind)

"""A rule that accepts a token of kind ``kind`` and returns its location, or returns None."""

@llrule(loc, lambda parser: [kind])

def rule(parser):

result = parser._accept(kind)

if result is unmatched:

return result

return result.loc

"""A proxy for a rule called ``name`` which may not be yet defined."""

@llrule(loc, lambda parser: getattr(parser, name).expected(parser))

def rule(parser):

return getattr(parser, name)()

"""A rule that executes ``inner_rule`` and emits a diagnostic error if it returns None."""

@llrule(loc, inner_rule.expected)

def rule(parser):

result = inner_rule(parser)

if result is unmatched:

expected = reduce(list.__add__, [rule.expected(parser) for rule in parser._errrules])

expected = list(sorted(set(expected)))

if len(expected) > 1:

expected = " or ".join([", ".join(expected[0:-1]), expected[-1]])

elif len(expected) == 1:

expected = expected[0]

else:

expected = "(impossible)"

error_tok = parser._tokens[parser._errindex]

error = diagnostic.Diagnostic(

"fatal", "unexpected {actual}: expected {expected}",

{"actual": error_tok.kind, "expected": expected},

error_tok.loc)

parser.diagnostic_engine.process(error)

return result

"""

@llrule(kwargs.get("loc", None), first_rule.expected)

def rule(parser):

result = first_rule(parser)

if result is unmatched:

return result

results = [result]

for rule in rest_of_rules:

result = rule(parser)

if result is unmatched:

return result

results.append(result)

return tuple(results)

"""

@action(Seq(*inner_rules), loc=kwargs.get("loc", None))

def rule(parser, *values):

return values[n]

"""

loc = kwargs.get("loc", None)

expected = lambda parser: reduce(list.__add__, map(lambda x: x.expected(parser), inner_rules))

if loc is not None:

@llrule(loc, expected, cases=len(inner_rules))

def rule(parser):

data = parser._save()

for idx, inner_rule in enumerate(inner_rules):

result = inner_rule(parser)

if result is unmatched:

parser._restore(data, rule=inner_rule)

else:

rule.covered[idx] = True

return result

return unmatched

else:

@llrule(loc, expected, cases=len(inner_rules))

def rule(parser):

data = parser._save()

for inner_rule in inner_rules:

result = inner_rule(parser)

if result is unmatched:

parser._restore(data, rule=inner_rule)

else:

return result

return unmatched

"""

@llrule(loc, lambda parser: [])

def rule(parser):

results = []

while True:

data = parser._save()

result = inner_rule(parser)

if result is unmatched:

parser._restore(data, rule=inner_rule)

return results

results.append(result)

"""

@llrule(loc, inner_rule.expected)

def rule(parser):

result = inner_rule(parser)

if result is unmatched:

return result

results = [result]

while True:

data = parser._save()

result = inner_rule(parser)

if result is unmatched:

parser._restore(data, rule=inner_rule)

return results

results.append(result)

if not trailing:

@action(Seq(inner_rule, Star(SeqN(1, Tok(separator_tok), inner_rule))), loc=loc)

def outer_rule(parser, first, rest):

return [first] + rest

return outer_rule

else:

# A rule like this: stmt (';' stmt)* [';']

# This doesn't yield itself to combinators above, because disambiguating

# another iteration of the Kleene star and the trailing separator

# requires two lookahead tokens (naively).

separator_rule = Tok(separator_tok)

@llrule(loc, inner_rule.expected)

def rule(parser):

results = commalist()

if leading:

result = inner_rule(parser)

if result is unmatched:

return result

else:

results.append(result)

while True:

result = separator_rule(parser)

if result is unmatched:

results.trailing_comma = None

return results

result_1 = inner_rule(parser)

if result_1 is unmatched:

results.trailing_comma = result

return results

else:

results.append(result_1)

"""A rule that accepts token of kind ``newline`` and returns an empty list."""

@llrule(loc, lambda parser: ["newline"])

def rule(parser):

result = parser._accept("newline")

if result is unmatched:

return result

return []

"""

@action(Seq(*map(Loc, kinds)), loc=kwargs.get("loc", None))

def rule(parser, *tokens):

return klass(loc=tokens[0].join(tokens[-1]))

@action(Seq(Rule(expr_rulename), Star(Seq(op_rule, Rule(expr_rulename)))), loc=loc)

def rule(parser, lhs, trailers):

for (op, rhs) in trailers:

lhs = node(left=lhs, op=op, right=rhs,

loc=lhs.loc.join(rhs.loc))

return lhs

@action(Seq(Loc(begin_tok), inner_rule, Loc(end_tok)), loc=loc)

def rule(parser, begin_loc, node, end_loc):

if node is None:

node = empty(parser)

# Collection nodes don't have loc yet. If a node has loc at this

# point, it means it's an expression passed in parentheses.

if node.loc is None and type(node) in [

ast.List, ast.ListComp,

ast.Dict, ast.DictComp,

ast.Set, ast.SetComp,

ast.GeneratorExp,

ast.Tuple, ast.Repr,

ast.Call, ast.Subscript,

ast.arguments]:

node.begin_loc, node.end_loc, node.loc = \

begin_loc, end_loc, begin_loc.join(end_loc)

return node

# Generic LL parsing methods

def __init__(self, lexer, version, diagnostic_engine):

self._init_version(version)

self.diagnostic_engine = diagnostic_engine

self.lexer = lexer

self._tokens = []

self._index = -1

self._errindex = -1

self._errrules = []

self._advance()

def _save(self):

return self._index

def _restore(self, data, rule):

self._index = data

self._token = self._tokens[self._index]

if self._index > self._errindex:

# We have advanced since last error

self._errindex = self._index

self._errrules = [rule]

elif self._index == self._errindex:

# We're at the same place as last error

self._errrules.append(rule)

else:

# We've backtracked far and are now just failing the

# whole parse

pass

def _advance(self):

self._index += 1

if self._index == len(self._tokens):

self._tokens.append(self.lexer.next(eof_token=True))

self._token = self._tokens[self._index]

def _accept(self, expected_kind):

if self._token.kind == expected_kind:

result = self._token

self._advance()

return result

return unmatched

# Python-specific methods

def _init_version(self, version):

if version in ((2, 6), (2, 7)):

if version == (2, 6):

self.with_stmt = self.with_stmt__26

self.atom_6 = self.atom_6__26

else:

self.with_stmt = self.with_stmt__27

self.atom_6 = self.atom_6__27

self.except_clause_1 = self.except_clause_1__26

self.classdef = self.classdef__26

self.subscript = self.subscript__26

self.raise_stmt = self.raise_stmt__26

self.comp_if = self.comp_if__26

self.atom = self.atom__26

self.funcdef = self.funcdef__26

self.parameters = self.parameters__26

self.varargslist = self.varargslist__26

self.comparison_1 = self.comparison_1__26

self.exprlist_1 = self.exprlist_1__26

self.testlist_comp_1 = self.testlist_comp_1__26

self.expr_stmt_1 = self.expr_stmt_1__26

self.yield_expr = self.yield_expr__26

return

elif version in ((3, 0), (3, 1), (3, 2), (3, 3), (3, 4), (3, 5)):

if version == (3, 0):

self.with_stmt = self.with_stmt__26 # lol

else:

self.with_stmt = self.with_stmt__27

self.except_clause_1 = self.except_clause_1__30

self.classdef = self.classdef__30

self.subscript = self.subscript__30

self.raise_stmt = self.raise_stmt__30

self.comp_if = self.comp_if__30

self.atom = self.atom__30

self.funcdef = self.funcdef__30

self.parameters = self.parameters__30

if version < (3, 2):

self.varargslist = self.varargslist__30

self.typedargslist = self.typedargslist__30

self.comparison_1 = self.comparison_1__30

self.star_expr = self.star_expr__30

self.exprlist_1 = self.exprlist_1__30

self.testlist_comp_1 = self.testlist_comp_1__26

self.expr_stmt_1 = self.expr_stmt_1__26

else:

self.varargslist = self.varargslist__32

self.typedargslist = self.typedargslist__32

self.comparison_1 = self.comparison_1__32

self.star_expr = self.star_expr__32

self.exprlist_1 = self.exprlist_1__32

self.testlist_comp_1 = self.testlist_comp_1__32

self.expr_stmt_1 = self.expr_stmt_1__32

if version < (3, 3):

self.yield_expr = self.yield_expr__26

else:

self.yield_expr = self.yield_expr__33

return

raise NotImplementedError("pythonparser.parser.Parser cannot parse Python %s" %

str(version))

def _arguments(self, args=None, defaults=None, kwonlyargs=None, kw_defaults=None,

vararg=None, kwarg=None,

star_loc=None, dstar_loc=None, begin_loc=None, end_loc=None,

equals_locs=None, kw_equals_locs=None, loc=None):

if args is None:

args = []

if defaults is None:

defaults = []

if kwonlyargs is None:

kwonlyargs = []

if kw_defaults is None:

kw_defaults = []

if equals_locs is None:

equals_locs = []

if kw_equals_locs is None:

kw_equals_locs = []

return ast.arguments(args=args, defaults=defaults,

kwonlyargs=kwonlyargs, kw_defaults=kw_defaults,

vararg=vararg, kwarg=kwarg,

star_loc=star_loc, dstar_loc=dstar_loc,

begin_loc=begin_loc, end_loc=end_loc,

equals_locs=equals_locs, kw_equals_locs=kw_equals_locs,

loc=loc)

def _arg(self, tok, colon_loc=None, annotation=None):

loc = tok.loc

if annotation:

loc = loc.join(annotation.loc)

return ast.arg(arg=tok.value, annotation=annotation,

arg_loc=tok.loc, colon_loc=colon_loc, loc=loc)

def _empty_arglist(self):

return ast.Call(args=[], keywords=[], starargs=None, kwargs=None,

star_loc=None, dstar_loc=None, loc=None)

def _wrap_tuple(self, elts):

assert len(elts) > 0

if len(elts) > 1:

return ast.Tuple(ctx=None, elts=elts,

loc=elts[0].loc.join(elts[-1].loc), begin_loc=None, end_loc=None)

else:

return elts[0]

def _assignable(self, node, is_delete=False):

if isinstance(node, ast.Name) or isinstance(node, ast.Subscript) or \

isinstance(node, ast.Attribute) or isinstance(node, ast.Starred):

return node

elif (isinstance(node, ast.List) or isinstance(node, ast.Tuple)) and \

any(node.elts):

node.elts = [self._assignable(elt, is_delete) for elt in node.elts]

return node

else:

if is_delete:

error = diagnostic.Diagnostic(

"fatal", "cannot delete this expression", {}, node.loc)

else:

error = diagnostic.Diagnostic(

"fatal", "cannot assign to this expression", {}, node.loc)

self.diagnostic_engine.process(error)

def add_flags(self, flags):

if "print_function" in flags:

self.lexer.print_function = True

# Grammar

@action(Expect(Alt(Newline(),

def single_input(self, body):

"""single_input: NEWLINE | simple_stmt | compound_stmt NEWLINE"""

loc = None

if body != []:

loc = body[0].loc

return ast.Interactive(body=body, loc=loc)

@action(Expect(SeqN(0, Star(Alt(Newline(), Rule("stmt"))), Tok("eof"))))

def file_input(parser, body):

"""file_input: (NEWLINE | stmt)* ENDMARKER"""

body = reduce(list.__add__, body, [])

loc = None

if body != []:

loc = body[0].loc

return ast.Module(body=body, loc=loc)

@action(Expect(SeqN(0, Rule("testlist"), Star(Tok("newline")), Tok("eof"))))

def eval_input(self, expr):

"""eval_input: testlist NEWLINE* ENDMARKER"""

return ast.Expression(body=[expr], loc=expr.loc)

@action(Seq(Loc("@"), List(Tok("ident"), ".", trailing=False),

def decorator(self, at_loc, idents, call_opt, newline_loc):

"""decorator: '@' dotted_name [ '(' [arglist] ')' ] NEWLINE"""

root = idents[0]

dec_loc = root.loc

expr = ast.Name(id=root.value, ctx=None, loc=root.loc)

for ident in idents[1:]:

dot_loc = ident.loc.begin()

dot_loc.begin_pos -= 1

dec_loc = dec_loc.join(ident.loc)

expr = ast.Attribute(value=expr, attr=ident.value, ctx=None,

loc=expr.loc.join(ident.loc),

attr_loc=ident.loc, dot_loc=dot_loc)

if call_opt:

call_opt.func = expr

call_opt.loc = dec_loc.join(call_opt.loc)

expr = call_opt

return at_loc, expr

decorators = Plus(Rule("decorator"))

"""decorators: decorator+"""

@action(Seq(Rule("decorators"), Alt(Rule("classdef"), Rule("funcdef"))))

def decorated(self, decorators, classfuncdef):

"""decorated: decorators (classdef | funcdef)"""

classfuncdef.at_locs = list(map(lambda x: x[0], decorators))

classfuncdef.decorator_list = list(map(lambda x: x[1], decorators))

classfuncdef.loc = classfuncdef.loc.join(decorators[0][0])

return classfuncdef

@action(Seq(Loc("def"), Tok("ident"), Rule("parameters"), Loc(":"), Rule("suite")))

def funcdef__26(self, def_loc, ident_tok, args, colon_loc, suite):

"""(2.6, 2.7) funcdef: 'def' NAME parameters ':' suite"""

return ast.FunctionDef(name=ident_tok.value, args=args, returns=None,

body=suite, decorator_list=[],

at_locs=[], keyword_loc=def_loc, name_loc=ident_tok.loc,

colon_loc=colon_loc, arrow_loc=None,

loc=def_loc.join(suite[-1].loc))

@action(Seq(Loc("def"), Tok("ident"), Rule("parameters"),

def funcdef__30(self, def_loc, ident_tok, args, returns_opt, colon_loc, suite):

"""(3.0-) funcdef: 'def' NAME parameters ['->' test] ':' suite"""

arrow_loc = returns = None

if returns_opt:

arrow_loc, returns = returns_opt

return ast.FunctionDef(name=ident_tok.value, args=args, returns=returns,

body=suite, decorator_list=[],

at_locs=[], keyword_loc=def_loc, name_loc=ident_tok.loc,

colon_loc=colon_loc, arrow_loc=arrow_loc,

loc=def_loc.join(suite[-1].loc))

parameters__26 = BeginEnd("(", Opt(Rule("varargslist")), ")", empty=_arguments)

"""(2.6, 2.7) parameters: '(' [varargslist] ')'"""

parameters__30 = BeginEnd("(", Opt(Rule("typedargslist")), ")", empty=_arguments)

"""(3.0) parameters: '(' [typedargslist] ')'"""

varargslist__26_1 = Seq(Rule("fpdef"), Opt(Seq(Loc("="), Rule("test"))))

@action(Seq(Loc("**"), Tok("ident")))

def varargslist__26_2(self, dstar_loc, kwarg_tok):

return self._arguments(kwarg=self._arg(kwarg_tok),

dstar_loc=dstar_loc, loc=dstar_loc.join(kwarg_tok.loc))

@action(Seq(Loc("*"), Tok("ident"),

def varargslist__26_3(self, star_loc, vararg_tok, kwarg_opt):

dstar_loc = kwarg = None

loc = star_loc.join(vararg_tok.loc)

vararg = self._arg(vararg_tok)

if kwarg_opt:

_, dstar_loc, kwarg_tok = kwarg_opt

kwarg = self._arg(kwarg_tok)

loc = star_loc.join(kwarg_tok.loc)

return self._arguments(vararg=vararg, kwarg=kwarg,

star_loc=star_loc, dstar_loc=dstar_loc, loc=loc)

@action(Eps(value=()))

def varargslist__26_4(self):

return self._arguments()

@action(Alt(Seq(Star(SeqN(0, varargslist__26_1, Tok(","))),

def varargslist__26(self, fparams, args):

"""

for fparam, default_opt in fparams:

if default_opt:

equals_loc, default = default_opt

args.equals_locs.append(equals_loc)

args.defaults.append(default)

elif len(args.defaults) > 0:

error = diagnostic.Diagnostic(

"fatal", "non-default argument follows default argument", {},

fparam.loc, [args.args[-1].loc.join(args.defaults[-1].loc)])

self.diagnostic_engine.process(error)

args.args.append(fparam)

def fparam_loc(fparam, default_opt):

if default_opt:

equals_loc, default = default_opt

return fparam.loc.join(default.loc)

else:

return fparam.loc

if args.loc is None:

args.loc = fparam_loc(*fparams[0]).join(fparam_loc(*fparams[-1]))

elif len(fparams) > 0:

args.loc = args.loc.join(fparam_loc(*fparams[0]))

return args

@action(Tok("ident"))

def fpdef_1(self, ident_tok):

return ast.arg(arg=ident_tok.value, annotation=None,

arg_loc=ident_tok.loc, colon_loc=None,

loc=ident_tok.loc)

fpdef = Alt(fpdef_1, BeginEnd("(", Rule("fplist"), ")",

empty=lambda self: ast.Tuple(elts=[], ctx=None, loc=None)))

"""fpdef: NAME | '(' fplist ')'"""

def _argslist(fpdef_rule, old_style=False):

argslist_1 = Seq(fpdef_rule, Opt(Seq(Loc("="), Rule("test"))))

@action(Seq(Loc("**"), Tok("ident")))

def argslist_2(self, dstar_loc, kwarg_tok):

return self._arguments(kwarg=self._arg(kwarg_tok),

dstar_loc=dstar_loc, loc=dstar_loc.join(kwarg_tok.loc))

@action(Seq(Loc("*"), Tok("ident"),

def argslist_3(self, star_loc, vararg_tok, fparams, kwarg_opt):

dstar_loc = kwarg = None

loc = star_loc.join(vararg_tok.loc)

vararg = self._arg(vararg_tok)

if kwarg_opt:

_, dstar_loc, kwarg_tok = kwarg_opt

kwarg = self._arg(kwarg_tok)

loc = star_loc.join(kwarg_tok.loc)

kwonlyargs, kw_defaults, kw_equals_locs = [], [], []

for fparam, default_opt in fparams:

if default_opt:

equals_loc, default = default_opt

kw_equals_locs.append(equals_loc)

kw_defaults.append(default)

else:

kw_defaults.append(None)

kwonlyargs.append(fparam)

if any(kw_defaults):

loc = loc.join(kw_defaults[-1].loc)

elif any(kwonlyargs):

loc = loc.join(kwonlyargs[-1].loc)

return self._arguments(vararg=vararg, kwarg=kwarg,

kwonlyargs=kwonlyargs, kw_defaults=kw_defaults,

star_loc=star_loc, dstar_loc=dstar_loc,

kw_equals_locs=kw_equals_locs, loc=loc)

argslist_4 = Alt(argslist_2, argslist_3)

@action(Eps(value=()))

def argslist_5(self):

return self._arguments()

if old_style:

argslist = Alt(Seq(Star(SeqN(0, argslist_1, Tok(","))),

argslist_4),

Seq(List(argslist_1, ",", trailing=True),

argslist_5))

else:

argslist = Alt(Seq(Eps(value=[]), argslist_4),

Seq(List(argslist_1, ",", trailing=False),

Alt(SeqN(1, Tok(","), Alt(argslist_4, argslist_5)),

argslist_5)))

def argslist_action(self, fparams, args):

for fparam, default_opt in fparams:

if default_opt:

equals_loc, default = default_opt

args.equals_locs.append(equals_loc)

args.defaults.append(default)

elif len(args.defaults) > 0:

error = diagnostic.Diagnostic(

"fatal", "non-default argument follows default argument", {},

fparam.loc, [args.args[-1].loc.join(args.defaults[-1].loc)])

self.diagnostic_engine.process(error)

args.args.append(fparam)

def fparam_loc(fparam, default_opt):

if default_opt:

equals_loc, default = default_opt

return fparam.loc.join(default.loc)

else:

return fparam.loc

if args.loc is None:

args.loc = fparam_loc(*fparams[0]).join(fparam_loc(*fparams[-1]))

elif len(fparams) > 0:

args.loc = args.loc.join(fparam_loc(*fparams[0]))

return args

return action(argslist)(argslist_action)

typedargslist__30 = _argslist(Rule("tfpdef"), old_style=True)

"""

typedargslist__32 = _argslist(Rule("tfpdef"))

"""

varargslist__30 = _argslist(Rule("vfpdef"), old_style=True)

"""

varargslist__32 = _argslist(Rule("vfpdef"))

"""

@action(Seq(Tok("ident"), Opt(Seq(Loc(":"), Rule("test")))))

def tfpdef(self, ident_tok, annotation_opt):

"""(3.0-) tfpdef: NAME [':' test]"""

if annotation_opt:

colon_loc, annotation = annotation_opt

return self._arg(ident_tok, colon_loc, annotation)

return self._arg(ident_tok)

vfpdef = fpdef_1

"""(3.0-) vfpdef: NAME"""

@action(List(Rule("fpdef"), ",", trailing=True))

def fplist(self, elts):

"""fplist: fpdef (',' fpdef)* [',']"""

return ast.Tuple(elts=elts, ctx=None, loc=None)

stmt = Alt(Rule("simple_stmt"), Rule("compound_stmt"))

"""stmt: simple_stmt | compound_stmt"""

simple_stmt = SeqN(0, List(Rule("small_stmt"), ";", trailing=True), Tok("newline"))

"""simple_stmt: small_stmt (';' small_stmt)* [';'] NEWLINE"""

small_stmt = Alt(Rule("expr_stmt"), Rule("print_stmt"), Rule("del_stmt"),

Rule("pass_stmt"), Rule("flow_stmt"), Rule("import_stmt"),

Rule("global_stmt"), Rule("nonlocal_stmt"), Rule("exec_stmt"),

Rule("assert_stmt"))

"""

expr_stmt_1__26 = Rule("testlist")

expr_stmt_1__32 = Rule("testlist_star_expr")

@action(Seq(Rule("augassign"), Alt(Rule("yield_expr"), Rule("testlist"))))

def expr_stmt_2(self, augassign, rhs_expr):

return ast.AugAssign(op=augassign, value=rhs_expr)

@action(Star(Seq(Loc("="), Alt(Rule("yield_expr"), Rule("expr_stmt_1")))))

def expr_stmt_3(self, seq):

if len(seq) > 0:

return ast.Assign(targets=list(map(lambda x: x[1], seq[:-1])), value=seq[-1][1],

op_locs=list(map(lambda x: x[0], seq)))

else:

return None

@action(Seq(Rule("expr_stmt_1"), Alt(expr_stmt_2, expr_stmt_3)))

def expr_stmt(self, lhs, rhs):

"""

if isinstance(rhs, ast.AugAssign):

if isinstance(lhs, ast.Tuple) or isinstance(lhs, ast.List):

error = diagnostic.Diagnostic(

"fatal", "illegal expression for augmented assignment", {},

rhs.op.loc, [lhs.loc])

self.diagnostic_engine.process(error)

else:

rhs.target = self._assignable(lhs)

rhs.loc = rhs.target.loc.join(rhs.value.loc)

return rhs

elif rhs is not None:

rhs.targets = list(map(self._assignable, [lhs] + rhs.targets))

rhs.loc = lhs.loc.join(rhs.value.loc)

return rhs

else:

return ast.Expr(value=lhs, loc=lhs.loc)

testlist_star_expr = action(

List(Alt(Rule("test"), Rule("star_expr")), ",", trailing=True)) \

(_wrap_tuple)

"""(3.2-) testlist_star_expr: (test|star_expr) (',' (test|star_expr))* [',']"""

augassign = Alt(Oper(ast.Add, "+="), Oper(ast.Sub, "-="), Oper(ast.MatMult, "@="),

Oper(ast.Mult, "*="), Oper(ast.Div, "/="), Oper(ast.Mod, "%="),

Oper(ast.BitAnd, "&="), Oper(ast.BitOr, "|="), Oper(ast.BitXor, "^="),

Oper(ast.LShift, "<<="), Oper(ast.RShift, ">>="),

Oper(ast.Pow, "**="), Oper(ast.FloorDiv, "//="))

"""augassign: ('+=' | '-=' | '*=' | '/=' | '%=' | '&=' | '|=' | '^=' |

@action(List(Rule("test"), ",", trailing=True))

def print_stmt_1(self, values):

nl, loc = True, values[-1].loc

if values.trailing_comma:

nl, loc = False, values.trailing_comma.loc

return ast.Print(dest=None, values=values, nl=nl,

dest_loc=None, loc=loc)

@action(Seq(Loc(">>"), Rule("test"), Tok(","), List(Rule("test"), ",", trailing=True)))

def print_stmt_2(self, dest_loc, dest, comma_tok, values):

nl, loc = True, values[-1].loc

if values.trailing_comma:

nl, loc = False, values.trailing_comma.loc

return ast.Print(dest=dest, values=values, nl=nl,

dest_loc=dest_loc, loc=loc)

@action(Seq(Loc("print"), Alt(print_stmt_1, print_stmt_2)))

def print_stmt(self, print_loc, stmt):

"""

stmt.keyword_loc = print_loc

stmt.loc = print_loc.join(stmt.loc)

return stmt

@action(Seq(Loc("del"), List(Rule("expr"), ",", trailing=True)))

def del_stmt(self, stmt_loc, exprs):

# Python uses exprlist here, but does *not* obey the usual

# tuple-wrapping semantics, so we embed the rule directly.

"""del_stmt: 'del' exprlist"""

return ast.Delete(targets=[self._assignable(expr, is_delete=True) for expr in exprs],

loc=stmt_loc.join(exprs[-1].loc), keyword_loc=stmt_loc)

@action(Loc("pass"))

def pass_stmt(self, stmt_loc):

"""pass_stmt: 'pass'"""

return ast.Pass(loc=stmt_loc, keyword_loc=stmt_loc)

flow_stmt = Alt(Rule("break_stmt"), Rule("continue_stmt"), Rule("return_stmt"),

Rule("raise_stmt"), Rule("yield_stmt"))

"""flow_stmt: break_stmt | continue_stmt | return_stmt | raise_stmt | yield_stmt"""

@action(Loc("break"))

def break_stmt(self, stmt_loc):

"""break_stmt: 'break'"""

return ast.Break(loc=stmt_loc, keyword_loc=stmt_loc)

@action(Loc("continue"))

def continue_stmt(self, stmt_loc):

"""continue_stmt: 'continue'"""

return ast.Continue(loc=stmt_loc, keyword_loc=stmt_loc)

@action(Seq(Loc("return"), Opt(Rule("testlist"))))

def return_stmt(self, stmt_loc, values):