From 0e6322e49d96915933130fb84ae12329c7d49161 Mon Sep 17 00:00:00 2001 From: Stefan Behnel <stefan_ml@behnel.de> Date: Sun, 10 Sep 2017 09:08:03 +0200 Subject: [PATCH] Clean up Pythran module: normalise whitespace, remove dead code, etc. --- Cython/Compiler/Pythran.py | 74 ++++++++++++++++++++++---------------- 1 file changed, 43 insertions(+), 31 deletions(-) diff --git a/Cython/Compiler/Pythran.py b/Cython/Compiler/Pythran.py index 9bf09245a..82e96ffd8 100644 --- a/Cython/Compiler/Pythran.py +++ b/Cython/Compiler/Pythran.py @@ -1,19 +1,25 @@ -from .PyrexTypes import BufferType, CType, CTypedefType, CStructOrUnionType +from __future__ import absolute_import + +from .PyrexTypes import CType, CTypedefType, CStructOrUnionType + -_pythran_var_prefix = "__pythran__" # Pythran/Numpy specific operations + def has_np_pythran(env): - while not env is None: - if hasattr(env, "directives") and env.directives.get('np_pythran', False): + while env is not None: + directives = getattr(env, 'directives', None) + if directives and env.directives.get('np_pythran', False): return True env = env.outer_scope + def is_pythran_supported_dtype(type_): if isinstance(type_, CTypedefType): return is_pythran_supported_type(type_.typedef_base_type) return type_.is_numeric -def pythran_type(Ty,ptype="ndarray"): + +def pythran_type(Ty, ptype="ndarray"): if Ty.is_buffer: ndim,dtype = Ty.ndim, Ty.dtype if isinstance(dtype, CStructOrUnionType): @@ -23,29 +29,31 @@ def pythran_type(Ty,ptype="ndarray"): elif isinstance(dtype, CTypedefType): ctype = dtype.typedef_cname else: - raise ValueError("unsupported type %s!" % str(dtype)) + raise ValueError("unsupported type %s!" % dtype) return "pythonic::types::%s<%s,%d>" % (ptype,ctype, ndim) - from .PyrexTypes import PythranExpr if Ty.is_pythran_expr: return Ty.pythran_type #if Ty.is_none: # return "decltype(pythonic::__builtin__::None)" if Ty.is_numeric: return Ty.sign_and_name() - raise ValueError("unsupported pythran type %s (%s)" % (str(Ty), str(type(Ty)))) - return None + raise ValueError("unsupported pythran type %s (%s)" % (Ty, type(Ty))) + def type_remove_ref(ty): return "typename std::remove_reference<%s>::type" % ty + def pythran_binop_type(op, tA, tB): - return "decltype(std::declval<%s>() %s std::declval<%s>())" % \ - (pythran_type(tA), op, pythran_type(tB)) + return "decltype(std::declval<%s>() %s std::declval<%s>())" % ( + pythran_type(tA), op, pythran_type(tB)) + def pythran_unaryop_type(op, type_): return "decltype(%sstd::declval<%s>())" % ( op, pythran_type(type_)) + def pythran_indexing_type(type_, indices): def index_code(idx): if idx.is_slice: @@ -55,15 +63,18 @@ def pythran_indexing_type(type_, indices): else: func = "slice" n = 3 - return "pythonic::types::%s(%s)" % (func,",".join(["0"]*n)) + return "pythonic::types::%s(%s)" % ( + func, ",".join(["0"]*n)) elif idx.type.is_int: return "std::declval<%s>()" % idx.type.sign_and_name() elif idx.type.is_pythran_expr: return "std::declval<%s>()" % idx.type.pythran_type - raise ValueError("unsupported indice type %s!" % idx.type) + raise ValueError("unsupported indexing type %s!" % idx.type) + indexing = ",".join(index_code(idx) for idx in indices) return type_remove_ref("decltype(std::declval<%s>()(%s))" % (pythran_type(type_), indexing)) + def pythran_indexing_code(indices): def index_code(idx): if idx.is_slice: @@ -73,18 +84,22 @@ def pythran_indexing_code(indices): values = values[:2] else: func = "slice" - return "pythonic::types::%s(%s)" % (func,",".join((v.pythran_result() for v in values))) + return "pythonic::types::%s(%s)" % ( + func, ",".join((v.pythran_result() for v in values))) elif idx.type.is_int: return to_pythran(idx) elif idx.type.is_pythran_expr: return idx.pythran_result() - raise ValueError("unsupported indice type %s!" % str(idx.type)) + raise ValueError("unsupported indexing type %s" % idx.type) + return ",".join(index_code(idx) for idx in indices) + def pythran_func_type(func, args): args = ",".join(("std::declval<%s>()" % pythran_type(a.type) for a in args)) return "decltype(pythonic::numpy::functor::%s{}(%s))" % (func, args) + def to_pythran(op, ptype=None): op_type = op.type if op_type.is_int: @@ -96,11 +111,10 @@ def to_pythran(op, ptype=None): return "pythonic::__builtin__::None" if ptype is None: ptype = pythran_type(op_type) - assert(op.type.is_pyobject) + + assert op.type.is_pyobject return "from_python<%s>(%s)" % (ptype, op.py_result()) -def from_pythran(): - return "to_python" def is_type(type_, types): for attr in types: @@ -108,25 +122,31 @@ def is_type(type_, types): return True return False + def is_pythran_supported_node_or_none(node): return node.is_none or is_pythran_supported_type(node.type) + def is_pythran_supported_type(type_): pythran_supported = ( "is_pythran_expr", "is_int", "is_numeric", "is_float", "is_none", "is_complex") return is_type(type_, pythran_supported) or is_pythran_expr(type_) + def is_pythran_supported_operation_type(type_): pythran_supported = ( "is_pythran_expr", "is_int", "is_numeric", "is_float", "is_complex") return is_type(type_,pythran_supported) or is_pythran_expr(type_) + def is_pythran_expr(type_): return type_.is_pythran_expr + def is_pythran_buffer(type_): - return type_.is_numpy_buffer and is_pythran_supported_dtype(type_.dtype) and \ - type_.mode in ("c","strided") and not type_.cast + return (type_.is_numpy_buffer and is_pythran_supported_dtype(type_.dtype) and + type_.mode in ("c", "strided") and not type_.cast) + def include_pythran_generic(env): # Generic files @@ -134,19 +154,11 @@ def include_pythran_generic(env): env.add_include_file("pythonic/python/core.hpp") env.add_include_file("pythonic/types/bool.hpp") env.add_include_file("pythonic/types/ndarray.hpp") - env.add_include_file("<new>") # for placement new + env.add_include_file("<new>") # for placement new - for i in (8,16,32,64): + for i in (8, 16, 32, 64): env.add_include_file("pythonic/types/uint%d.hpp" % i) env.add_include_file("pythonic/types/int%d.hpp" % i) for t in ("float", "float32", "float64", "set", "slice", "tuple", "int", - "long", "complex", "complex64", "complex128"): + "long", "complex", "complex64", "complex128"): env.add_include_file("pythonic/types/%s.hpp" % t) - -def include_pythran_type(env, type_): - pass - -def type_is_numpy(type_): - if not hasattr(type_, "is_numpy"): - return False - return type_.is_numpy -- 2.30.9