Merge pull request #533 from serpilliere/fix_exprmatch

Fix exprmatch

1 files changed, 287 insertions, 279 deletions

diff --git a/miasm2/expression/expression.py b/miasm2/expression/expression.py
index ee233abe..bf27218b 100644
--- a/miasm2/expression/expression.py
+++ b/miasm2/expression/expression.py
@@ -28,12 +28,11 @@
 #
 
 
+import warnings
 import itertools
-from operator import itemgetter
 from miasm2.expression.modint import mod_size2uint, is_modint, size2mask, \
     define_uint
 from miasm2.core.graph import DiGraph
-import warnings
 
 # Define tokens
 TOK_INF = "<"
@@ -59,14 +58,14 @@ EXPRCOMPOSE = 5
 
 def visit_chk(visitor):
     "Function decorator launching callback on Expression visit"
-    def wrapped(e, cb, test_visit=lambda x: True):
-        if (test_visit is not None) and (not test_visit(e)):
-            return e
-        e_new = visitor(e, cb, test_visit)
-        if e_new is None:
+    def wrapped(expr, callback, test_visit=lambda x: True):
+        if (test_visit is not None) and (not test_visit(expr)):
+            return expr
+        expr_new = visitor(expr, callback, test_visit)
+        if expr_new is None:
             return None
-        e_new2 = cb(e_new)
-        return e_new2
+        expr_new2 = callback(expr_new)
+        return expr_new2
     return wrapped
 
 
@@ -123,7 +122,7 @@ class Expr(object):
     canon_exprs = set()
     use_singleton = True
 
-    def set_size(self, value):
+    def set_size(self, _):
         raise ValueError('size is not mutable')
 
     def __init__(self):
@@ -134,21 +133,21 @@ class Expr(object):
     size = property(lambda self: self.__size)
 
     @staticmethod
-    def get_object(cls, args):
-        if not cls.use_singleton:
-            return object.__new__(cls, args)
+    def get_object(expr_cls, args):
+        if not expr_cls.use_singleton:
+            return object.__new__(expr_cls, args)
 
-        expr = Expr.args2expr.get((cls, args))
+        expr = Expr.args2expr.get((expr_cls, args))
         if expr is None:
-            expr = object.__new__(cls, args)
-            Expr.args2expr[(cls, args)] = expr
+            expr = object.__new__(expr_cls, args)
+            Expr.args2expr[(expr_cls, args)] = expr
         return expr
 
     def get_is_canon(self):
         return self in Expr.canon_exprs
 
     def set_is_canon(self, value):
-        assert(value is True)
+        assert value is True
         Expr.canon_exprs.add(self)
 
     is_canon = property(get_is_canon, set_is_canon)
@@ -198,44 +197,44 @@ class Expr(object):
             return False
         return repr(self) == repr(other)
 
-    def __ne__(self, a):
-        return not self.__eq__(a)
+    def __ne__(self, other):
+        return not self.__eq__(other)
 
-    def __add__(self, a):
-        return ExprOp('+', self, a)
+    def __add__(self, other):
+        return ExprOp('+', self, other)
 
-    def __sub__(self, a):
-        return ExprOp('+', self, ExprOp('-', a))
+    def __sub__(self, other):
+        return ExprOp('+', self, ExprOp('-', other))
 
-    def __div__(self, a):
-        return ExprOp('/', self, a)
+    def __div__(self, other):
+        return ExprOp('/', self, other)
 
-    def __mod__(self, a):
-        return ExprOp('%', self, a)
+    def __mod__(self, other):
+        return ExprOp('%', self, other)
 
-    def __mul__(self, a):
-        return ExprOp('*', self, a)
+    def __mul__(self, other):
+        return ExprOp('*', self, other)
 
-    def __lshift__(self, a):
-        return ExprOp('<<', self, a)
+    def __lshift__(self, other):
+        return ExprOp('<<', self, other)
 
-    def __rshift__(self, a):
-        return ExprOp('>>', self, a)
+    def __rshift__(self, other):
+        return ExprOp('>>', self, other)
 
-    def __xor__(self, a):
-        return ExprOp('^', self, a)
+    def __xor__(self, other):
+        return ExprOp('^', self, other)
 
