error_type = ErrorType()
unspecified_type = UnspecifiedType()
-
modifiers_and_name_to_type = {
- #(signed, longness, name)
- (0, 0, "char"): c_uchar_type,
+ #(signed, longness, name) : type
+ (0, 0, "char"): c_uchar_type,
+ (1, 0, "char"): c_char_type,
+ (2, 0, "char"): c_schar_type,
+
(0, -1, "int"): c_ushort_type,
- (0, 0, "int"): c_uint_type,
- (0, 1, "int"): c_ulong_type,
- (0, 2, "int"): c_ulonglong_type,
- (1, 0, "void"): c_void_type,
- (1, 0, "char"): c_char_type,
+ (0, 0, "int"): c_uint_type,
+ (0, 1, "int"): c_ulong_type,
+ (0, 2, "int"): c_ulonglong_type,
+
(1, -1, "int"): c_short_type,
- (1, 0, "int"): c_int_type,
- (1, 1, "int"): c_long_type,
- (1, 2, "int"): c_longlong_type,
- (1, 0, "float"): c_float_type,
- (1, 0, "double"): c_double_type,
- (1, 1, "double"): c_longdouble_type,
- (1, 0, "object"): py_object_type,
- (1, 0, "bint"): c_bint_type,
- (2, 0, "char"): c_schar_type,
+ (1, 0, "int"): c_int_type,
+ (1, 1, "int"): c_long_type,
+ (1, 2, "int"): c_longlong_type,
+
(2, -1, "int"): c_sshort_type,
- (2, 0, "int"): c_sint_type,
- (2, 1, "int"): c_slong_type,
- (2, 2, "int"): c_slonglong_type,
+ (2, 0, "int"): c_sint_type,
+ (2, 1, "int"): c_slong_type,
+ (2, 2, "int"): c_slonglong_type,
+
+ (1, 0, "bint"): c_bint_type,
+ (0, 0, "size_t") : c_size_t_type,
+ (2, 0, "Py_ssize_t"): c_py_ssize_t_type,
- (2, 0, "Py_ssize_t"): c_py_ssize_t_type,
- (0, 0, "size_t") : c_size_t_type,
+ (1, 0, "float"): c_float_type,
+ (1, 0, "double"): c_double_type,
+ (1, 1, "double"): c_longdouble_type,
- (1, 0, "long"): c_long_type,
- (1, 0, "short"): c_short_type,
- (1, 0, "longlong"): c_longlong_type,
- (1, 0, "bint"): c_bint_type,
+ (1, 0, "complex"): c_float_complex_type,
+ (1, 0, "floatcomplex"): c_float_complex_type,
+ (1, 0, "doublecomplex"): c_double_complex_type,
+ (1, 1, "doublecomplex"): c_longdouble_complex_type,
+
+ #
+ (1, 0, "void"): c_void_type,
+ (1, 0, "object"): py_object_type,
}
def is_promotion(src_type, dst_type):
base = parse_basic_type(name[:-1])
if base:
return CPtrType(base)
- elif name.startswith('u'):
- return simple_c_type(0, 0, name[1:])
+ #
+ basic_type = simple_c_type(1, 0, name)
+ if basic_type:
+ return basic_type
+ #
+ signed = 1
+ longness = 0
+ if name == 'Py_ssize_t':
+ signed = 2
+ elif name == 'size_t':
+ signed = 0
else:
- return simple_c_type(1, 0, name)
+ if name.startswith('u'):
+ name = name[1:]
+ signed = 0
+ elif (name.startswith('s') and
+ not name.startswith('short')):
+ name = name[1:]
+ signed = 2
+ longness = 0
+ while name.startswith('short'):
+ name = name.replace('short', '', 1).strip()
+ longness -= 1
+ while name.startswith('long'):
+ name = name.replace('long', '', 1).strip()
+ longness += 1
+ if longness != 0 and not name:
+ name = 'int'
+ return simple_c_type(signed, longness, name)
def c_array_type(base_type, size):
# Construct a C array type.
-py_float = float
py_int = int
try:
py_long = long
except NameError: # Py3
py_long = int
+py_float = float
+py_complex = complex
try:
# Python 3
# Predefined types
-int_types = ['char', 'short', 'int', 'long', 'longlong', 'Py_ssize_t']
-float_types = ['double', 'float']
+int_types = ['char', 'short', 'int', 'long', 'longlong', 'Py_ssize_t', 'size_t']
+float_types = ['longdouble', 'double', 'float']
+complex_types = ['longdoublecomplex', 'doublecomplex', 'floatcomplex', 'complex']
other_types = ['bint', 'void']
+
gs = globals()
for name in int_types:
gs[name] = typedef(py_int)
- gs['u'+name] = typedef(py_int)
+ if not name.endswith('size_t'):
+ gs['u'+name] = typedef(py_int)
+ gs['s'+name] = typedef(py_int)
-double = float = typedef(py_float)
+for name in float_types:
+ gs[name] = typedef(py_float)
+
+for name in complex_types:
+ gs[name] = typedef(py_complex)
+
bint = typedef(bool)
void = typedef(int)
-for t in int_types + float_types + other_types:
+for t in int_types + float_types + complex_types + other_types:
for i in range(1, 4):
gs["%s_%s" % ('p'*i, t)] = globals()[t]._pointer(i)
MyStruct3 = typedef(MyStruct[3])
MyStruct4 = my_typedef(MyStruct[4])
MyStruct5 = cy.typedef(MyStruct[5])
+
+def test_declare_c_types(n):
+ """
+ >>> test_declare_c_types(0)
+ >>> test_declare_c_types(1)
+ >>> test_declare_c_types(2)
+ """
+ #
+ b00 = cython.declare(cython.bint, 0)
+ b01 = cython.declare(cython.bint, 1)
+ b02 = cython.declare(cython.bint, 2)
+ #
+ i00 = cython.declare(cython.uchar, n)
+ i01 = cython.declare(cython.char, n)
+ i02 = cython.declare(cython.schar, n)
+ i03 = cython.declare(cython.ushort, n)
+ i04 = cython.declare(cython.short, n)
+ i05 = cython.declare(cython.sshort, n)
+ i06 = cython.declare(cython.uint, n)
+ i07 = cython.declare(cython.int, n)
+ i08 = cython.declare(cython.sint, n)
+ i09 = cython.declare(cython.slong, n)
+ i10 = cython.declare(cython.long, n)
+ i11 = cython.declare(cython.ulong, n)
+ i12 = cython.declare(cython.slonglong, n)
+ i13 = cython.declare(cython.longlong, n)
+ i14 = cython.declare(cython.ulonglong, n)
+
+ i20 = cython.declare(cython.Py_ssize_t, n)
+ i21 = cython.declare(cython.size_t, n)
+ #
+ f00 = cython.declare(cython.float, n)
+ f01 = cython.declare(cython.double, n)
+ f02 = cython.declare(cython.longdouble, n)
+ #
+ #z00 = cython.declare(cython.complex, n+1j)
+ #z01 = cython.declare(cython.floatcomplex, n+1j)
+ #z02 = cython.declare(cython.doublecomplex, n+1j)
+ #z03 = cython.declare(cython.longdoublecomplex, n+1j)