def operator(mod): op = ast.Add() if mod == 'or': op = ast.Or() if mod == '|': op = ast.Or() if mod == '||': op = ast.Or() if mod == 'and': op = ast.And() if mod == '&': op = ast.And() if mod == '&&': op = ast.And() if mod == 'plus': op = ast.Add() if mod == '+': op = ast.Add() if mod == '-': op = ast.Sub() if mod == 'minus': op = ast.Sub() if mod == 'times': op = ast.Mult() if mod == '*': op = ast.Mult() if mod == '**': op = ast.Pow() if mod == 'divide': op = ast.Div() if mod == 'divided': op = ast.Div() if mod == 'divided by': op = ast.Div() if mod == '/': op = ast.Div() if mod == '//': op = ast.FloorDiv() if mod == 'floor div': op = ast.FloorDiv() if mod == '%': op = ast.Mod() if mod == 'mod': op = ast.Mod() if mod == 'modulus': op = ast.Mod() if mod == 'modulo': op = ast.Mod() if mod == '^': op = ast.BitXor() if mod == 'xor': op = ast.BitXor() if mod == '<<': op = ast.LShift() if mod == '>>': op = ast.RShift() return op
def compile_floordivide(p):
if len(p) == 2:
return ast.BinOp(ast.Num(1), ast.FloorDiv(), build_ast(p[1]))
elif len(p) == 3:
return ast.BinOp(build_ast(p[1]), ast.FloorDiv(), build_ast(p[2]))
else:
return ast.BinOp(compile_divide(p[:-1]), ast.FloorDiv(), build_ast(p[-1]))
def visit_BinOp(self, node):
# operator = Add | Sub | Mult | MatMult | Div | Mod | Pow | LShift | RShift | BitOr | BitXor | BitAnd | FloorDiv
print(" in MyTransformer.visit_BinOp()")
print(" curr op =", node.op)
bin_negate = node.op
# use pseudorandomness to determine whether to negate or just mix up
rand_num = random.randint(1, 10)
# negate
if rand_num >= 4:
print(" negating...")
if isinstance(node.op, ast.Add): bin_negate = ast.Sub()
elif isinstance(node.op, ast.Sub): bin_negate = ast.Add()
elif isinstance(node.op, ast.Mult): bin_negate = ast.Div()
elif isinstance(node.op, ast.Div): bin_negate = ast.FloorDiv()
elif isinstance(node.op, ast.FloorDiv): bin_negate = ast.Div()
elif isinstance(node.op, ast.LShift): bin_negate = ast.RShift()
elif isinstance(node.op, ast.RShift): bin_negate = ast.LShift()
elif isinstance(node.op, ast.BitOr): bin_negate = ast.BitAnd()
elif isinstance(node.op, ast.BitAnd): bin_negate = ast.BitXor()
elif isinstance(node.op, ast.BitXor): bin_negate = ast.BitOr()
elif isinstance(node.op, ast.Pow): bin_negate = ast.Mult()
elif isinstance(node.op, ast.Mod): bin_negate = ast.Div()
elif isinstance(node.op, ast.MatMult): bin_negate = ast.Mult()
else: print(" did not find negation for", node.op)
# mix up
else:
print(" mixing up...")
if isinstance(node.op, ast.Add): bin_negate = ast.Mult()
elif isinstance(node.op, ast.Sub): bin_negate = ast.Div()
elif isinstance(node.op, ast.Mult): bin_negate = ast.Pow()
elif isinstance(node.op, ast.Div): bin_negate = ast.FloorDiv()
elif isinstance(node.op, ast.FloorDiv): bin_negate = ast.Div()
elif isinstance(node.op, ast.BitOr): bin_negate = ast.BitXor()
elif isinstance(node.op, ast.BitAnd): bin_negate = ast.BitOr()
elif isinstance(node.op, ast.BitXor): bin_negate = ast.BitOr()
elif isinstance(node.op, ast.Pow): bin_negate = ast.Mult()
elif isinstance(node.op, ast.Mod): bin_negate = ast.FloorDiv()
else: print(" did not find negation for", node.op)
print(" bin_negate =", bin_negate)
# create negated node | BinOp(expr left, operator op, expr right)
new_node = node
new_node.op = bin_negate
ast.copy_location(new_node, node)
ast.fix_missing_locations(new_node)
return new_node
def visit_Operator(self, node: Operator, *args, **kwargs) -> C.operator:
if node == Operator.Add:
return C.Add()
elif node == Operator.Sub:
return C.Sub()
elif node == Operator.Mult:
return C.Mult()
elif node == Operator.MatMult:
return C.MatMult()
elif node == Operator.Div:
return C.Div()
elif node == Operator.Mod:
return C.Mod()
elif node == Operator.Pow:
return C.Pow()
elif node == Operator.LShift:
return C.LShift()
elif node == Operator.RShift:
return C.RShift()
elif node == Operator.BitOr:
return C.BitOr()
elif node == Operator.BitXor:
return C.BitXor()
elif node == Operator.BitAnd:
return C.BitAnd()
elif node == Operator.FloorDiv:
return C.FloorDiv()
else:
raise Exception(f'unknown Operator {node!r}')
def __init__(self, base_node):
BaseMutator.__init__(self, base_node)
self.original_bin_op = base_node.op
if type(base_node.op) in [
ast.LShift, ast.RShift, ast.BitOr, ast.BitXor, ast.BitAnd,
ast.FloorDiv
]:
if type(base_node.op) is ast.LShift:
self.mutations.append({"op": ast.RShift()})
if type(base_node.op) is ast.RShift:
self.mutations.append({"op": ast.LShift()})
if type(base_node.op) is ast.BitOr:
self.mutations.append({"op": ast.BitAnd()})
if type(base_node.op) is ast.BitXor:
self.mutations.append({"op": ast.FloorDiv()})
if type(base_node.op) is ast.BitAnd:
self.mutations.append({"op": ast.BitOr()})
if type(base_node.op) is ast.FloorDiv:
self.mutations.append({"op": ast.BitXor()})
def visit_BinOp(self, node):
# Replace x / y with x // y if x and y are integers
if isinstance(node.op, ast.Div) and \
isinstance(node.left, ast.Num) and \
isinstance(node.right, ast.Num) and \
isinstance(node.left.n, int) and \
isinstance(node.right.n, int):
node.op = ast.FloorDiv()
return node
def visit_BinOp(self, node):
global visit_count, visit_target
self.generic_visit(node)
visit_count = visit_count + 1
#print(visit_count)
if (visit_count == visit_target):
#print("Hi")
node.op = ast.FloorDiv()
return node
def visitMult(self, ctx: vjjParser.MultContext):
left = self.visit(ctx.left)
if ctx.right:
right = self.visit(ctx.right)
if ctx.op.text == '*':
op = ast.Mult()
elif ctx.op.text == '/':
op = ast.FloorDiv()
return ast.BinOp(left=left, op=op, right=right)
return left
def visit_AugAssign(self, node):
target = self.visit(node.target)
value = self.visit(node.value)
if not self.future_division and isinstance(node.op, ast.Div):
node.op = ast.FloorDiv()
name = node.op.__class__.__name__
if name in self.ops_augassign:
return self.visit_AssignSimple(node.target,
"%s.PY$__%s__(%s)" % (target, self.ops_augassign[name], value))
else:
raise JSError("Unsupported AugAssign type %s" % node.op)
def mutate(cls, node):
"""
mutate augmented assignment operators: +=, -=, *=, /=, //=
"""
if node not in config.visited_nodes:
if node.__class__ is ast.AugAssign:
if node.op.__class__ is ast.Add:
if node.value.__class__ is ast.Str and node.value.__class__ is ast.Call and hasattr(
node.value.func,
'id') and node.value.func.id == 'str':
return node
if node.op.__class__ in config.arithmetic_operators:
config.arithmetic_operators.remove(node.op.__class__)
while len(config.arithmetic_operators) > 0:
original_node = deepcopy(node)
parent = config.parent_dict[node]
del config.parent_dict[node]
op_node = None
op_type = config.arithmetic_operators.pop()
if op_type is ast.Add:
op_node = ast.Add()
elif op_type is ast.Sub:
op_node = ast.Sub()
elif op_type is ast.Mult:
op_node = ast.Mult()
elif op_type is ast.Div:
op_node = ast.Div()
elif op_type is ast.FloorDiv:
op_node = ast.FloorDiv()
else:
print "TypeError in ASR"
if op_node:
node.op = op_node
config.parent_dict[node] = parent
config.node_pairs[node] = original_node
config.current_mutated_node = node
config.mutated = True
return node
if len(config.arithmetic_operators) == 0:
config.arithmetic_operators = [
ast.Add, ast.Sub, ast.Mult, ast.Div, ast.FloorDiv
]
config.visited_nodes.add(node)
return node
def test_scalar_bin_op_init(self):
ScalarBinOp(self.constant, ast.Add(), self.constant)
ScalarBinOp(self.output_element, ast.Add(), self.neighbor)
ScalarBinOp(self.output_element, ast.Sub(), self.neighbor)
ScalarBinOp(self.output_element, ast.Mult(), self.neighbor)
ScalarBinOp(self.output_element, ast.Div(), self.neighbor)
ScalarBinOp(self.output_element, ast.FloorDiv(), self.neighbor)
ScalarBinOp(self.output_element, ast.Mod(), self.neighbor)
for op in [
ast.Mod, ast.Pow, ast.LShift, ast.RShift, ast.BitOr,
ast.BitXor, ast.BitAnd
]:
with self.assertRaises(AssertionError):
ScalarBinOp(self.output_element, op, self.neighbor)
def visit_BinOp(self, node):
left = self.visit(node.left)
right = self.visit(node.right)
if isinstance(node.op, ast.Mod) and isinstance(node.left, ast.Str):
return "%s.PY$__mod__(%s)" % (left, right)
if not self.future_division and isinstance(node.op, ast.Div):
node.op = ast.FloorDiv()
name = node.op.__class__.__name__
if name in self.ops_binop:
return "%s.PY$__%s__(%s)" % (left, self.ops_binop[name], right)
else:
raise JSError("Unknown binary operation type %s" % node.op)
def visit_BinOp(self, node):
global visit_count, visit_target
visit_count += 1
if (visit_count == visit_target):
##print("Rewrite_binary Line: ", node.lineno)
if (isinstance(node.op, ast.Add)):
node.op = ast.Sub()
elif (isinstance(node.op, ast.Sub)):
node.op = ast.Add()
elif (isinstance(node.op, ast.Mult)):
node.op = ast.FloorDiv()
elif (isinstance(node.op, ast.Div)
or isinstance(node.op, ast.FloorDiv)):
node.op = ast.Mult()
return node
def operator_equals(mod): op = ast.Add() if mod == '|=': op = ast.Or() if mod == '||=': op = ast.Or() if mod == '&=': op = ast.And() if mod == '&&=': op = ast.And() if mod == '+=': op = ast.Add() if mod == '-=': op = ast.Sub() if mod == '*=': op = ast.Mult() if mod == '**=': op = ast.Pow() if mod == '/=': op = ast.Div() if mod == '//=': op = ast.FloorDiv() if mod == '%=': op = ast.Mod() if mod == '^=': op = ast.BitXor() if mod == '<<': op = ast.LShift() if mod == '>>': op = ast.RShift() return op
def to_node(self):
node = self.left.to_node()
if len(self.operator) == 0:
return node
else:
for i in range(len(self.right)):
if self.operator[i] in ['*', 'times']:
node = ast.BinOp(node, ast.Mult(), self.right[i].to_node())
elif self.operator[i] in ['/', 'divided by']:
node = ast.BinOp(node, ast.Div(), self.right[i].to_node())
elif self.operator[i] in ['%', 'modulo']:
node = ast.BinOp(node, ast.Mod(), self.right[i].to_node())
elif self.operator[i] == '@':
node = ast.BinOp(node, ast.MatMult(),
self.right[i].to_node())
elif self.operator[i] == '//':
node = ast.BinOp(node, ast.FloorDiv(),
self.right[i].to_node())
return node
def BinOp(draw, expression) -> ast.BinOp:
op = draw(
sampled_from([
ast.Add(),
ast.Sub(),
ast.Mult(),
ast.Div(),
ast.FloorDiv(),
ast.Mod(),
ast.Pow(),
ast.LShift(),
ast.RShift(),
ast.BitOr(),
ast.BitXor(),
ast.BitOr(),
ast.BitAnd(),
ast.MatMult()
]))
le = draw(lists(expression, min_size=2, max_size=2))
return ast.BinOp(le[0], op, le[1])
def AugAssign(draw):
op = draw(
sampled_from([
ast.Add(),
ast.Sub(),
ast.Mult(),
ast.Div(),
ast.FloorDiv(),
ast.Mod(),
ast.Pow(),
ast.LShift(),
ast.RShift(),
ast.BitOr(),
ast.BitXor(),
ast.BitOr(),
ast.BitAnd(),
ast.MatMult()
]))
return ast.AugAssign(target=draw(Name(ast.Store)),
op=op,
value=draw(expression()))
def visit_BinOp(self, node):
if isinstance(node.op, ast.Add):
self.counter += 1
if self.counter == self.nodeToMutate:
new_node = ast.BinOp()
new_node.left = node.left
new_node.right = node.right
new_node.ops = [ast.Sub()]
print('changing add {} to sub.'.format(self.counter))
return ast.copy_location(new_node, node) # helps debugging
if isinstance(node.op, ast.Sub):
self.counter += 1
if self.counter == self.nodeToMutate:
new_node = ast.BinOp()
new_node.left = node.left
new_node.right = node.right
new_node.op = ast.Add()
print('changing sub {} to add.'.format(self.counter))
return ast.copy_location(new_node, node) # helps debugging
if isinstance(node.op, ast.FloorDiv):
self.counter += 1
if self.counter == self.nodeToMutate:
new_node = ast.BinOp()
new_node.left = node.left
new_node.right = node.right
new_node.op = ast.Div()
print('changing floorDiv {} to div.'.format(self.counter))
return ast.copy_location(new_node, node) # helps debugging
if isinstance(node.op, ast.Div):
self.counter += 1
if self.counter == self.nodeToMutate:
new_node = ast.BinOp()
new_node.left = node.left
new_node.right = node.right
new_node.op = ast.FloorDiv()
print('changing div {} to floordiv.'.format(self.counter))
return ast.copy_location(new_node, node) # helps debugging
if isinstance(node.op, ast.Mult):
self.counter += 1
if self.counter == self.nodeToMutate:
new_node = ast.BinOp()
new_node.left = node.left
new_node.right = node.right
new_node.op = ast.Pow()
print('changing mult {} to pow.'.format(self.counter))
return ast.copy_location(new_node, node) # helps debugging
return self.generic_visit(node)
def mutate_Div_to_FloorDiv(self, node):
if self.should_mutate(node):
return ast.FloorDiv()
raise MutationResign()
def mutate(cls, node):
"""
mutate binary mathematical operators: +, -, *, /, %, **
"""
if node not in config.visited_nodes:
if node.__class__ is ast.BinOp and node.op.__class__ in [
ast.Add, ast.Sub, ast.Mult, ast.Div, ast.FloorDiv, ast.Mod,
ast.Pow
]:
if node.op.__class__ is ast.Add:
if node.left.__class__ in [
ast.Str, ast.List
] or node.right.__class__ in [ast.Str, ast.List]:
return node
if node.op.__class__ in config.arithmetic_operators:
config.arithmetic_operators.remove(node.op.__class__)
while len(config.arithmetic_operators) > 0:
original_node = deepcopy(node)
if node in config.parent_dict:
parent = config.parent_dict[node]
del config.parent_dict[node]
op_node = None
op_type = config.arithmetic_operators.pop()
if op_type is ast.Add:
op_node = ast.Add()
elif op_type is ast.Sub:
op_node = ast.Sub()
elif op_type is ast.Mult:
op_node = ast.Mult()
elif op_type is ast.Div:
op_node = ast.Div()
elif op_type is ast.FloorDiv:
op_node = ast.FloorDiv()
elif op_type is ast.Mod:
op_node = ast.Div()
elif op_type is ast.Pow:
op_node = ast.Mult()
else:
print "TypeError in AOR"
if op_node:
node.op = op_node
config.parent_dict[node] = parent
config.node_pairs[node] = original_node
config.current_mutated_node = node
config.mutated = True
return node
if len(config.arithmetic_operators) == 0:
config.arithmetic_operators = [
ast.Add, ast.Sub, ast.Mult, ast.Div, ast.FloorDiv
]
config.visited_nodes.add(node)
elif node.__class__ is ast.UnaryOp:
if node.op.__class__ is ast.UAdd:
config.mutated = True
original_node = deepcopy(node)
parent = config.parent_dict[node]
del config.parent_dict[node]
node.op = ast.USub()
config.parent_dict[node] = parent
config.node_pairs[node] = original_node
config.current_mutated_node = node
elif node.op.__class__ is ast.USub:
config.mutated = True
original_node = deepcopy(node)
parent = config.parent_dict[node]
del config.parent_dict[node]
node.op = ast.UAdd()
config.parent_dict[node] = parent
config.node_pairs[node] = original_node
config.current_mutated_node = node
# todo: try more unary operations
return node
def mutate_Div_to_FloorDiv(self, node):
if self.should_mutate(node):
return ast.FloorDiv()
def __floordiv__(self, other):
return _make_binop(ast.FloorDiv(), self._expr, other)
# [ast.Name(array_id.name, ast.Load())],
# [],
# ),
# )
# )
# return inner
register(Content(NPArray(w("array_init"))),
lambda array_init: PythonContent(array_init))
CONTENT_OPERATIONS = [
(Multiply, ast.Mult()),
(Add, ast.Add()),
(Remainder, ast.Mod()),
(Quotient, ast.FloorDiv()),
]
for _op, _a in CONTENT_OPERATIONS:
def _op_python_content(l_init, r_init, a_=_a):
@PythonContent
@statements_then_init
def inner():
l_id = identifier()
r_id = identifier()
yield CallUnary(l_init, l_id)
yield CallUnary(r_init, r_id)
return Expression(
ast.BinOp(ast.Name(l_id.name, ast.Load()), a_,
ast.Name(r_id.name, ast.Load())))
def test_empty_init(self):
# Jython 2.5.0 did not allow empty constructors for many ast node types
# but CPython ast nodes do allow this. For the moment, I don't see a
# reason to allow construction of the super types (like ast.AST and
# ast.stmt) as well as the op types that are implemented as enums in
# Jython (like boolop), but I've left them in but commented out for
# now. We may need them in the future since CPython allows this, but
# it may fall under implementation detail.
#ast.AST()
ast.Add()
ast.And()
ast.Assert()
ast.Assign()
ast.Attribute()
ast.AugAssign()
ast.AugLoad()
ast.AugStore()
ast.BinOp()
ast.BitAnd()
ast.BitOr()
ast.BitXor()
ast.BoolOp()
ast.Break()
ast.Call()
ast.ClassDef()
ast.Compare()
ast.Continue()
ast.Del()
ast.Delete()
ast.Dict()
ast.Div()
ast.Ellipsis()
ast.Eq()
ast.Exec()
ast.Expr()
ast.Expression()
ast.ExtSlice()
ast.FloorDiv()
ast.For()
ast.FunctionDef()
ast.GeneratorExp()
ast.Global()
ast.Gt()
ast.GtE()
ast.If()
ast.IfExp()
ast.Import()
ast.ImportFrom()
ast.In()
ast.Index()
ast.Interactive()
ast.Invert()
ast.Is()
ast.IsNot()
ast.LShift()
ast.Lambda()
ast.List()
ast.ListComp()
ast.Load()
ast.Lt()
ast.LtE()
ast.Mod()
ast.Module()
ast.Mult()
ast.Name()
ast.Not()
ast.NotEq()
ast.NotIn()
ast.Num()
ast.Or()
ast.Param()
ast.Pass()
ast.Pow()
ast.Print()
ast.RShift()
ast.Raise()
ast.Repr()
ast.Return()
ast.Slice()
ast.Store()
ast.Str()
ast.Sub()
ast.Subscript()
ast.Suite()
ast.TryExcept()
ast.TryFinally()
ast.Tuple()
ast.UAdd()
ast.USub()
ast.UnaryOp()
ast.While()
ast.With()
ast.Yield()
ast.alias()
ast.arguments()
#ast.boolop()
#ast.cmpop()
ast.comprehension()
#ast.excepthandler()
#ast.expr()
#ast.expr_context()
ast.keyword()
def __floordiv__(self, other: Union[T, Expr[T]]) -> BinOp[T]:
return BinOp(self, ast.FloorDiv(), other)
def translateExpr(n):
if isinstance(n, Token):
if n.type.name == 'INTEGER':
if n.arg > 2**63:
return ast.NameConstant('__BIGINT__')
return ast.Num(n.arg)
if n.type.name == 'FLOAT':
return ast.Num(n.arg)
if n.type.name == 'IDENT':
return ast.NameConstant(mungeName(n.arg))
if n.type.name == 'FALSE':
return ast.NameConstant('False')
if n.type.name == 'TRUE':
return ast.NameConstant('True')
if n.type.name == 'BITSTRING':
if n.arg.find('x') >= 0:
return ast.Call(ast.NameConstant('__BITSTRING_MATCH__'),
[ast.Str(n.arg)], [])
return ast.NameConstant('0b' + n.arg)
raise Exception('q %s' % n)
if isinstance(n, Type):
return ast.Num(800)
if n.type == 'e-land':
return ast.BoolOp(
ast.And(),
[translateExpr(n.children[0]),
translateExpr(n.children[1])])
elif n.type == 'e-lor':
return ast.BoolOp(
ast.Or(),
[translateExpr(n.children[0]),
translateExpr(n.children[1])])
elif n.type == 'e-eq':
return ast.Compare(translateExpr(n.children[0]), [ast.Eq()],
[translateExpr(n.children[1])])
elif n.type == 'e-ne':
return ast.Compare(translateExpr(n.children[0]), [ast.NotEq()],
[translateExpr(n.children[1])])
elif n.type == 'e-call':
return ast.Call(translateExpr(n.children[0]),
[translateExpr(x) for x in n.children[1]], [])
elif n.type == 'e-range':
return ast.Subscript(translateExpr(n.children[0]),
translateRange(n.children[1]), None)
elif n.type == 'e-not':
return ast.UnaryOp(ast.Not(), translateExpr(n.children[0]))
elif n.type == 'e-negate':
return ast.UnaryOp(ast.USub(), translateExpr(n.children[0]))
elif n.type == 'e-add':
return ast.BinOp(translateExpr(n.children[0]), ast.Add(),
translateExpr(n.children[1]))
elif n.type == 'e-sub':
return ast.BinOp(translateExpr(n.children[0]), ast.Sub(),
translateExpr(n.children[1]))
elif n.type == 'e-mul':
return ast.BinOp(translateExpr(n.children[0]), ast.Mult(),
translateExpr(n.children[1]))
elif n.type == 'e-div':
return ast.BinOp(translateExpr(n.children[0]), ast.FloorDiv(),
translateExpr(n.children[1]))
elif n.type == 'e-fdiv':
return ast.BinOp(translateExpr(n.children[0]), ast.Div(),
translateExpr(n.children[1]))
elif n.type == 'e-rem':
return ast.BinOp(translateExpr(n.children[0]), ast.Mod(),
translateExpr(n.children[1]))
elif n.type == 'e-lt':
return ast.Compare(translateExpr(n.children[0]), [ast.Lt()],
[translateExpr(n.children[1])])
elif n.type == 'e-le':
return ast.Compare(translateExpr(n.children[0]), [ast.LtE()],
[translateExpr(n.children[1])])
elif n.type == 'e-gt':
return ast.Compare(translateExpr(n.children[0]), [ast.Gt()],
[translateExpr(n.children[1])])
elif n.type == 'e-ge':
return ast.Compare(translateExpr(n.children[0]), [ast.GtE()],
[translateExpr(n.children[1])])
elif n.type == 'e-lsh':
return ast.BinOp(translateExpr(n.children[0]), ast.LShift(),
translateExpr(n.children[1]))
elif n.type == 'e-rsh':
return ast.BinOp(translateExpr(n.children[0]), ast.RShift(),
translateExpr(n.children[1]))
elif n.type == 'e-eor':
return ast.BinOp(translateExpr(n.children[0]), ast.BitXor(),
translateExpr(n.children[1]))
elif n.type == 'e-or':
return ast.BinOp(translateExpr(n.children[0]), ast.BitOr(),
translateExpr(n.children[1]))
elif n.type == 'e-and':
return ast.BinOp(translateExpr(n.children[0]), ast.BitAnd(),
translateExpr(n.children[1]))
elif n.type == 'e-ternary':
return ast.IfExp(translateExpr(n.children[0]),
translateExpr(n.children[1]),
translateExpr(n.children[2]))
elif n.type == 'e-subrange':
return ast.Num(113)
elif n.type == 'e-lnegate':
return ast.UnaryOp(ast.Invert(), translateExpr(n.children[0]))
elif n.type == 'e-subscript':
return ast.Attribute(translateExpr(n.children[0]), n.children[1].arg,
None)
elif n.type == 'e-indexempty':
return ast.Subscript(translateExpr(n.children[0]),
ast.Slice(None, None, None), None)
elif n.type == 'e-implementation-defined':
return ast.Call(ast.NameConstant('IMPLEMENTATION_DEFINED'), [], [])
elif n.type == 'e-exp':
return ast.BinOp(translateExpr(n.children[0]), ast.Pow(),
translateExpr(n.children[1]))
elif n.type == 'e-mod':
return ast.BinOp(translateExpr(n.children[0]), ast.Mod(),
translateExpr(n.children[1]))
elif n.type == 'e-unknown':
return ast.Call(ast.NameConstant('UNKNOWN'), [], [])
elif n.type == 'e-index':
return ast.Subscript(translateExpr(n.children[0]),
ast.Slice(None, None, None), None)
elif n.type == 'e-tuple':
return ast.Tuple([translateExpr(x) for x in n.children[0]], None)
elif n.type == 'e-set-in':
return ast.Num(114)
elif n.type == 'e-concat':
return ast.Call(
ast.NameConstant('_CONCAT_'),
[translateExpr(n.children[0]),
translateExpr(n.children[1])], [])
elif n.type == 'tuple-nomatch':
return ast.NameConstant('_')
elif n.type == 'range':
return ast.Num(122) #return translateRange(n)
else:
raise Exception('unknown node type: %s' % (n, ))
return ast.Num(42)
def __init__(self, str, lineno=0):
self.value = str
self.lineno = lineno
op_ast_map = {
'+': ast.Add(),
'-': ast.Sub(),
'*': ast.Mult(),
'/': ast.Div(),
'%': ast.Mod(),
'**': ast.Pow(),
'<<': ast.LShift(),
'>>': ast.RShift(),
'|': ast.BitOr(),
'^^': ast.BitXor(),
'&&': ast.BitAnd(),
'//': ast.FloorDiv(),
'==': ast.Eq(),
'!=': ast.NotEq(),
'<': ast.Lt(),
'<=': ast.LtE(),
'>': ast.Gt(),
'>=': ast.GtE(),
'is': ast.Is(),
'is_not': ast.IsNot(),
'in': ast.In(),
'not_in': ast.NotIn(),
'and': ast.And(),
'or': ast.Or()
}
def visit_BinOp(self, node):
self.generic_visit(node)
self.binop_count += 1
# Check if this is the node we want to alter. We can accomplish this by
# keeping track of a counter, which we increment every time encounter
# a BinOp. Since the traversal through the AST is deterministic using the visitor
# pattern (IT IS NOT DETERMINISTIC IF YOU USE ast.walk), we can identify AST nodes
# uniquely by the value of the counter
if (self.binop_count == self.count_of_node_to_mutate):
# We make sure to use deepcopy so that we preserve all extra
# information we don't explicitly modify
new_node = copy.deepcopy(node)
ast.copy_location(new_node, node)
# figure out a way to randomize what operator it transforms to based on the current operator
if isinstance(node.op, ast.Add):
#randomly generate a number which will associate to a certain type of transformation
num = random.randint(0, 2)
print('random number', num)
if num == 0:
new_node.op = ast.Mult()
if num == 1:
new_node.op = ast.Sub()
if num == 2:
new_node.op = ast.Div()
if isinstance(node.op, ast.Mult):
num = random.randint(0, 3)
if num == 0:
new_node.op = ast.Div()
if num == 1:
new_node.op = ast.Add()
if num == 2:
new_node.op = ast.FloorDiv()
if num == 3:
new_node.op = ast.Sub()
if isinstance(node.op, ast.Div):
num = random.randint(0, 2)
if num == 0:
new_node.op = ast.FloorDiv()
if num == 1:
new_node.op = ast.Mult()
if num == 2:
new_node.op = ast.Add()
if isinstance(node.op, ast.Sub):
num = random.randint(0, 2)
if num == 0:
new_node.op = ast.Add()
if num == 1:
new_node.op = ast.Mult()
if num == 2:
new_node.op = ast.Div()
if isinstance(node.op, ast.FloorDiv):
new_node.op = ast.Div()
print('I AM CREATING A NEW NODE HERE', self.binop_count)
return new_node
else:
# If we're not looking at an add node we want to change, don't modify
# this node whatsoever
return node
def as_ast(dct):
"""See https://docs.python.org/2/library/ast.html"""
if dct['ast_type'] == "Module":
return ast.Module(dct["body"])
elif dct['ast_type'] == "Interactive":
return ast.Interactive(dct["body"])
elif dct['ast_type'] == "Expression":
return ast.Expression(dct["body"])
elif dct['ast_type'] == "Suite":
return ast.Suite(dct["body"])
elif dct['ast_type'] == "FunctionDef":
return ast.FunctionDef(dct["name"], dct["args"], dct["body"],
dct["decorator_list"])
elif dct['ast_type'] == "ClassDef":
return ast.ClassDef(dct["name"], dct["bases"], dct["body"],
dct["decorator_list"])
elif dct['ast_type'] == "Return":
return ast.Return(dct["value"])
elif dct['ast_type'] == "Delete":
return ast.Delete(dct["targets"])
elif dct['ast_type'] == "Assign":
return ast.Assign(dct["targets"], dct["value"])
elif dct['ast_type'] == "AugAssign":
return ast.AugAssign(dct["target"], dct["op"], dct["value"])
elif dct['ast_type'] == "Print":
return ast.Print(dct["dest"], dct["values"], dct["nl"])
elif dct['ast_type'] == "For":
return ast.For(dct["target"], dct["iter"], dct["body"], dct["orelse"])
elif dct['ast_type'] == "While":
return ast.While(dct["test"], dct["body"], dct["orelse"])
elif dct['ast_type'] == "If":
return ast.If(dct["test"], dct["body"], dct["orelse"])
elif dct['ast_type'] == "With":
return ast.With(dct["context_expr"], dct["optional_vars"], dct["body"])
elif dct['ast_type'] == "Raise":
return ast.Raise(dct["type"], dct["inst"], dct["tback"])
elif dct['ast_type'] == "TryExcept":
return ast.TryExcept(dct["body"], dct["handlers"], dct["orelse"])
elif dct['ast_type'] == "TryFinally":
return ast.TryFinally(dct["body"], dct["finalbody"])
elif dct['ast_type'] == "Assert":
return ast.Assert(dct["test"], dct["msg"])
elif dct['ast_type'] == "Import":
return ast.Import(dct["names"])
elif dct['ast_type'] == "ImportFrom":
return ast.ImportFrom(dct["module"], dct["names"], dct["level"])
elif dct['ast_type'] == "Exec":
return ast.Exec(dct["body"], dct["globals"], dct["locals"])
elif dct['ast_type'] == "Global":
return ast.Global(dct["names"])
elif dct['ast_type'] == "Expr":
return ast.Expr(dct["value"])
elif dct['ast_type'] == "Pass":
return ast.Pass()
elif dct['ast_type'] == "Break":
return ast.Break()
elif dct['ast_type'] == "Continue":
return ast.Continue()
elif dct['ast_type'] == "BoolOp":
return ast.BoolOp(dct["op"], dct["values"])
elif dct['ast_type'] == "BinOp":
return ast.BinOp(dct["left"], dct["op"], dct["right"])
elif dct['ast_type'] == "UnaryOp":
return ast.UnaryOp(dct["op"], dct["operand"])
elif dct['ast_type'] == "Lambda":
return ast.Lambda(dct["args"], dct["body"])
elif dct['ast_type'] == "IfExp":
return ast.IfExp(dct["test"], dct["body"], dct["orelse"])
elif dct['ast_type'] == "Dict":
return ast.Dict(dct["keys"], dct["values"])
elif dct['ast_type'] == "Set":
return ast.Set(dct["elts"])
elif dct['ast_type'] == "ListComp":
return ast.ListComp(dct["elt"], dct["generators"])
elif dct['ast_type'] == "SetComp":
return ast.SetComp(dct["elt"], dct["generators"])
elif dct['ast_type'] == "DictComp":
return ast.DictComp(dct["key"], dct["value"], dct["generators"])
elif dct['ast_type'] == "GeneratorExp":
return ast.GeneratorExp(dct["elt"], dct["generators"])
elif dct['ast_type'] == "Yield":
return ast.Yield(dct["value"])
elif dct['ast_type'] == "Compare":
return ast.Compare(dct["left"], dct["ops"], dct["comparators"])
elif dct['ast_type'] == "Call":
return ast.Call(dct["func"], dct["args"], dct["keywords"],
dct["starargs"], dct["kwargs"])
elif dct['ast_type'] == "Repr":
return ast.Repr(dct["value"])
elif dct['ast_type'] == "Num":
return ast.Num(dct["n"])
elif dct['ast_type'] == "Str":
# Converting to ASCII
return ast.Str(dct["s"].encode('ascii', 'ignore'))
elif dct['ast_type'] == "Attribute":
return ast.Attribute(dct["value"], dct["attr"], dct["ctx"])
elif dct['ast_type'] == "Subscript":
return ast.Subscript(dct["value"], dct["slice"], dct["ctx"])
elif dct['ast_type'] == "Name":
return ast.Name(dct["id"], dct["ctx"])
elif dct['ast_type'] == "List":
return ast.List(dct["elts"], dct["ctx"])
elif dct['ast_type'] == "Tuple":
return ast.Tuple(dct["elts"], dct["ctx"])
elif dct['ast_type'] == "Load":
return ast.Load()
elif dct['ast_type'] == "Store":
return ast.Store()
elif dct['ast_type'] == "Del":
return ast.Del()
elif dct['ast_type'] == "AugLoad":
return ast.AugLoad()
elif dct['ast_type'] == "AugStore":
return ast.AugStore()
elif dct['ast_type'] == "Param":
return ast.Param()
elif dct['ast_type'] == "Ellipsis":
return ast.Ellipsis()
elif dct['ast_type'] == "Slice":
return ast.Slice(dct["lower"], dct["upper"], dct["step"])
elif dct['ast_type'] == "ExtSlice":
return ast.ExtSlice(dct["dims"])
elif dct['ast_type'] == "Index":
return ast.Index(dct["value"])
elif dct['ast_type'] == "And":
return ast.And()
elif dct['ast_type'] == "Or":
return ast.Or()
elif dct['ast_type'] == "Add":
return ast.Add()
elif dct['ast_type'] == "Sub":
return ast.Sub()
elif dct['ast_type'] == "Mult":
return ast.Mult()
elif dct['ast_type'] == "Div":
return ast.Div()
elif dct['ast_type'] == "Mod":
return ast.Mod()
elif dct['ast_type'] == "Pow":
return ast.Pow()
elif dct['ast_type'] == "LShift":
return ast.LShift()
elif dct['ast_type'] == "RShift":
return ast.RShift()
elif dct['ast_type'] == "BitOr":
return ast.BitOr()
elif dct['ast_type'] == "BitXor":
return ast.BitXor()
elif dct['ast_type'] == "BitAnd":
return ast.BitAnd()
elif dct['ast_type'] == "FloorDiv":
return ast.FloorDiv()
elif dct['ast_type'] == "Invert":
return ast.Invert()
elif dct['ast_type'] == "Not":
return ast.Not()
elif dct['ast_type'] == "UAdd":
return ast.UAdd()
elif dct['ast_type'] == "USub":
return ast.USub()
elif dct['ast_type'] == "Eq":
return ast.Eq()
elif dct['ast_type'] == "NotEq":
return ast.NotEq()
elif dct['ast_type'] == "Lt":
return ast.Lt()
elif dct['ast_type'] == "LtE":
return ast.LtE()
elif dct['ast_type'] == "Gt":
return ast.Gt()
elif dct['ast_type'] == "GtE":
return ast.GtE()
elif dct['ast_type'] == "Is":
return ast.Is()
elif dct['ast_type'] == "IsNot":
return ast.IsNot()
elif dct['ast_type'] == "In":
return ast.In()
elif dct['ast_type'] == "NotIn":
return ast.NotIn()
elif dct['ast_type'] == "comprehension":
return ast.comprehension(dct["target"], dct["iter"], dct["ifs"])
elif dct['ast_type'] == "ExceptHandler":
return ast.ExceptHandler(dct["type"], dct["name"], dct["body"])
elif dct['ast_type'] == "arguments":
return ast.arguments(dct["args"], dct["vararg"], dct["kwarg"],
dct["defaults"])
elif dct['ast_type'] == "keyword":
return ast.keyword(dct["arg"], dct["value"])
elif dct['ast_type'] == "alias":
return ast.alias(dct["name"], dct["asname"])
else:
return dct
'NAME',
'NUMBER',
)
Add = ast.Add()
Sub = ast.Sub()
Mult = ast.Mult()
Div = ast.Div()
Mod = ast.Mod()
Pow = ast.Pow()
LShift = ast.LShift()
RShift = ast.RShift()
BitOr = ast.BitOr()
BitAnd = ast.BitAnd()
BitXor = ast.BitXor()
FloorDiv = ast.FloorDiv()
op_dict = {
"+": Add,
"-": Sub,
"*": Mult,
"/": Div,
"//": FloorDiv,
"%": Mod,
"**": Pow,
"<<": LShift,
">>": RShift,
"|": BitOr,
"&": BitAnd,
"^": BitXor,
"+=": Add,
