本文整理匯總了Python中ast.BitAnd方法的典型用法代碼示例。如果您正苦於以下問題:Python ast.BitAnd方法的具體用法?Python ast.BitAnd怎麽用?Python ast.BitAnd使用的例子?那麽, 這裏精選的方法代碼示例或許可以為您提供幫助。您也可以進一步了解該方法所在類ast
的用法示例。
在下文中一共展示了ast.BitAnd方法的15個代碼示例,這些例子默認根據受歡迎程度排序。您可以為喜歡或者感覺有用的代碼點讚,您的評價將有助於係統推薦出更棒的Python代碼示例。
示例1: augassign_rewrite
# 需要導入模塊: import ast [as 別名]
# 或者: from ast import BitAnd [as 別名]
def augassign_rewrite(it: Tokenizer):
return {
'+=': ast.Add,
'-=': ast.Sub,
'*=': ast.Mult,
'/=': ast.Div,
'//=': ast.FloorDiv,
'@=': ast.MatMult,
'%=': ast.Mod,
'&=': ast.BitAnd,
'|=': ast.BitOr,
'^=': ast.BitXor,
'<<=': ast.LShift,
'>>=': ast.RShift,
'**=': ast.Pow,
}[it.value]
示例2: visit_BoolOp
# 需要導入模塊: import ast [as 別名]
# 或者: from ast import BitAnd [as 別名]
def visit_BoolOp(self, node):
'A custom BoolOp can be used in flattened AST'
if type(node.op) not in (ast.Add, ast.Mult,
ast.BitXor, ast.BitAnd, ast.BitOr):
return self.generic_visit(node)
# get constant parts of node:
list_cste = [child for child in node.values
if isinstance(child, ast.Num)]
if len(list_cste) < 2:
return self.generic_visit(node)
rest_values = [n for n in node.values if n not in list_cste]
fake_node = Unflattening().visit(ast.BoolOp(node.op, list_cste))
fake_node = ast.Expression(fake_node)
ast.fix_missing_locations(fake_node)
code = compile(fake_node, '<constant folding>', 'eval')
obj_env = globals().copy()
exec code in obj_env
value = eval(code, obj_env)
new_node = ast.Num(value)
rest_values.append(new_node)
return ast.BoolOp(node.op, rest_values)
示例3: visit_BinOp
# 需要導入模塊: import ast [as 別名]
# 或者: from ast import BitAnd [as 別名]
def visit_BinOp(self, node):
'Replace bitwise operation with function call'
self.generic_visit(node)
if isinstance(node.op, ast.BitAnd):
return ast.Call(ast.Name('mand', ast.Load()),
[node.left, node.right], [], None, None)
if isinstance(node.op, ast.BitOr):
return ast.Call(ast.Name('mor', ast.Load()),
[node.left, node.right], [], None, None)
if isinstance(node.op, ast.BitXor):
return ast.Call(ast.Name('mxor', ast.Load()),
[node.left, node.right], [], None, None)
if isinstance(node.op, ast.LShift):
return ast.Call(ast.Name('mlshift', ast.Load()),
[node.left, node.right], [], None, None)
if isinstance(node.op, ast.RShift):
return ast.Call(ast.Name('mrshift', ast.Load()),
[node.left, node.right], [], None, None)
return node
示例4: visit_BinOp
# 需要導入模塊: import ast [as 別名]
# 或者: from ast import BitAnd [as 別名]
def visit_BinOp(self, node: ast.BinOp) -> ast.AST:
"""BinOp nodes are bit-shifts and general operators like add, divide, etc."""
self.generic_visit(node)
log_header = f"visit_BinOp: {self.src_file}:"
# default case for this node, can be BinOpBC or BinOpBS
ast_class = "BinOp"
op_type = type(node.op)
# binop_bit_cmp_types: Set[type] = {ast.BitAnd, ast.BitOr, ast.BitXor}
if op_type in {ast.BitAnd, ast.BitOr, ast.BitXor}:
ast_class = "BinOpBC"
# binop_bit_shift_types: Set[type] = {ast.LShift, ast.RShift}
if op_type in {ast.LShift, ast.RShift}:
ast_class = "BinOpBS"
node_span = NodeSpan(node)
idx = LocIndex(
ast_class=ast_class,
lineno=node_span.lineno,
col_offset=node_span.col_offset,
op_type=op_type,
end_lineno=node_span.end_lineno,
end_col_offset=node_span.end_col_offset,
)
self.locs.add(idx)
if idx == self.target_idx and self.mutation and not self.readonly:
LOGGER.debug("%s mutating idx: %s with %s", log_header, self.target_idx, self.mutation)
return ast.copy_location(
ast.BinOp(left=node.left, op=self.mutation(), right=node.right), node
)
LOGGER.debug("%s (%s, %s): no mutations applied.", log_header, node.lineno, node.col_offset)
return node
示例5: visit_BinOp
# 需要導入模塊: import ast [as 別名]
# 或者: from ast import BitAnd [as 別名]
def visit_BinOp(self, node):
if isinstance(node.op, (ast.LShift, ast.RShift)):
self.shiftOp(node)
elif isinstance(node.op, (ast.BitAnd, ast.BitOr, ast.BitXor)):
self.BitOp(node)
else:
self.BinOp(node)
示例6: visit_AugAssign
# 需要導入模塊: import ast [as 別名]
# 或者: from ast import BitAnd [as 別名]
def visit_AugAssign(self, node):
self.visit(node.target)
self.visit(node.value)
if isinstance(node.op, (ast.BitOr, ast.BitAnd, ast.BitXor)):
node.value.vhd = copy(node.target.vhd)
node.vhdOri = copy(node.target.vhd)
elif isinstance(node.op, (ast.RShift, ast.LShift)):
node.value.vhd = vhd_int()
node.vhdOri = copy(node.target.vhd)
else:
node.left, node.right = node.target, node.value
self.inferBinOpType(node)
node.vhd = copy(node.target.vhd)
示例7: and_expr_rewrite
# 需要導入模塊: import ast [as 別名]
# 或者: from ast import BitAnd [as 別名]
def and_expr_rewrite(head, tail):
if tail:
for op, each in tail:
head = ast.BinOp(head, ast.BitAnd(), each, **loc @ op)
return head
示例8: test_differentops
# 需要導入模塊: import ast [as 別名]
# 或者: from ast import BitAnd [as 別名]
def test_differentops(self):
'Test with other types of operators'
tests = [("(3 & 5 & 6)",
ast.BoolOp(ast.BitAnd(),
[ast.Num(3), ast.Num(5), ast.Num(6)])),
("(1 ^ 2 ^ 3) - 4",
ast.BinOp(ast.BoolOp(ast.BitXor(),
[ast.Num(1), ast.Num(2), ast.Num(3)]),
ast.Add(),
ast.BinOp(ast.Num(-1), ast.Mult(), ast.Num(4)))),
("((1 + 2 + 3) & (4 + 5))",
ast.BinOp(ast.BoolOp(ast.Add(),
[ast.Num(1), ast.Num(2), ast.Num(3)]),
ast.BitAnd(),
ast.BinOp(ast.Num(4), ast.Add(), ast.Num(5)))),
("(1 & 2 & 3) - (4 & 5)",
ast.BinOp(ast.BoolOp(ast.BitAnd(),
[ast.Num(1), ast.Num(2), ast.Num(3)]),
ast.Add(),
ast.BinOp(ast.Num(-1), ast.Mult(),
ast.BinOp(ast.Num(4), ast.BitAnd(),
ast.Num(5))))),
("(1 & 2 & 3) << (4 & 5)",
ast.BinOp(ast.BoolOp(ast.BitAnd(),
[ast.Num(1), ast.Num(2), ast.Num(3)]),
ast.LShift(),
ast.BinOp(ast.Num(4), ast.BitAnd(), ast.Num(5))))]
for teststring, ref_ast in tests:
test_ast = ast.parse(teststring, mode="eval").body
test_ast = pre_processing.all_preprocessings(test_ast)
test_ast = Flattening().visit(test_ast)
self.assertTrue(Comparator().visit(test_ast, ref_ast))
示例9: visit_BinOp
# 需要導入模塊: import ast [as 別名]
# 或者: from ast import BitAnd [as 別名]
def visit_BinOp(self, node):
'Change (A & 2**self.nbits - 1) in A'
if isinstance(node.op, ast.BitAnd):
if isinstance(node.right, ast.Num):
if node.right.n != (2**self.nbits - 1):
return self.generic_visit(node)
return self.generic_visit(node.left)
if isinstance(node.left, ast.Num):
if node.left.n != (2**self.nbits - 1):
return self.generic_visit(node)
return self.generic_visit(node.right)
return self.generic_visit(node)
示例10: visit_Call
# 需要導入模塊: import ast [as 別名]
# 或者: from ast import BitAnd [as 別名]
def visit_Call(self, node):
'Replace custom function with bitwise operators'
self.generic_visit(node)
if isinstance(node.func, ast.Name):
if len(node.args) == 2:
if node.func.id == "mand":
op = ast.BitAnd()
elif node.func.id == "mxor":
op = ast.BitXor()
elif node.func.id == "mor":
op = ast.BitOr()
elif node.func.id == "mlshift":
op = ast.LShift()
elif node.func.id == "mrshift":
op = ast.RShift()
else:
return node
return ast.BinOp(node.args[0],
op,
node.args[1])
elif len(node.args) == 1 and node.func.id == "mnot":
arg = node.args[0]
self.generic_visit(node)
return ast.UnaryOp(ast.Invert(), arg)
return self.generic_visit(node)
示例11: __init__
# 需要導入模塊: import ast [as 別名]
# 或者: from ast import BitAnd [as 別名]
def __init__( s, component ):
super().__init__( component )
s.loop_var_env = set()
s.tmp_var_env = set()
# opmap maps an ast operator to its RTLIR counterpart.
s.opmap = {
# Bool operators
# Note: we do not support boolean operators because Python does
# not allow overloading And and Or operators. Using them in
# expressions might lead to inconsistent semantics.
# ast.And : bir.And(), ast.Or : bir.Or(),
# Unary operators
# Note: ast.Not is disallowed because it is a boolean operator
# ast.Not : bir.Not(),
ast.Invert : bir.Invert(),
ast.UAdd : bir.UAdd(), ast.USub : bir.USub(),
# Binary operators
ast.Add : bir.Add(), ast.Sub : bir.Sub(),
ast.Mult : bir.Mult(), ast.Div : bir.Div(),
ast.Mod : bir.Mod(), ast.Pow : bir.Pow(),
ast.LShift : bir.ShiftLeft(), ast.RShift : bir.ShiftRightLogic(),
ast.BitOr : bir.BitOr(), ast.BitAnd : bir.BitAnd(),
ast.BitXor : bir.BitXor(),
# Compare bir.bir.operators
ast.Eq : bir.Eq(), ast.NotEq : bir.NotEq(),
ast.Lt : bir.Lt(), ast.LtE : bir.LtE(),
ast.Gt : bir.Gt(), ast.GtE : bir.GtE()
}
# Override
示例12: visit_BinOp
# 需要導入模塊: import ast [as 別名]
# 或者: from ast import BitAnd [as 別名]
def visit_BinOp(self, node: ast.BinOp) -> Any:
"""Recursively visit the left and right operand, respectively, and apply the operation on the results."""
# pylint: disable=too-many-branches
left = self.visit(node=node.left)
right = self.visit(node=node.right)
if isinstance(node.op, ast.Add):
result = left + right
elif isinstance(node.op, ast.Sub):
result = left - right
elif isinstance(node.op, ast.Mult):
result = left * right
elif isinstance(node.op, ast.Div):
result = left / right
elif isinstance(node.op, ast.FloorDiv):
result = left // right
elif isinstance(node.op, ast.Mod):
result = left % right
elif isinstance(node.op, ast.Pow):
result = left**right
elif isinstance(node.op, ast.LShift):
result = left << right
elif isinstance(node.op, ast.RShift):
result = left >> right
elif isinstance(node.op, ast.BitOr):
result = left | right
elif isinstance(node.op, ast.BitXor):
result = left ^ right
elif isinstance(node.op, ast.BitAnd):
result = left & right
elif isinstance(node.op, ast.MatMult):
result = left @ right
else:
raise NotImplementedError("Unhandled op of {}: {}".format(node, node.op))
self.recomputed_values[node] = result
return result
示例13: binop
# 需要導入模塊: import ast [as 別名]
# 或者: from ast import BitAnd [as 別名]
def binop(self, block, node, var=None):
if var is None:
var = self.add_variable(None)
left = self.expression(block, node.left)
right = self.expression(block, node.right)
if isinstance(node.op, ast.Add):
op = Operator.add
elif isinstance(node.op, ast.Sub):
op = Operator.subtract
elif isinstance(node.op, ast.Mult):
op = Operator.multiply
elif isinstance(node.op, ast.Div):
op = Operator.divide
elif isinstance(node.op, ast.FloorDiv):
op = Operator.divide_int
elif isinstance(node.op, ast.Mod):
op = Operator.mod
elif isinstance(node.op, ast.Pow):
op = Operator.pow
elif isinstance(node.op, ast.BitAnd):
op = Operator.bit_and
elif isinstance(node.op, ast.BitOr):
op = Operator.bit_or
elif isinstance(node.op, ast.BitXor):
op = Operator.bit_xor
elif isinstance(node.op, ast.LShift):
op = Operator.shift_left
elif isinstance(node.op, ast.RShift):
op = Operator.shift_right
else:
raise Exception('Unexpected BinOp (%s)'%(node.op.__class__))
operation = BinaryOperation(left, op, right)
assignment = Assignment(var, operation)
block.add(assignment)
return var
#Parses a unary uperation (AST UnaryOp)
示例14: p_augassign_6
# 需要導入模塊: import ast [as 別名]
# 或者: from ast import BitAnd [as 別名]
def p_augassign_6(p):
'''augassign : AMPEREQUAL'''
# 1
p[0] = ast.BitAnd(rule=inspect.currentframe().f_code.co_name, **p[1][1])
示例15: p_and_expr_star_1
# 需要導入模塊: import ast [as 別名]
# 或者: from ast import BitAnd [as 別名]
def p_and_expr_star_1(p):
'''and_expr_star : AMPER shift_expr'''
# 1 2
p[0] = [ast.BitAnd(rule=inspect.currentframe().f_code.co_name, **p[1][1]), p[2]]