-    def __or__(self, a):
-        return ExprOp('|', self, a)
+    def __or__(self, other):
+        return ExprOp('|', self, other)
 
-    def __and__(self, a):
-        return ExprOp('&', self, a)
+    def __and__(self, other):
+        return ExprOp('&', self, other)
 
     def __neg__(self):
         return ExprOp('-', self)
 
-    def __pow__(self, a):
-        return ExprOp("**",self, a)
+    def __pow__(self, other):
+        return ExprOp("**", self, other)
 
     def __invert__(self):
         return ExprOp('^', self, self.mask)
@@ -254,37 +253,37 @@ class Expr(object):
         if dct is None:
             dct = {}
 
-        def my_replace(e, dct):
-            if e in dct:
-                return dct[e]
-            return e
+        def my_replace(expr, dct):
+            if expr in dct:
+                return dct[expr]
+            return expr
 
-        return self.visit(lambda e: my_replace(e, dct))
+        return self.visit(lambda expr: my_replace(expr, dct))
 
     def canonize(self):
         "Canonize the Expression"
 
-        def must_canon(e):
-            return not e.is_canon
+        def must_canon(expr):
+            return not expr.is_canon
 
-        def canonize_visitor(e):
-            if e.is_canon:
-                return e
-            if isinstance(e, ExprOp):
-                if e.is_associative():
+        def canonize_visitor(expr):
+            if expr.is_canon:
+                return expr
+            if isinstance(expr, ExprOp):
+                if expr.is_associative():
                     # ((a+b) + c) => (a + b + c)
                     args = []
-                    for arg in e.args:
-                        if isinstance(arg, ExprOp) and e.op == arg.op:
+                    for arg in expr.args:
+                        if isinstance(arg, ExprOp) and expr.op == arg.op:
                             args += arg.args
                         else:
                             args.append(arg)
                     args = canonize_expr_list(args)
-                    new_e = ExprOp(e.op, *args)
+                    new_e = ExprOp(expr.op, *args)
                 else:
-                    new_e = e
+                    new_e = expr
             else:
-                new_e = e
+                new_e = expr
             new_e.is_canon = True
             return new_e
 
@@ -292,33 +291,30 @@ class Expr(object):
 
     def msb(self):
         "Return the Most Significant Bit"
-        s = self.size
-        return self[s - 1:s]
+        return self[self.size - 1:self.size]
 
     def zeroExtend(self, size):
         """Zero extend to size
         @size: int
         """
-        assert(self.size <= size)
+        assert self.size <= size
         if self.size == size:
             return self
         ad_size = size - self.size
-        n = ExprInt(0, ad_size)
-        return ExprCompose(self, n)
+        return ExprCompose(self, ExprInt(0, ad_size))
 
     def signExtend(self, size):
         """Sign extend to size
         @size: int
         """
-        assert(self.size <= size)
+        assert self.size <= size
         if self.size == size:
             return self
         ad_size = size - self.size
