_inotify.c
601 lines
| 13.0 KiB
| text/x-c
|
CLexer
|
r6239 | /* | ||
* _inotify.c - Python extension interfacing to the Linux inotify subsystem | ||||
* | ||||
* Copyright 2006 Bryan O'Sullivan <bos@serpentine.com> | ||||
* | ||||
* This library is free software; you can redistribute it and/or | ||||
* modify it under the terms of version 2.1 of the GNU Lesser General | ||||
|
r10263 | * Public License or any later version. | ||
|
r6239 | */ | ||
#include <Python.h> | ||||
#include <alloca.h> | ||||
#include <sys/inotify.h> | ||||
#include <stdint.h> | ||||
#include <sys/ioctl.h> | ||||
#include <unistd.h> | ||||
static PyObject *init(PyObject *self, PyObject *args) | ||||
{ | ||||
|
r10282 | PyObject *ret = NULL; | ||
int fd = -1; | ||||
|
r6334 | |||
|
r10282 | if (!PyArg_ParseTuple(args, ":init")) | ||
goto bail; | ||||
|
r6334 | |||
|
r10282 | Py_BEGIN_ALLOW_THREADS; | ||
fd = inotify_init(); | ||||
Py_END_ALLOW_THREADS; | ||||
|
r6239 | |||
|
r10282 | if (fd == -1) { | ||
PyErr_SetFromErrno(PyExc_OSError); | ||||
goto bail; | ||||
} | ||||
|
r6334 | |||
|
r10282 | ret = PyInt_FromLong(fd); | ||
if (ret == NULL) | ||||
goto bail; | ||||
|
r6239 | |||
|
r10282 | goto done; | ||
|
r6334 | |||
|
r6239 | bail: | ||
|
r10282 | if (fd != -1) | ||
close(fd); | ||||
|
r6239 | |||
|
r10282 | Py_CLEAR(ret); | ||
|
r6334 | |||
|
r6239 | done: | ||
|
r10282 | return ret; | ||
|
r6239 | } | ||
PyDoc_STRVAR( | ||||
|
r10282 | init_doc, | ||
"init() -> fd\n" | ||||
"\n" | ||||
"Initialise an inotify instance.\n" | ||||
"Return a file descriptor associated with a new inotify event queue."); | ||||
|
r6239 | |||
static PyObject *add_watch(PyObject *self, PyObject *args) | ||||
{ | ||||
|
r10282 | PyObject *ret = NULL; | ||
uint32_t mask; | ||||
int wd = -1; | ||||
char *path; | ||||
int fd; | ||||
|
r6239 | |||
|
r10282 | if (!PyArg_ParseTuple(args, "isI:add_watch", &fd, &path, &mask)) | ||
goto bail; | ||||
|
r6239 | |||
|
r10282 | Py_BEGIN_ALLOW_THREADS; | ||
wd = inotify_add_watch(fd, path, mask); | ||||
Py_END_ALLOW_THREADS; | ||||
|
r6239 | |||
|
r10282 | if (wd == -1) { | ||
PyErr_SetFromErrnoWithFilename(PyExc_OSError, path); | ||||
goto bail; | ||||
} | ||||
|
r6334 | |||
|
r10282 | ret = PyInt_FromLong(wd); | ||
if (ret == NULL) | ||||
goto bail; | ||||
|
r6334 | |||
|
r10282 | goto done; | ||
|
r6334 | |||
|
r6239 | bail: | ||
|
r10282 | if (wd != -1) | ||
inotify_rm_watch(fd, wd); | ||||
|
r6334 | |||
|
r10282 | Py_CLEAR(ret); | ||
|
r6239 | |||
done: | ||||
|
r10282 | return ret; | ||
|
r6239 | } | ||
PyDoc_STRVAR( | ||||
|
r10282 | add_watch_doc, | ||
"add_watch(fd, path, mask) -> wd\n" | ||||
"\n" | ||||
"Add a watch to an inotify instance, or modify an existing watch.\n" | ||||
"\n" | ||||
" fd: file descriptor returned by init()\n" | ||||
" path: path to watch\n" | ||||
" mask: mask of events to watch for\n" | ||||
"\n" | ||||
"Return a unique numeric watch descriptor for the inotify instance\n" | ||||
"mapped by the file descriptor."); | ||||
|
r6239 | |||
static PyObject *remove_watch(PyObject *self, PyObject *args) | ||||
{ | ||||
|
r10282 | uint32_t wd; | ||
int fd; | ||||
int r; | ||||
|
r6334 | |||
|
r10282 | if (!PyArg_ParseTuple(args, "iI:remove_watch", &fd, &wd)) | ||
return NULL; | ||||
|
r6239 | |||
|
r10282 | Py_BEGIN_ALLOW_THREADS; | ||
r = inotify_rm_watch(fd, wd); | ||||
Py_END_ALLOW_THREADS; | ||||
|
r6239 | |||
|
r10282 | if (r == -1) { | ||
PyErr_SetFromErrno(PyExc_OSError); | ||||
return NULL; | ||||
} | ||||
|
r6334 | |||
|
r10282 | Py_INCREF(Py_None); | ||
return Py_None; | ||||
|
r6239 | } | ||
PyDoc_STRVAR( | ||||
|
r10282 | remove_watch_doc, | ||
"remove_watch(fd, wd)\n" | ||||
"\n" | ||||
" fd: file descriptor returned by init()\n" | ||||
" wd: watch descriptor returned by add_watch()\n" | ||||
"\n" | ||||
"Remove a watch associated with the watch descriptor wd from the\n" | ||||
"inotify instance associated with the file descriptor fd.\n" | ||||
"\n" | ||||
"Removing a watch causes an IN_IGNORED event to be generated for this\n" | ||||
"watch descriptor."); | ||||
|
r6239 | |||
#define bit_name(x) {x, #x} | ||||
static struct { | ||||
|
r10282 | int bit; | ||
const char *name; | ||||
PyObject *pyname; | ||||
|
r6239 | } bit_names[] = { | ||
|
r10282 | bit_name(IN_ACCESS), | ||
bit_name(IN_MODIFY), | ||||
bit_name(IN_ATTRIB), | ||||
bit_name(IN_CLOSE_WRITE), | ||||
bit_name(IN_CLOSE_NOWRITE), | ||||
bit_name(IN_OPEN), | ||||
bit_name(IN_MOVED_FROM), | ||||
bit_name(IN_MOVED_TO), | ||||
bit_name(IN_CREATE), | ||||
bit_name(IN_DELETE), | ||||
bit_name(IN_DELETE_SELF), | ||||
bit_name(IN_MOVE_SELF), | ||||
bit_name(IN_UNMOUNT), | ||||
bit_name(IN_Q_OVERFLOW), | ||||
bit_name(IN_IGNORED), | ||||
bit_name(IN_ONLYDIR), | ||||
bit_name(IN_DONT_FOLLOW), | ||||
bit_name(IN_MASK_ADD), | ||||
bit_name(IN_ISDIR), | ||||
bit_name(IN_ONESHOT), | ||||
{0} | ||||
|
r6239 | }; | ||
static PyObject *decode_mask(int mask) | ||||
{ | ||||
|
r10282 | PyObject *ret = PyList_New(0); | ||
int i; | ||||
|
r6239 | |||
|
r10282 | if (ret == NULL) | ||
goto bail; | ||||
|
r6334 | |||
|
r10282 | for (i = 0; bit_names[i].bit; i++) { | ||
if (mask & bit_names[i].bit) { | ||||
if (bit_names[i].pyname == NULL) { | ||||
bit_names[i].pyname = PyString_FromString(bit_names[i].name); | ||||
if (bit_names[i].pyname == NULL) | ||||
goto bail; | ||||
} | ||||
Py_INCREF(bit_names[i].pyname); | ||||
if (PyList_Append(ret, bit_names[i].pyname) == -1) | ||||
goto bail; | ||||
} | ||||
|
r6239 | } | ||
|
r6334 | |||
|
r10282 | goto done; | ||
|
r6334 | |||
|
r6239 | bail: | ||
|
r10282 | Py_CLEAR(ret); | ||
|
r6239 | |||
done: | ||||
|
r10282 | return ret; | ||
|
r6239 | } | ||
|
r6334 | |||
|
r6239 | static PyObject *pydecode_mask(PyObject *self, PyObject *args) | ||
{ | ||||
|
r10282 | int mask; | ||
|
r6334 | |||
|
r10282 | if (!PyArg_ParseTuple(args, "i:decode_mask", &mask)) | ||
return NULL; | ||||
|
r6239 | |||
|
r10282 | return decode_mask(mask); | ||
|
r6239 | } | ||
|
r6334 | |||
|
r6239 | PyDoc_STRVAR( | ||
|
r10282 | decode_mask_doc, | ||
"decode_mask(mask) -> list_of_strings\n" | ||||
"\n" | ||||
"Decode an inotify mask value into a list of strings that give the\n" | ||||
"name of each bit set in the mask."); | ||||
|
r6239 | |||
static char doc[] = "Low-level inotify interface wrappers."; | ||||
static void define_const(PyObject *dict, const char *name, uint32_t val) | ||||
{ | ||||
|
r10282 | PyObject *pyval = PyInt_FromLong(val); | ||
PyObject *pyname = PyString_FromString(name); | ||||
|
r6239 | |||
|
r10282 | if (!pyname || !pyval) | ||
goto bail; | ||||
|
r6334 | |||
|
r10282 | PyDict_SetItem(dict, pyname, pyval); | ||
|
r6239 | |||
bail: | ||||
|
r10282 | Py_XDECREF(pyname); | ||
Py_XDECREF(pyval); | ||||
|
r6239 | } | ||
static void define_consts(PyObject *dict) | ||||
{ | ||||
|
r10282 | define_const(dict, "IN_ACCESS", IN_ACCESS); | ||
define_const(dict, "IN_MODIFY", IN_MODIFY); | ||||
define_const(dict, "IN_ATTRIB", IN_ATTRIB); | ||||
define_const(dict, "IN_CLOSE_WRITE", IN_CLOSE_WRITE); | ||||
define_const(dict, "IN_CLOSE_NOWRITE", IN_CLOSE_NOWRITE); | ||||
define_const(dict, "IN_OPEN", IN_OPEN); | ||||
define_const(dict, "IN_MOVED_FROM", IN_MOVED_FROM); | ||||
define_const(dict, "IN_MOVED_TO", IN_MOVED_TO); | ||||
|
r6239 | |||
|
r10282 | define_const(dict, "IN_CLOSE", IN_CLOSE); | ||
define_const(dict, "IN_MOVE", IN_MOVE); | ||||
|
r6239 | |||
|
r10282 | define_const(dict, "IN_CREATE", IN_CREATE); | ||
define_const(dict, "IN_DELETE", IN_DELETE); | ||||
define_const(dict, "IN_DELETE_SELF", IN_DELETE_SELF); | ||||
define_const(dict, "IN_MOVE_SELF", IN_MOVE_SELF); | ||||
define_const(dict, "IN_UNMOUNT", IN_UNMOUNT); | ||||
define_const(dict, "IN_Q_OVERFLOW", IN_Q_OVERFLOW); | ||||
define_const(dict, "IN_IGNORED", IN_IGNORED); | ||||
|
r6239 | |||
|
r10282 | define_const(dict, "IN_ONLYDIR", IN_ONLYDIR); | ||
define_const(dict, "IN_DONT_FOLLOW", IN_DONT_FOLLOW); | ||||
define_const(dict, "IN_MASK_ADD", IN_MASK_ADD); | ||||
define_const(dict, "IN_ISDIR", IN_ISDIR); | ||||
define_const(dict, "IN_ONESHOT", IN_ONESHOT); | ||||
define_const(dict, "IN_ALL_EVENTS", IN_ALL_EVENTS); | ||||
|
r6239 | } | ||
struct event { | ||||
|
r10282 | PyObject_HEAD | ||
PyObject *wd; | ||||
PyObject *mask; | ||||
PyObject *cookie; | ||||
PyObject *name; | ||||
|
r6239 | }; | ||
|
r6334 | |||
|
r6239 | static PyObject *event_wd(PyObject *self, void *x) | ||
{ | ||||
|
r10282 | struct event *evt = (struct event *)self; | ||
Py_INCREF(evt->wd); | ||||
return evt->wd; | ||||
|
r6239 | } | ||
|
r6334 | |||
|
r6239 | static PyObject *event_mask(PyObject *self, void *x) | ||
{ | ||||
|
r10282 | struct event *evt = (struct event *)self; | ||
Py_INCREF(evt->mask); | ||||
return evt->mask; | ||||
|
r6239 | } | ||
|
r6334 | |||
|
r6239 | static PyObject *event_cookie(PyObject *self, void *x) | ||
{ | ||||
|
r10282 | struct event *evt = (struct event *)self; | ||
Py_INCREF(evt->cookie); | ||||
return evt->cookie; | ||||
|
r6239 | } | ||
|
r6334 | |||
|
r6239 | static PyObject *event_name(PyObject *self, void *x) | ||
{ | ||||
|
r10282 | struct event *evt = (struct event *)self; | ||
Py_INCREF(evt->name); | ||||
return evt->name; | ||||
|
r6239 | } | ||
static struct PyGetSetDef event_getsets[] = { | ||||
|
r10282 | {"wd", event_wd, NULL, | ||
"watch descriptor"}, | ||||
{"mask", event_mask, NULL, | ||||
"event mask"}, | ||||
{"cookie", event_cookie, NULL, | ||||
"rename cookie, if rename-related event"}, | ||||
{"name", event_name, NULL, | ||||
"file name"}, | ||||
{NULL} | ||||
|
r6239 | }; | ||
PyDoc_STRVAR( | ||||
event_doc, | ||||
"event: Structure describing an inotify event."); | ||||
static PyObject *event_new(PyTypeObject *t, PyObject *a, PyObject *k) | ||||
{ | ||||
|
r10282 | return (*t->tp_alloc)(t, 0); | ||
|
r6239 | } | ||
static void event_dealloc(struct event *evt) | ||||
{ | ||||
|
r10282 | Py_XDECREF(evt->wd); | ||
Py_XDECREF(evt->mask); | ||||
Py_XDECREF(evt->cookie); | ||||
Py_XDECREF(evt->name); | ||||
|
r6334 | |||
|
r10282 | (*evt->ob_type->tp_free)(evt); | ||
|
r6239 | } | ||
static PyObject *event_repr(struct event *evt) | ||||
{ | ||||
|
r10282 | int wd = PyInt_AsLong(evt->wd); | ||
int cookie = evt->cookie == Py_None ? -1 : PyInt_AsLong(evt->cookie); | ||||
PyObject *ret = NULL, *pymasks = NULL, *pymask = NULL; | ||||
PyObject *join = NULL; | ||||
char *maskstr; | ||||
|
r6239 | |||
|
r10282 | join = PyString_FromString("|"); | ||
if (join == NULL) | ||||
goto bail; | ||||
|
r6239 | |||
|
r10282 | pymasks = decode_mask(PyInt_AsLong(evt->mask)); | ||
if (pymasks == NULL) | ||||
goto bail; | ||||
|
r6334 | |||
|
r10282 | pymask = _PyString_Join(join, pymasks); | ||
if (pymask == NULL) | ||||
goto bail; | ||||
|
r6334 | |||
|
r10282 | maskstr = PyString_AsString(pymask); | ||
if (evt->name != Py_None) { | ||||
PyObject *pyname = PyString_Repr(evt->name, 1); | ||||
char *name = pyname ? PyString_AsString(pyname) : "???"; | ||||
|
r6334 | |||
|
r10282 | if (cookie == -1) | ||
ret = PyString_FromFormat( | ||||
"event(wd=%d, mask=%s, name=%s)", | ||||
wd, maskstr, name); | ||||
else | ||||
ret = PyString_FromFormat("event(wd=%d, mask=%s, " | ||||
"cookie=0x%x, name=%s)", | ||||
wd, maskstr, cookie, name); | ||||
|
r6239 | |||
|
r10282 | Py_XDECREF(pyname); | ||
} else { | ||||
if (cookie == -1) | ||||
ret = PyString_FromFormat("event(wd=%d, mask=%s)", | ||||
wd, maskstr); | ||||
else { | ||||
ret = PyString_FromFormat( | ||||
"event(wd=%d, mask=%s, cookie=0x%x)", | ||||
wd, maskstr, cookie); | ||||
} | ||||
|
r6239 | } | ||
|
r10282 | goto done; | ||
|
r6239 | bail: | ||
|
r10282 | Py_CLEAR(ret); | ||
|
r6334 | |||
|
r6239 | done: | ||
|
r10282 | Py_XDECREF(pymask); | ||
Py_XDECREF(pymasks); | ||||
Py_XDECREF(join); | ||||
|
r6239 | |||
|
r10282 | return ret; | ||
|
r6239 | } | ||
static PyTypeObject event_type = { | ||||
|
r10282 | PyObject_HEAD_INIT(NULL) | ||
0, /*ob_size*/ | ||||
"_inotify.event", /*tp_name*/ | ||||
sizeof(struct event), /*tp_basicsize*/ | ||||
0, /*tp_itemsize*/ | ||||
(destructor)event_dealloc, /*tp_dealloc*/ | ||||
0, /*tp_print*/ | ||||
0, /*tp_getattr*/ | ||||
0, /*tp_setattr*/ | ||||
0, /*tp_compare*/ | ||||
(reprfunc)event_repr, /*tp_repr*/ | ||||
0, /*tp_as_number*/ | ||||
0, /*tp_as_sequence*/ | ||||
0, /*tp_as_mapping*/ | ||||
0, /*tp_hash */ | ||||
0, /*tp_call*/ | ||||
0, /*tp_str*/ | ||||
0, /*tp_getattro*/ | ||||
0, /*tp_setattro*/ | ||||
0, /*tp_as_buffer*/ | ||||
Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, /*tp_flags*/ | ||||
event_doc, /* tp_doc */ | ||||
0, /* tp_traverse */ | ||||
0, /* tp_clear */ | ||||
0, /* tp_richcompare */ | ||||
0, /* tp_weaklistoffset */ | ||||
0, /* tp_iter */ | ||||
0, /* tp_iternext */ | ||||
0, /* tp_methods */ | ||||
0, /* tp_members */ | ||||
event_getsets, /* tp_getset */ | ||||
0, /* tp_base */ | ||||
0, /* tp_dict */ | ||||
0, /* tp_descr_get */ | ||||
0, /* tp_descr_set */ | ||||
0, /* tp_dictoffset */ | ||||
0, /* tp_init */ | ||||
0, /* tp_alloc */ | ||||
event_new, /* tp_new */ | ||||
|
r6239 | }; | ||
|
r6334 | |||
|
r6239 | PyObject *read_events(PyObject *self, PyObject *args) | ||
{ | ||||
|
r10282 | PyObject *ctor_args = NULL; | ||
PyObject *pybufsize = NULL; | ||||
PyObject *ret = NULL; | ||||
int bufsize = 65536; | ||||
char *buf = NULL; | ||||
int nread, pos; | ||||
int fd; | ||||
if (!PyArg_ParseTuple(args, "i|O:read", &fd, &pybufsize)) | ||||
goto bail; | ||||
|
r6239 | |||
|
r10282 | if (pybufsize && pybufsize != Py_None) | ||
bufsize = PyInt_AsLong(pybufsize); | ||||
|
r6239 | |||
|
r10282 | ret = PyList_New(0); | ||
if (ret == NULL) | ||||
goto bail; | ||||
|
r6334 | |||
|
r10282 | if (bufsize <= 0) { | ||
int r; | ||||
|
r6334 | |||
|
r10282 | Py_BEGIN_ALLOW_THREADS; | ||
r = ioctl(fd, FIONREAD, &bufsize); | ||||
Py_END_ALLOW_THREADS; | ||||
|
r6334 | |||
|
r10282 | if (r == -1) { | ||
PyErr_SetFromErrno(PyExc_OSError); | ||||
goto bail; | ||||
} | ||||
if (bufsize == 0) | ||||
goto done; | ||||
|
r6239 | } | ||
|
r10282 | else { | ||
static long name_max; | ||||
static long name_fd = -1; | ||||
long min; | ||||
|
r6334 | |||
|
r10282 | if (name_fd != fd) { | ||
name_fd = fd; | ||||
Py_BEGIN_ALLOW_THREADS; | ||||
name_max = fpathconf(fd, _PC_NAME_MAX); | ||||
Py_END_ALLOW_THREADS; | ||||
} | ||||
min = sizeof(struct inotify_event) + name_max + 1; | ||||
if (bufsize < min) { | ||||
PyErr_Format(PyExc_ValueError, | ||||
"bufsize must be at least %d", (int)min); | ||||
goto bail; | ||||
} | ||||
|
r6239 | } | ||
|
r6334 | |||
|
r10282 | buf = alloca(bufsize); | ||
|
r6334 | |||
|
r10282 | Py_BEGIN_ALLOW_THREADS; | ||
nread = read(fd, buf, bufsize); | ||||
Py_END_ALLOW_THREADS; | ||||
|
r6239 | |||
|
r10282 | if (nread == -1) { | ||
PyErr_SetFromErrno(PyExc_OSError); | ||||
goto bail; | ||||
|
r6239 | } | ||
|
r10282 | ctor_args = PyTuple_New(0); | ||
if (ctor_args == NULL) | ||||
goto bail; | ||||
pos = 0; | ||||
|
r6239 | |||
|
r10282 | while (pos < nread) { | ||
struct inotify_event *in = (struct inotify_event *)(buf + pos); | ||||
struct event *evt; | ||||
PyObject *obj; | ||||
|
r6239 | |||
|
r10282 | obj = PyObject_CallObject((PyObject *)&event_type, ctor_args); | ||
if (obj == NULL) | ||||
goto bail; | ||||
evt = (struct event *)obj; | ||||
|
r6239 | |||
|
r10282 | evt->wd = PyInt_FromLong(in->wd); | ||
evt->mask = PyInt_FromLong(in->mask); | ||||
if (in->mask & IN_MOVE) | ||||
evt->cookie = PyInt_FromLong(in->cookie); | ||||
else { | ||||
Py_INCREF(Py_None); | ||||
evt->cookie = Py_None; | ||||
} | ||||
if (in->len) | ||||
evt->name = PyString_FromString(in->name); | ||||
else { | ||||
Py_INCREF(Py_None); | ||||
evt->name = Py_None; | ||||
} | ||||
if (!evt->wd || !evt->mask || !evt->cookie || !evt->name) | ||||
goto mybail; | ||||
|
r6239 | |||
|
r10282 | if (PyList_Append(ret, obj) == -1) | ||
goto mybail; | ||||
pos += sizeof(struct inotify_event) + in->len; | ||||
continue; | ||||
|
r6334 | |||
|
r10282 | mybail: | ||
Py_CLEAR(evt->wd); | ||||
Py_CLEAR(evt->mask); | ||||
Py_CLEAR(evt->cookie); | ||||
Py_CLEAR(evt->name); | ||||
Py_DECREF(obj); | ||||
goto bail; | ||||
} | ||||
goto done; | ||||
|
r6239 | |||
bail: | ||||
|
r10282 | Py_CLEAR(ret); | ||
|
r6334 | |||
|
r6239 | done: | ||
|
r10282 | Py_XDECREF(ctor_args); | ||
|
r6239 | |||
|
r10282 | return ret; | ||
|
r6239 | } | ||
PyDoc_STRVAR( | ||||
|
r10282 | read_doc, | ||
"read(fd, bufsize[=65536]) -> list_of_events\n" | ||||
"\n" | ||||
"\nRead inotify events from a file descriptor.\n" | ||||
"\n" | ||||
" fd: file descriptor returned by init()\n" | ||||
" bufsize: size of buffer to read into, in bytes\n" | ||||
"\n" | ||||
"Return a list of event objects.\n" | ||||
"\n" | ||||
"If bufsize is > 0, block until events are available to be read.\n" | ||||
"Otherwise, immediately return all events that can be read without\n" | ||||
"blocking."); | ||||
|
r6239 | |||
static PyMethodDef methods[] = { | ||||
|
r10282 | {"init", init, METH_VARARGS, init_doc}, | ||
{"add_watch", add_watch, METH_VARARGS, add_watch_doc}, | ||||
{"remove_watch", remove_watch, METH_VARARGS, remove_watch_doc}, | ||||
{"read", read_events, METH_VARARGS, read_doc}, | ||||
{"decode_mask", pydecode_mask, METH_VARARGS, decode_mask_doc}, | ||||
{NULL}, | ||||
|
r6239 | }; | ||
void init_inotify(void) | ||||
{ | ||||
|
r10282 | PyObject *mod, *dict; | ||
|
r6239 | |||
|
r10282 | if (PyType_Ready(&event_type) == -1) | ||
return; | ||||
|
r6239 | |||
|
r10282 | mod = Py_InitModule3("_inotify", methods, doc); | ||
|
r6239 | |||
|
r10282 | dict = PyModule_GetDict(mod); | ||
|
r6334 | |||
|
r10282 | if (dict) | ||
define_consts(dict); | ||||
|
r6239 | } | ||