python/gsf.override

   1 /* -*- Mode: C; c-basic-offset: 4 -*- */
   2 %%
   3 headers
   4 #include <Python.h>
   5
   6 #define NO_IMPORT_PYGOBJECT
   7 #include "pygobject.h"
   8 #include <gsf/gsf-input.h>
   9 #include <gsf/gsf-input-stdio.h>
  10 #include <gsf/gsf-input-memory.h>
  11 #include <gsf/gsf-input-textline.h>
  12 #include <gsf/gsf-input-gzip.h>
  13 #include <gsf/gsf-infile.h>
  14 #include <gsf/gsf-infile-msole.h>
  15 #include <gsf/gsf-infile-msvba.h>
  16 #include <gsf/gsf-infile-zip.h>
  17 #include <gsf/gsf-libxml.h>
  18 #include <gsf/gsf-output.h>
  19 #include <gsf/gsf-outfile.h>
  20 #include <gsf/gsf-outfile-msole.h>
  21 #include <gsf/gsf-outfile-zip.h>
  22 #include <gsf/gsf-output-stdio.h>
  23 #include <gsf/gsf-output-memory.h>
  24
  25 #define GSF_TYPE_INPUT          GSF_INPUT_TYPE
  26 #define GSF_TYPE_INPUT_STDIO    GSF_INPUT_STDIO_TYPE
  27 #define GSF_TYPE_INPUT_MEMORY   GSF_INPUT_MEMORY_TYPE
  28 #define GSF_TYPE_INPUT_TEXTLINE GSF_INPUT_TEXTLINE_TYPE
  29 #define GSF_TYPE_INPUT_GZIP     GSF_INPUT_GZIP_TYPE
  30
  31 #define GSF_TYPE_INFILE         GSF_INFILE_TYPE
  32 #define GSF_TYPE_INFILE_ZIP     GSF_INFILE_ZIP_TYPE
  33 #define GSF_TYPE_INFILE_MSVBA   GSF_INFILE_MSVBA_TYPE
  34 #define GSF_TYPE_INFILE_MS_OLE  GSF_INFILE_MSOLE_TYPE
  35 #
  36 #define GSF_TYPE_META_DATA_BAG  GSF_METADATA_BAG_TYPE
  37 #define GSF_TYPE_OUTPUT         GSF_OUTPUT_TYPE
  38 #define GSF_TYPE_OUTFILE        GSF_OUTFILE_TYPE
  39 #define GSF_TYPE_OUTFILE_MS_OLE GSF_OUTFILE_MSOLE_TYPE
  40 #define GSF_TYPE_OUTFILE_ZIP    GSF_OUTFILE_ZIP_TYPE
  41 #define GSF_TYPE_OUTPUT_MEMORY  GSF_OUTPUT_MEMORY_TYPE
  42 #define GSF_TYPE_OUTPUT_STDIO   GSF_OUTPUT_STDIO_TYPE
  43 %%
  44 modulename gsf
  45 %%
  46 import gobject.GObject as PyGObject_Type
  47 %%
  48 ignore-glob
  49  _*
  50  gsf_input_set_*
  51  *_get_type
  52  gsf_metadata_bag_*
  53  gsf_*_error
  54  gsf_infile_child_by_vname
  55 %%
  56 override gsf_input_size noargs
  57 static PyObject *
  58 _wrap_gsf_input_size(PyGObject *self)
  59 {
  60     long ret;
  61     gsf_off_t size = gsf_input_size(GSF_INPUT(self->obj));
  62
  63     ret = size;
  64     if (ret != size) {          /* Check for overflow */
  65         PyErr_SetString(PyExc_OverflowError, "Size is too large");
  66     }
  67     return PyInt_FromLong(ret);
  68 }
  69 %%
  70 override gsf_input_read kwargs
  71 static PyObject *
  72 _wrap_gsf_input_read(PyGObject *self, PyObject *args, PyObject *kwargs)
  73 {
  74     static char *kwlist[] = { (char *) "num_bytes",
  75                               (char *) "optional_buffer", NULL };
  76     size_t num_bytes;
  77     guint8 *optional_buffer = NULL;
  78     guint8 const *ret;
  79
  80     if (!PyArg_ParseTupleAndKeywords(args, kwargs, (char *) "i|z:GsfInput.read",
  81                                      kwlist, &num_bytes, &optional_buffer))
  82         return NULL;
  83     ret = gsf_input_read(GSF_INPUT(self->obj), num_bytes, optional_buffer);
  84     if (ret)
  85         return PyString_FromStringAndSize(ret, (int) num_bytes);
  86     Py_INCREF(Py_None);
  87     return Py_None;
  88 }
  89 %%
  90 override gsf_input_seek kwargs
  91 static PyObject *
  92 _wrap_gsf_input_seek(PyGObject *self, PyObject *args, PyObject *kwargs)
  93 {
  94     static char *kwlist[] = { (char *) "offset", (char *) "whence", NULL };
  95     long loffset;
  96     gsf_off_t offset;
  97     GSeekType whence;
  98     gboolean ret;
  99
 100     if (!PyArg_ParseTupleAndKeywords(args, kwargs, (char *) "li:GsfInput.seek",
 101                                      kwlist, &loffset, &whence))
 102         return NULL;
 103     offset = loffset;
 104     ret = gsf_input_seek(GSF_INPUT(self->obj), offset, whence);
 105     return PyInt_FromLong(ret);
 106 }
 107 %%
 108 override gsf_input_remaining noargs
 109 static PyObject *
 110 _wrap_gsf_input_remaining(PyGObject *self)
 111 {
 112     long ret;
 113     gsf_off_t remain = gsf_input_remaining(GSF_INPUT(self->obj));
 114
 115     ret = remain;
 116     if (ret != remain) {                /* Check for overflow */
 117         PyErr_SetString(PyExc_OverflowError, "Size is too large");
 118     }
 119     return PyInt_FromLong(ret);
 120 }
 121 %%
 122 override gsf_input_tell noargs
 123 static PyObject *
 124 _wrap_gsf_input_tell(PyGObject *self)
 125 {
 126     long ret;
 127     gsf_off_t pos = gsf_input_tell(GSF_INPUT(self->obj));
 128     ret = pos;
 129     if (ret != pos) {           /* Check for overflow */
 130         PyErr_SetString(PyExc_OverflowError, "Position is too large");
 131     }
 132     return PyInt_FromLong(ret);
 133 }
 134 %%
 135 override gsf_input_memory_new kwargs
 136 static int
 137 _wrap_gsf_input_memory_new(PyGObject *self, PyObject *args, PyObject *kwargs)
 138 {
 139     static char *kwlist[] = {
 140         (char *) "buf", (char *) "needs_free", NULL };
 141     guint8 *buf;
 142     size_t length;
 143     gboolean needs_free;
 144
 145     if (!PyArg_ParseTupleAndKeywords(args, kwargs,
 146                                      (char *) "s#i:GsfInputMemory.__init__",
 147                                      kwlist, &buf, &length, &needs_free))
 148         return -1;
 149     self->obj = (GObject *)gsf_input_memory_new(buf, (gsf_off_t) length,
 150                                                 needs_free);
 151
 152     if (!self->obj) {
 153         PyErr_SetString(PyExc_RuntimeError, "could not create GsfInputMemory object");
 154         return -1;
 155     }
 156     pygobject_register_wrapper((PyObject *)self);
 157     return 0;
 158 }
 159 %%
 160 override gsf_input_textline_ascii_gets noargs
 161 static PyObject *
 162 _wrap_gsf_input_textline_ascii_gets(PyGObject *self)
 163 {
 164     const unsigned char *ret;
 165
 166     ret = gsf_input_textline_ascii_gets(GSF_INPUT_TEXTLINE(self->obj));
 167     if (ret)
 168         return PyString_FromString(ret);
 169     Py_INCREF(Py_None);
 170     return Py_None;
 171 }
 172 %%
 173 override gsf_output_size noargs
 174 static PyObject *
 175 _wrap_gsf_output_size(PyGObject *self)
 176 {
 177     long ret;
 178     gsf_off_t size = gsf_output_size(GSF_OUTPUT(self->obj));
 179
 180     ret = size;
 181     if (ret != size) {          /* Check for overflow */
 182         PyErr_SetString(PyExc_OverflowError, "Size is too large");
 183     }
 184     return PyInt_FromLong(ret);
 185 }
 186 %%
 187 override gsf_output_tell noargs
 188 static PyObject *
 189 _wrap_gsf_output_tell(PyGObject *self)
 190 {
 191     long ret;
 192     gsf_off_t pos = gsf_output_tell(GSF_OUTPUT(self->obj));
 193     ret = pos;
 194     if (ret != pos) {           /* Check for overflow */
 195         PyErr_SetString(PyExc_OverflowError, "Position is too large");
 196     }
 197     return PyInt_FromLong(ret);
 198 }
 199 %%
 200 override gsf_output_seek kwargs
 201 static PyObject *
 202 _wrap_gsf_output_seek(PyGObject *self, PyObject *args, PyObject *kwargs)
 203 {
 204     static char *kwlist[] = { (char *) "offset", (char *) "whence", NULL };
 205     long loffset;
 206     gsf_off_t offset;
 207     GSeekType whence;
 208     gboolean ret;
 209
 210     if (!PyArg_ParseTupleAndKeywords(args, kwargs,
 211                                      (char *) "li:GsfOutput.seek",
 212                                      kwlist, &loffset, &whence))
 213         return NULL;
 214     offset = loffset;
 215     ret = gsf_output_seek(GSF_OUTPUT(self->obj), offset, whence);
 216     return PyInt_FromLong(ret);
 217 }
 218 %%
 219 override gsf_output_write kwargs
 220 static PyObject *
 221 _wrap_gsf_output_write(PyGObject *self, PyObject *args, PyObject *kwargs)
 222 {
 223     static char *kwlist[] = { (char *) "num_bytes", (char *) "data", NULL };
 224     size_t num_bytes, ret;
 225     char *data;
 226
 227     if (!PyArg_ParseTupleAndKeywords(args, kwargs,
 228                                      (char *) "is:GsfOutput.write",
 229                                      kwlist, &num_bytes, &data))
 230         return NULL;
 231     ret = gsf_output_write(GSF_OUTPUT(self->obj), num_bytes, data);
 232     return PyInt_FromLong((long) ret);
 233 }
 234 %%
 235 override gsf_output_memory_get_bytes noargs
 236 static PyObject *
 237 _wrap_gsf_output_memory_get_bytes(PyGObject *self, PyObject *args, PyObject *kwargs)
 238 {
 239     const guint8 *outbuffer = NULL;
 240
 241     outbuffer = gsf_output_memory_get_bytes (GSF_OUTPUT_MEMORY(self->obj));
 242     if (outbuffer) {
 243         gsf_off_t outlength = gsf_output_size (GSF_OUTPUT(self->obj));
 244         int       num_bytes = outlength;
 245         if (num_bytes != outlength) { /* Check for overflow */
 246             PyErr_SetString(PyExc_OverflowError, "Size is too large");
 247         }
 248         return PyString_FromStringAndSize(outbuffer, (int) num_bytes);
 249     } else
 250         return NULL;
 251 }
 252 %%
 253 override gsf_xml_parser_context kwargs
 254 static PyObject *
 255 _wrap_gsf_xml_parser_context(PyObject *self, PyObject *args, PyObject *kwargs)
 256 {
 257     static char *kwlist[] = { (char *) "input", NULL };
 258     PyGObject *input;
 259     xmlParserCtxtPtr ret;
 260
 261     if (!PyArg_ParseTupleAndKeywords(args, kwargs,
 262                                      (char *) "O!:gsf_xml_parser_context",
 263                                      kwlist, &PyGsfInput_Type, &input))
 264         return NULL;
 265     ret = gsf_xml_parser_context(GSF_INPUT(input->obj));
 266     if (ret)
 267         return PyCObject_FromVoidPtrAndDesc((void *) ret,
 268                                             (char *) "xmlParserCtxtPtr",
 269                                             NULL);
 270     Py_INCREF(Py_None);
 271     return Py_None;
 272 }