コード例 #1
0
ファイル: compiler.py プロジェクト: Quickblink/donat
def preprocess_boolean(expr, inv):
    if type(expr) is ast.BoolOp:
        if type(expr.op) is ast.And or type(expr.op) is ast.Or:
            new_vs = []
            pos_child = None
            for v in expr.values:
                nv, is_inv = preprocess_boolean(v, inv)
                new_vs.append(nv)
                pos_child = pos_child if is_inv else nv
            pos_child = pos_child or new_vs[0]
            if (type(expr.op) is ast.And and inv) or (type(expr.op) is ast.Or
                                                      and not inv):
                return ast.BoolOp(ast.Or(), new_vs), False
            new_vs.remove(pos_child)
            new_vs2 = []
            for v in new_vs:
                nv, _ = preprocess_boolean(v, True)
                new_vs2.append(nv)
            expr = ast.BoolOp(ast.And(), new_vs2)
            expr.pos_child = pos_child
            return expr, False
        else:
            raise Babeception(
                str(type(expr.op)) + ' is not supported in boolean!')
    elif type(expr) is ast.UnaryOp:
        if type(expr.op) is ast.Not:
            return preprocess_boolean(expr.operand,
                                      False) if inv else preprocess_boolean(
                                          expr.operand, True)
        else:
            raise Babeception(
                str(type(expr.op)) + ' is not supported in boolean!')
    elif type(expr) is ast.Compare:
        if type(expr.ops[0]) is ast.NotEq or type(
                expr.ops[0]) is ast.Lt or type(expr.ops[0]) is ast.Gt:
            return preprocess_child(expr, inv)
        elif type(expr.ops[0]) is ast.Eq:
            return preprocess_boolean(
                ast.UnaryOp(
                    ast.Not(),
                    ast.Compare(expr.left, [ast.NotEq()], expr.comparators)),
                inv)
        elif type(expr.ops[0]) is ast.LtE:
            return preprocess_boolean(
                ast.UnaryOp(
                    ast.Not(),
                    ast.Compare(expr.left, [ast.Gt()], expr.comparators)), inv)
        elif type(expr.ops[0]) is ast.GtE:
            return preprocess_boolean(
                ast.UnaryOp(
                    ast.Not(),
                    ast.Compare(expr.left, [ast.Lt()], expr.comparators)), inv)
        else:
            raise Babeception(
                str(type(expr.ops[0])) + ' is not supported in boolean!')
    elif type(expr) is ast.Call or type(expr) is ast.Name:
        return preprocess_child(expr, inv)
    else:
        raise Babeception(str(type(expr)) + ' is not supported in boolean!')
コード例 #2
0
ファイル: test_source_emission.py プロジェクト: moreati/mnfy
 def test_UnaryOp(self):
     self.verify(ast.UnaryOp(ast.Invert(), ast.Num(42)), '~42')
     self.verify(ast.UnaryOp(ast.Not(), ast.Num(42)), 'not 42')
     self.verify(ast.UnaryOp(ast.UAdd(), ast.Num(42)), '+42')
     self.verify(ast.UnaryOp(ast.USub(), ast.Num(42)), '-42')
     precedence = ast.UnaryOp(
         ast.Not(), ast.BoolOp(ast.Or(),
                               [ast.Num(n=1), ast.Num(2)]))
     self.verify(precedence, 'not (1 or 2)')
