diff -r ffa851df0825 -r 2fb8b9db1c86 symbian-qemu-0.9.1-12/python-2.6.1/Modules/_ctypes/ctypes.h --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/symbian-qemu-0.9.1-12/python-2.6.1/Modules/_ctypes/ctypes.h Fri Jul 31 15:01:17 2009 +0100 @@ -0,0 +1,455 @@ +/***************************************************************** + This file should be kept compatible with Python 2.3, see PEP 291. + *****************************************************************/ + +#if defined (__SVR4) && defined (__sun) +# include +#endif + +#if (PY_VERSION_HEX < 0x02040000) +#define PyDict_CheckExact(ob) (Py_TYPE(ob) == &PyDict_Type) +#endif + +#if (PY_VERSION_HEX < 0x02050000) +typedef int Py_ssize_t; +#define PyInt_FromSsize_t PyInt_FromLong +#define PyNumber_AsSsize_t(ob, exc) PyInt_AsLong(ob) +#define PyIndex_Check(ob) PyInt_Check(ob) +typedef Py_ssize_t (*readbufferproc)(PyObject *, Py_ssize_t, void **); +typedef Py_ssize_t (*writebufferproc)(PyObject *, Py_ssize_t, void **); +typedef Py_ssize_t (*segcountproc)(PyObject *, Py_ssize_t *); +typedef Py_ssize_t (*charbufferproc)(PyObject *, Py_ssize_t, char **); +#endif + +#if (PY_VERSION_HEX < 0x02060000) +#define Py_TYPE(ob) (((PyObject*)(ob))->ob_type) +#define PyVarObject_HEAD_INIT(type, size) \ + PyObject_HEAD_INIT(type) size, +#define PyImport_ImportModuleNoBlock PyImport_ImportModule +#define PyLong_FromSsize_t PyInt_FromLong +#define Py_TPFLAGS_HAVE_NEWBUFFER 0 +#endif + + +#ifndef MS_WIN32 +#define max(a, b) ((a) > (b) ? (a) : (b)) +#define min(a, b) ((a) < (b) ? (a) : (b)) + +#define PARAMFLAG_FIN 0x1 +#define PARAMFLAG_FOUT 0x2 +#define PARAMFLAG_FLCID 0x4 +#endif + +/* + Backwards compatibility: + Python2.2 used LONG_LONG instead of PY_LONG_LONG +*/ +#if defined(HAVE_LONG_LONG) && !defined(PY_LONG_LONG) +#define PY_LONG_LONG LONG_LONG +#endif + +typedef struct tagPyCArgObject PyCArgObject; +typedef struct tagCDataObject CDataObject; +typedef PyObject *(* GETFUNC)(void *, Py_ssize_t size); +typedef PyObject *(* SETFUNC)(void *, PyObject *value, Py_ssize_t size); +typedef PyCArgObject *(* PARAMFUNC)(CDataObject *obj); + +/* A default buffer in CDataObject, which can be used for small C types. If +this buffer is too small, PyMem_Malloc will be called to create a larger one, +and this one is not used. + +Making CDataObject a variable size object would be a better solution, but more +difficult in the presence of CFuncPtrObject. Maybe later. +*/ +union value { + char c[16]; + short s; + int i; + long l; + float f; + double d; +#ifdef HAVE_LONG_LONG + PY_LONG_LONG ll; +#endif + long double D; +}; + +/* + Hm. Are there CDataObject's which do not need the b_objects member? In + this case we probably should introduce b_flags to mark it as present... If + b_objects is not present/unused b_length is unneeded as well. +*/ + +struct tagCDataObject { + PyObject_HEAD + char *b_ptr; /* pointer to memory block */ + int b_needsfree; /* need _we_ free the memory? */ + CDataObject *b_base; /* pointer to base object or NULL */ + Py_ssize_t b_size; /* size of memory block in bytes */ + Py_ssize_t b_length; /* number of references we need */ + Py_ssize_t b_index; /* index of this object into base's + b_object list */ + PyObject *b_objects; /* dictionary of references we need to keep, or Py_None */ + union value b_value; +}; + +typedef struct { + PyObject_VAR_HEAD + ffi_closure *pcl; /* the C callable */ + ffi_cif cif; + int flags; + PyObject *converters; + PyObject *callable; + PyObject *restype; + SETFUNC setfunc; + ffi_type *ffi_restype; + ffi_type *atypes[1]; +} CThunkObject; +extern PyTypeObject CThunk_Type; +#define CThunk_CheckExact(v) ((v)->ob_type == &CThunk_Type) + +typedef struct { + /* First part identical to tagCDataObject */ + PyObject_HEAD + char *b_ptr; /* pointer to memory block */ + int b_needsfree; /* need _we_ free the memory? */ + CDataObject *b_base; /* pointer to base object or NULL */ + Py_ssize_t b_size; /* size of memory block in bytes */ + Py_ssize_t b_length; /* number of references we need */ + Py_ssize_t b_index; /* index of this object into base's + b_object list */ + PyObject *b_objects; /* list of references we need to keep */ + union value b_value; + /* end of tagCDataObject, additional fields follow */ + + CThunkObject *thunk; + PyObject *callable; + + /* These two fields will override the ones in the type's stgdict if + they are set */ + PyObject *converters; + PyObject *argtypes; + PyObject *restype; + PyObject *checker; + PyObject *errcheck; +#ifdef MS_WIN32 + int index; + GUID *iid; +#endif + PyObject *paramflags; +} CFuncPtrObject; + +extern PyTypeObject StgDict_Type; +#define StgDict_CheckExact(v) ((v)->ob_type == &StgDict_Type) +#define StgDict_Check(v) PyObject_TypeCheck(v, &StgDict_Type) + +extern int StructUnionType_update_stgdict(PyObject *fields, PyObject *type, int isStruct); +extern int PyType_stginfo(PyTypeObject *self, Py_ssize_t *psize, Py_ssize_t *palign, Py_ssize_t *plength); +extern int PyObject_stginfo(PyObject *self, Py_ssize_t *psize, Py_ssize_t *palign, Py_ssize_t *plength); + + + +extern PyTypeObject CData_Type; +#define CDataObject_CheckExact(v) ((v)->ob_type == &CData_Type) +#define CDataObject_Check(v) PyObject_TypeCheck(v, &CData_Type) + +extern PyTypeObject SimpleType_Type; +#define SimpleTypeObject_CheckExact(v) ((v)->ob_type == &SimpleType_Type) +#define SimpleTypeObject_Check(v) PyObject_TypeCheck(v, &SimpleType_Type) + +extern PyTypeObject CField_Type; +extern struct fielddesc *getentry(char *fmt); + + +extern PyObject * +CField_FromDesc(PyObject *desc, Py_ssize_t index, + Py_ssize_t *pfield_size, int bitsize, int *pbitofs, + Py_ssize_t *psize, Py_ssize_t *poffset, Py_ssize_t *palign, + int pack, int is_big_endian); + +extern PyObject *CData_AtAddress(PyObject *type, void *buf); +extern PyObject *CData_FromBytes(PyObject *type, char *data, Py_ssize_t length); + +extern PyTypeObject ArrayType_Type; +extern PyTypeObject Array_Type; +extern PyTypeObject PointerType_Type; +extern PyTypeObject Pointer_Type; +extern PyTypeObject CFuncPtr_Type; +extern PyTypeObject CFuncPtrType_Type; +extern PyTypeObject StructType_Type; + +#define ArrayTypeObject_Check(v) PyObject_TypeCheck(v, &ArrayType_Type) +#define ArrayObject_Check(v) PyObject_TypeCheck(v, &Array_Type) +#define PointerObject_Check(v) PyObject_TypeCheck(v, &Pointer_Type) +#define PointerTypeObject_Check(v) PyObject_TypeCheck(v, &PointerType_Type) +#define CFuncPtrObject_Check(v) PyObject_TypeCheck(v, &CFuncPtr_Type) +#define CFuncPtrTypeObject_Check(v) PyObject_TypeCheck(v, &CFuncPtrType_Type) +#define StructTypeObject_Check(v) PyObject_TypeCheck(v, &StructType_Type) + +extern PyObject * +CreateArrayType(PyObject *itemtype, Py_ssize_t length); + +extern void init_callbacks_in_module(PyObject *m); + +extern PyMethodDef module_methods[]; + +extern CThunkObject *AllocFunctionCallback(PyObject *callable, + PyObject *converters, + PyObject *restype, + int flags); +/* a table entry describing a predefined ctypes type */ +struct fielddesc { + char code; + SETFUNC setfunc; + GETFUNC getfunc; + ffi_type *pffi_type; /* always statically allocated */ + SETFUNC setfunc_swapped; + GETFUNC getfunc_swapped; +}; + +typedef struct { + PyObject_HEAD + Py_ssize_t offset; + Py_ssize_t size; + Py_ssize_t index; /* Index into CDataObject's + object array */ + PyObject *proto; /* a type or NULL */ + GETFUNC getfunc; /* getter function if proto is NULL */ + SETFUNC setfunc; /* setter function if proto is NULL */ + int anonymous; +} CFieldObject; + +/* A subclass of PyDictObject, used as the instance dictionary of ctypes + metatypes */ +typedef struct { + PyDictObject dict; /* first part identical to PyDictObject */ +/* The size and align fields are unneeded, they are in ffi_type as well. As + an experiment shows, it's trivial to get rid of them, the only thing to + remember is that in ArrayType_new the ffi_type fields must be filled in - + so far it was unneeded because libffi doesn't support arrays at all + (because they are passed as pointers to function calls anyway). But it's + too much risk to change that now, and there are other fields which doen't + belong into this structure anyway. Maybe in ctypes 2.0... (ctypes 2000?) +*/ + Py_ssize_t size; /* number of bytes */ + Py_ssize_t align; /* alignment requirements */ + Py_ssize_t length; /* number of fields */ + ffi_type ffi_type_pointer; + PyObject *proto; /* Only for Pointer/ArrayObject */ + SETFUNC setfunc; /* Only for simple objects */ + GETFUNC getfunc; /* Only for simple objects */ + PARAMFUNC paramfunc; + + /* Following fields only used by CFuncPtrType_Type instances */ + PyObject *argtypes; /* tuple of CDataObjects */ + PyObject *converters; /* tuple([t.from_param for t in argtypes]) */ + PyObject *restype; /* CDataObject or NULL */ + PyObject *checker; + int flags; /* calling convention and such */ + + /* pep3118 fields, pointers neeed PyMem_Free */ + char *format; + int ndim; + Py_ssize_t *shape; +/* Py_ssize_t *strides; */ /* unused in ctypes */ +/* Py_ssize_t *suboffsets; */ /* unused in ctypes */ + +} StgDictObject; + +/**************************************************************** + StgDictObject fields + + setfunc and getfunc is only set for simple data types, it is copied from the + corresponding fielddesc entry. These are functions to set and get the value + in a memory block. + They should probably by used by other types as well. + + proto is only used for Pointer and Array types - it points to the item type + object. + + Probably all the magic ctypes methods (like from_param) should have C + callable wrappers in the StgDictObject. For simple data type, for example, + the fielddesc table could have entries for C codec from_param functions or + other methods as well, if a subtype overrides this method in Python at + construction time, or assigns to it later, tp_setattro should update the + StgDictObject function to a generic one. + + Currently, CFuncPtr types have 'converters' and 'checker' entries in their + type dict. They are only used to cache attributes from other entries, whihc + is wrong. + + One use case is the .value attribute that all simple types have. But some + complex structures, like VARIANT, represent a single value also, and should + have this attribute. + + Another use case is a _check_retval_ function, which is called when a ctypes + type is used as return type of a function to validate and compute the return + value. + + Common ctypes protocol: + + - setfunc: store a python value in a memory block + - getfunc: convert data from a memory block into a python value + + - checkfunc: validate and convert a return value from a function call + - toparamfunc: convert a python value into a function argument + +*****************************************************************/ + +/* May return NULL, but does not set an exception! */ +extern StgDictObject *PyType_stgdict(PyObject *obj); + +/* May return NULL, but does not set an exception! */ +extern StgDictObject *PyObject_stgdict(PyObject *self); + +extern int StgDict_clone(StgDictObject *src, StgDictObject *dst); + +typedef int(* PPROC)(void); + +PyObject *_CallProc(PPROC pProc, + PyObject *arguments, +#ifdef MS_WIN32 + IUnknown *pIUnk, + GUID *iid, +#endif + int flags, + PyObject *argtypes, + PyObject *restype, + PyObject *checker); + + +#define FUNCFLAG_STDCALL 0x0 +#define FUNCFLAG_CDECL 0x1 +#define FUNCFLAG_HRESULT 0x2 +#define FUNCFLAG_PYTHONAPI 0x4 +#define FUNCFLAG_USE_ERRNO 0x8 +#define FUNCFLAG_USE_LASTERROR 0x10 + +#define TYPEFLAG_ISPOINTER 0x100 +#define TYPEFLAG_HASPOINTER 0x200 + +#define DICTFLAG_FINAL 0x1000 + +struct tagPyCArgObject { + PyObject_HEAD + ffi_type *pffi_type; + char tag; + union { + char c; + char b; + short h; + int i; + long l; +#ifdef HAVE_LONG_LONG + PY_LONG_LONG q; +#endif + long double D; + double d; + float f; + void *p; + } value; + PyObject *obj; + Py_ssize_t size; /* for the 'V' tag */ +}; + +extern PyTypeObject PyCArg_Type; +extern PyCArgObject *new_CArgObject(void); +#define PyCArg_CheckExact(v) ((v)->ob_type == &PyCArg_Type) +extern PyCArgObject *new_CArgObject(void); + +extern PyObject * +CData_get(PyObject *type, GETFUNC getfunc, PyObject *src, + Py_ssize_t index, Py_ssize_t size, char *ptr); + +extern int +CData_set(PyObject *dst, PyObject *type, SETFUNC setfunc, PyObject *value, + Py_ssize_t index, Py_ssize_t size, char *ptr); + +extern void Extend_Error_Info(PyObject *exc_class, char *fmt, ...); + +struct basespec { + CDataObject *base; + Py_ssize_t index; + char *adr; +}; + +extern char basespec_string[]; + +extern ffi_type *GetType(PyObject *obj); + +/* exception classes */ +extern PyObject *PyExc_ArgError; + +extern char *conversion_mode_encoding; +extern char *conversion_mode_errors; + +/* Python 2.4 macros, which are not available in Python 2.3 */ + +#ifndef Py_CLEAR +#define Py_CLEAR(op) \ + do { \ + if (op) { \ + PyObject *tmp = (PyObject *)(op); \ + (op) = NULL; \ + Py_DECREF(tmp); \ + } \ + } while (0) +#endif + +#ifndef Py_VISIT +/* Utility macro to help write tp_traverse functions. + * To use this macro, the tp_traverse function must name its arguments + * "visit" and "arg". This is intended to keep tp_traverse functions + * looking as much alike as possible. + */ +#define Py_VISIT(op) \ + do { \ + if (op) { \ + int vret = visit((op), arg); \ + if (vret) \ + return vret; \ + } \ + } while (0) +#endif + +/* Python's PyUnicode_*WideChar functions are broken ... */ +#if defined(Py_USING_UNICODE) && defined(HAVE_WCHAR_H) +# define CTYPES_UNICODE +#endif + + +#ifdef CTYPES_UNICODE +# undef PyUnicode_FromWideChar +# define PyUnicode_FromWideChar My_PyUnicode_FromWideChar + +# undef PyUnicode_AsWideChar +# define PyUnicode_AsWideChar My_PyUnicode_AsWideChar + +extern PyObject *My_PyUnicode_FromWideChar(const wchar_t *, Py_ssize_t); +extern Py_ssize_t My_PyUnicode_AsWideChar(PyUnicodeObject *, wchar_t *, Py_ssize_t); + +#endif + +extern void FreeClosure(void *); +extern void *MallocClosure(void); + +extern void _AddTraceback(char *, char *, int); + +extern PyObject *CData_FromBaseObj(PyObject *type, PyObject *base, Py_ssize_t index, char *adr); +extern char *alloc_format_string(const char *prefix, const char *suffix); + +/* XXX better name needed! */ +extern int IsSimpleSubType(PyObject *obj); + +extern PyObject *_pointer_type_cache; +PyObject *get_error_object(int **pspace); + +#ifdef MS_WIN32 +extern PyObject *ComError; +#endif + +/* + Local Variables: + compile-command: "python setup.py -q build install --home ~" + End: +*/