我们从Python开源项目中，提取了以下15个代码示例，用于说明如何使用ast.BitXor()。
def num_negate(op): top = type(op) neg = not op.num_negated if hasattr(op, "num_negated") else True if top == ast.Add: newOp = ast.Sub() elif top == ast.Sub: newOp = ast.Add() elif top in [ast.Mult, ast.Div, ast.Mod, ast.Pow, ast.LShift, ast.RShift, ast.BitOr, ast.BitXor, ast.BitAnd, ast.FloorDiv]: return None # can't negate this elif top in [ast.Num, ast.Name]: # this is a normal value, so put a - in front of it newOp = ast.UnaryOp(ast.USub(addedNeg=True), op) else: log("astTools\tnum_negate\tUnusual type: " + str(top), "bug") transferMetaData(op, newOp) newOp.num_negated = neg return newOp
def binop_str(op: ast.AST) -> str: if isinstance(op, ast.Add): return '+' if isinstance(op, ast.Sub): return '-' if isinstance(op, ast.Mult): return '*' if isinstance(op, ast.Div): return '/ ' if isinstance(op, ast.Mod): return '%' if isinstance(op, ast.LShift): return '<<' if isinstance(op, ast.RShift): return '>>' if isinstance(op, ast.BitOr): return '|' if isinstance(op, ast.BitXor): return '^' if isinstance(op, ast.BitAnd): return '&' if isinstance(op, ast.MatMult): return '@' error(loc(op), "Invalid binary operator encountered: {0}:{1}. Check supported intrinsics.".format(op.lineno, op.col_offset)) return 'INVALID_BINOP'
def eval_expr(expr): import ast import operator as op op = { ast.Add: op.add, ast.Sub: op.sub, ast.Mult: op.mul, ast.Div: op.truediv, ast.Pow: op.pow, ast.BitXor: op.xor, ast.USub: op.neg, } def eval_(node): if isinstance(node, ast.Num): return fractions.Fraction(node.n) elif isinstance(node, ast.BinOp): return op[type(node.op)](eval_(node.left), eval_(node.right)) elif isinstance(node, ast.UnaryOp): return op[type(node.op)](eval_(node.operand)) raise TypeError(node) return eval_(ast.parse(str(expr), mode='eval').body)
def __init__(self): super().__init__() # add support for bitwise operators if ast.LShift not in self.MATH_OPERATORS: # '<<' self.MATH_OPERATORS[ast.LShift] = simpleeval.op.lshift if ast.RShift not in self.MATH_OPERATORS: # '>>' self.MATH_OPERATORS[ast.RShift] = simpleeval.op.rshift if ast.BitOr not in self.MATH_OPERATORS: # '|' self.MATH_OPERATORS[ast.BitOr] = simpleeval.op.or_ if ast.BitXor not in self.MATH_OPERATORS: # '^' self.MATH_OPERATORS[ast.BitXor] = simpleeval.op.xor if ast.BitAnd not in self.MATH_OPERATORS: # '&' self.MATH_OPERATORS[ast.BitAnd] = simpleeval.op.and_ # add support for extra operators #if ast.Not not in self.MATH_OPERATORS: # not ('not') # self.MATH_OPERATORS[ast.Not] = simpleeval.op.not_ if ast.FloorDiv not in self.MATH_OPERATORS: # floordiv ('//') self.MATH_OPERATORS[ast.FloorDiv] = simpleeval.op.floordiv
def doBinaryOp(op, l, r): """Perform the given AST binary operation on the values""" top = type(op) if top == ast.Add: return l + r elif top == ast.Sub: return l - r elif top == ast.Mult: return l * r elif top == ast.Div: # Don't bother if this will be a really long float- it won't work properly! # Also, in Python 3 this is floating division, so perform it accordingly. val = 1.0 * l / r if (val * 1e10 % 1.0) != 0: raise Exception("Repeating Float") return val elif top == ast.Mod: return l % r elif top == ast.Pow: return l ** r elif top == ast.LShift: return l << r elif top == ast.RShift: return l >> r elif top == ast.BitOr: return l | r elif top == ast.BitXor: return l ^ r elif top == ast.BitAnd: return l & r elif top == ast.FloorDiv: return l // r
def __init__(self, range_op=ast.BitXor): assert range_op in [ast.BitXor, ast.BitAnd, ast.BitOr, ast.MatMult] self.range_op = range_op
def BitXor(): return operator.xor
def _infer_bitwise(left_type, right_type, op, lineno, solver): """Infer the type of a bitwise operation, and add the corresponding axioms""" result_type = solver.new_z3_const("bitwise_result") magic_method = "" if isinstance(op, ast.BitOr): magic_method = "__or__" elif isinstance(op, ast.BitXor): magic_method = "__xor__" elif isinstance(op, ast.BitAnd): magic_method = "__and__" solver.add(axioms.bitwise(left_type, right_type, result_type, magic_method, solver.z3_types), fail_message="Bitwise operation in line {}".format(lineno)) return result_type
def binary_operation_type(left_type, op, right_type, lineno, solver): """Infer the type of a binary operation result""" if isinstance(op, ast.Add): inference_func = _infer_add elif isinstance(op, ast.Mult): inference_func = _infer_mult elif isinstance(op, ast.Div): inference_func = _infer_div elif isinstance(op, (ast.BitOr, ast.BitXor, ast.BitAnd)): return _infer_bitwise(left_type, right_type, op, lineno, solver) else: return _infer_arithmetic(left_type, right_type, op, lineno, solver) return inference_func(left_type, right_type, lineno, solver)
def syn_BinOp(self, ctx, e): if isinstance(e.op, (ast.LShift, ast.RShift, ast.BitOr, ast.BitXor, ast.BitAnd)): raise _errors.TyError("Cannot use bitwise operators on ieee values.", e) ctx.ana(e.right, self) return self
def syn_BinOp(self, ctx, e): if isinstance(e.op, (ast.LShift, ast.RShift, ast.BitOr, ast.BitXor, ast.BitAnd)): raise _errors.TyError("Cannot use bitwise operators on cplx values.", e) if isinstance(e.op, ast.Mod): raise _errors.TyError("Cannot take the modulus of a complex number.", e) right = e.right ctx.ana(right, self) return self
def _update(self): """update tkk """ # we don't need to update the base TKK value when it is still valid now = math.floor(int(time.time() * 1000) / 3600000.0) if self.tkk and int(self.tkk.split('.')[0]) == now: return r = self.session.get(self.host) # this will be the same as python code after stripping out a reserved word 'var' code = unicode(self.RE_TKK.search(r.text).group(1)).replace('var ', '') # unescape special ascii characters such like a \x3d(=) if PY3: # pragma: no cover code = code.encode().decode('unicode-escape') else: # pragma: no cover code = code.decode('string_escape') if code: tree = ast.parse(code) visit_return = False operator = '+' n, keys = 0, dict(a=0, b=0) for node in ast.walk(tree): if isinstance(node, ast.Assign): name = node.targets[0].id if name in keys: if isinstance(node.value, ast.Num): keys[name] = node.value.n # the value can sometimes be negative elif isinstance(node.value, ast.UnaryOp) and \ isinstance(node.value.op, ast.USub): # pragma: nocover keys[name] = -node.value.operand.n elif isinstance(node, ast.Return): # parameters should be set after this point visit_return = True elif visit_return and isinstance(node, ast.Num): n = node.n elif visit_return and n > 0: # the default operator is '+' but implement some more for # all possible scenarios if isinstance(node, ast.Add): # pragma: nocover pass elif isinstance(node, ast.Sub): # pragma: nocover operator = '-' elif isinstance(node, ast.Mult): # pragma: nocover operator = '*' elif isinstance(node, ast.Pow): # pragma: nocover operator = '**' elif isinstance(node, ast.BitXor): # pragma: nocover operator = '^' # a safety way to avoid Exceptions clause = compile('{1}{0}{2}'.format( operator, keys['a'], keys['b']), '', 'eval') value = eval(clause, dict(__builtin__={})) result = '{}.{}'.format(n, value) self.tkk = result
def visit_BinOp(self, node): left_term = self.visit(node.left) right_term = self.visit(node.right) if self.__is_bool(left_term) and self.__is_bool(right_term): if isinstance(node.op, ast.BitAnd): return And(left_term, right_term) elif isinstance(node.op, ast.BitOr): return Or(left_term, right_term) elif isinstance(node.op, ast.BitXor): return Xor(left_term, right_term) else: raise Exception("Unsupported bool binary operation %s" % unparse(node)) if DATA_TYPE == "int": if isinstance(node.op, ast.Mod): return left_term % right_term elif isinstance(node.op, ast.Add): return left_term + right_term elif isinstance(node.op, ast.Sub): return left_term - right_term elif isinstance(node.op, ast.Mult): return left_term * right_term elif isinstance(node.op, ast.BitXor): # Special-case for bool circuit-examples: if is_is_int(left_term): left_term = left_term == IntVal(1) if is_is_int(right_term): right_term = right_term == IntVal(1) return left_term != right_term else: raise Exception("Unsupported integer binary operation %s" % unparse(node)) elif DATA_TYPE.startswith("bit_"): if isinstance(node.op, ast.BitAnd): return left_term & right_term elif isinstance(node.op, ast.BitOr): return left_term | right_term elif isinstance(node.op, ast.BitXor): return left_term ^ right_term else: raise Exception("Unsupported bitvector operation %s" % unparse(node)) else: raise Exception("Unsupported data type %s" % DATA_TYPE)
def _update(self): """update tkk """ # we don't need to update the base TKK value when it is still valid now = math.floor(int(time.time() * 1000) / 3600000.0) if self.tkk and int(self.tkk.split('.')[0]) == now: return r = self.session.get(self.host) # this will be the same as python code after stripping out a reserved word 'var' code = str(self.RE_TKK.search(r.text).group(1)).replace('var ', '') # unescape special ascii characters such like a \x3d(=) code = code.encode().decode('unicode-escape') if code: tree = ast.parse(code) visit_return = False operator = '+' n, keys = 0, dict(a=0, b=0) for node in ast.walk(tree): if isinstance(node, ast.Assign): name = node.targets[0].id if name in keys: if isinstance(node.value, ast.Num): keys[name] = node.value.n # the value can sometimes be negative elif isinstance(node.value, ast.UnaryOp) and \ isinstance(node.value.op, ast.USub): # pragma: nocover keys[name] = -node.value.operand.n elif isinstance(node, ast.Return): # parameters should be set after this point visit_return = True elif visit_return and isinstance(node, ast.Num): n = node.n elif visit_return and n > 0: # the default operator is '+' but implement some more for # all possible scenarios if isinstance(node, ast.Add): # pragma: nocover pass elif isinstance(node, ast.Sub): # pragma: nocover operator = '-' elif isinstance(node, ast.Mult): # pragma: nocover operator = '*' elif isinstance(node, ast.Pow): # pragma: nocover operator = '**' elif isinstance(node, ast.BitXor): # pragma: nocover operator = '^' # a safety way to avoid Exceptions clause = compile('{1}{0}{2}'.format( operator, keys['a'], keys['b']), '', 'eval') value = eval(clause, dict(__builtin__={})) result = '{}.{}'.format(n, value) self.tkk = result
def seteval(str_, get=None, stemmer=None, target=None): """Evaluate a set operation string, where each Name is fetched Parameters ---------- str_ : str The query to evaluate get : function, optional A getting method, defaults to instatiating one from _requests stemmer : function, optional A method to stem a query Name. If None, defaults to passthrough. target : str, optional A subcontext to query against. If None, defaults to text-search. """ if get is None: import redbiom config = redbiom.get_config() get = redbiom._requests.make_get(config) if stemmer is None: stemmer = passthrough if target is None: target = 'text-search' # Load is subject to indirection to simplify testing globals()['Load'] = make_Load(get) # this seems right now to be the easiest way to inject parameters # into Name globals()['stemmer'] = stemmer globals()['target'] = target formed = ast.parse(str_, mode='eval') node_types = (ast.BitAnd, ast.BitOr, ast.BitXor, ast.Name, ast.Sub, ast.Expression, ast.BinOp, ast.Load) for node in ast.walk(formed): if not isinstance(node, node_types): raise TypeError("Unsupported node type: %s" % ast.dump(node)) result = eval(ast.dump(formed)) # clean up global Load del Load del stemmer del target return result