-        c = ExprCompose(self,
-                        ExprCond(self.msb(),
-                                 ExprInt(size2mask(ad_size), ad_size),
-                                 ExprInt(0, ad_size)))
-        return c
+        return ExprCompose(self,
+                           ExprCond(self.msb(),
+                                    ExprInt(size2mask(ad_size), ad_size),
+                                    ExprInt(0, ad_size)))
 
     def graph_recursive(self, graph):
         """Recursive method used by graph
@@ -453,11 +449,11 @@ class ExprInt(Expr):
         return "%s(0x%X, %d)" % (self.__class__.__name__, self.__get_int(),
                                  self.__size)
 
-    def __contains__(self, e):
-        return self == e
+    def __contains__(self, expr):
+        return self == expr
 
     @visit_chk
-    def visit(self, cb, tv=None):
+    def visit(self, callback, test_visit=None):
         return self
 
     def copy(self):
@@ -522,17 +518,16 @@ class ExprId(Expr):
         return set([self])
 
     def _exprhash(self):
-        # TODO XXX: hash size ??
         return hash((EXPRID, self.__name, self.__size))
 
     def _exprrepr(self):
         return "%s(%r, %d)" % (self.__class__.__name__, self.__name, self.__size)
 
-    def __contains__(self, e):
-        return self == e
+    def __contains__(self, expr):
+        return self == expr
 
     @visit_chk
-    def visit(self, cb, tv=None):
+    def visit(self, callback, test_visit=None):
         return self
 
     def copy(self):
@@ -571,7 +566,7 @@ class ExprAff(Expr):
         if dst.size != src.size:
             raise ValueError(
                 "sanitycheck: ExprAff args must have same size! %s" %
-                             ([(str(arg), arg.size) for arg in [dst, src]]))
+                ([(str(arg), arg.size) for arg in [dst, src]]))
 
         self.__size = self.dst.size
 
@@ -627,8 +622,8 @@ class ExprAff(Expr):
                 self.__dst.__contains__(expr))
 
     @visit_chk
-    def visit(self, cb, tv=None):
-        dst, src = self.__dst.visit(cb, tv), self.__src.visit(cb, tv)
+    def visit(self, callback, test_visit=None):
+        dst, src = self.__dst.visit(callback, test_visit), self.__src.visit(callback, test_visit)
         if dst == self.__dst and src == self.__src:
             return self
         else:
@@ -672,7 +667,7 @@ class ExprCond(Expr):
         super(ExprCond, self).__init__()
 
         self.__cond, self.__src1, self.__src2 = cond, src1, src2
-        assert(src1.size == src2.size)
+        assert src1.size == src2.size
         self.__size = self.src1.size
 
     size = property(lambda self: self.__size)
@@ -707,20 +702,18 @@ class ExprCond(Expr):
         return "%s(%r, %r, %r)" % (self.__class__.__name__,
                                    self.__cond, self.__src1, self.__src2)
 
-    def __contains__(self, e):
-        return (self == e or
-                self.cond.__contains__(e) or
-                self.src1.__contains__(e) or
-                self.src2.__contains__(e))
+    def __contains__(self, expr):
+        return (self == expr or
+                self.cond.__contains__(expr) or
+                self.src1.__contains__(expr) or
+                self.src2.__contains__(expr))
 
     @visit_chk
-    def visit(self, cb, tv=None):
-        cond = self.__cond.visit(cb, tv)
-        src1 = self.__src1.visit(cb, tv)
-        src2 = self.__src2.visit(cb, tv)
-        if (cond == self.__cond and
-            src1 == self.__src1 and
-                src2 == self.__src2):
+    def visit(self, callback, test_visit=None):
+        cond = self.__cond.visit(callback, test_visit)
+        src1 = self.__src1.visit(callback, test_visit)
+        src2 = self.__src2.visit(callback, test_visit)
+        if cond == self.__cond and src1 == self.__src1 and src2 == self.__src2:
             return self
         return ExprCond(cond, src1, src2)
 
@@ -802,8 +795,8 @@ class ExprMem(Expr):
         return self == expr or self.__arg.__contains__(expr)
 
     @visit_chk
-    def visit(self, cb, tv=None):
-        arg = self.__arg.visit(cb, tv)
+    def visit(self, callback, test_visit=None):
+        arg = self.__arg.visit(callback, test_visit)
         if arg == self.__arg:
             return self
         return ExprMem(arg, self.size)
@@ -855,7 +848,7 @@ class ExprOp(Expr):
             if op not in ["segm"]:
                 raise ValueError(
                     "sanitycheck: ExprOp args must have same size! %s" %
-                                 ([(str(arg), arg.size) for arg in args]))
+                    ([(str(arg), arg.size) for arg in args]))
 
         if not isinstance(op, str):
             raise ValueError("ExprOp: 'op' argument must be a string")
@@ -869,44 +862,44 @@ class ExprOp(Expr):
                 'fxam_c0', 'fxam_c1', 'fxam_c2', 'fxam_c3',
                 "access_segment_ok", "load_segment_limit_ok", "bcdadd_cf",
                 "ucomiss_zf", "ucomiss_pf", "ucomiss_cf"]:
-            sz = 1
+            size = 1
         elif self.__op in [TOK_INF, TOK_INF_SIGNED,
                            TOK_INF_UNSIGNED, TOK_INF_EQUAL,
                            TOK_INF_EQUAL_SIGNED, TOK_INF_EQUAL_UNSIGNED,
                            TOK_EQUAL, TOK_POS,
                            TOK_POS_STRICT,
-                           ]:
-            sz = 1
+                          ]:
+            size = 1
         elif self.__op in ['mem_16_to_double', 'mem_32_to_double',
                            'mem_64_to_double', 'mem_80_to_double',
                            'int_16_to_double', 'int_32_to_double',
                            'int_64_to_double', 'int_80_to_double']:
-            sz = 64
+            size = 64
         elif self.__op in ['double_to_mem_16', 'double_to_int_16',
                            'float_trunc_to_int_16', 'double_trunc_to_int_16']:
-            sz = 16
+            size = 16
         elif self.__op in ['double_to_mem_32', 'double_to_int_32',
                            'float_trunc_to_int_32', 'double_trunc_to_int_32',
                            'double_to_float']:
-            sz = 32
+            size = 32
         elif self.__op in ['double_to_mem_64', 'double_to_int_64',
                            'float_trunc_to_int_64', 'double_trunc_to_int_64',
                            'float_to_double']:
-            sz = 64
+            size = 64
         elif self.__op in ['double_to_mem_80', 'double_to_int_80',
                            'float_trunc_to_int_80',
                            'double_trunc_to_int_80']:
-            sz = 80
+            size = 80
         elif self.__op in ['segm']:
-            sz = self.__args[1].size
+            size = self.__args[1].size
         else:
             if None in sizes:
-                sz = None
+                size = None
             else:
                 # All arguments have the same size
-                sz = list(sizes)[0]
+                size = list(sizes)[0]
 
-        self.__size = sz
+        self.__size = size
 
     size = property(lambda self: self.__size)
     op = property(lambda self: self.__op)
@@ -950,11 +943,11 @@ class ExprOp(Expr):
         return "%s(%r, %s)" % (self.__class__.__name__, self.__op,
                                ', '.join(repr(arg) for arg in self.__args))
 
-    def __contains__(self, e):
-        if self == e:
+    def __contains__(self, expr):
+        if self == expr:
             return True
         for arg in self.__args:
-            if arg.__contains__(e):
+            if arg.__contains__(expr):
                 return True
         return False
 
@@ -970,8 +963,8 @@ class ExprOp(Expr):
         return (self.__op in ['+', '*', '^', '&', '|'])
 
     @visit_chk
-    def visit(self, cb, tv=None):
-        args = [arg.visit(cb, tv) for arg in self.__args]
+    def visit(self, callback, test_visit=None):
+        args = [arg.visit(callback, test_visit) for arg in self.__args]
         modified = any([arg[0] != arg[1] for arg in zip(self.__args, args)])
         if modified:
             return ExprOp(self.__op, *args)
@@ -1007,7 +1000,7 @@ class ExprSlice(Expr):
     def __init__(self, arg, start, stop):
         super(ExprSlice, self).__init__()
 
-        assert(start < stop)
+        assert start < stop
         self.__arg, self.__start, self.__stop = arg, start, stop
         self.__size = self.__stop - self.__start
 
@@ -1045,8 +1038,8 @@ class ExprSlice(Expr):
         return self.__arg.__contains__(expr)
 
     @visit_chk
-    def visit(self, cb, tv=None):
-        arg = self.__arg.visit(cb, tv)
+    def visit(self, callback, test_visit=None):
+        arg = self.__arg.visit(callback, test_visit)
         if arg == self.__arg:
             return self
         return ExprSlice(arg, self.__start, self.__stop)
@@ -1137,19 +1130,19 @@ class ExprCompose(Expr):
     def _exprrepr(self):
         return "%s%r" % (self.__class__.__name__, self.__args)
 
-    def __contains__(self, e):
-        if self == e:
+    def __contains__(self, expr):
+        if self == expr:
             return True
         for arg in self.__args:
-            if arg == e:
+            if arg == expr:
                 return True
-            if arg.__contains__(e):
+            if arg.__contains__(expr):
                 return True
         return False
 
     @visit_chk
-    def visit(self, cb, tv=None):
-        args = [arg.visit(cb, tv) for arg in self.__args]
+    def visit(self, callback, test_visit=None):
+        args = [arg.visit(callback, test_visit) for arg in self.__args]
         modified = any([arg != arg_new for arg, arg_new in zip(self.__args, args)])
         if modified:
             return ExprCompose(*args)
@@ -1179,116 +1172,116 @@ class ExprCompose(Expr):
         return True
 
 # Expression order for comparaison
-expr_order_dict = {ExprId: 1,
+EXPR_ORDER_DICT = {ExprId: 1,
                    ExprCond: 2,
                    ExprMem: 3,
                    ExprOp: 4,
                    ExprSlice: 5,
                    ExprCompose: 7,
                    ExprInt: 8,
-                   }
+                  }
 
 
-def compare_exprs_compose(e1, e2):
+def compare_exprs_compose(expr1, expr2):
     # Sort by start bit address, then expr, then stop but address
-    x = cmp(e1[1], e2[1])
-    if x:
-        return x
-    x = compare_exprs(e1[0], e2[0])
-    if x:
-        return x
-    x = cmp(e1[2], e2[2])
-    return x
+    ret = cmp(expr1[1], expr2[1])
+    if ret:
+        return ret
+    ret = compare_exprs(expr1[0], expr2[0])
+    if ret:
+        return ret
+    ret = cmp(expr1[2], expr2[2])
+    return ret
 
 
 def compare_expr_list_compose(l1_e, l2_e):
     # Sort by list elements in incremental order, then by list size
     for i in xrange(min(len(l1_e), len(l2_e))):
-        x = compare_exprs(l1_e[i], l2_e[i])
-        if x:
-            return x
+        ret = compare_exprs(l1_e[i], l2_e[i])
+        if ret:
+            return ret
     return cmp(len(l1_e), len(l2_e))
 
 
 def compare_expr_list(l1_e, l2_e):
     # Sort by list elements in incremental order, then by list size
     for i in xrange(min(len(l1_e), len(l2_e))):
-        x = compare_exprs(l1_e[i], l2_e[i])
-        if x:
-            return x
+        ret = compare_exprs(l1_e[i], l2_e[i])
+        if ret:
+            return ret
     return cmp(len(l1_e), len(l2_e))
 
 
-def compare_exprs(e1, e2):
+def compare_exprs(expr1, expr2):
     """Compare 2 expressions for canonization
