miasm2.expression.expression_helper.Variables_Identifier Class Reference

Inheritance diagram for miasm2.expression.expression_helper.Variables_Identifier:

Collaboration diagram for miasm2.expression.expression_helper.Variables_Identifier:

Public Member Functions
def	__init__
def	is_var_identifier
def	find_variables_rec
def	vars
def	equation
def	__str__

Public Attributes
	var_indice
	var_asked
	var_prefix

Static Public Attributes
string	is_var_ident = "is_var_ident"

Private Attributes
	_vars
	_equation
	_vars_ordered

Detailed Description

Identify variables in an expression.
Returns:
- variables with their corresponding values
- original expression with variables translated

Definition at line 206 of file expression_helper.py.

Constructor & Destructor Documentation

def miasm2.expression.expression_helper.Variables_Identifier.__init__	(		self,
			expr,
			var_prefix = "v"
	)

Set the expression @expr to handle and launch variable identification
process
@expr: Expr instance
@var_prefix: (optional) prefix of the variable name, default is 'v'

Definition at line 216 of file expression_helper.py.

    def __init__(self, expr, var_prefix="v"):
        """Set the expression @expr to handle and launch variable identification
        process
        @expr: Expr instance
        @var_prefix: (optional) prefix of the variable name, default is 'v'"""

        # Init
        self.var_indice = itertools.count()
        self.var_asked = set()
        self._vars = {} # VarID -> Expr
        self.var_prefix = var_prefix

        # Launch recurrence
        self.find_variables_rec(expr)

        # Compute inter-variable dependencies
        has_change = True
        while has_change:
            has_change = False
            for var_id, var_value in self._vars.iteritems():
                cur = var_value

                # Do not replace with itself
                to_replace = {v_val:v_id
                              for v_id, v_val in self._vars.iteritems()
                              if v_id != var_id}
                var_value = var_value.replace_expr(to_replace)

                if cur != var_value:
                    # Force @self._vars update
                    has_change = True
                    self._vars[var_id] = var_value
                    break

        # Replace in the original equation
        self._equation = expr.replace_expr({v_val: v_id for v_id, v_val
                                            in self._vars.iteritems()})

        # Compute variables dependencies
        self._vars_ordered = collections.OrderedDict()
        todo = set(self._vars.iterkeys())
        needs = {}

        ## Build initial needs
        for var_id, var_expr in self._vars.iteritems():
            ### Handle corner cases while using Variable Identifier on an
            ### already computed equation
            needs[var_id] = [var_name
                             for var_name in var_expr.get_r(mem_read=True)
                             if self.is_var_identifier(var_name) and \
                                 var_name in todo and \
                                 var_name != var_id]

        ## Build order list
        while todo:
            done = set()
            for var_id in todo:
                all_met = True
                for need in needs[var_id]:
                    if need not in self._vars_ordered:
                        # A dependency is not met
                        all_met = False
                        break
                if not all_met:
                    continue

                # All dependencies are already met, add current
                self._vars_ordered[var_id] = self._vars[var_id]
                done.add(var_id)

            # Update the todo list
            for element_done in done:
                todo.remove(element_done)