def test_inline_list_decompile():
d = Decompiler()
x = [1, 1, 2., 3j, False, 3L, '3', u'3']
d.ingest(x)
ref = d.mgr.reference(x)
result = "%s = %r" % (ref, x)
assert d.render() == result
_test_equality(d.render(), ref, x)
def test_dict_decompile(arg):
d = Decompiler()
x = dict([('b', arg), ('a', arg)])
d.ingest(x)
ref = d.mgr.reference(x)
result = "%s = { 'a': %r, 'b': %r }" % (ref, arg, arg)
assert d.render() == result
_test_equality(d.render(), ref, x)
def test_name_hint():
"""In the absence of name conflicts, output ref should use name_hint"""
x = [5, 5, 5, 5, 5, 5]
d = Decompiler()
d.ingest(x, name_hint='zzz')
answer = "zzz = [5, 5, 5, 5, 5, 5]"
result = d.render()
assert answer == result
def test_unsupported_type():
"""Raise type error when trying to ingest an unsupported type"""
class Foo(object):
pass
d = Decompiler()
with pytest.raises(TypeError) as exc:
d.ingest(Foo())
assert exc.value.args[0] == ("Don't know how to decompile objects of "
"type %s" % type(Foo()))
def test_numpy_decompile():
import numpy as np
x = np.array([1,2,3,4])
s = x.dumps()
d = Decompiler()
d.ingest(x)
ref = d.mgr.reference(x)
answer = "import numpy as np\n%s = np.loads(%r)" % (ref, s)
assert d.render() == answer
exec(d.render())
np.testing.assert_array_equal(locals()[ref], x)
def test_magic_method():
"""Decompiler looks for __expfac__ for expression factories"""
class Foo(object):
def __init__(self, x):
self.x = x
def __expfac__(self, decompiler, obj):
return [Expression("Foo({{x}})", x=obj.x, output_ref = obj)]
f = Foo(4)
d = Decompiler()
d.ingest(f)
ref = d.mgr.reference(f)
answer = "%s = Foo(4)" % ref
result = d.render()
assert result == answer
def main(input_par, output_par):
output_file = open(output_par, 'w')
with open(input_par, 'r') as file:
body_of_file = file.read().splitlines()
# flag_config = False
# flag_instructions = False
status_of_parse = "start"
set_of_instructions = []
set_of_config = []
name_of_program = ""
for row in body_of_file:
row = re.sub("/\*(.*?)\*/", '', row)
row = row.strip()
if row.find(".kernel ") != -1:
# if flag_instructions:
if status_of_parse == "instruction":
# flag_instructions = False
status_of_parse = "kernel"
decompiler = Decompiler(output_file)
decompiler.process_src(name_of_program, set_of_config,
set_of_instructions)
output_file.write("\n")
set_of_instructions = []
set_of_config = []
name_of_program = ""
name_of_program = row.split()[1]
if row == ".config":
# flag_config = True
status_of_parse = "config"
elif row == ".text":
# flag_config = False
# flag_instructions = True
status_of_parse = "instruction"
# elif flag_instructions:
elif status_of_parse == "instruction":
set_of_instructions.append(row)
# elif flag_config:
elif status_of_parse == "config":
set_of_config.append(row)
else:
continue
decompiler = Decompiler(output_file)
decompiler.process_src(name_of_program, set_of_config, set_of_instructions)
output_file.close()
""" Example use of the Decompiler Try running this script like python demo.py > out.py python out.py ISSUES: ------- Axes limits are not being set correctly? """ import matplotlib.pyplot as plt from decompiler import Decompiler p, = plt.plot([1,2,3], [2,3,4], 'ro-', alpha = .3, markerfacecolor='b') p.axes.set_xlim(-2, 20) p.axes.set_ylim(-50, 50) d = Decompiler() d.ingest(p.figure) print d.render() print 'plt.show()'
def __init__(self, parameters):
unittest.TestCase.__init__(self, parameters)
self.decompiler = Decompiler()
class DecomplierTests(unittest.TestCase):
def __init__(self, parameters):
unittest.TestCase.__init__(self, parameters)
self.decompiler = Decompiler()
def test_ExceptionThrowWhenRegisterDecodingFailed(self):
self.decompiler.load([0x00, 0xAA, 0x02])
self.assertRaises(Exception, self.decompiler.run)
def test_ExceptionThrowWhenInstructionDecodingFailed(self):
self.decompiler.load([0x04])
self.assertRaises(Exception, self.decompiler.run)
def test_ExceptionThrowWhenNotEnoughOperands(self):
self.decompiler.load([0x00, 0x00])
self.assertRaises(Exception, self.decompiler.run)
def test_IfItsPutCommaBetweenTwoOperands(self):
self.decompiler.load([0x00, 0x01, 0x02])
self.decompiler.run()
result = self.decompiler.getDecompiled()
self.assertEqual(result, "MOV R1, R2")
def test_IfItsNotPutCommaBetweenMnemonicInstructionAndFirstOperand(self):
self.decompiler.load([0x18, 0x01])
self.decompiler.run()
result = self.decompiler.getDecompiled()
self.assertEqual(result, "NOT R1")
def test_IfItsPuttingConstantsHexadecimaly(self):
self.decompiler.load([0x42, 0xFA])
self.decompiler.run()
result = self.decompiler.getDecompiled()
self.assertEqual(result, "CALL 0xFA")
def test_IfItCanHandleInstructionWithoutOperands(self):
self.decompiler.load([0xFF])
self.decompiler.run()
result = self.decompiler.getDecompiled()
self.assertEqual(result, "HALT")
def test_repeated_add_import():
"""Don't repeat import statements on render"""
d = Decompiler()
d.add_import('import numpy as np')
d.add_import('import numpy as np')
assert d.render() == 'import numpy as np'
def test_add_import():
d = Decompiler()
d.add_import('import numpy as np')
assert d.render() == 'import numpy as np'