コード例 #3
0
 def flatten(self, body, breakJump=None):
     """
     :type body: list[ast.AST]
     :param breakJump: if we find some ast.Break in a while-loop, add this jump
     :rtype: list[ast.AST]
     """
     r = []
     for s in body:
         if isinstance(s, ast.If):
             a = ast.UnaryOp()
             a.op = ast.Not()
             a.operand = s.test
             goto_final_stmnt = self.make_jump()
             if s.orelse:
                 goto_orelse_stmnt = self.make_jump()
                 r += [ast.If(test=a, body=[goto_orelse_stmnt], orelse=[])]
             else:
                 goto_orelse_stmnt = None
                 r += [ast.If(test=a, body=[goto_final_stmnt], orelse=[])]
             r += self.flatten(s.body, breakJump=breakJump)
             if s.orelse:
                 r += [goto_final_stmnt]
                 r += [GotoLabel(goto_orelse_stmnt.label)]
                 r += self.flatten(s.orelse, breakJump=breakJump)
             r += [GotoLabel(goto_final_stmnt.label)]
         elif isinstance(s, ast.While):
             if s.orelse: raise NotImplementedError
             goto_repeat_stmnt = self.make_jump()
             r += [GotoLabel(goto_repeat_stmnt.label)]
             a = ast.UnaryOp()
             a.op = ast.Not()
             a.operand = s.test
             goto_final_stmnt = self.make_jump()
             r += [ast.If(test=a, body=[goto_final_stmnt], orelse=[])]
             r += self.flatten(s.body, breakJump=goto_final_stmnt)
             r += [goto_repeat_stmnt]
             r += [GotoLabel(goto_final_stmnt.label)]
         elif isinstance(s, ast.For):
             raise NotImplementedError
         elif isinstance(s, (ast.TryExcept,
                             ast.TryFinally) if PY2 else ast.Try):
             raise NotImplementedError
         elif isinstance(s, ast.Break):
             assert breakJump, "found break in unexpected scope"
             r += [breakJump]
         else:
             r += [s]
     return r
コード例 #4
0
def invert(node):

    inverse = {
        ast.Eq: ast.NotEq,
        ast.NotEq: ast.Eq,
        ast.Lt: ast.GtE,
        ast.LtE: ast.Gt,
        ast.Gt: ast.LtE,
        ast.GtE: ast.Lt,
        ast.Is: ast.IsNot,
        ast.IsNot: ast.Is,
        ast.In: ast.NotIn,
        ast.NotIn: ast.In
    }

    if type(node) == ast.Compare:
        op = type(node.ops[0])
        inverse_node = ast.Compare(left=node.left,
                                   ops=[inverse[op]()],
                                   comparators=node.comparators)
    elif type(node) == ast.NameConstant and node.value in [True, False]:
        inverse_node = ast.NameConstant(value=not node.value)
    else:
        inverse_node = ast.UnaryOp(op=ast.Not(), operand=node)

    return inverse_node
コード例 #5
0
    def pre_If(self):
        if hasattr(self.cur_node, 'custom_id') \
                and self.cur_node.custom_id == self.target \
                and SplitAndConditional.is_applicable(self.cur_node):
            self.applied = True
            parent_list = self.parent
            and_left = self.cur_node.test.values[0]
            and_right = self.cur_node.test.values[1]
            body_list = self.cur_node.body
            orelse_list = self.cur_node.orelse

            new_upper_if = ast.If()
            new_lower_if = ast.If()
            new_else_if = ast.If()

            new_upper_if.test = and_left
            new_upper_if.body = [new_lower_if]
            new_upper_if.orelse = []

            new_lower_if.test = and_right
            new_lower_if.body = body_list
            new_lower_if.orelse = []

            if len(orelse_list) > 0:
                new_else_if.test = ast.UnaryOp(ast.Not(), self.cur_node.test)
                new_else_if.body = orelse_list
                new_else_if.orelse = []
                index = parent_list.index(self.cur_node)
                parent_list[index:index + 1] = [new_upper_if, new_else_if]
            else:
                self.replace(new_upper_if)
