def test_include():
cdef1 = """
typedef ssize_t Py_ssize_t;
#define PyObject_HEAD \
Py_ssize_t ob_refcnt; \
Py_ssize_t ob_pypy_link; \
typedef struct {
char *name;
} Type;
"""
cdef2 = """
typedef struct {
PyObject_HEAD
Py_ssize_t ob_foo;
Type *type;
} Object;
"""
cts1 = parse_source(cdef1)
Type = cts1.definitions['Type']
assert isinstance(Type, lltype.Struct)
cts2 = parse_source(cdef2, includes=[cts1])
assert 'Type' not in cts2.definitions
Object = cts2.definitions['Object']
assert Object.c_type.TO is Type
def test_const():
cdef = """
typedef struct {
const char * const foo;
} bar;
"""
cts = parse_source(cdef)
assert cts.definitions['bar'].c_foo == rffi.CONST_CCHARP != rffi.CCHARP
def test_wchar_t():
cdef = """
typedef struct { wchar_t* x; } test;
"""
cts = parse_source(cdef, headers=['stddef.h'])
obj = lltype.malloc(cts.gettype('test'), flavor='raw')
obj.c_x = cts.cast('wchar_t*', 0)
obj.c_x = lltype.nullptr(rffi.CWCHARP.TO)
lltype.free(obj, flavor='raw')
def test_struct_in_func_args():
decl = """
typedef struct {int x;} obj;
typedef int (*func)(obj x);
"""
cts = parse_source(decl)
OBJ = cts.gettype('obj')
FUNCPTR = cts.gettype('func')
assert FUNCPTR.TO.ARGS == (OBJ, )
def test_incomplete_struct():
cdef = """
typedef struct s *ptr;
struct s {void* x;};
"""
cts = parse_source(cdef)
PTR = cts.gettype("ptr")
assert isinstance(PTR.TO, lltype.Struct)
hash(PTR)
def test_win64():
decl = """
#ifdef _WIN64
typedef long long Py_ssize_t;
#else
typedef long Py_ssize_t;
#endif
"""
cts = parse_source(decl)
assert cts.definitions == {'Py_ssize_t': rffi.SIGNED}
def test_enum():
cdef = """
typedef enum {
mp_ass_subscript = 3,
mp_length = 4,
mp_subscript = 5,
} Slot;
"""
cts = parse_source(cdef)
assert cts.gettype('Slot').mp_length == 4
def test_named_struct():
cdef = """
struct foo {
int x;
};
"""
cts = parse_source(cdef)
foo = cts.gettype('struct foo')
assert isinstance(foo, lltype.Struct)
hash(foo)
def test_translate_cast():
cdef = "typedef ssize_t Py_ssize_t;"
cts = parse_source(cdef)
def f():
return cts.cast('Py_ssize_t*', 0)
graph = build_flow(f)
simplify_graph(graph)
assert len(graph.startblock.operations) == 1
op = graph.startblock.operations[0]
assert op.args[0] == const(rffi.cast)
assert op.args[1].value is cts.gettype('Py_ssize_t*')
def test_nested_struct():
cdef = """
typedef struct {
int x;
} foo;
typedef struct {
foo y;
} bar;
"""
cts = parse_source(cdef)
bar = cts.gettype('bar')
assert isinstance(bar, lltype.Struct)
hash(bar) # bar is hashable
def test_write_func():
db = LowLevelDatabase()
cdef = """
typedef ssize_t Py_ssize_t;
"""
cts = parse_source(cdef)
cdecl = "Py_ssize_t * some_func(Py_ssize_t*)"
decl = cts.parse_func(cdecl)
api_function = ApiFunction(
decl.get_llargs(cts), decl.get_llresult(cts), lambda space, x: None,
cdecl=decl)
assert (api_function.get_api_decl('some_func', db)
== "PyAPI_FUNC(Py_ssize_t *) some_func(Py_ssize_t * arg0);")
def test_translate_gettype():
cdef = "typedef ssize_t Py_ssize_t;"
cts = parse_source(cdef)
def f():
return cts.gettype('Py_ssize_t*')
graph = build_flow(f)
simplify_graph(graph)
# Check that the result is constant-folded
assert graph.startblock.operations == []
[link] = graph.startblock.exits
assert link.target is graph.returnblock
assert link.args[0] == const(rffi.CArrayPtr(rffi.SSIZE_T))
def test_configure():
decl = """
typedef ssize_t Py_ssize_t;
typedef struct {
Py_ssize_t ob_refcnt;
Py_ssize_t ob_pypy_link;
double ob_fval;
} TestFloatObject;
"""
cts = parse_source(decl)
TestFloatObject = cts.definitions['TestFloatObject']
assert isinstance(TestFloatObject, lltype.Struct)
assert TestFloatObject.c_ob_refcnt == rffi.SSIZE_T
assert TestFloatObject.c_ob_pypy_link == rffi.SSIZE_T
assert TestFloatObject.c_ob_fval == rffi.DOUBLE
def test_macro():
decl = """
typedef ssize_t Py_ssize_t;
#define PyObject_HEAD \
Py_ssize_t ob_refcnt; \
Py_ssize_t ob_pypy_link; \
typedef struct {
PyObject_HEAD
double ob_fval;
} PyFloatObject;
"""
cts = parse_source(decl)
assert 'PyFloatObject' in cts.definitions
assert 'PyObject_HEAD' in cts.macros
def test_gettype():
decl = """
typedef ssize_t Py_ssize_t;
#define PyObject_HEAD \
Py_ssize_t ob_refcnt; \
Py_ssize_t ob_pypy_link; \
typedef struct {
PyObject_HEAD
double ob_fval;
} TestFloatObject;
"""
cts = parse_source(decl)
assert cts.gettype('Py_ssize_t') == rffi.SSIZE_T
assert cts.gettype('TestFloatObject *').TO.c_ob_refcnt == rffi.SSIZE_T
assert cts.cast('Py_ssize_t', 42) == rffi.cast(rffi.SSIZE_T, 42)
def test_translate_enum():
cdef = """
typedef enum {
mp_ass_subscript = 3,
mp_length = 4,
mp_subscript = 5,
} Slot;
"""
cts = parse_source(cdef)
def f():
return cts.gettype('Slot').mp_length
graph = build_flow(f)
simplify_graph(graph)
# Check that the result is constant-folded
assert graph.startblock.operations == []
[link] = graph.startblock.exits
assert link.target is graph.returnblock
assert link.args[0] == const(4)
def test_parse_funcdecl():
decl = """
typedef ssize_t Py_ssize_t;
#define PyObject_HEAD \
Py_ssize_t ob_refcnt; \
Py_ssize_t ob_pypy_link; \
typedef struct {
PyObject_HEAD
double ob_fval;
} TestFloatObject;
typedef TestFloatObject* (*func_t)(int, int);
"""
cts = parse_source(decl)
func_decl = cts.parse_func("func_t * some_func(TestFloatObject*)")
assert func_decl.name == 'some_func'
assert func_decl.get_llresult(cts) == cts.gettype('func_t*')
assert func_decl.get_llargs(cts) == [cts.gettype('TestFloatObject *')]
def test_nested_struct_2():
cdef = """
typedef struct _object {
int ob_refcnt;
struct _typeobject *ob_type;
} PyObject;
typedef struct _varobject {
PyObject ob_base;
int ob_size;
} PyVarObject;
typedef struct _typeobject {
PyVarObject ob_base;
} PyTypeObject;
"""
cts = parse_source(cdef)
bar = cts.gettype('PyTypeObject')
assert isinstance(bar, lltype.Struct)
hash(bar) # bar is hashable
def test_recursive():
cdef = """
typedef ssize_t Py_ssize_t;
typedef struct {
Py_ssize_t ob_refcnt;
Py_ssize_t ob_pypy_link;
struct _typeobject *ob_type;
} Object;
typedef struct {
void *buf;
Object *obj;
} Buffer;
typedef struct _typeobject {
Object *obj;
} Type;
"""
cts = parse_source(cdef)
Object = cts.definitions['Object']
assert isinstance(Object, lltype.Struct)
hash(Object)
def test_simple():
decl = "typedef ssize_t Py_ssize_t;"
cts = parse_source(decl)
assert cts.definitions == {'Py_ssize_t': rffi.SSIZE_T}
