src/python.c

   1 /* Python scripting support
   2  *
   3  * Copyright (c) 2009 Sadrul Habib Chowdhury (sadrul@users.sf.net)
   4  *
   5  * This program is free software; you can redistribute it and/or modify
   6  * it under the terms of the GNU General Public License as published by
   7  * the Free Software Foundation; either version 3, or (at your option)
   8  * any later version.
   9  *
  10  * This program is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13  * GNU General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU General Public License
  16  * along with this program (see the file COPYING); if not, write to the
  17  * Free Software Foundation, Inc.,
  18  * 51 Franklin Street, Fifth Floor, Boston, MA  02111-1301  USA
  19  *
  20  ****************************************************************
  21  */
  22 #include <sys/types.h>
  23
  24 #include "config.h"
  25 #include "screen.h"
  26 #include "script.h"
  27 #include <sys/stat.h>
  28 #include <unistd.h>
  29
  30 #include <stdio.h>
  31 #include <string.h>
  32 #include <stdlib.h>
  33
  34 #include "extern.h"
  35 #include "logfile.h"
  36
  37 #include <Python.h>
  38 #include <structmember.h>
  39
  40 extern struct win *windows;
  41
  42 static PyObject * SPy_Get(PyObject *obj, void *closure);
  43 static PyObject * SPy_Set(PyObject *obj, PyObject *value, void *closure);
  44
  45 typedef struct
  46 {
  47   char *name;
  48   char *doc;
  49
  50   int type;
  51   size_t offset1;
  52   size_t offset2;
  53   PyObject * (*conv)(void *);
  54 } SPyClosure;
  55
  56 #define REGISTER_TYPE(type, Type, closures) \
  57 static int \
  58 register_##type(PyObject *module) \
  59 { \
  60   static PyGetSetDef getsets[sizeof(closures)]; \
  61   int i, count = sizeof(closures); \
  62   for (i = 0; i < count; i++) \
  63     { \
  64       getsets[i].name = closures[i].name; \
  65       getsets[i].doc = closures[i].doc; \
  66       getsets[i].closure = &closures[i]; \
  67       getsets[i].get = SPy_Get; \
  68       getsets[i].set = SPy_Set; \
  69     } \
  70   PyType##Type.tp_getset = getsets; \
  71   PyType_Ready(&PyType##Type); \
  72   Py_INCREF(&PyType##Type); \
  73   PyModule_AddObject(module, #Type, (PyObject *)&PyType##Type); \
  74   return 1; \
  75 }
  76
  77 /** Window {{{ */
  78 typedef struct
  79 {
  80   PyObject_HEAD
  81   struct win *_obj;
  82 } PyWindow;
  83
  84 static PyTypeObject PyTypeWindow =
  85 {
  86   PyObject_HEAD_INIT(NULL)
  87   .ob_size = 0,
  88   .tp_name = "screen.window",
  89   .tp_basicsize = sizeof(PyWindow),
  90   .tp_flags = Py_TPFLAGS_DEFAULT,
  91   .tp_doc = "Window object",
  92   .tp_methods = NULL,
  93   .tp_getset = NULL,
  94 };
  95
  96 #define SPY_CLOSURE(name, doc, type, member, func) \
  97     {name, doc, type, offsetof(PyWindow, _obj), offsetof(struct win, member), func}
  98 static SPyClosure wclosures[] =
  99 {
 100   SPY_CLOSURE("title", "Window title", T_STRING, w_title, PyString_FromString),
 101   SPY_CLOSURE("number", "Window number", T_INT, w_number, PyInt_FromLong),
 102   {NULL}
 103 };
 104 REGISTER_TYPE(window, Window, wclosures)
 105 #undef SPY_CLOSURE
 106
 107 static PyObject *
 108 PyWindow_FromWindow(struct win *w)
 109 {
 110   PyWindow *obj = PyTypeWindow.tp_alloc(&PyTypeWindow, 0);
 111   obj->_obj = w;
 112   return (PyObject *)obj;
 113 }
 114
 115 /** }}} */
 116
 117 static PyObject *
 118 SPy_Get(PyObject *obj, void *closure)
 119 {
 120   SPyClosure *sc = closure;
 121   char **first = (char *)obj + sc->offset1;
 122   char **second = (char *)*first + sc->offset2;
 123   return sc->conv(*second);
 124 }
 125
 126 static PyObject *
 127 SPy_Set(PyObject *obj, PyObject *value, void *closure)
 128 {
 129   return NULL;
 130 }
 131
 132 static PyObject *
 133 screen_windows(PyObject *self)
 134 {
 135   struct win *w = windows;
 136   int count = 0;
 137   for (; w; w = w->w_next)
 138     ++count;
 139   PyObject *tuple = PyTuple_New(count);
 140
 141   for (w = windows, count = 0; w; w = w->w_next, ++count)
 142     PyTuple_SetItem(tuple, count, PyWindow_FromWindow(w));
 143
 144   return tuple;
 145 }
 146
 147 const PyMethodDef py_methods[] = {
 148   {"windows", (PyCFunction)screen_windows, METH_NOARGS, NULL},
 149   {NULL, NULL, 0, NULL}
 150 };
 151
 152 static int
 153 SPyInit(void)
 154 {
 155   PyObject *m;
 156
 157   Py_Initialize();
 158
 159   m = Py_InitModule3 ("screen", py_methods, NULL);
 160   register_window(m);
 161
 162   return 0;
 163 }
 164
 165 static int
 166 SPyFinit(void)
 167 {
 168   /*Py_Finalize(); // Crashes -- why? */
 169   return 0;
 170 }
 171
 172 static int
 173 SPySource(const char *file, int async)
 174 {
 175   FILE *f = fopen(file, "rb");
 176   int ret = PyRun_SimpleFile(f, file);
 177   fclose(f);
 178
 179   if (ret == 0)
 180       return 1; /* Success */
 181
 182   if (PyErr_Occurred())
 183     {
 184       PyErr_Print();
 185       return 0;
 186     }
 187
 188   return 1;
 189 }
 190
 191 struct binding py_binding =
 192 {
 193   "python",
 194   0,
 195   0,
 196   SPyInit,
 197   SPyFinit,
 198   0,
 199   SPySource,
 200   0,
 201   0
 202 };
 203