コード例 #6
0
def __parseRuleNode(node):
    tag = node.tagName
    if tag == 'Or':
        return __parseBoolOp(node, ast.Or())
    elif tag == 'And':
        return __parseBoolOp(node, ast.And())
    elif tag == 'Not':
        expr = __parseBoolOp(node, ast.Or())
        return ast.UnaryOp(ast.Not(), expr) if expr else None
    elif tag == 'All':
        return ast.Name('True', ast.Load())
    elif tag == 'Category':
        category = _get_node_text(node)
        return ast.Compare(left=ast.Str(category),
                           ops=[ast.In()],
                           comparators=[
                               ast.Attribute(value=ast.Name(id='menuentry',
                                                            ctx=ast.Load()),
                                             attr='Categories',
                                             ctx=ast.Load())
                           ])
    elif tag == 'Filename':
        filename = _get_node_text(node)
        return ast.Compare(left=ast.Str(filename),
                           ops=[ast.Eq()],
                           comparators=[
                               ast.Attribute(value=ast.Name(id='menuentry',
                                                            ctx=ast.Load()),
                                             attr='DesktopFileID',
                                             ctx=ast.Load())
                           ])
コード例 #7
0
 def to_node(self):
     value = self.value
     operator = self.operator
     if operator == 'not':
         return ast.UnaryOp(ast.Not(), value.to_node())
     else:
         return value.to_node()
コード例 #8
0
    def visit_Assert(self, assert_):
        """Return the AST statements to replace the ast.Assert instance.

        This rewrites the test of an assertion to provide
        intermediate values and replace it with an if statement which
        raises an assertion error with a detailed explanation in case
        the expression is false.

        """
        if isinstance(assert_.test, ast.Tuple) and len(assert_.test.elts) >= 1:
            from _pytest.warning_types import PytestWarning
            import warnings

            warnings.warn_explicit(
                PytestWarning(
                    "assertion is always true, perhaps remove parentheses?"),
                category=None,
                filename=str(self.module_path),
                lineno=assert_.lineno,
            )

        self.statements = []
        self.variables = []
        self.variable_counter = itertools.count()
        self.stack = []
        self.on_failure = []
        self.push_format_context()
        # Rewrite assert into a bunch of statements.
        top_condition, explanation = self.visit(assert_.test)
        # Create failure message.
        body = self.on_failure
        negation = ast.UnaryOp(ast.Not(), top_condition)
        self.statements.append(ast.If(negation, body, []))
        if assert_.msg:
            assertmsg = self.helper("format_assertmsg", assert_.msg)
            explanation = "\n>assert " + explanation
        else:
            assertmsg = ast.Str("")
            explanation = "assert " + explanation
        template = ast.BinOp(assertmsg, ast.Add(), ast.Str(explanation))
        msg = self.pop_format_context(template)
        fmt = self.helper("format_explanation", msg)
        err_name = ast.Name("AssertionError", ast.Load())
        exc = ast_Call(err_name, [fmt], [])
        if sys.version_info[0] >= 3:
            raise_ = ast.Raise(exc, None)
        else:
            raise_ = ast.Raise(exc, None, None)
        body.append(raise_)
        # Clear temporary variables by setting them to None.
        if self.variables:
            variables = [
                ast.Name(name, ast.Store()) for name in self.variables
            ]
            clear = ast.Assign(variables, _NameConstant(None))
            self.statements.append(clear)
        # Fix line numbers.
        for stmt in self.statements:
            set_location(stmt, assert_.lineno, assert_.col_offset)
        return self.statements
コード例 #9
0
ファイル: flatten.py プロジェクト: zhangwen0411/kappa-public
    def visit_BoolOp(self, boolop: ast.BoolOp) -> VisitExprReturnT:
        """
        Due to short-circuiting, desugars boolop into nested if-statements before being flattened.

        For example, this expression::

            x = v1 and v2 and v3

        gets desugared into::

            x = v1
            if x:            # if_test (`x` for `and`, `not x` for `or`)
                x = v2
                if x:
                    x = v3

        This statement block then gets flattened.  The strategy is similar for the `or` operation.
        """
        result_id = self.next_symbol_id()
        result_node = load(result_id)

        if_test: ast.expr
        if isinstance(boolop.op, ast.And):
            if_test = result_node
        elif isinstance(boolop.op, ast.Or):
            if_test = ast.UnaryOp(op=ast.Not(), operand=result_node)
        else:
            assert False, f"BoolOp operation not recognized: {boolop}"

        body: List[ast.stmt] = [assign(result_id, boolop.values[-1])]
        for value in reversed(boolop.values[:-1]):  # Iteratively wrap body in if-statements.
            body = [ast.If(test=if_test, body=body, orelse=[])]
            body.insert(0, assign(result_id, value))

        return load(result_id), self.visit_stmt_list(body)
