def LeftTernary(p, token, left, bp): """ e.g. a > 1 ? x : y """ true_expr = p.ParseUntil(bp) p.Eat(':') false_expr = p.ParseUntil(bp) children = [left, true_expr, false_expr] return CompositeNode(token, children)
def LeftIncDec(p, token, left, rbp): """ For i++ and i-- """ if left.token.type not in ('name', 'get'): raise tdop.ParseError("Can't assign to %r (%s)" % (left, left.token)) token.type = 'post' + token.type return CompositeNode(token, [left])
def NullPrefixOp(p, token, bp): """Prefix operator. Low precedence: return, raise, etc. return x+y is return (x+y), not (return x) + y High precedence: logical negation, bitwise complement, etc. !x && y is (!x) && y, not !(x && y) """ r = p.ParseUntil(bp) return CompositeNode(token, [r])
def LeftComma(p, token, left, rbp): """ foo, bar, baz Could be sequencing operator, or tuple without parens """ r = p.ParseUntil(rbp) if left.token.type == ',': # Keep adding more children left.children.append(r) return left children = [left, r] return CompositeNode(token, children)
def NullIncDec(p, token, bp): """ ++x or ++x[1] """ right = p.ParseUntil(bp) if right.token.type not in ('name', 'get'): raise tdop.ParseError("Can't assign to %r (%s)" % (right, right.token)) return CompositeNode(token, [right])
def LeftAssign(p, token, left, rbp): """ Normal binary operator like 1+2 or 2*3, etc. """ # x += 1, or a[i] += 1 if left.token.type not in ('name', 'get'): raise tdop.ParseError("Can't assign to %r (%s)" % (left, left.token)) return CompositeNode(token, [left, p.ParseUntil(rbp)])