X-Git-Url: https://git.distorted.org.uk/~mdw/pyke/blobdiff_plain/fcfa1c8692de00ec31dfedf5614428df571b7441..1c0e9c88b06e3422c7afa0cf4bd3fbe166b401da:/pyke.h diff --git a/pyke.h b/pyke.h index 4e67464..cd13507 100644 --- a/pyke.h +++ b/pyke.h @@ -62,6 +62,124 @@ PRIVATE_SYMBOLS; +/*----- Python version compatibility hacks --------------------------------*/ + +/* The handy `Py_TYPE' and `Py_SIZE' macros turned up in 2.6. Define them if + * they're not already here. + */ +#ifndef Py_TYPE +# define Py_TYPE(obj) (((PyObject *)(obj))->ob_type) +#endif +#ifndef Py_SIZE +# define Py_SIZE(obj) (((PyVarObject *)(obj))->ob_size) +#endif + +/* Python 3 added internal structure to the various object headers, and + * defined a new macro `PyVarObject_HEAD_INIT' to initialize variable-length + * static instances correctly. Define it if it's not already here. + */ +#ifndef PyVarObject_HEAD_INIT +# define PyVarObject_HEAD_INIT(super, sz) PyObject_HEAD_INIT(super) sz, +#endif + +/* Python 3.2 changed the type of hash values, so paper over this annoying + * difference. + */ +#if PY_VERSION_HEX < 0x03020000 + typedef long Py_hash_t; +#endif + +/* Plain octet strings. Python 2 calls these `str', while Python 3 calls + * them `bytes'. We call them `bin' here, and define the following. + * + * * `BINOBJ' is the C type of a `bin' object. + * * `BIN_TYPE' is the Python `type' object for `bin'. + * * `BIN_CHECK(OBJ)' is true if OBJ is a `bin' object. + * * `BIN_PTR(OBJ)' points to the first octet of OBJ, without checking! + * * `BIN_LEN(OBJ)' yields the length of OBJ in octets, without checking! + * * `BIN_FROMSTR(STR)' makes a `bin' object from a null-terminated string. + * * `BIN_FORMAT(FMT, ARGS...)' and `BIN_VFORMAT(FMT, AP)' make a `bin' + * object from a `printf'-like format string and arguments. + * * `BIN_PREPAREWRITE(OBJ, PTR, LEN)' prepares to make a `bin' object: it + * sets PTR to point to a buffer of LEN bytes; call `BIN_DONEWRITE' when + * finished. The variable OBJ will eventually be the resulting object, + * but until `BIN_DONEWRITE' is called, it may in fact be some different + * object. + * * `BIN_DONEWRITE(OBJ, LEN)' completes making a `bin' object: it adjusts + * its length to be LEN, which must not be larger than the LEN given to + * `BIN_PREPAREWRITE', and sets OBJ to point to the finished object. + * * `BIN_SETLEN(OBJ, LEN)' adjusts the length of OBJ downwards to LEN, + * without checking! + # * `Y' is a format character for `PyArg_ParseTuple...' for retrieving a + * null-terminated octet string from a `bin' object. + # * `YN' is a format character for `PyArg_ParseTuple...' for retrieving an + * octet string and length from any sort-of vaguely binary-ish object. + */ +#define BINOBJ PyStringObject +#define BIN_TYPE PyString_Type +#define BIN_CHECK(obj) PyString_Check(obj) +#define BIN_PTR(obj) PyString_AS_STRING(obj) +#define BIN_LEN(obj) PyString_GET_SIZE(obj) +#define BIN_FROMSTR(str) PyString_FromString(str) +#define BIN_FROMSTRLEN(str, len) PyString_FromStringAndSize(str, len) +#define BIN_FORMAT PyString_FromFormat +#define BIN_VFORMAT PyString_FromFormatV +#define BIN_PREPAREWRITE(obj, ptr, sz) do { \ + (obj) = PyString_FromStringAndSize(0, (sz)); \ + (ptr) = PyString_AS_STRING(obj); \ +} while (0) +#define BIN_DONEWRITE(obj, sz) do Py_SIZE(obj) = (sz); while (0) +#define BIN_SETLEN(obj, len) do Py_SIZE(obj) = (len); while (0) +#define Y "s" +#define YN "s#" + +/* Text strings. Both Python 2 and Python 3 call these `str', but they're + * very different because a Python 3 `str' is Unicode inside. When dealing + * with Python 3 text, the data is UTF-8 encoded. We call them `text' here, + * and define the following. + * + * * `TEXTOBJ' is the C type of a `text' object. + * * `TEXT_TYPE' is the Python `type' object for `text'. + * * `TEXT_CHECK(OBJ)' is true if OBJ is a `text' object. + * * `TEXT_STR(OBJ)' points to the first byte of a null-terminated string + * OBJ, or is null. + * * `TEXT_PTR(OBJ)' points to the first byte of OBJ, without checking! + * * `TEXT_LEN(OBJ)' yields the length of OBJ in octets, without checking! + * * `TEXT_FROMSTR(STR)' makes a `text' object from a null-terminated + * string. + * * `TEXT_FORMAT(FMT, ARGS...)' and `TEST_VFORMAT(FMT, AP)' make a `text' + * object from a `printf'-like format string and arguments. + * * `TEXT_PREPAREWRITE(OBJ, PTR, LEN)' prepares to make a `text' object: + * it sets PTR to point to a buffer of LEN bytes; call `TEXT_DONEWRITE' + * when finished. The variable OBJ will eventually be the resulting + * object, but until `TEXT_DONEWRITE' is called, it may in fact be some + * different object. + * * `TEXT_DONEWRITE(OBJ, LEN)' completes making a `text' object: it + * adjusts its length to be LEN, which must not be larger than the LEN + * given to `TEXT_PREPAREWRITE', and sets OBJ to point to the finished + * object. + * + * (Use `s' and `s#' in `PyArg_ParseTuple...'.) + */ +#define TEXTOBJ PyStringObject +#define TEXT_TYPE PyString_Type +#define TEXT_CHECK(obj) PyString_Check(obj) +#define TEXT_PTR(obj) PyString_AS_STRING(obj) +#define TEXT_STR(obj) PyString_AsString(obj) +#define TEXT_PTRLEN(obj, ptr, len) do { \ + (ptr) = PyString_AS_STRING(obj); \ + (len) = PyString_GET_SIZE(obj); \ +} while (0) +#define TEXT_FORMAT PyString_FromFormat +#define TEXT_VFORMAT PyString_FromFormatV +#define TEXT_PREPAREWRITE(obj, ptr, sz) do { \ + (obj) = PyString_FromStringAndSize(0, (sz)); \ + (ptr) = PyString_AS_STRING(obj); \ +} while (0) +#define TEXT_DONEWRITE(obj, sz) do { Py_SIZE(obj) = (sz); } while (0) +#define TEXT_FROMSTR(str) PyString_FromString(str) +#define TEXT_FROMSTRLEN(str, len) PyString_FromStringAndSize(str, len) + /*----- Utilities for returning values and exceptions ---------------------*/ /* Returning values. */ @@ -142,10 +260,12 @@ extern void restore_exception(struct excinfo *, const char *, ...); /* Input conversion functions for standard kinds of objects, with overflow * checking where applicable. */ +struct bin { const void *p; Py_ssize_t sz; }; extern int convulong(PyObject *, void *); /* unsigned long */ extern int convuint(PyObject *, void *); /* unsigned int */ extern int convszt(PyObject *, void *); /* size_t */ extern int convbool(PyObject *, void *); /* bool */ +extern int convbin(PyObject *, void *); /* read buffer holding bytes */ /* Output conversions. */ extern PyObject *getbool(int); /* bool */ @@ -153,14 +273,35 @@ extern PyObject *getulong(unsigned long); /* any kind of unsigned integer */ /*----- Miscellaneous utilities -------------------------------------------*/ -#define FREEOBJ(obj) \ - (((PyObject *)(obj))->ob_type->tp_free((PyObject *)(obj))) +#define FREEOBJ(obj) (Py_TYPE(obj)->tp_free((PyObject *)(obj))) /* Actually free OBJ, e.g., in a deallocation function. */ extern PyObject *abstract_pynew(PyTypeObject *, PyObject *, PyObject *); /* A `tp_new' function which refuses to make the object. */ -#define KWLIST (/*unconst*/ char **)kwlist +extern PyObject *enrich_compare(int /*op*/, int /*cmp*/); + /* Use a traditional compare-against-zero comparison result CMP to answer a + * modern Python `tp_richcompare' operation OP. + */ + +#ifndef CONVERT_CAREFULLY +# define CONVERT_CAREFULLY(newty, expty, obj) \ + (!sizeof(*(expty *)0 = (obj)) + (/*unconst*/ newty)(obj)) + /* Convert OBJ to the type NEWTY, having previously checked that it is + * convertible to the expected type EXPTY. + * + * Because of the way we set up types, we can make many kinds of tables be + * `const' which can't usually be so (because Python will want to fiddle + * with their reference counts); and, besides, Python's internals are + * generally quite bad at being `const'-correct about tables. One frequent + * application of this macro, then, is in removing `const' from a type + * without sacrificing all type safety. The other common use is in + * checking that method function types match up with the signatures + * expected in their method definitions. + */ +#endif + +#define KWLIST CONVERT_CAREFULLY(char **, const char *const *, kwlist) /* Strip `const' qualifiers from the keyword list `kwlist'. Useful when * calling `PyArg_ParseTupleAndKeywords', which isn't `const'-correct. */ @@ -191,11 +332,11 @@ extern void *newtype(PyTypeObject */*meta*/, extern void typeready(PyTypeObject *); /* The type object is now ready to be used. */ -extern PyTypeObject *inittype(PyTypeObject */*skel*/, +extern PyTypeObject *inittype(const PyTypeObject */*skel*/, + PyTypeObject */*base*/, PyTypeObject */*meta*/); /* All-in-one function to construct a working type from a type skeleton - * SKEL, with metaclass META. The caller is expected to have filled in the - * direct superclass in SKEL->tp_base. + * SKEL, with known base type BASE (null for `object') and metaclass. */ /* Alias for built-in types, to fit in with Pyke naming conventions. */ @@ -203,12 +344,27 @@ extern PyTypeObject *inittype(PyTypeObject */*skel*/, #define type_pytype &PyType_Type #define INITTYPE_META(ty, base, meta) do { \ - ty##_pytype_skel.tp_base = base##_pytype; \ - ty##_pytype = inittype(&ty##_pytype_skel, meta##_pytype); \ + ty##_pytype = inittype(&ty##_pytype_skel, base##_pytype, meta##_pytype); \ } while (0) #define INITTYPE(ty, base) INITTYPE_META(ty, base, type) /* Macros to initialize a type from its skeleton. */ +/* Macros for filling in `PyMethodDef' tables, ensuring that functions have + * the expected signatures. + */ +#define STD_METHOD(decor, func, flags, doc) \ + { #func, decor(func), METH_VARARGS | flags, doc }, +#define KEYWORD_METHOD(decor, func, flags, doc) \ + { #func, \ + CONVERT_CAREFULLY(PyCFunction, PyCFunctionWithKeywords, decor(func)), \ + METH_VARARGS | METH_KEYWORDS | flags, \ + doc }, +#define NOARG_METHOD(decor, func, flags, doc) \ + { #func, \ + CONVERT_CAREFULLY(PyCFunction, PyNoArgsFunction, decor(func)), \ + METH_NOARGS | flags, \ + doc }, + /* Convenience wrappers for filling in `PyMethodDef' tables, following * Pyke naming convention. Define `METHNAME' locally as * @@ -216,11 +372,15 @@ extern PyTypeObject *inittype(PyTypeObject */*skel*/, * * around the method table. */ -#define METH(func, doc) \ - { #func, METHNAME(func), METH_VARARGS, doc }, -#define KWMETH(func, doc) \ - { #func, (PyCFunction)METHNAME(func), \ - METH_VARARGS | METH_KEYWORDS, doc }, +#define METH(func, doc) STD_METHOD(METHNAME, func, 0, doc) +#define KWMETH(func, doc) KEYWORD_METHOD(METHNAME, func, 0, doc) +#define NAMETH(func, doc) NOARG_METHOD(METHNAME, func, 0, doc) +#define CMTH(func, doc) STD_METHOD(METHNAME, func, METH_CLASS, doc) +#define KWCMTH(func, doc) KEYWORD_METHOD(METHNAME, func, METH_CLASS, doc) +#define NACMTH(func, doc) NOARG_METHOD(METHNAME, func, METH_CLASS, doc) +#define SMTH(func, doc) STD_METHOD(METHNAME, func, METH_STATIC, doc) +#define KWSMTH(func, doc) KEYWORD_METHOD(METHNAME, func, METH_STATIC, doc) +#define NASMTH(func, doc) NOARG_METHOD(METHNAME, func, METH_STATIC, doc) /* Convenience wrappers for filling in `PyGetSetDef' tables, following Pyke * naming convention. Define `GETSETNAME' locally as @@ -234,26 +394,41 @@ extern PyTypeObject *inittype(PyTypeObject */*skel*/, #define GETSET(func, doc) \ { #func, GETSETNAME(get, func), GETSETNAME(set, func), doc }, -/* Convenience wrapper for filling in `PyMemberDef' tables. Define +/* Convenience wrappers for filling in `PyMemberDef' tables. Define * `MEMBERSTRUCT' locally as * * #define MEMBERSTRUCT foo_pyobj * * around the member table. */ -#define MEMBER(name, ty, f, doc) \ - { #name, ty, offsetof(MEMBERSTRUCT, name), f, doc }, +#define MEMRNM(name, ty, mem, f, doc) \ + { #name, ty, offsetof(MEMBERSTRUCT, mem), f, doc }, +#define MEMBER(name, ty, f, doc) MEMRNM(name, ty, name, f, doc) + +/* Wrappers for filling in pointers in a `PyTypeObject' structure, (a) + * following Pyke naming convention, and (b) stripping `const' from the types + * without losing type safety. + */ +#define UNCONST_TYPE_SLOT(type, suffix, op, ty) \ + CONVERT_CAREFULLY(type *, const type *, op ty##_py##suffix) +#define PYGETSET(ty) UNCONST_TYPE_SLOT(PyGetSetDef, getset, NOTHING, ty) +#define PYMETHODS(ty) UNCONST_TYPE_SLOT(PyMethodDef, methods, NOTHING, ty) +#define PYMEMBERS(ty) UNCONST_TYPE_SLOT(PyMemberDef, members, NOTHING, ty) +#define PYNUMBER(ty) UNCONST_TYPE_SLOT(PyNumberMethods, number, &, ty) +#define PYSEQUENCE(ty) UNCONST_TYPE_SLOT(PySequenceMethods, sequence, &, ty) +#define PYMAPPING(ty) UNCONST_TYPE_SLOT(PyMappingMethods, mapping, &, ty) +#define PYBUFFER(ty) UNCONST_TYPE_SLOT(PyBufferProcs, buffer, &, ty) /*----- Populating modules ------------------------------------------------*/ extern PyObject *modname; - /* The overall module name. Set this with `PyString_FromString'. */ + /* The overall module name. Set this with `TEXT_FROMSTR'. */ extern PyObject *home_module; /* The overall module object. */ extern PyObject *mkexc(PyObject */*mod*/, PyObject */*base*/, - const char */*name*/, PyMethodDef */*methods*/); + const char */*name*/, const PyMethodDef */*methods*/); /* Make and return an exception class called NAME, which will end up in * module MOD (though it is not added at this time). The new class is a * subclass of BASE. Attach the METHODS to it. @@ -270,6 +445,8 @@ extern PyObject *mkexc(PyObject */*mod*/, PyObject */*base*/, struct nameval { const char *name; unsigned f; unsigned long value; }; #define CF_SIGNED 1u extern void setconstants(PyObject *, const struct nameval *); +#define CONST(x) { #x, (x) >= 0 ? 0 : CF_SIGNED, x } +#define CONSTFLAG(f, x) { #x, f, x } #define INSEXC(name, var, base, meth) \ INSERT(name, var = mkexc(mod, base, name, meth)) @@ -318,41 +495,98 @@ extern PyMethodDef *donemethods(void); /*----- Generic mapping support -------------------------------------------*/ +/* Operations table. ME is the mapping object throughout. */ +typedef struct gmap_ops { + size_t isz; /* iterator size */ + + void *(*lookup)(PyObject *me, PyObject *key, unsigned *f); + /* Lookup the KEY. If it is found, return an entry pointer for it; if F + * is not null, set *F nonzero. Otherwise, if F is null, return a null + * pointer (without setting a pending exception); if F is not null, then + * set *F zero and return a fresh entry pointer. Return null on a Python + * exception (the caller will notice the difference.) + */ + + void (*iter_init)(PyObject *me, void *i); + /* Initialize an iterator at I. */ + + void *(*iter_next)(PyObject *me, void *i); + /* Return an entry pointer for a different item, or null if all have been + * visited. + */ + + PyObject *(*entry_key)(PyObject *me, void *e); + /* Return the key object for a mapping entry. */ + + PyObject *(*entry_value)(PyObject *me, void *e); + /* Return the value object for a mapping entry. */ + + int (*set_entry)(PyObject *me, void *e, PyObject *val); + /* Modify the entry by storing VAL in its place. Return 0 on success, + * or -1 on a Python error. + */ + + int (*del_entry)(PyObject *me, void *e); + /* Delete the entry. (It may be necessary to delete a freshly allocated + * entry, e.g., if `set_entry' failed.) Return 0 on success, or -1 on a + * Python error. + */ +} gmap_ops; + +/* The intrusion at the head of a mapping object. */ +#define GMAP_PYOBJ_HEAD \ + PyObject_HEAD \ + const gmap_ops *gmops; + +typedef struct gmap_pyobj { + GMAP_PYOBJ_HEAD +} gmap_pyobj; +#define GMAP_OPS(obj) (((gmap_pyobj *)(obj))->gmops) + /* Discover the operations from a mapping object. */ + /* Mapping methods. */ -#define GMAP_METH(func, doc) { #func, gmapmeth_##func, METH_VARARGS, doc }, -#define GMAP_KWMETH(func, doc) \ - { #func, (PyCFunction)gmapmeth_##func, METH_VARARGS|METH_KEYWORDS, doc }, +#define GMAP_METMNAME(func) gmapmeth_##func +#define GMAP_METH(func, doc) STD_METHOD(GMAP_METMNAME, func, 0, doc) +#define GMAP_KWMETH(func, doc) KEYWORD_METHOD(GMAP_METMNAME, func, 0, doc) +#define GMAP_NAMETH(func, doc) NOARG_METHOD(GMAP_METMNAME, func, 0, doc) #define GMAP_METHDECL(func, doc) \ extern PyObject *gmapmeth_##func(PyObject *, PyObject *); #define GMAP_KWMETHDECL(func, doc) \ extern PyObject *gmapmeth_##func(PyObject *, PyObject *, PyObject *); +#define GMAP_NAMETHDECL(func, doc) \ + extern PyObject *gmapmeth_##func(PyObject *); -#define GMAP_DOROMETHODS(METH, KWMETH) \ +#define GMAP_DOROMETHODS(METH, KWMETH, NAMETH) \ METH (has_key, "D.has_key(KEY) -> BOOL") \ - METH (keys, "D.keys() -> LIST") \ - METH (values, "D.values() -> LIST") \ - METH (items, "D.items() -> LIST") \ - METH (iterkeys, "D.iterkeys() -> ITER") \ - METH (itervalues, "D.itervalues() -> ITER") \ - METH (iteritems, "D.iteritems() -> ITER") \ + NAMETH(keys, "D.keys() -> LIST") \ + NAMETH(values, "D.values() -> LIST") \ + NAMETH(items, "D.items() -> LIST") \ + NAMETH(iterkeys, "D.iterkeys() -> ITER") \ + NAMETH(itervalues, "D.itervalues() -> ITER") \ + NAMETH(iteritems, "D.iteritems() -> ITER") \ KWMETH(get, "D.get(KEY, [default = None]) -> VALUE") -#define GMAP_DOMETHODS(METH, KWMETH) \ - GMAP_DOROMETHODS(METH, KWMETH) \ - METH (clear, "D.clear()") \ +#define GMAP_DOMETHODS(METH, KWMETH, NAMETH) \ + GMAP_DOROMETHODS(METH, KWMETH, NAMETH) \ + NAMETH(clear, "D.clear()") \ KWMETH(setdefault, "D.setdefault(K, [default = None]) -> VALUE") \ KWMETH(pop, "D.pop(KEY, [default = ]) -> VALUE") \ - METH (popitem, "D.popitem() -> (KEY, VALUE)") \ - METH (update, "D.update(MAP)") + NAMETH(popitem, "D.popitem() -> (KEY, VALUE)") \ + KWMETH(update, "D.update(MAP)") -GMAP_DOMETHODS(GMAP_METHDECL, GMAP_KWMETHDECL) -#define GMAP_ROMETHODS GMAP_DOROMETHODS(GMAP_METH, GMAP_KWMETH) -#define GMAP_METHODS GMAP_DOMETHODS(GMAP_METH, GMAP_KWMETH) +GMAP_DOMETHODS(GMAP_METHDECL, GMAP_KWMETHDECL, GMAP_NAMETHDECL) +#define GMAP_ROMETHODS GMAP_DOROMETHODS(GMAP_METH, GMAP_KWMETH, GMAP_NAMETH) +#define GMAP_METHODS GMAP_DOMETHODS(GMAP_METH, GMAP_KWMETH, GMAP_NAMETH) /* Mapping protocol implementation. */ extern Py_ssize_t gmap_pysize(PyObject *); /* for `mp_length' */ -extern PySequenceMethods gmap_pysequence; /* for `tp_as_sequence' */ -extern PyMethodDef gmap_pymethods[]; /* all the standard methods */ +extern PyObject *gmap_pyiter(PyObject *); /* for `tp_iter' */ +extern PyObject *gmap_pylookup(PyObject *, PyObject *); /* for `mp_subscript' */ +extern int gmap_pystore(PyObject *, PyObject *, PyObject *); /* for `mp_ass_subscript' */ +extern int gmap_pyhaskey(PyObject *, PyObject *); /* for `sq_contains' */ +extern const PySequenceMethods gmap_pysequence; /* for `tp_as_sequence' */ +extern const PyMethodDef gmapro_pymethods[]; /* read-only methods */ +extern const PyMethodDef gmap_pymethods[]; /* all the standard methods */ /*----- That's all, folks -------------------------------------------------*/