コード例 #10
0
    def test_visit_UnaryOp(self, get_logger_mock):
        node = MagicMock()
        node.operand = "operand"
        node.op = ast.Not()

        analyzer = ExpressionAnalyzer()
        self.assertIsNone(analyzer.visit_UnaryOp(node))
        self.assertEqual(analyzer.parts, ["not", " ", "operand"])

        node.op = ast.Invert()
        analyzer = ExpressionAnalyzer()
        self.assertIsNone(analyzer.visit_UnaryOp(node))
        self.assertEqual(analyzer.parts, ["~", "operand"])

        node.op = ast.UAdd()
        analyzer = ExpressionAnalyzer()
        self.assertIsNone(analyzer.visit_UnaryOp(node))
        self.assertEqual(analyzer.parts, ["+", "operand"])

        node.op = ast.USub()
        analyzer = ExpressionAnalyzer()
        self.assertIsNone(analyzer.visit_UnaryOp(node))
        self.assertEqual(analyzer.parts, ["-", "operand"])

        node.op = ast.Import()
        analyzer = ExpressionAnalyzer()
        self.assertIsNone(analyzer.visit_UnaryOp(node))
        self.assertEqual(analyzer.parts, ["...", "operand"])
        get_logger_mock().warning.assert_called_once_with(ANY)
コード例 #11
0
ファイル: prepass.py プロジェクト: kcolford/py2js
    def visit_BinOp(self, node):
        if isinstance(node.op, ast.NotIn):
            return ast.copy_location(
                ast.UnaryOp(ast.Not(),
                            ast.BinOp(node.left, ast.In(), node.right)), node)

        return node
コード例 #12
0
ファイル: MuOperators.py プロジェクト: sainimma/muupi
    def mutate(cls, node):
        if node not in config.visited_nodes:
            if config.parent_dict[node].__class__ in [
                    ast.If, ast.While, ast.IfExp, ast.Assert
            ]:
                if node.__class__ is ast.UnaryOp:
                    config.mutated = True
                    original_node = deepcopy(node)
                    parent = config.parent_dict[node]
                    del config.parent_dict[node]
                    node = node.operand
                    config.parent_dict[node] = parent
                    config.node_pairs[node] = original_node
                    config.current_mutated_node = node

                elif node.__class__ is ast.BoolOp:
                    config.mutated = True
                    original_node = deepcopy(node)
                    parent = config.parent_dict[node]
                    del config.parent_dict[node]
                    unary_op_node = ast.UnaryOp()
                    unary_op_node.op = ast.Not()
                    unary_op_node.operand = node
                    node = unary_op_node
                    config.parent_dict[node] = parent
                    config.node_pairs[node] = original_node
                    config.current_mutated_node = node

        return node
コード例 #13
0
 def create_logical_factor_node(self, logical_factor):
     if logical_factor.sign in ['!', 'not']:
         return ast.UnaryOp(ast.Not(), self.to_node(logical_factor.operand))
     elif logical_factor.sign is None:
         return self.to_node(logical_factor.operand)
     else:
         raise
