| |
| /* A Lib object is what is in the "lib" attribute of a C extension |
| module originally created by recompile(). |
| |
| A Lib object is special in the sense that it has a custom |
| __getattr__ which returns C globals, functions and constants. The |
| original idea was to raise AttributeError for anything else, even |
| attrs like '__class__', but it breaks various things; now, standard |
| attrs are returned, but in the unlikely case where a user cdef()s |
| the same name, then the standard attr is hidden (and the various |
| things like introspection might break). |
| |
| A Lib object has got a reference to the _cffi_type_context_s |
| structure, which is used to create lazily the objects returned by |
| __getattr__. |
| */ |
| |
| struct CPyExtFunc_s { |
| PyMethodDef md; |
| void *direct_fn; |
| int type_index; |
| char doc[1]; |
| }; |
| |
| struct LibObject_s { |
| PyObject_HEAD |
| builder_c_t *l_types_builder; /* same as the one on the ffi object */ |
| PyObject *l_dict; /* content, built lazily */ |
| PyObject *l_libname; /* some string that gives the name of the lib */ |
| FFIObject *l_ffi; /* reference back to the ffi object */ |
| void *l_libhandle; /* the dlopen()ed handle, if any */ |
| int l_auto_close; /* if we must dlclose() this handle */ |
| }; |
| |
| static struct CPyExtFunc_s *_cpyextfunc_get(PyObject *x) |
| { |
| PyObject *y; |
| LibObject *lo; |
| PyCFunctionObject *fo; |
| |
| if (!PyCFunction_Check(x)) |
| return NULL; |
| y = PyCFunction_GET_SELF(x); |
| if (!LibObject_Check(y)) |
| return NULL; |
| |
| fo = (PyCFunctionObject *)x; |
| lo = (LibObject *)y; |
| if (lo->l_libname != fo->m_module) |
| return NULL; |
| |
| return (struct CPyExtFunc_s *)(fo->m_ml); |
| } |
| |
| static PyObject *_cpyextfunc_type(LibObject *lib, struct CPyExtFunc_s *exf) |
| { |
| PyObject *tuple, *result; |
| tuple = realize_c_type_or_func(lib->l_types_builder, |
| lib->l_types_builder->ctx.types, |
| exf->type_index); |
| if (tuple == NULL) |
| return NULL; |
| |
| /* 'tuple' is a tuple of length 1 containing the real CT_FUNCTIONPTR |
| object */ |
| result = PyTuple_GetItem(tuple, 0); |
| Py_XINCREF(result); |
| Py_DECREF(tuple); |
| return result; |
| } |
| |
| static PyObject *_cpyextfunc_type_index(PyObject *x) |
| { |
| struct CPyExtFunc_s *exf; |
| LibObject *lib; |
| |
| assert(PyErr_Occurred()); |
| exf = _cpyextfunc_get(x); |
| if (exf == NULL) |
| return NULL; /* still the same exception is set */ |
| |
| PyErr_Clear(); |
| |
| lib = (LibObject *)PyCFunction_GET_SELF(x); |
| return _cpyextfunc_type(lib, exf); |
| } |
| |
| static void cdlopen_close_ignore_errors(void *libhandle); /* forward */ |
| static void *cdlopen_fetch(PyObject *libname, void *libhandle, |
| const char *symbol); |
| |
| static void lib_dealloc(LibObject *lib) |
| { |
| PyObject_GC_UnTrack(lib); |
| if (lib->l_auto_close) |
| cdlopen_close_ignore_errors(lib->l_libhandle); |
| Py_DECREF(lib->l_dict); |
| Py_DECREF(lib->l_libname); |
| Py_DECREF(lib->l_ffi); |
| PyObject_GC_Del(lib); |
| } |
| |
| static int lib_traverse(LibObject *lib, visitproc visit, void *arg) |
| { |
| Py_VISIT(lib->l_dict); |
| Py_VISIT(lib->l_libname); |
| Py_VISIT(lib->l_ffi); |
| return 0; |
| } |
| |
| static PyObject *lib_repr(LibObject *lib) |
| { |
| return PyText_FromFormat("<Lib object for '%.200s'>", |
| PyText_AS_UTF8(lib->l_libname)); |
| } |
| |
| static PyObject *lib_build_cpython_func(LibObject *lib, |
| const struct _cffi_global_s *g, |
| const char *s, int flags) |
| { |
| /* First make sure the argument types and return type are really |
| built. The C extension code can then assume that they are, |
| by calling _cffi_type(). |
| */ |
| PyObject *result = NULL; |
| CTypeDescrObject **pfargs = NULL; |
| CTypeDescrObject *fresult; |
| Py_ssize_t nargs = 0; |
| struct CPyExtFunc_s *xfunc; |
| int i, type_index = _CFFI_GETARG(g->type_op); |
| _cffi_opcode_t *opcodes = lib->l_types_builder->ctx.types; |
| static const char *const format = ";\n\nCFFI C function from %s.lib"; |
| const char *libname = PyText_AS_UTF8(lib->l_libname); |
| struct funcbuilder_s funcbuilder; |
| |
| /* return type: */ |
| fresult = realize_c_func_return_type(lib->l_types_builder, opcodes, |
| type_index); |
| if (fresult == NULL) |
| goto error; |
| |
| /* argument types: */ |
| /* note that if the arguments are already built, they have a |
| pointer in the 'opcodes' array, and GETOP() returns a |
| random even value. But OP_FUNCTION_END is odd, so the |
| condition below still works correctly. */ |
| i = type_index + 1; |
| while (_CFFI_GETOP(opcodes[i]) != _CFFI_OP_FUNCTION_END) |
| i++; |
| pfargs = alloca(sizeof(CTypeDescrObject *) * (i - type_index - 1)); |
| i = type_index + 1; |
| while (_CFFI_GETOP(opcodes[i]) != _CFFI_OP_FUNCTION_END) { |
| CTypeDescrObject *ct = realize_c_type(lib->l_types_builder, opcodes, i); |
| if (ct == NULL) |
| goto error; |
| pfargs[nargs++] = ct; |
| i++; |
| } |
| |
| memset(&funcbuilder, 0, sizeof(funcbuilder)); |
| if (fb_build_name(&funcbuilder, g->name, pfargs, nargs, fresult, 0) < 0) |
| goto error; |
| |
| /* The few bytes of memory we allocate here appear to leak, but |
| this is not a real leak. Indeed, CPython never unloads its C |
| extension modules. There is only one PyMem_Malloc() per real |
| C function in a CFFI C extension module. That means that this |
| PyMem_Malloc() could also have been written with a static |
| global variable generated for each CPYTHON_BLTN defined in the |
| C extension, and the effect would be the same (but a bit more |
| complicated). |
| */ |
| xfunc = PyMem_Malloc(sizeof(struct CPyExtFunc_s) + |
| funcbuilder.nb_bytes + |
| strlen(format) + strlen(libname)); |
| if (xfunc == NULL) { |
| PyErr_NoMemory(); |
| goto error; |
| } |
| memset((char *)xfunc, 0, sizeof(struct CPyExtFunc_s)); |
| assert(g->address); |
| xfunc->md.ml_meth = (PyCFunction)g->address; |
| xfunc->md.ml_flags = flags; |
| xfunc->md.ml_name = g->name; |
| xfunc->md.ml_doc = xfunc->doc; |
| xfunc->direct_fn = g->size_or_direct_fn; |
| xfunc->type_index = type_index; |
| |
| /* build the docstring */ |
| funcbuilder.bufferp = xfunc->doc; |
| if (fb_build_name(&funcbuilder, g->name, pfargs, nargs, fresult, 0) < 0) |
| goto error; |
| sprintf(funcbuilder.bufferp - 1, format, libname); |
| /* done building the docstring */ |
| |
| result = PyCFunction_NewEx(&xfunc->md, (PyObject *)lib, lib->l_libname); |
| /* fall-through */ |
| error: |
| Py_XDECREF(fresult); |
| while (nargs > 0) { |
| --nargs; |
| Py_DECREF(pfargs[nargs]); |
| } |
| return result; |
| } |
| |
| static PyObject *lib_build_and_cache_attr(LibObject *lib, PyObject *name, |
| int recursion) |
| { |
| /* does not return a new reference! */ |
| PyObject *x; |
| int index; |
| const struct _cffi_global_s *g; |
| CTypeDescrObject *ct; |
| builder_c_t *types_builder = lib->l_types_builder; |
| const char *s = PyText_AsUTF8(name); |
| if (s == NULL) |
| return NULL; |
| |
| index = search_in_globals(&types_builder->ctx, s, strlen(s)); |
| if (index < 0) { |
| |
| if (types_builder->included_libs != NULL) { |
| Py_ssize_t i; |
| PyObject *included_ffis = types_builder->included_ffis; |
| PyObject *included_libs = types_builder->included_libs; |
| |
| if (recursion > 100) { |
| PyErr_SetString(PyExc_RuntimeError, |
| "recursion overflow in ffi.include() delegations"); |
| return NULL; |
| } |
| |
| for (i = 0; i < PyTuple_GET_SIZE(included_libs); i++) { |
| LibObject *lib1; |
| |
| lib1 = (LibObject *)PyTuple_GET_ITEM(included_libs, i); |
| if (lib1 != NULL) { |
| x = PyDict_GetItem(lib1->l_dict, name); |
| if (x != NULL) { |
| Py_INCREF(x); |
| goto found; |
| } |
| x = lib_build_and_cache_attr(lib1, name, recursion + 1); |
| if (x != NULL) { |
| Py_INCREF(x); |
| goto found; |
| } |
| } |
| else { |
| FFIObject *ffi1; |
| |
| ffi1 = (FFIObject *)PyTuple_GetItem(included_ffis, i); |
| if (ffi1 == NULL) |
| return NULL; |
| x = ffi_fetch_int_constant(ffi1, s, recursion + 1); |
| if (x != NULL) |
| goto found; |
| } |
| if (PyErr_Occurred()) |
| return NULL; |
| } |
| } |
| |
| if (recursion > 0) |
| return NULL; /* no error set, continue looking elsewhere */ |
| |
| PyErr_Format(PyExc_AttributeError, |
| "cffi library '%.200s' has no function, constant " |
| "or global variable named '%.200s'", |
| PyText_AS_UTF8(lib->l_libname), s); |
| return NULL; |
| } |
| |
| g = &types_builder->ctx.globals[index]; |
| |
| switch (_CFFI_GETOP(g->type_op)) { |
| |
| case _CFFI_OP_CPYTHON_BLTN_V: |
| x = lib_build_cpython_func(lib, g, s, METH_VARARGS); |
| break; |
| |
| case _CFFI_OP_CPYTHON_BLTN_N: |
| x = lib_build_cpython_func(lib, g, s, METH_NOARGS); |
| break; |
| |
| case _CFFI_OP_CPYTHON_BLTN_O: |
| x = lib_build_cpython_func(lib, g, s, METH_O); |
| break; |
| |
| case _CFFI_OP_CONSTANT_INT: |
| case _CFFI_OP_ENUM: |
| { |
| /* a constant integer whose value, in an "unsigned long long", |
| is obtained by calling the function at g->address */ |
| x = realize_global_int(types_builder, index); |
| break; |
| } |
| |
| case _CFFI_OP_CONSTANT: |
| case _CFFI_OP_DLOPEN_CONST: |
| { |
| /* a constant which is not of integer type */ |
| char *data; |
| ct = realize_c_type(types_builder, types_builder->ctx.types, |
| _CFFI_GETARG(g->type_op)); |
| if (ct == NULL) |
| return NULL; |
| |
| if (ct->ct_size <= 0) { |
| PyErr_Format(FFIError, "constant '%s' is of type '%s', " |
| "whose size is not known", s, ct->ct_name); |
| return NULL; |
| } |
| if (g->address == NULL) { |
| /* for dlopen() style */ |
| assert(_CFFI_GETOP(g->type_op) == _CFFI_OP_DLOPEN_CONST); |
| data = cdlopen_fetch(lib->l_libname, lib->l_libhandle, s); |
| if (data == NULL) |
| return NULL; |
| } |
| else { |
| /* The few bytes of memory we allocate here appear to leak, but |
| this is not a real leak. Indeed, CPython never unloads its C |
| extension modules. There is only one PyMem_Malloc() per real |
| non-integer C constant in a CFFI C extension module. That |
| means that this PyMem_Malloc() could also have been written |
| with a static global variable generated for each OP_CONSTANT |
| defined in the C extension, and the effect would be the same |
| (but a bit more complicated). |
| |
| Note that we used to do alloca(), but see issue #198. We |
| could still do alloca(), or explicit PyMem_Free(), in some |
| cases; but there is no point and it only makes the remaining |
| less-common cases more suspicious. |
| */ |
| assert(_CFFI_GETOP(g->type_op) == _CFFI_OP_CONSTANT); |
| data = PyMem_Malloc(ct->ct_size); |
| if (data == NULL) { |
| PyErr_NoMemory(); |
| return NULL; |
| } |
| ((void(*)(char*))g->address)(data); |
| } |
| x = convert_to_object(data, ct); |
| Py_DECREF(ct); |
| break; |
| } |
| |
| case _CFFI_OP_GLOBAL_VAR: |
| { |
| /* global variable of the exact type specified here |
| (nowadays, only used by the ABI mode or backward |
| compatibility; see _CFFI_OP_GLOBAL_VAR_F for the API mode) |
| */ |
| Py_ssize_t g_size = (Py_ssize_t)g->size_or_direct_fn; |
| ct = realize_c_type(types_builder, types_builder->ctx.types, |
| _CFFI_GETARG(g->type_op)); |
| if (ct == NULL) |
| return NULL; |
| if (g_size != ct->ct_size && g_size != 0 && ct->ct_size > 0) { |
| PyErr_Format(FFIError, |
| "global variable '%.200s' should be %zd bytes " |
| "according to the cdef, but is actually %zd", |
| s, ct->ct_size, g_size); |
| x = NULL; |
| } |
| else { |
| void *address = g->address; |
| if (address == NULL) { |
| /* for dlopen() style */ |
| address = cdlopen_fetch(lib->l_libname, lib->l_libhandle, s); |
| if (address == NULL) |
| return NULL; |
| } |
| x = make_global_var(name, ct, address, NULL); |
| } |
| Py_DECREF(ct); |
| break; |
| } |
| |
| case _CFFI_OP_GLOBAL_VAR_F: |
| ct = realize_c_type(types_builder, types_builder->ctx.types, |
| _CFFI_GETARG(g->type_op)); |
| if (ct == NULL) |
| return NULL; |
| x = make_global_var(name, ct, NULL, (gs_fetch_addr_fn)g->address); |
| Py_DECREF(ct); |
| break; |
| |
| case _CFFI_OP_DLOPEN_FUNC: |
| { |
| /* For dlopen(): the function of the given 'name'. We use |
| dlsym() to get the address of something in the dynamic |
| library, which we interpret as being exactly a function of |
| the specified type. |
| */ |
| PyObject *ct1; |
| void *address = cdlopen_fetch(lib->l_libname, lib->l_libhandle, s); |
| if (address == NULL) |
| return NULL; |
| |
| ct1 = realize_c_type_or_func(types_builder, |
| types_builder->ctx.types, |
| _CFFI_GETARG(g->type_op)); |
| if (ct1 == NULL) |
| return NULL; |
| |
| assert(!CTypeDescr_Check(ct1)); /* must be a function */ |
| x = new_simple_cdata(address, unwrap_fn_as_fnptr(ct1)); |
| |
| Py_DECREF(ct1); |
| break; |
| } |
| |
| case _CFFI_OP_EXTERN_PYTHON: |
| /* for reading 'lib.bar' where bar is declared with extern "Python" */ |
| ct = realize_c_type(types_builder, types_builder->ctx.types, |
| _CFFI_GETARG(g->type_op)); |
| if (ct == NULL) |
| return NULL; |
| x = convert_to_object((char *)&g->size_or_direct_fn, ct); |
| Py_DECREF(ct); |
| break; |
| |
| default: |
| PyErr_Format(PyExc_NotImplementedError, "in lib_build_attr: op=%d", |
| (int)_CFFI_GETOP(g->type_op)); |
| return NULL; |
| } |
| |
| found: |
| if (x != NULL) { |
| int err = PyDict_SetItem(lib->l_dict, name, x); |
| Py_DECREF(x); |
| if (err < 0) /* else there is still one ref left in the dict */ |
| return NULL; |
| } |
| return x; |
| } |
| |
| #define LIB_GET_OR_CACHE_ADDR(x, lib, name, error) \ |
| do { \ |
| x = PyDict_GetItem(lib->l_dict, name); \ |
| if (x == NULL) { \ |
| x = lib_build_and_cache_attr(lib, name, 0); \ |
| if (x == NULL) { \ |
| error; \ |
| } \ |
| } \ |
| } while (0) |
| |
| static PyObject *_lib_dir1(LibObject *lib, int ignore_global_vars) |
| { |
| const struct _cffi_global_s *g = lib->l_types_builder->ctx.globals; |
| int i, count = 0, total = lib->l_types_builder->ctx.num_globals; |
| PyObject *s, *lst = PyList_New(total); |
| if (lst == NULL) |
| return NULL; |
| |
| for (i = 0; i < total; i++) { |
| if (ignore_global_vars) { |
| int op = _CFFI_GETOP(g[i].type_op); |
| if (op == _CFFI_OP_GLOBAL_VAR || op == _CFFI_OP_GLOBAL_VAR_F) |
| continue; |
| } |
| s = PyText_FromString(g[i].name); |
| if (s == NULL) |
| goto error; |
| PyList_SET_ITEM(lst, count, s); |
| count++; |
| } |
| if (PyList_SetSlice(lst, count, total, NULL) < 0) |
| goto error; |
| return lst; |
| |
| error: |
| Py_DECREF(lst); |
| return NULL; |
| } |
| |
| static PyObject *_lib_dict(LibObject *lib) |
| { |
| const struct _cffi_global_s *g = lib->l_types_builder->ctx.globals; |
| int i, total = lib->l_types_builder->ctx.num_globals; |
| PyObject *name, *x, *d = PyDict_New(); |
| if (d == NULL) |
| return NULL; |
| |
| for (i = 0; i < total; i++) { |
| name = PyText_FromString(g[i].name); |
| if (name == NULL) |
| goto error; |
| |
| LIB_GET_OR_CACHE_ADDR(x, lib, name, goto error); |
| |
| if (PyDict_SetItem(d, name, x) < 0) |
| goto error; |
| Py_DECREF(name); |
| } |
| return d; |
| |
| error: |
| Py_XDECREF(name); |
| Py_DECREF(d); |
| return NULL; |
| } |
| |
| static PyObject *lib_getattr(LibObject *lib, PyObject *name) |
| { |
| const char *p; |
| PyObject *x; |
| LIB_GET_OR_CACHE_ADDR(x, lib, name, goto missing); |
| |
| if (GlobSupport_Check(x)) { |
| return read_global_var((GlobSupportObject *)x); |
| } |
| Py_INCREF(x); |
| return x; |
| |
| missing: |
| /*** ATTRIBUTEERROR IS SET HERE ***/ |
| p = PyText_AsUTF8(name); |
| if (p == NULL) |
| return NULL; |
| if (strcmp(p, "__all__") == 0) { |
| PyErr_Clear(); |
| return _lib_dir1(lib, 1); |
| } |
| if (strcmp(p, "__dict__") == 0) { |
| PyErr_Clear(); |
| return _lib_dict(lib); |
| } |
| if (strcmp(p, "__class__") == 0) { |
| PyErr_Clear(); |
| x = (PyObject *)&PyModule_Type; |
| /* ^^^ used to be Py_TYPE(lib). But HAAAAAACK! That makes |
| help() behave correctly. I couldn't find a more reasonable |
| way. Urgh. */ |
| Py_INCREF(x); |
| return x; |
| } |
| /* this hack is for Python 3.5, and also to give a more |
| module-like behavior */ |
| if (strcmp(p, "__name__") == 0) { |
| PyErr_Clear(); |
| return PyText_FromFormat("%s.lib", PyText_AS_UTF8(lib->l_libname)); |
| } |
| #if PY_MAJOR_VERSION >= 3 |
| if (strcmp(p, "__loader__") == 0 || strcmp(p, "__spec__") == 0) { |
| /* some more module-like behavior hacks */ |
| PyErr_Clear(); |
| Py_INCREF(Py_None); |
| return Py_None; |
| } |
| #endif |
| return NULL; |
| } |
| |
| static int lib_setattr(LibObject *lib, PyObject *name, PyObject *val) |
| { |
| PyObject *x; |
| LIB_GET_OR_CACHE_ADDR(x, lib, name, return -1); |
| |
| if (val == NULL) { |
| PyErr_SetString(PyExc_AttributeError, "C attribute cannot be deleted"); |
| return -1; |
| } |
| |
| if (GlobSupport_Check(x)) { |
| return write_global_var((GlobSupportObject *)x, val); |
| } |
| |
| PyErr_Format(PyExc_AttributeError, |
| "cannot write to function or constant '%.200s'", |
| PyText_Check(name) ? PyText_AS_UTF8(name) : "?"); |
| return -1; |
| } |
| |
| static PyObject *lib_dir(PyObject *self, PyObject *noarg) |
| { |
| return _lib_dir1((LibObject *)self, 0); |
| } |
| |
| static PyMethodDef lib_methods[] = { |
| {"__dir__", lib_dir, METH_NOARGS}, |
| {NULL, NULL} /* sentinel */ |
| }; |
| |
| static PyTypeObject Lib_Type = { |
| PyVarObject_HEAD_INIT(NULL, 0) |
| "_cffi_backend.Lib", |
| sizeof(LibObject), |
| 0, |
| (destructor)lib_dealloc, /* tp_dealloc */ |
| 0, /* tp_print */ |
| 0, /* tp_getattr */ |
| 0, /* tp_setattr */ |
| 0, /* tp_compare */ |
| (reprfunc)lib_repr, /* tp_repr */ |
| 0, /* tp_as_number */ |
| 0, /* tp_as_sequence */ |
| 0, /* tp_as_mapping */ |
| 0, /* tp_hash */ |
| 0, /* tp_call */ |
| 0, /* tp_str */ |
| (getattrofunc)lib_getattr, /* tp_getattro */ |
| (setattrofunc)lib_setattr, /* tp_setattro */ |
| 0, /* tp_as_buffer */ |
| Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC, /* tp_flags */ |
| 0, /* tp_doc */ |
| (traverseproc)lib_traverse, /* tp_traverse */ |
| 0, /* tp_clear */ |
| 0, /* tp_richcompare */ |
| 0, /* tp_weaklistoffset */ |
| 0, /* tp_iter */ |
| 0, /* tp_iternext */ |
| lib_methods, /* tp_methods */ |
| 0, /* tp_members */ |
| 0, /* tp_getset */ |
| 0, /* tp_base */ |
| 0, /* tp_dict */ |
| 0, /* tp_descr_get */ |
| 0, /* tp_descr_set */ |
| offsetof(LibObject, l_dict), /* tp_dictoffset */ |
| }; |
| |
| static LibObject *lib_internal_new(FFIObject *ffi, const char *module_name, |
| void *dlopen_libhandle, int auto_close) |
| { |
| LibObject *lib; |
| PyObject *libname, *dict; |
| |
| libname = PyText_FromString(module_name); |
| if (libname == NULL) |
| goto err1; |
| |
| dict = PyDict_New(); |
| if (dict == NULL) |
| goto err2; |
| |
| lib = (LibObject *)PyType_GenericAlloc(&Lib_Type, 0); |
| if (lib == NULL) |
| goto err3; |
| |
| lib->l_types_builder = &ffi->types_builder; |
| lib->l_dict = dict; |
| lib->l_libname = libname; |
| Py_INCREF(ffi); |
| lib->l_ffi = ffi; |
| lib->l_libhandle = dlopen_libhandle; |
| lib->l_auto_close = auto_close; |
| return lib; |
| |
| err3: |
| Py_DECREF(dict); |
| err2: |
| Py_DECREF(libname); |
| err1: |
| if (auto_close) |
| cdlopen_close_ignore_errors(dlopen_libhandle); |
| return NULL; |
| } |
| |
| static PyObject *address_of_global_var(PyObject *args) |
| { |
| LibObject *lib; |
| PyObject *x, *o_varname; |
| char *varname; |
| |
| if (!PyArg_ParseTuple(args, "O!s", &Lib_Type, &lib, &varname)) |
| return NULL; |
| |
| /* rebuild a string from 'varname', to do typechecks and to force |
| a unicode back to a plain string (on python 2) */ |
| o_varname = PyText_FromString(varname); |
| if (o_varname == NULL) |
| return NULL; |
| |
| LIB_GET_OR_CACHE_ADDR(x, lib, o_varname, goto error); |
| Py_DECREF(o_varname); |
| if (GlobSupport_Check(x)) { |
| return cg_addressof_global_var((GlobSupportObject *)x); |
| } |
| else { |
| struct CPyExtFunc_s *exf = _cpyextfunc_get(x); |
| if (exf != NULL) { /* an OP_CPYTHON_BLTN: '&func' returns a cdata */ |
| PyObject *ct; |
| if (exf->direct_fn == NULL) { |
| Py_INCREF(x); /* backward compatibility */ |
| return x; |
| } |
| ct = _cpyextfunc_type(lib, exf); |
| if (ct == NULL) |
| return NULL; |
| x = new_simple_cdata(exf->direct_fn, (CTypeDescrObject *)ct); |
| Py_DECREF(ct); |
| return x; |
| } |
| if (CData_Check(x) && /* a constant functionptr cdata: 'f == &f' */ |
| (((CDataObject *)x)->c_type->ct_flags & CT_FUNCTIONPTR) != 0) { |
| Py_INCREF(x); |
| return x; |
| } |
| else { |
| PyErr_Format(PyExc_AttributeError, |
| "cannot take the address of the constant '%.200s'", |
| varname); |
| return NULL; |
| } |
| } |
| |
| error: |
| Py_DECREF(o_varname); |
| return NULL; |
| } |