-    @e1: Expr
-    @e2: Expr
+    @expr1: Expr
+    @expr2: Expr
     0  => ==
-    1  => e1 > e2
-    -1 => e1 < e2
+    1  => expr1 > expr2
+    -1 => expr1 < expr2
     """
-    c1 = e1.__class__
-    c2 = e2.__class__
-    if c1 != c2:
-        return cmp(expr_order_dict[c1], expr_order_dict[c2])
-    if e1 == e2:
+    cls1 = expr1.__class__
+    cls2 = expr2.__class__
+    if cls1 != cls2:
+        return cmp(EXPR_ORDER_DICT[cls1], EXPR_ORDER_DICT[cls2])
+    if expr1 == expr2:
         return 0
-    if c1 == ExprInt:
-        ret = cmp(e1.size, e2.size)
+    if cls1 == ExprInt:
+        ret = cmp(expr1.size, expr2.size)
         if ret != 0:
             return ret
-        return cmp(e1.arg, e2.arg)
-    elif c1 == ExprId:
-        x = cmp(e1.name, e2.name)
-        if x:
-            return x
-        return cmp(e1.size, e2.size)
-    elif c1 == ExprAff:
+        return cmp(expr1.arg, expr2.arg)
+    elif cls1 == ExprId:
+        ret = cmp(expr1.name, expr2.name)
+        if ret:
+            return ret
+        return cmp(expr1.size, expr2.size)
+    elif cls1 == ExprAff:
         raise NotImplementedError(
             "Comparaison from an ExprAff not yet implemented")
-    elif c2 == ExprCond:
-        x = compare_exprs(e1.cond, e2.cond)
-        if x:
-            return x
-        x = compare_exprs(e1.src1, e2.src1)
-        if x:
-            return x
-        x = compare_exprs(e1.src2, e2.src2)
-        return x
-    elif c1 == ExprMem:
-        x = compare_exprs(e1.arg, e2.arg)
-        if x:
-            return x
-        return cmp(e1.size, e2.size)
-    elif c1 == ExprOp:
-        if e1.op != e2.op:
-            return cmp(e1.op, e2.op)
-        return compare_expr_list(e1.args, e2.args)
-    elif c1 == ExprSlice:
-        x = compare_exprs(e1.arg, e2.arg)
-        if x:
-            return x
-        x = cmp(e1.start, e2.start)
-        if x:
-            return x
-        x = cmp(e1.stop, e2.stop)
-        return x
-    elif c1 == ExprCompose:
-        return compare_expr_list_compose(e1.args, e2.args)
+    elif cls2 == ExprCond:
+        ret = compare_exprs(expr1.cond, expr2.cond)
+        if ret:
+            return ret
+        ret = compare_exprs(expr1.src1, expr2.src1)
+        if ret:
+            return ret
+        ret = compare_exprs(expr1.src2, expr2.src2)
+        return ret
+    elif cls1 == ExprMem:
+        ret = compare_exprs(expr1.arg, expr2.arg)
+        if ret:
+            return ret
+        return cmp(expr1.size, expr2.size)
+    elif cls1 == ExprOp:
+        if expr1.op != expr2.op:
+            return cmp(expr1.op, expr2.op)
+        return compare_expr_list(expr1.args, expr2.args)
+    elif cls1 == ExprSlice:
+        ret = compare_exprs(expr1.arg, expr2.arg)
+        if ret:
+            return ret
+        ret = cmp(expr1.start, expr2.start)
+        if ret:
+            return ret
+        ret = cmp(expr1.stop, expr2.stop)
+        return ret
+    elif cls1 == ExprCompose:
+        return compare_expr_list_compose(expr1.args, expr2.args)
     raise NotImplementedError(
-        "Comparaison between %r %r not implemented" % (e1, e2))
+        "Comparaison between %r %r not implemented" % (expr1, expr2))
 
 
-def canonize_expr_list(l):
-    l = list(l)
-    l.sort(cmp=compare_exprs)
-    return l
+def canonize_expr_list(expr_list):
+    expr_list = list(expr_list)
+    expr_list.sort(cmp=compare_exprs)
+    return expr_list
 
 
-def canonize_expr_list_compose(l):
-    l = list(l)
-    l.sort(cmp=compare_exprs_compose)
-    return l
+def canonize_expr_list_compose(expr_list):
+    expr_list = list(expr_list)
+    expr_list.sort(cmp=compare_exprs_compose)
+    return expr_list
 
 # Generate ExprInt with common size
 
@@ -1323,47 +1316,51 @@ def ExprInt64(i):
     return ExprInt(i, 64)
 
 
-def ExprInt_from(e, i):
+def ExprInt_from(expr, i):
     "Generate ExprInt with size equal to expression"
     warnings.warn('DEPRECATION WARNING: use ExprInt(i, expr.size) instead of'\
                   'ExprInt_from(expr, i))')
-    return ExprInt(i, e.size)
+    return ExprInt(i, expr.size)
 
 
-def get_expr_ids_visit(e, ids):
-    if isinstance(e, ExprId):
-        ids.add(e)
-    return e
+def get_expr_ids_visit(expr, ids):
+    """Visitor to retrieve ExprId in @expr
+    @expr: Expr"""
+    if isinstance(expr, ExprId):
+        ids.add(expr)
+    return expr
 
 
-def get_expr_ids(e):
+def get_expr_ids(expr):
+    """Retrieve ExprId in @expr
+    @expr: Expr"""
     ids = set()
-    e.visit(lambda x: get_expr_ids_visit(x, ids))
+    expr.visit(lambda x: get_expr_ids_visit(x, ids))
     return ids
 
 
-def test_set(e, v, tks, result):
+def test_set(expr, pattern, tks, result):
     """Test if v can correspond to e. If so, update the context in result.
     Otherwise, return False
