Replace ExprInt[num](x) -> ExprInt(x, num)

4 files changed, 25 insertions, 25 deletions

diff --git a/test/ir/ir2C.py b/test/ir/ir2C.py
index 395703ed..a966938b 100755
--- a/test/ir/ir2C.py
+++ b/test/ir/ir2C.py
@@ -13,10 +13,10 @@ class TestIrIr2C(unittest.TestCase):
         self.assertEqual(translator.from_expr(expr), expected)
 
     def test_ExprOp_toC(self):
-        from miasm2.expression.expression import ExprInt32, ExprOp
+        from miasm2.expression.expression import ExprInt, ExprOp
         from miasm2.ir.translators.C import Translator
 
-        args = [ExprInt32(i) for i in xrange(9)]
+        args = [ExprInt(i, 32) for i in xrange(9)]
         translator = Translator.to_language("C")
 
         # Unary operators
diff --git a/test/ir/symbexec.py b/test/ir/symbexec.py
index 48de6573..bd28c4ee 100755
--- a/test/ir/symbexec.py
+++ b/test/ir/symbexec.py
@@ -7,20 +7,20 @@ import unittest
 class TestSymbExec(unittest.TestCase):
 
     def test_ClassDef(self):
-        from miasm2.expression.expression import ExprInt32, ExprId, ExprMem, \
+        from miasm2.expression.expression import ExprInt, ExprId, ExprMem, \
             ExprCompose, ExprAff
         from miasm2.arch.x86.sem import ir_x86_32
         from miasm2.ir.symbexec import SymbolicExecutionEngine
         from miasm2.ir.ir import AssignBlock
 
-        addrX = ExprInt32(-1)
-        addr0 = ExprInt32(0)
-        addr1 = ExprInt32(1)
-        addr8 = ExprInt32(8)
-        addr9 = ExprInt32(9)
-        addr20 = ExprInt32(20)
-        addr40 = ExprInt32(40)
-        addr50 = ExprInt32(50)
+        addrX = ExprInt(-1, 32)
+        addr0 = ExprInt(0, 32)
+        addr1 = ExprInt(1, 32)
+        addr8 = ExprInt(8, 32)
+        addr9 = ExprInt(9, 32)
+        addr20 = ExprInt(20, 32)
+        addr40 = ExprInt(40, 32)
+        addr50 = ExprInt(50, 32)
         mem0 = ExprMem(addr0)
         mem1 = ExprMem(addr1, 8)
         mem8 = ExprMem(addr8)
@@ -44,18 +44,18 @@ class TestSymbExec(unittest.TestCase):
         self.assertEqual(e.eval_expr(ExprMem(addr1 - addr1)), id_x)
         self.assertEqual(e.eval_expr(ExprMem(addr1, 8)), id_y)
         self.assertEqual(e.eval_expr(ExprMem(addr1 + addr1)), ExprCompose(
-            id_x[16:32], ExprMem(ExprInt32(4), 16)))
+            id_x[16:32], ExprMem(ExprInt(4, 32), 16)))
         self.assertEqual(e.eval_expr(mem8), ExprCompose(
-            id_x[0:24], ExprMem(ExprInt32(11), 8)))
+            id_x[0:24], ExprMem(ExprInt(11, 32), 8)))
         self.assertEqual(e.eval_expr(mem40v), id_x[:8])
         self.assertEqual(e.eval_expr(mem50w), ExprCompose(
-            id_y, ExprMem(ExprInt32(51), 8)))
+            id_y, ExprMem(ExprInt(51, 32), 8)))
         self.assertEqual(e.eval_expr(mem20), mem20)
         e.func_read = lambda x: x
         self.assertEqual(e.eval_expr(mem20), mem20)
         self.assertEqual(set(e.modified()), set(e.symbols))
         self.assertRaises(
-            KeyError, e.symbols.__getitem__, ExprMem(ExprInt32(100)))
+            KeyError, e.symbols.__getitem__, ExprMem(ExprInt(100, 32)))
         self.assertEqual(e.apply_expr(id_eax), addr0)
         self.assertEqual(e.apply_expr(ExprAff(id_eax, addr9)), addr9)
         self.assertEqual(e.apply_expr(id_eax), addr9)
diff --git a/test/ir/translators/smt2.py b/test/ir/translators/smt2.py
index 97877a3b..838b0bc5 100644
--- a/test/ir/translators/smt2.py
+++ b/test/ir/translators/smt2.py
@@ -14,10 +14,10 @@ left = ExprCond(e + ExprOp('parity', a),
                 ExprMem(a * a, 64),
                 ExprMem(a, 64))
 
-cond = ExprSlice(ExprSlice(ExprSlice(a, 0, 32) + b, 0, 16) * c, 0, 8) << ExprOp('>>>', d, ExprInt(uint8(0x5L)))
+cond = ExprSlice(ExprSlice(ExprSlice(a, 0, 32) + b, 0, 16) * c, 0, 8) << ExprOp('>>>', d, ExprInt(0x5L, 8))
 right = ExprCond(cond,
-                 a + ExprInt(uint64(0x64L)),
-                 ExprInt(uint64(0x16L)))
+                 a + ExprInt(0x64L, 64),
+                 ExprInt(0x16L, 64))
 
 e = ExprAff(left, right)
 
diff --git a/test/ir/translators/z3_ir.py b/test/ir/translators/z3_ir.py
index 0251c2fe..83744786 100644
--- a/test/ir/translators/z3_ir.py
+++ b/test/ir/translators/z3_ir.py
@@ -60,8 +60,8 @@ z3_e = z3.BitVec('x', 32)
 assert equiv(ez3, z3_e)
 
 # --------------------------------------------------------------------------
-four = ExprInt32(4)
-five = ExprInt32(5)
+four = ExprInt(4, 32)
+five = ExprInt(5, 32)
 e2 = (e + five + four) * five
 ez3 = Translator.to_language('z3').from_expr(e2)
 
@@ -71,9 +71,9 @@ z3_e2 = (z3_e + z3_five + z3_four) * z3_five
 assert equiv(ez3, z3_e2)
 
 # --------------------------------------------------------------------------
-emem = ExprMem(ExprInt32(0xdeadbeef), size=32)
-emem2 = ExprMem(ExprInt32(0xfee1dead), size=32)
-e3 = (emem + e) * ExprInt32(2) * emem2
+emem = ExprMem(ExprInt(0xdeadbeef, 32), size=32)
+emem2 = ExprMem(ExprInt(0xfee1dead, 32), size=32)
+e3 = (emem + e) * ExprInt(2, 32) * emem2
 ez3 = Translator.to_language('z3').from_expr(e3)
 
 mem = Z3Mem()
@@ -122,8 +122,8 @@ assert equiv(ez3, z3_e5)
 
 # --------------------------------------------------------------------------
 # Parity
-seven = ExprInt32(7)
-one0seven = ExprInt32(0x107)
+seven = ExprInt(7, 32)
+one0seven = ExprInt(0x107, 32)
 for miasm_int, res in [(five, 1), (four, 0), (seven, 0), (one0seven, 0)]:
     e6 = ExprOp('parity', miasm_int)
     ez3 = Translator.to_language('z3').from_expr(e6)