コード例 #14
0
ファイル: astutils.py プロジェクト: gibchikafa/dace
def negate_expr(node):
    """ Negates an AST expression by adding a `Not` AST node in front of it. 
    """

    # Negation support for SymPy expressions
    if isinstance(node, sympy.Basic):
        return sympy.Not(node)
    # Support for numerical constants
    if isinstance(node, numbers.Number):
        return str(not node)
    # Negation support for strings (most likely dace.Data.Scalar names)
    if isinstance(node, str):
        return "not ({})".format(node)

    from dace.properties import CodeBlock  # Avoid import loop
    if isinstance(node, CodeBlock):
        node = node.code
    if hasattr(node, "__len__"):
        if len(node) > 1:
            raise ValueError("negate_expr only expects "
                             "single expressions, got: {}".format(node))
        expr = node[0]
    else:
        expr = node
    if isinstance(expr, ast.Expr):
        expr = expr.value

    newexpr = ast.Expr(value=ast.UnaryOp(op=ast.Not(), operand=expr))
    newexpr = ast.copy_location(newexpr, expr)
    return ast.fix_missing_locations(newexpr)
コード例 #15
0
 def visit_BoolOp(self, boolop):
     res_var = self.variable()
     expl_list = self.assign(ast.List([], ast.Load()))
     app = ast.Attribute(expl_list, "append", ast.Load())
     is_or = int(isinstance(boolop.op, ast.Or))
     body = save = self.statements
     fail_save = self.on_failure
     levels = len(boolop.values) - 1
     self.push_format_context()
     # Process each operand, short-circuting if needed.
     for i, v in enumerate(boolop.values):
         if i:
             fail_inner = []
             # cond is set in a prior loop iteration below
             self.on_failure.append(ast.If(cond, fail_inner, []))  # noqa
             self.on_failure = fail_inner
         self.push_format_context()
         res, expl = self.visit(v)
         body.append(ast.Assign([ast.Name(res_var, ast.Store())], res))
         expl_format = self.pop_format_context(ast.Str(expl))
         call = ast_Call(app, [expl_format], [])
         self.on_failure.append(ast.Expr(call))
         if i < levels:
             cond = res
             if is_or:
                 cond = ast.UnaryOp(ast.Not(), cond)
             inner = []
             self.statements.append(ast.If(cond, inner, []))
             self.statements = body = inner
     self.statements = save
     self.on_failure = fail_save
     expl_template = self.helper("format_boolop", expl_list, ast.Num(is_or))
     expl = self.pop_format_context(expl_template)
     return ast.Name(res_var, ast.Load()), self.explanation_param(expl)
コード例 #16
0
def invert(node):
    """
    Invert the operation in an ast node object (get its negation).

    Args:
        node: An ast node object.

    Returns:
        An ast node object containing the inverse (negation) of the input node.
    """
    inverse = {ast.Eq: ast.NotEq,
               ast.NotEq: ast.Eq,
               ast.Lt: ast.GtE,
               ast.LtE: ast.Gt,
               ast.Gt: ast.LtE,
               ast.GtE: ast.Lt,
               ast.Is: ast.IsNot,
               ast.IsNot: ast.Is,
               ast.In: ast.NotIn,
               ast.NotIn: ast.In}

    if type(node) == ast.Compare:
        op = type(node.ops[0])
        inverse_node = ast.Compare(left=node.left, ops=[inverse[op]()],
                                   comparators=node.comparators)
    elif type(node) == ast.NameConstant and node.value in [True, False]:
        inverse_node = ast.NameConstant(value=not node.value)
    else:
        inverse_node = ast.UnaryOp(op=ast.Not(), operand=node)

    return inverse_node
コード例 #17
0
ファイル: cfg_generator.py プロジェクト: hexie1996/653project
def invert(
        node):  # to get the opposite condition so that we can get the exitcase
    inverse = {
        ast.Eq: ast.NotEq,
        ast.NotEq: ast.Eq,
        ast.Lt: ast.GtE,
        ast.LtE: ast.Gt,
        ast.Gt: ast.LtE,
        ast.GtE: ast.Lt,
        ast.Is: ast.IsNot,
        ast.IsNot: ast.Is,
        ast.In: ast.NotIn,
        ast.NotIn: ast.In
    }
    if type(node) == ast.Compare:
        op = type(node.ops[0])
        inverse_node = ast.Compare(left=node.left,
                                   ops=[inverse[op]()],
                                   comparators=node.comparators)
    elif type(node) == ast.BinOp and type(node.op) in inverse:
        op = type(node.op)
        inverse_node = ast.BinOp(node.left, inverse[op](), node.right)
    elif type(node) == ast.NameConstant and node.value in [True, False]:
        inverse_node = ast.NameConstant(value=not node.value)
    else:
        inverse_node = ast.UnaryOp(op=ast.Not(), operand=node)

    return inverse_node