-    @e : Expr
-    @v : Expr
+    @expr : Expr to match
+    @pattern : pattern Expr
     @tks : list of ExprId, available jokers
     @result : dictionary of ExprId -> Expr, current context
     """
 
-    if not v in tks:
-        return e == v
-    if v in result and result[v] != e:
+    if not pattern in tks:
+        return expr == pattern
+    if pattern in result and result[pattern] != expr:
         return False
-    result[v] = e
+    result[pattern] = expr
     return result
 
 
-def MatchExpr(pattern, expr, tks, result=None):
-    """Try to match the @expr expression with the pattern @pattern with @tks jokers.
+def match_expr(expr, pattern, tks, result=None):
+    """Try to match the @pattern expression with the pattern @expr with @tks jokers.
     Result is output dictionary with matching joker values.
-    @pattern : Expr pattern
-    @expr : Targetted Expr to match
+    @expr : Expr pattern
+    @pattern : Targetted Expr to match
     @tks : list of ExprId, available jokers
     @result : dictionary of ExprId -> Expr, output matching context
     """
@@ -1371,41 +1368,41 @@ def MatchExpr(pattern, expr, tks, result=None):
     if result is None:
         result = {}
 
-    if expr in tks:
-        # expr is a Joker
-        return test_set(pattern, expr, tks, result)
+    if pattern in tks:
+        # pattern is a Joker
+        return test_set(expr, pattern, tks, result)
 
