picurv_cli.source_expressions._LogicalRewriter Class Reference

Rewrite logical operators and chained comparisons into array operations. More...

Inheritance diagram for picurv_cli.source_expressions._LogicalRewriter:

Collaboration diagram for picurv_cli.source_expressions._LogicalRewriter:

Public Member Functions
	visit_Call (self, node)
	Rewrite sum(k, lo, hi, body) as a loop over lambda k: body.
	visit_BoolOp (self, node)
	Fold a and b and c into nested logical calls.
	visit_UnaryOp (self, node)
	Rewrite not a as logical_not(a).
	visit_Compare (self, node)
	Rewrite a < b < c as logical_and(a < b, b < c).

Static Protected Member Functions
	_call (name, args)
	Build a call to one of the evaluation-only logical helpers.

Detailed Description

Rewrite logical operators and chained comparisons into array operations.

and, or, not and a chain a < b < c have no elementwise meaning for arrays, so they become logical_and, logical_or, logical_not calls, the same 1-or-0 semantics the runtime evaluator gives them.

Definition at line 197 of file source_expressions.py.

Member Function Documentation

_call()

picurv_cli.source_expressions._LogicalRewriter._call (   name,   args  )

staticprotected

Build a call to one of the evaluation-only logical helpers.

Parameters

[in]	name	Helper name.
[in]	args	Argument nodes.

Returns

Call node.

Definition at line 206 of file source_expressions.py.

    def _call(name, args):
        """!
        @brief Build a call to one of the evaluation-only logical helpers.
        @param[in] name Helper name.
        @param[in] args Argument nodes.
        @return Call node.
        """
        return ast.Call(func=ast.Name(id=name, ctx=ast.Load()), args=list(args), keywords=[])
 

Here is the caller graph for this function:

visit_Call()

picurv_cli.source_expressions._LogicalRewriter.visit_Call	(		self,
			node
	)

Rewrite sum(k, lo, hi, body) as a loop over lambda k: body.

Parameters

[in]

node

Call node.

Returns

Rewritten node.

Definition at line 215 of file source_expressions.py.

    def visit_Call(self, node):
        """!
        @brief Rewrite `sum(k, lo, hi, body)` as a loop over `lambda k: body`.
        @param[in] node Call node.
        @return Rewritten node.
        """
        self.generic_visit(node)
        if not (isinstance(node.func, ast.Name) and node.func.id == "sum"):
            return node
        index, lower, upper, body = node.args
        loop = ast.Lambda(args=ast.arguments(posonlyargs=[], args=[ast.arg(arg=index.id)], vararg=None,
                                             kwonlyargs=[], kw_defaults=[], kwarg=None, defaults=[]),
                          body=body)
        return self._call("series", [loop, lower, upper])
 

Here is the call graph for this function:

visit_BoolOp()

picurv_cli.source_expressions._LogicalRewriter.visit_BoolOp	(		self,
			node
	)

Fold a and b and c into nested logical calls.

Parameters

[in]

node

BoolOp node.

Returns

Rewritten node.

Definition at line 230 of file source_expressions.py.

    def visit_BoolOp(self, node):
        """!
        @brief Fold `a and b and c` into nested logical calls.
        @param[in] node BoolOp node.
        @return Rewritten node.
        """
        self.generic_visit(node)
        name = "logical_and" if isinstance(node.op, ast.And) else "logical_or"
        result = node.values[0]
        for value in node.values[1:]:
            result = self._call(name, [result, value])
        return result
 

Here is the call graph for this function:

visit_UnaryOp()

picurv_cli.source_expressions._LogicalRewriter.visit_UnaryOp	(		self,
			node
	)

Rewrite not a as logical_not(a).

Parameters

[in]

node

UnaryOp node.

Returns

Rewritten node.

Definition at line 243 of file source_expressions.py.

    def visit_UnaryOp(self, node):
        """!
        @brief Rewrite `not a` as `logical_not(a)`.
        @param[in] node UnaryOp node.
        @return Rewritten node.
        """
        self.generic_visit(node)
        if isinstance(node.op, ast.Not):
            return self._call("logical_not", [node.operand])
        return node
 

Here is the call graph for this function:

visit_Compare()

picurv_cli.source_expressions._LogicalRewriter.visit_Compare	(		self,
			node
	)

Rewrite a < b < c as logical_and(a < b, b < c).

Parameters

[in]

node

Compare node.

Returns

Rewritten node.

Definition at line 254 of file source_expressions.py.

    def visit_Compare(self, node):
        """!
        @brief Rewrite `a < b < c` as `logical_and(a < b, b < c)`.
        @param[in] node Compare node.
        @return Rewritten node.
        """
        self.generic_visit(node)
        if len(node.ops) == 1:
            return node
        operands = [node.left] + node.comparators
        pairs = [ast.Compare(left=copy.deepcopy(operands[i]), ops=[op], comparators=[copy.deepcopy(operands[i + 1])])
                 for i, op in enumerate(node.ops)]
        result = pairs[0]
        for pair in pairs[1:]:
            result = self._call("logical_and", [result, pair])
        return result
 
 

Here is the call graph for this function:

---

The documentation for this class was generated from the following file:

• source_expressions.py