コード例 #18
0
 def parse_rule_node(self, node):
     tag = node.tag
     if tag == 'Or':
         return self.parse_bool_op(node, ast.Or())
     elif tag == 'And':
         return self.parse_bool_op(node, ast.And())
     elif tag == 'Not':
         expr = self.parse_bool_op(node, ast.Or())
         return ast.UnaryOp(ast.Not(), expr) if expr else None
     elif tag == 'All':
         return _ast_const('True')
     elif tag == 'Category':
         category = node.text
         return ast.Compare(left=ast.Str(category),
                            ops=[ast.In()],
                            comparators=[
                                ast.Attribute(value=ast.Name(
                                    id='menuentry', ctx=ast.Load()),
                                              attr='Categories',
                                              ctx=ast.Load())
                            ])
     elif tag == 'Filename':
         filename = node.text
         return ast.Compare(left=ast.Str(filename),
                            ops=[ast.Eq()],
                            comparators=[
                                ast.Attribute(value=ast.Name(
                                    id='menuentry', ctx=ast.Load()),
                                              attr='DesktopFileID',
                                              ctx=ast.Load())
                            ])
コード例 #19
0
def invert_ast_node(node):
    if type(node) == ast.UnaryOp:
        return node.operand
    else:
        new_node = ast.UnaryOp()
        new_node.op = ast.Not()
        new_node.operand = node
        return new_node
コード例 #20
0
 def visit_UnaryOp(self, unaryop_node):
     if isinstance(unaryop_node.op, ast.Not):
         format_string = "Asserted not {} but found it to be truthy"
         name = '@contexts_assertion_var'
         statements = [self.assign(name, unaryop_node.operand)]
         msg = self.format(format_string, [self.repr(self.load(name))])
         statements.append(ast.Assert(ast.UnaryOp(ast.Not(), self.load(name)), msg))
         return statements
コード例 #21
0
    def pre_If(self):
        if hasattr(self.cur_node, 'custom_id') \
                and self.cur_node.custom_id == self.target \
                and MergeNestedIfStatement.is_applicable(self.cur_node):
            self.applied = True
            parent_list = self.parent
            cur_index = self.parent.index(self.cur_node)

            first_if = self.cur_node
            first_test = first_if.test
            first_body = first_if.body
            first_else = first_if.orelse

            second_if = [
                node for node in first_body if isinstance(node, ast.If)
            ][0]
            second_index = first_body.index(second_if)
            second_test = second_if.test
            second_body = second_if.body
            second_else = second_if.orelse
            results = list()

            if first_body[:second_index]:
                results.append(
                    ast.If(first_test, first_body[:second_index], []))

            if second_body:
                a_and_b = ast.BoolOp(ast.And(), [first_test, second_test])
                if_a_and_b = ast.If(a_and_b, second_body, [])
                results.append(if_a_and_b)
                if second_else:
                    a_and_not_b = ast.BoolOp(
                        ast.And(),
                        [first_test,
                         ast.UnaryOp(ast.Not(), second_test)])
                    if_a_and_not_b = ast.If(a_and_not_b, second_else, [])
                    if_a_and_b.orelse = [if_a_and_not_b]
            if first_body[second_index + 1:]:
                results.append(
                    ast.If(first_test, first_body[second_index + 1:],
                           first_else))
            elif first_else:
                results.append(
                    ast.If(ast.UnaryOp(ast.Not(), first_test), first_else, []))
            self.parent[cur_index:cur_index + 1] = results
コード例 #22
0
    def mutate(self, node, _):
        """
        Add the 'not' keyword.

        Note: this will negate the entire if condition.
        """
        if hasattr(node, 'test'):
            node.test = ast.UnaryOp(op=ast.Not(), operand=node.test)
            return node