-    if pattern.is_int():
-        return test_set(pattern, expr, tks, result)
+    if expr.is_int():
+        return test_set(expr, pattern, tks, result)
 
-    elif pattern.is_id():
-        return test_set(pattern, expr, tks, result)
+    elif expr.is_id():
+        return test_set(expr, pattern, tks, result)
 
-    elif pattern.is_op():
+    elif expr.is_op():
 
-        # e need to be the same operation than expr
-        if not expr.is_op():
+        # expr need to be the same operation than pattern
+        if not pattern.is_op():
             return False
-        if pattern.op != expr.op:
+        if expr.op != pattern.op:
             return False
-        if len(pattern.args) != len(expr.args):
+        if len(expr.args) != len(pattern.args):
             return False
 
         # Perform permutation only if the current operation is commutative
-        if pattern.is_commutative():
-            permutations = itertools.permutations(pattern.args)
+        if expr.is_commutative():
+            permutations = itertools.permutations(expr.args)
         else:
-            permutations = [pattern.args]
+            permutations = [expr.args]
 
         # For each permutations of arguments
         for permut in permutations:
             good = True
             # We need to use a copy of result to not override it
             myresult = dict(result)
-            for sub_pattern, sub_expr in zip(permut, expr.args):
-                r = MatchExpr(sub_pattern, sub_expr, tks, myresult)
+            for sub_expr, sub_pattern in zip(permut, pattern.args):
+                ret = MatchExpr(sub_expr, sub_pattern, tks, myresult)
                 # If the current permutation do not match EVERY terms
