open Generator_actions
open Generator_structs
open Generator_c
+open Generator_events
(* Generate Python C module. *)
let rec generate_python_c () =
generate_header CStyle LGPLv2plus;
pr "\
-#define PY_SSIZE_T_CLEAN 1
-#include <Python.h>
-
-#if PY_VERSION_HEX < 0x02050000
-typedef int Py_ssize_t;
-#define PY_SSIZE_T_MAX INT_MAX
-#define PY_SSIZE_T_MIN INT_MIN
-#endif
+#include <config.h>
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
-#include \"guestfs.h\"
-
-#ifndef HAVE_PYCAPSULE_NEW
-typedef struct {
- PyObject_HEAD
- guestfs_h *g;
-} Pyguestfs_Object;
-#endif
-
-static guestfs_h *
-get_handle (PyObject *obj)
-{
- assert (obj);
- assert (obj != Py_None);
-#ifndef HAVE_PYCAPSULE_NEW
- return ((Pyguestfs_Object *) obj)->g;
-#else
- return (guestfs_h*) PyCapsule_GetPointer(obj, \"guestfs_h\");
-#endif
-}
-
-static PyObject *
-put_handle (guestfs_h *g)
-{
- assert (g);
-#ifndef HAVE_PYCAPSULE_NEW
- return
- PyCObject_FromVoidPtrAndDesc ((void *) g, (char *) \"guestfs_h\", NULL);
-#else
- return PyCapsule_New ((void *) g, \"guestfs_h\", NULL);
-#endif
-}
+#include \"guestfs-py.h\"
/* This list should be freed (but not the strings) after use. */
static char **
{
size_t i, len;
char **r;
+#ifndef HAVE_PYSTRING_ASSTRING
+ PyObject *bytes;
+#endif
assert (obj);
return NULL;
}
- for (i = 0; i < len; ++i)
+ for (i = 0; i < len; ++i) {
+#ifdef HAVE_PYSTRING_ASSTRING
r[i] = PyString_AsString (PyList_GetItem (obj, i));
+#else
+ bytes = PyUnicode_AsUTF8String (PyList_GetItem (obj, i));
+ r[i] = PyBytes_AS_STRING (bytes);
+#endif
+ }
r[len] = NULL;
return r;
;
list = PyList_New (argc);
- for (i = 0; i < argc; ++i)
+ for (i = 0; i < argc; ++i) {
+#ifdef HAVE_PYSTRING_ASSTRING
PyList_SetItem (list, i, PyString_FromString (argv[i]));
+#else
+ PyList_SetItem (list, i, PyUnicode_FromString (argv[i]));
+#endif
+ }
return list;
}
list = PyList_New (argc >> 1);
for (i = 0; i < argc; i += 2) {
item = PyTuple_New (2);
+#ifdef HAVE_PYSTRING_ASSTRING
PyTuple_SetItem (item, 0, PyString_FromString (argv[i]));
PyTuple_SetItem (item, 1, PyString_FromString (argv[i+1]));
+#else
+ PyTuple_SetItem (item, 0, PyUnicode_FromString (argv[i]));
+ PyTuple_SetItem (item, 1, PyUnicode_FromString (argv[i+1]));
+#endif
PyList_SetItem (list, i >> 1, item);
}
free (argv);
}
-static PyObject *
-py_guestfs_create (PyObject *self, PyObject *args)
-{
- guestfs_h *g;
-
- g = guestfs_create ();
- if (g == NULL) {
- PyErr_SetString (PyExc_RuntimeError,
- \"guestfs.create: failed to allocate handle\");
- return NULL;
- }
- guestfs_set_error_handler (g, NULL, NULL);
- /* This can return NULL, but in that case put_handle will have
- * set the Python error string.
- */
- return put_handle (g);
-}
-
-static PyObject *
-py_guestfs_close (PyObject *self, PyObject *args)
-{
- PyThreadState *py_save = NULL;
- PyObject *py_g;
- guestfs_h *g;
-
- if (!PyArg_ParseTuple (args, (char *) \"O:guestfs_close\", &py_g))
- return NULL;
- g = get_handle (py_g);
-
- if (PyEval_ThreadsInitialized ())
- py_save = PyEval_SaveThread ();
- guestfs_close (g);
- if (PyEval_ThreadsInitialized ())
- PyEval_RestoreThread (py_save);
-
- Py_INCREF (Py_None);
- return Py_None;
-}
-
";
let emit_put_list_function typ =
function
| name, FString ->
pr " PyDict_SetItemString (dict, \"%s\",\n" name;
+ pr "#ifdef HAVE_PYSTRING_ASSTRING\n";
pr " PyString_FromString (%s->%s));\n"
- typ name
+ typ name;
+ pr "#else\n";
+ pr " PyUnicode_FromString (%s->%s));\n"
+ typ name;
+ pr "#endif\n"
| name, FBuffer ->
pr " PyDict_SetItemString (dict, \"%s\",\n" name;
+ pr "#ifdef HAVE_PYSTRING_ASSTRING\n";
pr " PyString_FromStringAndSize (%s->%s, %s->%s_len));\n"
- typ name typ name
+ typ name typ name;
+ pr "#else\n";
+ pr " PyBytes_FromStringAndSize (%s->%s, %s->%s_len));\n"
+ typ name typ name;
+ pr "#endif\n"
| name, FUUID ->
pr " PyDict_SetItemString (dict, \"%s\",\n" name;
+ pr "#ifdef HAVE_PYSTRING_ASSTRING\n";
pr " PyString_FromStringAndSize (%s->%s, 32));\n"
- typ name
+ typ name;
+ pr "#else\n";
+ pr " PyBytes_FromStringAndSize (%s->%s, 32));\n"
+ typ name;
+ pr "#endif\n"
| name, (FBytes|FUInt64) ->
pr " PyDict_SetItemString (dict, \"%s\",\n" name;
pr " PyLong_FromUnsignedLongLong (%s->%s));\n"
pr " PyDict_SetItemString (dict, \"%s\", Py_None);\n" name;
pr " }\n"
| name, FChar ->
+ pr "#ifdef HAVE_PYSTRING_ASSTRING\n";
+ pr " PyDict_SetItemString (dict, \"%s\",\n" name;
+ pr " PyString_FromStringAndSize (&dirent->%s, 1));\n" name;
+ pr "#else\n";
pr " PyDict_SetItemString (dict, \"%s\",\n" name;
- pr " PyString_FromStringAndSize (&dirent->%s, 1));\n" name
+ pr " PyUnicode_FromStringAndSize (&dirent->%s, 1));\n" name;
+ pr "#endif\n"
) cols;
pr " return dict;\n";
pr "};\n";
pr " Py_INCREF (Py_None);\n";
pr " py_r = Py_None;\n"
| RInt _
- | RBool _ -> pr " py_r = PyInt_FromLong ((long) r);\n"
+ | RBool _ -> pr " py_r = PyLong_FromLong ((long) r);\n"
| RInt64 _ -> pr " py_r = PyLong_FromLongLong (r);\n"
- | RConstString _ -> pr " py_r = PyString_FromString (r);\n"
+ | RConstString _ ->
+ pr "#ifdef HAVE_PYSTRING_ASSTRING\n";
+ pr " py_r = PyString_FromString (r);\n";
+ pr "#else\n";
+ pr " py_r = PyUnicode_FromString (r);\n";
+ pr "#endif\n"
| RConstOptString _ ->
- pr " if (r)\n";
+ pr " if (r) {\n";
+ pr "#ifdef HAVE_PYSTRING_ASSTRING\n";
pr " py_r = PyString_FromString (r);\n";
- pr " else {\n";
+ pr "#else\n";
+ pr " py_r = PyUnicode_FromString (r);\n";
+ pr "#endif\n";
+ pr " } else {\n";
pr " Py_INCREF (Py_None);\n";
pr " py_r = Py_None;\n";
pr " }\n"
| RString _ ->
+ pr "#ifdef HAVE_PYSTRING_ASSTRING\n";
pr " py_r = PyString_FromString (r);\n";
+ pr "#else\n";
+ pr " py_r = PyUnicode_FromString (r);\n";
+ pr "#endif\n";
pr " free (r);\n"
| RStringList _ ->
pr " py_r = put_string_list (r);\n";
pr " py_r = put_table (r);\n";
pr " free_strings (r);\n"
| RBufferOut _ ->
+ pr "#ifdef HAVE_PYSTRING_ASSTRING\n";
pr " py_r = PyString_FromStringAndSize (r, size);\n";
+ pr "#else\n";
+ pr " py_r = PyBytes_FromStringAndSize (r, size);\n";
+ pr "#endif\n";
pr " free (r);\n"
);
pr "static PyMethodDef methods[] = {\n";
pr " { (char *) \"create\", py_guestfs_create, METH_VARARGS, NULL },\n";
pr " { (char *) \"close\", py_guestfs_close, METH_VARARGS, NULL },\n";
+ pr " { (char *) \"set_event_callback\",\n";
+ pr " py_guestfs_set_event_callback, METH_VARARGS, NULL },\n";
+ pr " { (char *) \"delete_event_callback\",\n";
+ pr " py_guestfs_delete_event_callback, METH_VARARGS, NULL },\n";
List.iter (
fun (name, _, _, _, _, _, _) ->
pr " { (char *) \"%s\", py_guestfs_%s, METH_VARARGS, NULL },\n"
(* Init function. *)
pr "\
+#if PY_MAJOR_VERSION >= 3
+static struct PyModuleDef moduledef = {
+ PyModuleDef_HEAD_INIT,
+ \"libguestfsmod\", /* m_name */
+ \"libguestfs module\", /* m_doc */
+ -1, /* m_size */
+ methods, /* m_methods */
+ NULL, /* m_reload */
+ NULL, /* m_traverse */
+ NULL, /* m_clear */
+ NULL, /* m_free */
+};
+#endif
+
+static PyObject *
+moduleinit (void)
+{
+ PyObject *m;
+
+#if PY_MAJOR_VERSION >= 3
+ m = PyModule_Create (&moduledef);
+#else
+ m = Py_InitModule ((char *) \"libguestfsmod\", methods);
+#endif
+
+ return m; /* m might be NULL if module init failed */
+}
+
+#if PY_MAJOR_VERSION >= 3
+PyMODINIT_FUNC
+PyInit_libguestfsmod (void)
+{
+ return moduleinit ();
+}
+#else
void
initlibguestfsmod (void)
{
- static int initialized = 0;
-
- if (initialized) return;
- Py_InitModule ((char *) \"libguestfsmod\", methods);
- initialized = 1;
+ (void) moduleinit ();
}
+#endif
"
(* Generate Python module. *)
generate_header HashStyle LGPLv2plus;
pr "\
-u\"\"\"Python bindings for libguestfs
+\"\"\"Python bindings for libguestfs
import guestfs
g = guestfs.GuestFS ()
import libguestfsmod
+";
+
+ List.iter (
+ fun (name, bitmask) ->
+ pr "EVENT_%s = 0x%x\n" (String.uppercase name) bitmask
+ ) events;
+ pr "\n";
+
+ pr "\
+class ClosedHandle(ValueError):
+ pass
+
class GuestFS:
\"\"\"Instances of this class are libguestfs API handles.\"\"\"
self._o = libguestfsmod.create ()
def __del__ (self):
+ if self._o:
+ libguestfsmod.close (self._o)
+
+ def _check_not_closed (self):
+ if not self._o:
+ raise ClosedHandle (\"GuestFS: method called on closed handle\")
+
+ def close (self):
+ \"\"\"Explicitly close the guestfs handle.
+
+ The handle is closed implicitly when its reference count goes
+ to zero (eg. when it goes out of scope or the program ends).
+
+ This call is only needed if you want to force the handle to
+ close now. After calling this, the program must not call
+ any method on the handle (except the implicit call to
+ __del__ which happens when the final reference is cleaned up).
+ \"\"\"
+ self._check_not_closed ()
libguestfsmod.close (self._o)
+ self._o = None
+
+ def set_event_callback (self, cb, event_bitmask):
+ \"\"\"Register an event callback.
+
+ Register \"cb\" as a callback function for all of the
+ events in \"event_bitmask\". \"event_bitmask\" should be
+ one or more \"guestfs.EVENT_*\" flags logically or'd together.
+
+ This function returns an event handle which can be used
+ to delete the callback (see \"delete_event_callback\").
+
+ The callback function receives 4 parameters:
+
+ cb (event, event_handle, buf, array)
+
+ \"event\" is one of the \"EVENT_*\" flags. \"buf\" is a
+ message buffer (only for some types of events). \"array\"
+ is an array of integers (only for some types of events).
+
+ You should read the documentation for
+ \"guestfs_set_event_callback\" in guestfs(3) before using
+ this function.
+ \"\"\"
+ self._check_not_closed ()
+ return libguestfsmod.set_event_callback (self._o, cb, event_bitmask)
+
+ def delete_event_callback (self, event_handle):
+ \"\"\"Delete an event callback.\"\"\"
+ self._check_not_closed ()
+ libguestfsmod.delete_event_callback (self._o, event_handle)
";
doc ^ "\n\n" ^ protocol_limit_warning
else doc in
let doc =
- if List.mem DangerWillRobinson flags then
- doc ^ "\n\n" ^ danger_will_robinson
- else doc in
- let doc =
match deprecation_notice flags with
| None -> doc
| Some txt -> doc ^ "\n\n" ^ txt in
let doc = pod2text ~width:60 name doc in
let doc = List.map (fun line -> replace_str line "\\" "\\\\") doc in
let doc = String.concat "\n " doc in
- pr " u\"\"\"%s\"\"\"\n" doc;
+ pr " \"\"\"%s\"\"\"\n" doc;
);
(* Callers might pass in iterables instead of plain lists;
* convert those to plain lists because the C side of things
| StringList n | DeviceList n ->
pr " %s = list (%s)\n" n n
) args;
+ pr " self._check_not_closed ()\n";
pr " return libguestfsmod.%s (self._o" name;
List.iter (fun arg -> pr ", %s" (name_of_argt arg)) (args@optargs);
pr ")\n\n";