PyObject *ret = NULL;

	int fd = -1;

	if (!PyArg_ParseTuple(args, ":init"))

		goto bail;

	Py_BEGIN_ALLOW_THREADS;

	fd = inotify_init();

	Py_END_ALLOW_THREADS;

	if (fd == -1) {

		PyErr_SetFromErrno(PyExc_OSError);

		goto bail;

	}

	ret = PyInt_FromLong(fd);

	if (ret == NULL)

		goto bail;

	goto done;

	if (fd != -1)

		close(fd);

	Py_CLEAR(ret);

	return ret;

	init_doc,

	"init() -> fd\n"

	"\n"

	"Initialise an inotify instance.\n"

	"Return a file descriptor associated with a new inotify event queue.");

	PyObject *ret = NULL;

	uint32_t mask;

	int wd = -1;

	char *path;

	int fd;

	if (!PyArg_ParseTuple(args, "isI:add_watch", &fd, &path, &mask))

		goto bail;

	Py_BEGIN_ALLOW_THREADS;

	wd = inotify_add_watch(fd, path, mask);

	Py_END_ALLOW_THREADS;

	if (wd == -1) {

		PyErr_SetFromErrnoWithFilename(PyExc_OSError, path);

		goto bail;

	}

	ret = PyInt_FromLong(wd);

	if (ret == NULL)

		goto bail;

	goto done;

	if (wd != -1)

		inotify_rm_watch(fd, wd);

	Py_CLEAR(ret);

	return ret;

	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.");

	uint32_t wd;

	int fd;

	int r;

	if (!PyArg_ParseTuple(args, "iI:remove_watch", &fd, &wd))

		return NULL;

	Py_BEGIN_ALLOW_THREADS;

	r = inotify_rm_watch(fd, wd);

	Py_END_ALLOW_THREADS;

	if (r == -1) {

		PyErr_SetFromErrno(PyExc_OSError);

		return NULL;

	}

	Py_INCREF(Py_None);

	return Py_None;

	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.");

	int bit;

	const char *name;

	PyObject *pyname;

	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}

	PyObject *ret = PyList_New(0);

	int i;

	if (ret == NULL)

		goto bail;

	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;

		}

	goto done;

	Py_CLEAR(ret);

	return ret;

	int mask;

	if (!PyArg_ParseTuple(args, "i:decode_mask", &mask))

		return NULL;

	return decode_mask(mask);

	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.");

	PyObject *pyval = PyInt_FromLong(val);

	PyObject *pyname = PyString_FromString(name);

	if (!pyname || !pyval)

		goto bail;

	PyDict_SetItem(dict, pyname, pyval);

	Py_XDECREF(pyname);

	Py_XDECREF(pyval);

	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);

	define_const(dict, "IN_CLOSE", IN_CLOSE);

	define_const(dict, "IN_MOVE", IN_MOVE);

	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);

	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);

	PyObject_HEAD

	PyObject *wd;

	PyObject *mask;

	PyObject *cookie;

	PyObject *name;

	struct event *evt = (struct event *)self;

	Py_INCREF(evt->wd);

	return evt->wd;

	struct event *evt = (struct event *)self;

	Py_INCREF(evt->mask);

	return evt->mask;

	struct event *evt = (struct event *)self;

	Py_INCREF(evt->cookie);

	return evt->cookie;

	struct event *evt = (struct event *)self;

	Py_INCREF(evt->name);

	return evt->name;

	{"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}

	return (*t->tp_alloc)(t, 0);

	Py_XDECREF(evt->wd);

	Py_XDECREF(evt->mask);

	Py_XDECREF(evt->cookie);

	Py_XDECREF(evt->name);

	(*evt->ob_type->tp_free)(evt);

	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;

	join = PyString_FromString("|");

	if (join == NULL)

		goto bail;

	pymasks = decode_mask(PyInt_AsLong(evt->mask));

	if (pymasks == NULL)

		goto bail;

	pymask = _PyString_Join(join, pymasks);

	if (pymask == NULL)

		goto bail;

	maskstr = PyString_AsString(pymask);

	if (evt->name != Py_None) {

		PyObject *pyname = PyString_Repr(evt->name, 1);

		char *name = pyname ? PyString_AsString(pyname) : "???";

		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);

		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);

		}

	goto done;

	Py_CLEAR(ret);

	Py_XDECREF(pymask);

	Py_XDECREF(pymasks);

	Py_XDECREF(join);

	return ret;

	PyObject_HEAD_INIT(NULL)

	0,                         /*ob_size*/

	"_inotify.event",             /*tp_name*/

	sizeof(struct event), /*tp_basicsize*/

	0,                         /*tp_itemsize*/