-                if r is False:
+                if ret is False:
                     good = False
                     break
             if good is True:
@@ -1418,105 +1415,116 @@ def MatchExpr(pattern, expr, tks, result=None):
 
     # Recursive tests
 
-    elif pattern.is_mem():
-        if not expr.is_mem():
+    elif expr.is_mem():
+        if not pattern.is_mem():
             return False
-        if pattern.size != expr.size:
+        if expr.size != pattern.size:
             return False
-        return MatchExpr(pattern.arg, expr.arg, tks, result)
+        return MatchExpr(expr.arg, pattern.arg, tks, result)
 
-    elif pattern.is_slice():
-        if not expr.is_slice():
+    elif expr.is_slice():
+        if not pattern.is_slice():
             return False
-        if pattern.start != expr.start or pattern.stop != expr.stop:
+        if expr.start != pattern.start or expr.stop != pattern.stop:
             return False
-        return MatchExpr(pattern.arg, expr.arg, tks, result)
+        return MatchExpr(expr.arg, pattern.arg, tks, result)
 
-    elif pattern.is_cond():
-        if not expr.is_cond():
+    elif expr.is_cond():
+        if not pattern.is_cond():
             return False
-        if MatchExpr(pattern.cond, expr.cond, tks, result) is False:
+        if MatchExpr(expr.cond, pattern.cond, tks, result) is False:
             return False
-        if MatchExpr(pattern.src1, expr.src1, tks, result) is False:
+        if MatchExpr(expr.src1, pattern.src1, tks, result) is False:
             return False
-        if MatchExpr(pattern.src2, expr.src2, tks, result) is False:
+        if MatchExpr(expr.src2, pattern.src2, tks, result) is False:
             return False
         return result
 
-    elif pattern.is_compose():
-        if not expr.is_compose():
+    elif expr.is_compose():
+        if not pattern.is_compose():
             return False