コード例 #23
0
 def UnaryopInvert(self, node: Type[ast.AST]) -> Type[ast.AST]:
     if type(node.op) == ast.UAdd:
         return ast.UnaryOp(op=ast.USub(), operand=node.operand)
     elif type(node.op) == ast.USub:
         return ast.UnaryOp(op=ast.UAdd(), operand=node.operand)
     elif type(node.op) == ast.Invert:
         return ast.UnaryOp(op=ast.Not(), operand=node)
     else:
         return node.operand
コード例 #24
0
def unary_action(s, loc, tokens):
    op_char, operand = tokens[0], tokens[1]
    if op_char == '+':
        return operand
    elif op_char == '-':
        return ast.UnaryOp(op=ast.USub(), operand=operand)
    elif op_char == '~':
        return ast.UnaryOp(op=ast.Invert(), operand=operand)
    else:  # not
        return ast.UnaryOp(op=ast.Not(), operand=operand)
コード例 #25
0
 def visit_UnaryOper(self, node: UnaryOper, *args, **kwargs) -> C.unaryop:
     if node == UnaryOper.Invert:
         return C.Invert
     elif node == UnaryOper.Not:
         return C.Not()
     elif node == UnaryOper.UAdd:
         return C.UAdd
     elif node == UnaryOper.USub:
         return C.USub
     else:
         raise Exception(f'unknown UnaryOper {node!r}')
コード例 #26
0
 def CmpOp_NotIn(self, left, comparator):
     self.visit(
         ast.UnaryOp(
             ast.Not(),
             ast.Compare(
                 left,
                 [ast.In()],
                 [comparator]
             )
         )
     )
コード例 #27
0
ファイル: guard_collectors.py プロジェクト: zeta1999/nagini
 def visit_IfExp(self, node: ast.IfExp) -> None:
     """Add ``If`` condition to guard."""
     # Visit then branch.
     self.current_guard.append(node.test)
     self.visit(node.body)
     self.current_guard.pop()
     # Visit else branch.
     condition = ast.UnaryOp(ast.Not(), node.test)
     self.current_guard.append(condition)
     self.visit(node.orelse)
     self.current_guard.pop()
コード例 #28
0
ファイル: expression.py プロジェクト: AndrewChuma/hw1
def not_expr(s: Scanner) -> ast.expr:
    if s.accept(TokenType.NOT):
        return ast.UnaryOp(ast.Not(), not_expr(s))
    if s.accept(TokenType.LPAREN):
        ret = expr(s)
        s.accept(TokenType.RPAREN, reject=True)
        return ret
    ident = s.accept(TokenType.IDENT)
    if ident:
        return ast.Name(IDENT_PREFIX + ident.value, ast.Load())
    s.reject((TokenType.NOT, TokenType.LPAREN, TokenType.IDENT))
コード例 #29
0
def make_not(cursor_trail, tree):
    selected_node = core_logic.get_node_at_cursor(cursor_trail, tree)
    expr = selected_node if isinstance(selected_node,
                                       ast.expr) else make_expression()

    if isinstance(expr, ast.UnaryOp) and isinstance(expr.op, ast.Not):
        # Having not not x doesn't really make sense
        # So let's just remove the not in this case
        return expr.operand

    return ast.UnaryOp(op=ast.Not(), operand=expr)
コード例 #30
0
def negate_expr(node):
    """ Negates an AST expression by adding a `Not` AST node in front of it. 
    """
    if hasattr(node, "__len__"):
        if len(node) > 1:
            raise ValueError("negate_expr only expects "
                             "single expressions, got: {}".format(node))
        expr = node[0]
    else:
        expr = node
    newexpr = ast.Expr(value=ast.UnaryOp(op=ast.Not(), operand=expr))
    newexpr = ast.copy_location(newexpr, expr)
    return ast.fix_missing_locations(newexpr)