def visitCompare(self, node):
lhs = node.expr
op, rhs = node.ops[0]
if len(node.ops)==1:
self.start(compare_map[op])
self.visit(lhs)
self.visit(rhs)
self.end()
return
n = ast.And([ast.Compare(lhs, node.ops[:1]),
ast.Compare(rhs, node.ops[1:])])
self.visit(n)
def _do_BinaryExpression(self, node):
operator = node.Operator.Symbol
left = self.transform(node.Left)
right = self.transform(node.Right)
if node.IsComparison():
return ast.Compare(left, [(operator, right)])
else:
cls = _binary_mapping[operator]
return cls((left, right))
def _not(self, x, elem=None, **kw):
if 'in' in kw:
assertResult(x, "test for membership")
assertResult(elem, "test for membership")
return ast.Compare(topy(elem), [('not in', topy(x))])
else:
assertResult(x, "negate")
if elem != None:
raise CompileError("invalid 'not'")
return ast.Not(topy(x))
def _generate(node):
if node.type == node.TERM:
return ast.Compare(ast.Const(node.value),
[('in', ast.Name('text'))])
elif node.type == node.AND:
return ast.And([_generate(node.left), _generate(node.right)])
elif node.type == node.OR:
return ast.Or([_generate(node.left), _generate(node.right)])
elif node.type == node.NOT:
return ast.Not(_generate(node.left))
elif node.type == node.ATTR:
raise NotImplementedError
def visitAugAssign(self, node):
if isinstance(node.node, ast.Name) and (
not self.locals or node.node.name not in flatten(self.locals)):
name = node.node.name
node.node = ast.Subscript(ast.Name('data'), 'OP_APPLY',
[ast.Const(name)])
node.expr = self.visit(node.expr)
return ast.If(
[(ast.Compare(ast.Const(name),
[('in', ast.Name('data'))]), ast.Stmt([node]))],
ast.Stmt([
ast.Raise(
ast.CallFunc(ast.Name('UndefinedError'),
[ast.Const(name)]), None, None)
]))
else:
return ASTTransformer.visitAugAssign(self, node)
def make_eq_compare((left, right)):
return ast.Compare(left, [('==', right), ])
def make_gt_compare((left, right)):
return ast.Compare(left, [('>', right), ])
def _is(self, l, r, **kw):
assertResult(l, "use in is")
assertResult(r, "use in is")
op = kw.get('not') and 'is not' or 'is'
return ast.Compare(topy(l), [(op, topy(r))])
def makeAST(op, l,r):
assertResult(l, "use in " + o)
assertResult(r, "use in " + o)
op = o == '<>' and '!=' or o
return ast.Compare(topy(l), [(op, topy(r))])
def greater_compare((left, right)):
return ast.Compare(left, [
('>', right),
])
def not_compare((left, right)):
return ast.Compare(left, [
('!=', right),
])
def less_compare((left, right)):
return ast.Compare(left, [
('<', right),
])
def less_equal_compare((left, right)):
return ast.Compare(left, [
('<=', right),
])
def equals_compare((left, right)):
return ast.Compare(left, [
('==', right),
])
def COMPARE_OP(decompiler, op):
oper2 = decompiler.stack.pop()
oper1 = decompiler.stack.pop()
return ast.Compare(oper1, [(op, oper2)])