-        for sub_pattern, sub_expr in zip(pattern.args, expr.args):
-            if  MatchExpr(sub_pattern, sub_expr, tks, result) is False:
+        for sub_expr, sub_pattern in zip(expr.args, pattern.args):
+            if  MatchExpr(sub_expr, sub_pattern, tks, result) is False:
                 return False
         return result
 
-    elif pattern.is_aff():
-        if not expr.is_aff():
+    elif expr.is_aff():
+        if not pattern.is_aff():
             return False
-        if MatchExpr(pattern.src, expr.src, tks, result) is False:
+        if MatchExpr(expr.src, pattern.src, tks, result) is False:
             return False
-        if MatchExpr(pattern.dst, expr.dst, tks, result) is False:
+        if MatchExpr(expr.dst, pattern.dst, tks, result) is False:
             return False
         return result
 
     else:
-        raise NotImplementedError("MatchExpr: Unknown type: %s" % type(pattern))
+        raise NotImplementedError("MatchExpr: Unknown type: %s" % type(expr))
+
+
+def MatchExpr(expr, pattern, tks, result=None):
+    warnings.warn('DEPRECATION WARNING: use match_expr instead of MatchExpr')
+    return match_expr(expr, pattern, tks, result)
 
 
 def get_rw(exprs):
     o_r = set()
     o_w = set()
-    for e in exprs:
-        o_r.update(e.get_r(mem_read=True))
-    for e in exprs:
-        o_w.update(e.get_w())
+    for expr in exprs:
+        o_r.update(expr.get_r(mem_read=True))
+    for expr in exprs:
+        o_w.update(expr.get_w())
     return o_r, o_w
 
 
 def get_list_rw(exprs, mem_read=False, cst_read=True):
-    """
-    return list of read/write reg/cst/mem for each expressions
+    """Return list of read/write reg/cst/mem for each @exprs
+    @exprs: list of expressions
+    @mem_read: walk though memory accesses
+    @cst_read: retrieve constants
     """
     list_rw = []
     # cst_num = 0
-    for e in exprs:
+    for expr in exprs:
         o_r = set()
         o_w = set()
         # get r/w
-        o_r.update(e.get_r(mem_read=mem_read, cst_read=cst_read))
-        if isinstance(e.dst, ExprMem):
-            o_r.update(e.dst.arg.get_r(mem_read=mem_read, cst_read=cst_read))
-        o_w.update(e.get_w())
+        o_r.update(expr.get_r(mem_read=mem_read, cst_read=cst_read))
+        if isinstance(expr.dst, ExprMem):
+            o_r.update(expr.dst.arg.get_r(mem_read=mem_read, cst_read=cst_read))
+        o_w.update(expr.get_w())
         # each cst is indexed
         o_r_rw = set()
-        for r in o_r:
-            o_r_rw.add(r)
+        for read in o_r:
+            o_r_rw.add(read)
         o_r = o_r_rw
         list_rw.append((o_r, o_w))
 
     return list_rw
 
 
-def get_expr_ops(e):
-    def visit_getops(e, out=None):
+def get_expr_ops(expr):
+    """Retrieve operators of an @expr
+    @expr: Expr"""
+    def visit_getops(expr, out=None):
         if out is None:
             out = set()
-        if isinstance(e, ExprOp):
-            out.add(e.op)
-        return e
+        if isinstance(expr, ExprOp):
+            out.add(expr.op)
+        return expr
     ops = set()
-    e.visit(lambda x: visit_getops(x, ops))
+    expr.visit(lambda x: visit_getops(x, ops))
     return ops
 
 
-def get_expr_mem(e):
-    def visit_getmem(e, out=None):
+def get_expr_mem(expr):
+    """Retrieve memory accesses of an @expr
+    @expr: Expr"""
+    def visit_getmem(expr, out=None):
         if out is None:
             out = set()
-        if isinstance(e, ExprMem):
-            out.add(e)
-        return e
+        if isinstance(expr, ExprMem):
+            out.add(expr)
+        return expr
     ops = set()
-    e.visit(lambda x: visit_getmem(x, ops))
+    expr.visit(lambda x: visit_getmem(x, ops))
     return ops