62746f4be4ea144618b9ccc1054ea53015e9d103
[enigma2.git] / lib / base / ebase.cpp
1 #include <lib/base/ebase.h>
2
3 #include <fcntl.h>
4 #include <unistd.h>
5 #include <errno.h>
6
7 #include <lib/base/eerror.h>
8 #include <lib/base/elock.h>
9 #include <lib/gdi/grc.h>
10
11 eSocketNotifier::eSocketNotifier(eMainloop *context, int fd, int requested, bool startnow): context(*context), fd(fd), state(0), requested(requested)
12 {
13         if (startnow)   
14                 start();
15 }
16
17 eSocketNotifier::~eSocketNotifier()
18 {
19         stop();
20 }
21
22 void eSocketNotifier::start()
23 {
24         if (state)
25                 stop();
26
27         context.addSocketNotifier(this);
28         state=2;  // running but not in poll yet
29 }
30
31 void eSocketNotifier::stop()
32 {
33         if (state)
34                 context.removeSocketNotifier(this);
35
36         state=0;
37 }
38
39                                         // timer
40 void eTimer::start(long msek, bool singleShot)
41 {
42         if (bActive)
43                 stop();
44
45         bActive = true;
46         bSingleShot = singleShot;
47         interval = msek;
48         clock_gettime(CLOCK_MONOTONIC, &nextActivation);
49 //      eDebug("this = %p\nnow sec = %d, nsec = %d\nadd %d msec", this, nextActivation.tv_sec, nextActivation.tv_nsec, msek);
50         nextActivation += (msek<0 ? 0 : msek);
51 //      eDebug("next Activation sec = %d, nsec = %d", nextActivation.tv_sec, nextActivation.tv_nsec );
52         context.addTimer(this);
53 }
54
55 void eTimer::startLongTimer( int seconds )
56 {
57         if (bActive)
58                 stop();
59
60         bActive = bSingleShot = true;
61         interval = 0;
62         clock_gettime(CLOCK_MONOTONIC, &nextActivation);
63 //      eDebug("this = %p\nnow sec = %d, nsec = %d\nadd %d sec", this, nextActivation.tv_sec, nextActivation.tv_nsec, seconds);
64         if ( seconds > 0 )
65                 nextActivation.tv_sec += seconds;
66 //      eDebug("next Activation sec = %d, nsec = %d", nextActivation.tv_sec, nextActivation.tv_nsec );
67         context.addTimer(this);
68 }
69
70 void eTimer::stop()
71 {
72         if (bActive)
73         {
74                 bActive=false;
75                 context.removeTimer(this);
76         }
77 }
78
79 void eTimer::changeInterval(long msek)
80 {
81         if (bActive)  // Timer is running?
82         {
83                 context.removeTimer(this);       // then stop
84                 nextActivation -= interval;  // sub old interval
85         }
86         else
87                 bActive=true; // then activate Timer
88
89         interval = msek;                                                // set new Interval
90         nextActivation += interval;             // calc nextActivation
91
92         context.addTimer(this);                         // add Timer to context TimerList
93 }
94
95 void eTimer::activate()   // Internal Funktion... called from eApplication
96 {
97         context.removeTimer(this);
98
99         if (!bSingleShot)
100         {
101                 nextActivation += interval;
102                 context.addTimer(this);
103         }
104         else
105                 bActive=false;
106
107         /*emit*/ timeout();
108 }
109
110 // mainloop
111 ePtrList<eMainloop> eMainloop::existing_loops;
112
113 eMainloop::~eMainloop()
114 {
115         existing_loops.remove(this);
116         for (std::map<int, eSocketNotifier*>::iterator it(notifiers.begin());it != notifiers.end();++it)
117                 it->second->stop();
118         while(m_timer_list.begin() != m_timer_list.end())
119                 m_timer_list.begin()->stop();
120 }
121
122 void eMainloop::addSocketNotifier(eSocketNotifier *sn)
123 {
124         int fd = sn->getFD();
125         ASSERT(notifiers.find(fd) == notifiers.end());
126         notifiers[fd]=sn;
127 }
128
129 void eMainloop::removeSocketNotifier(eSocketNotifier *sn)
130 {
131         int fd = sn->getFD();
132         std::map<int,eSocketNotifier*>::iterator i(notifiers.find(fd));
133         if (i != notifiers.end())
134                 return notifiers.erase(i);
135         eFatal("removed socket notifier which is not present");
136 }
137
138 int eMainloop::processOneEvent(unsigned int twisted_timeout, PyObject **res, ePyObject additional)
139 {
140         int return_reason = 0;
141                 /* get current time */
142
143         if (additional && !PyDict_Check(additional))
144                 eFatal("additional, but it's not dict");
145
146         if (additional && !res)
147                 eFatal("additional, but no res");
148
149         long poll_timeout = -1; /* infinite in case of empty timer list */
150
151         if (!m_timer_list.empty())
152         {
153                 /* process all timers which are ready. first remove them out of the list. */
154                 while (!m_timer_list.empty() && (poll_timeout = timeout_usec( m_timer_list.begin()->getNextActivation() ) ) <= 0 )
155                         m_timer_list.begin()->activate();
156                 if (poll_timeout < 0)
157                         poll_timeout = 0;
158                 else /* convert us to ms */
159                         poll_timeout /= 1000;
160         }
161
162         if ((twisted_timeout > 0) && (poll_timeout > 0) && ((unsigned int)poll_timeout > twisted_timeout))
163         {
164                 poll_timeout = twisted_timeout;
165                 return_reason = 1;
166         }
167
168         int nativecount=notifiers.size(),
169                 fdcount=nativecount,
170                 ret=0;
171
172         if (additional)
173                 fdcount += PyDict_Size(additional);
174
175                 // build the poll aray
176         pollfd pfd[fdcount];  // make new pollfd array
177         std::map<int,eSocketNotifier*>::iterator it = notifiers.begin();
178         int i=0;
179         for (; i < nativecount; ++i, ++it)
180         {
181                 it->second->state = 1; // running and in poll
182                 pfd[i].fd = it->first;
183                 pfd[i].events = it->second->getRequested();
184         }
185
186         if (additional)
187         {
188 #if PY_VERSION_HEX < 0x02050000 && !defined(PY_SSIZE_T_MIN)
189                 typedef int Py_ssize_t;
190 # define PY_SSIZE_T_MAX INT_MAX
191 # define PY_SSIZE_T_MIN INT_MIN
192 #endif
193                 PyObject *key, *val;
194                 Py_ssize_t pos=0;
195                 while (PyDict_Next(additional, &pos, &key, &val)) {
196                         pfd[i].fd = PyObject_AsFileDescriptor(key);
197                         pfd[i++].events = PyInt_AsLong(val);
198                 }
199         }
200
201         m_is_idle = 1;
202
203         if (this == eApp)
204         {
205                 gOpcode op;
206                 op.dc = 0;
207                 op.opcode = gOpcode::flush;
208                 gRC::getInstance()->submit(op);
209                 Py_BEGIN_ALLOW_THREADS
210                 ret = ::poll(pfd, fdcount, poll_timeout);
211                 Py_END_ALLOW_THREADS
212                 
213         } else
214                 ret = ::poll(pfd, fdcount, poll_timeout);
215
216         m_is_idle = 0;
217
218                         /* ret > 0 means that there are some active poll entries. */
219         if (ret > 0)
220         {
221                 int i=0;
222                 return_reason = 0;
223                 for (; i < nativecount; ++i)
224                 {
225                         if (pfd[i].revents)
226                         {
227                                 it = notifiers.find(pfd[i].fd);
228                                 if (it != notifiers.end()
229                                         && it->second->state == 1) // added and in poll
230                                 {
231                                         int req = it->second->getRequested();
232                                         if (pfd[i].revents & req)
233                                                 it->second->activate(pfd[i].revents & req);
234                                         pfd[i].revents &= ~req;
235                                 }
236                                 if (pfd[i].revents & (POLLERR|POLLHUP|POLLNVAL))
237                                         eDebug("poll: unhandled POLLERR/HUP/NVAL for fd %d(%d)", pfd[i].fd, pfd[i].revents);
238                         }
239                 }
240                 for (; i < fdcount; ++i)
241                 {
242                         if (pfd[i].revents)
243                         {
244                                 if (!*res)
245                                         *res = PyList_New(0);
246                                 ePyObject it = PyTuple_New(2);
247                                 PyTuple_SET_ITEM(it, 0, PyInt_FromLong(pfd[i].fd));
248                                 PyTuple_SET_ITEM(it, 1, PyInt_FromLong(pfd[i].revents));
249                                 PyList_Append(*res, it);
250                                 Py_DECREF(it);
251                         }
252                 }
253         }
254         else if (ret < 0)
255         {
256                         /* when we got a signal, we get EINTR. */
257                 if (errno != EINTR)
258                         eDebug("poll made error (%m)");
259                 else
260                         return_reason = 2; /* don't assume the timeout has passed when we got a signal */
261         }
262
263         return return_reason;
264 }
265
266 void eMainloop::addTimer(eTimer* e)
267 {
268         m_timer_list.insert_in_order(e);
269 }
270
271 void eMainloop::removeTimer(eTimer* e)
272 {
273         m_timer_list.remove(e);
274 }
275
276 int eMainloop::iterate(unsigned int twisted_timeout, PyObject **res, ePyObject dict)
277 {
278         int ret = 0;
279
280         if (twisted_timeout)
281         {
282                 clock_gettime(CLOCK_MONOTONIC, &m_twisted_timer);
283                 m_twisted_timer += twisted_timeout;
284         }
285
286                 /* TODO: this code just became ugly. fix that. */
287         do
288         {
289                 if (m_interrupt_requested)
290                 {
291                         m_interrupt_requested = 0;
292                         return 0;
293                 }
294
295                 if (app_quit_now)
296                         return -1;
297
298                 int to = 0;
299                 if (twisted_timeout)
300                 {
301                         timespec now, timeout;
302                         clock_gettime(CLOCK_MONOTONIC, &now);
303                         if (m_twisted_timer<=now) // timeout
304                                 return 0;
305                         timeout = m_twisted_timer - now;
306                         to = timeout.tv_sec * 1000 + timeout.tv_nsec / 1000000;
307                 }
308                 ret = processOneEvent(to, res, dict);
309         } while ( !ret && !(res && *res) );
310
311         return ret;
312 }
313
314 int eMainloop::runLoop()
315 {
316         while (!app_quit_now)
317                 iterate();
318         return retval;
319 }
320
321 void eMainloop::reset()
322 {
323         app_quit_now=false;
324 }
325
326 PyObject *eMainloop::poll(ePyObject timeout, ePyObject dict)
327 {
328         PyObject *res=0;
329
330         if (app_quit_now)
331                 Py_RETURN_NONE;
332
333         int twisted_timeout = (timeout == Py_None) ? 0 : PyInt_AsLong(timeout);
334
335         iterate(twisted_timeout, &res, dict);
336         if (res)
337                 return res;
338
339         return PyList_New(0); /* return empty list on timeout */
340 }
341
342 void eMainloop::interruptPoll()
343 {
344         m_interrupt_requested = 1;
345 }
346
347 void eMainloop::quit(int ret)
348 {
349         retval = ret;
350         app_quit_now = true;
351 }
352
353 eApplication* eApp = 0;
354
355 #include "structmember.h"
356
357 extern "C" {
358
359 // eTimer replacement
360
361 struct eTimerPy
362 {
363         PyObject_HEAD
364         eTimer *tm;
365         PyObject *in_weakreflist; /* List of weak references */
366 };
367
368 static int
369 eTimerPy_traverse(eTimerPy *self, visitproc visit, void *arg)
370 {
371         PyObject *obj = self->tm->timeout.get();
372         Py_VISIT(obj);
373         return 0;
374 }
375
376 static int
377 eTimerPy_clear(eTimerPy *self)
378 {
379         PyObject *obj = self->tm->timeout.get();
380         Py_CLEAR(obj);
381         return 0;
382 }
383
384 static void
385 eTimerPy_dealloc(eTimerPy* self)
386 {
387         if (self->in_weakreflist != NULL)
388                 PyObject_ClearWeakRefs((PyObject *) self);
389         eTimerPy_clear(self);
390         delete self->tm;
391         self->ob_type->tp_free((PyObject*)self);
392 }
393
394 static PyObject *
395 eTimerPy_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
396 {
397         eTimerPy *self = (eTimerPy *)type->tp_alloc(type, 0);
398         self->tm = new eTimer(eApp);
399         self->in_weakreflist = NULL;
400         return (PyObject *)self;
401 }
402
403 static PyObject *
404 eTimerPy_is_active(eTimerPy* self)
405 {
406         PyObject *ret = NULL;
407         ret = self->tm->isActive() ? Py_True : Py_False;
408         Org_Py_INCREF(ret);
409         return ret;
410 }
411
412 static PyObject *
413 eTimerPy_start(eTimerPy* self, PyObject *args)
414 {
415         long v=0;
416         long singleShot=0;
417         if (PyTuple_Size(args) > 1)
418         {
419                 if (!PyArg_ParseTuple(args, "ll", &v, &singleShot)) // when 2nd arg is a value
420                 {
421                         PyObject *obj=0;
422                         if (!PyArg_ParseTuple(args, "lO", &v, &obj)) // get 2nd arg as python object
423                                 return NULL;
424                         else if (obj == Py_True)
425                                 singleShot=1;
426                         else if (obj != Py_False)
427                                 return NULL;
428                 }
429         }
430         else if (!PyArg_ParseTuple(args, "l", &v))
431                 return NULL;
432         self->tm->start(v, singleShot);
433         Py_RETURN_NONE;
434 }
435
436 static PyObject *
437 eTimerPy_start_long(eTimerPy* self, PyObject *args)
438 {
439         long v=0;
440         if (!PyArg_ParseTuple(args, "l", &v)) {
441                 return NULL;
442         }
443         self->tm->startLongTimer(v);
444         Py_RETURN_NONE;
445 }
446
447 static PyObject *
448 eTimerPy_change_interval(eTimerPy* self, PyObject *args)
449 {
450         long v=0;
451         if (!PyArg_ParseTuple(args, "l", &v)) {
452                 return NULL;
453         }
454         self->tm->changeInterval(v);
455         Py_RETURN_NONE;
456 }
457
458 static PyObject *
459 eTimerPy_stop(eTimerPy* self)
460 {
461         self->tm->stop();
462         Py_RETURN_NONE;
463 }
464
465 static PyObject *
466 eTimerPy_get_callback_list(eTimerPy *self)
467 { //used for compatibilty with the old eTimer
468         return self->tm->timeout.get();
469 }
470
471 static PyMethodDef eTimerPy_methods[] = {
472         {"isActive", (PyCFunction)eTimerPy_is_active, METH_NOARGS,
473          "returns the timer state"
474         },
475         {"start", (PyCFunction)eTimerPy_start, METH_VARARGS,
476          "start timer with interval in msecs"
477         },
478         {"startLongTimer", (PyCFunction)eTimerPy_start_long, METH_VARARGS,
479          "start timer with interval in secs"
480         },
481         {"changeInterval", (PyCFunction)eTimerPy_change_interval, METH_VARARGS,
482          "change interval of a timer (in msecs)"
483         },
484         {"stop", (PyCFunction)eTimerPy_stop, METH_NOARGS,
485          "stops the timer"
486         },
487         //used for compatibilty with the old eTimer
488         {"get", (PyCFunction)eTimerPy_get_callback_list, METH_NOARGS,
489          "get timeout callback list"
490         },
491         {NULL}  /* Sentinel */
492 };
493
494 static PyObject *
495 eTimerPy_get_cb_list(eTimerPy *self, void *closure)
496 {
497         return self->tm->timeout.get();
498 }
499
500 static PyObject *
501 eTimerPy_timeout(eTimerPy *self, void *closure) 
502 { //used for compatibilty with the old eTimer
503         Org_Py_INCREF((PyObject*)self);
504         return (PyObject*)self;
505 }
506
507 static PyGetSetDef eTimerPy_getseters[] = {
508         {"callback",
509          (getter)eTimerPy_get_cb_list, (setter)0,
510          "returns the callback python list",
511          NULL},
512
513         {"timeout", //used for compatibilty with the old eTimer
514          (getter)eTimerPy_timeout, (setter)0,
515          "synonym for our self",
516          NULL},
517
518         {NULL} /* Sentinel */
519 };
520
521 static PyTypeObject eTimerPyType = {
522         PyObject_HEAD_INIT(NULL)
523         0, /*ob_size*/
524         "eBaseImpl.eTimer", /*tp_name*/
525         sizeof(eTimerPy), /*tp_basicsize*/
526         0, /*tp_itemsize*/
527         (destructor)eTimerPy_dealloc, /*tp_dealloc*/
528         0, /*tp_print*/
529         0, /*tp_getattr*/
530         0, /*tp_setattr*/
531         0, /*tp_compare*/
532         0, /*tp_repr*/
533         0, /*tp_as_number*/
534         0, /*tp_as_sequence*/
535         0, /*tp_as_mapping*/
536         0, /*tp_hash */
537         0, /*tp_call*/
538         0, /*tp_str*/
539         0, /*tp_getattro*/
540         0, /*tp_setattro*/
541         0, /*tp_as_buffer*/
542         Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC, /*tp_flags*/
543         "eTimer objects", /* tp_doc */
544         (traverseproc)eTimerPy_traverse, /* tp_traverse */
545         (inquiry)eTimerPy_clear, /* tp_clear */
546         0, /* tp_richcompare */
547         offsetof(eTimerPy, in_weakreflist), /* tp_weaklistoffset */
548         0, /* tp_iter */
549         0, /* tp_iternext */
550         eTimerPy_methods, /* tp_methods */
551         0, /* tp_members */
552         eTimerPy_getseters, /* tp_getset */
553         0, /* tp_base */
554         0, /* tp_dict */
555         0, /* tp_descr_get */
556         0, /* tp_descr_set */
557         0, /* tp_dictoffset */
558         0, /* tp_init */
559         0, /* tp_alloc */
560         eTimerPy_new, /* tp_new */
561 };
562
563 // eSocketNotifier replacement
564
565 struct eSocketNotifierPy
566 {
567         PyObject_HEAD
568         eSocketNotifier *sn;
569         PyObject *in_weakreflist; /* List of weak references */
570 };
571
572 static int
573 eSocketNotifierPy_traverse(eSocketNotifierPy *self, visitproc visit, void *arg)
574 {
575         PyObject *obj = self->sn->activated.get();
576         Py_VISIT(obj);
577         return 0;
578 }
579
580 static int
581 eSocketNotifierPy_clear(eSocketNotifierPy *self)
582 {
583         PyObject *obj = self->sn->activated.get();
584         Py_CLEAR(obj);
585         return 0;
586 }
587
588 static void
589 eSocketNotifierPy_dealloc(eSocketNotifierPy* self)
590 {
591         if (self->in_weakreflist != NULL)
592                 PyObject_ClearWeakRefs((PyObject *) self);
593         eSocketNotifierPy_clear(self);
594         delete self->sn;
595         self->ob_type->tp_free((PyObject*)self);
596 }
597
598 static PyObject *
599 eSocketNotifierPy_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
600 {
601         eSocketNotifierPy *self = (eSocketNotifierPy *)type->tp_alloc(type, 0);
602         int fd, req, immediate_start = 1, size = PyTuple_Size(args);
603         if (size > 2)
604         {
605                 if (!PyArg_ParseTuple(args, "iii", &fd, &req, &immediate_start))
606                 {
607                         PyObject *obj = NULL;
608                         if (!PyArg_ParseTuple(args, "iiO", &fd, &req, &immediate_start))
609                                 return NULL;
610                         if (obj == Py_False)
611                                 immediate_start = 0;
612                         else if (obj != Py_True)
613                                 return NULL;
614                 }
615         }
616         else if (size < 2 || !PyArg_ParseTuple(args, "ii", &fd, &req))
617                 return NULL;
618         self->sn = new eSocketNotifier(eApp, fd, req, immediate_start);
619         self->in_weakreflist = NULL;
620         return (PyObject *)self;
621 }
622
623 static PyObject *
624 eSocketNotifierPy_is_running(eSocketNotifierPy* self)
625 {
626         PyObject *ret = self->sn->isRunning() ? Py_True : Py_False;
627         Org_Py_INCREF(ret);
628         return ret;
629 }
630
631 static PyObject *
632 eSocketNotifierPy_start(eSocketNotifierPy* self)
633 {
634         self->sn->start();
635         Py_RETURN_NONE;
636 }
637
638 static PyObject *
639 eSocketNotifierPy_stop(eSocketNotifierPy* self)
640 {
641         self->sn->stop();
642         Py_RETURN_NONE;
643 }
644
645 static PyObject *
646 eSocketNotifierPy_get_fd(eSocketNotifierPy* self)
647 {
648         return PyInt_FromLong(self->sn->getFD());
649 }
650
651 static PyObject *
652 eSocketNotifierPy_get_requested(eSocketNotifierPy* self)
653 {
654         return PyInt_FromLong(self->sn->getRequested());
655 }
656
657 static PyObject *
658 eSocketNotifierPy_set_requested(eSocketNotifierPy* self, PyObject *args)
659 {
660         int req;
661         if (PyTuple_Size(args) != 1 || !PyArg_ParseTuple(args, "i", &req))
662                 return NULL;
663         self->sn->setRequested(req);
664         Py_RETURN_NONE;
665 }
666
667 static PyMethodDef eSocketNotifierPy_methods[] = {
668         {"isRunning", (PyCFunction)eSocketNotifierPy_is_running, METH_NOARGS,
669          "returns the running state"
670         },
671         {"start", (PyCFunction)eSocketNotifierPy_start, METH_NOARGS,
672          "start the sn"
673         },
674         {"stop", (PyCFunction)eSocketNotifierPy_stop, METH_NOARGS,
675          "stops the sn"
676         },
677         {"getFD", (PyCFunction)eSocketNotifierPy_get_fd, METH_NOARGS,
678          "get file descriptor"
679         },
680         {"getRequested", (PyCFunction)eSocketNotifierPy_get_requested, METH_NOARGS,
681          "get requested"
682         },
683         {"setRequested", (PyCFunction)eSocketNotifierPy_set_requested, METH_VARARGS,
684          "set requested"
685         },
686         {NULL}  /* Sentinel */
687 };
688
689 static PyObject *
690 eSocketNotifierPy_get_cb_list(eSocketNotifierPy *self, void *closure)
691 {
692         return self->sn->activated.get();
693 }
694
695 static PyGetSetDef eSocketNotifierPy_getseters[] = {
696         {"callback",
697          (getter)eSocketNotifierPy_get_cb_list, (setter)0,
698          "returns the callback python list",
699          NULL},
700         {NULL} /* Sentinel */
701 };
702
703 static PyTypeObject eSocketNotifierPyType = {
704         PyObject_HEAD_INIT(NULL)
705         0, /*ob_size*/
706         "eBaseImpl.eSocketNotifier", /*tp_name*/
707         sizeof(eSocketNotifierPy), /*tp_basicsize*/
708         0, /*tp_itemsize*/
709         (destructor)eSocketNotifierPy_dealloc, /*tp_dealloc*/
710         0, /*tp_print*/
711         0, /*tp_getattr*/
712         0, /*tp_setattr*/
713         0, /*tp_compare*/
714         0, /*tp_repr*/
715         0, /*tp_as_number*/
716         0, /*tp_as_sequence*/
717         0, /*tp_as_mapping*/
718         0, /*tp_hash */
719         0, /*tp_call*/
720         0, /*tp_str*/
721         0, /*tp_getattro*/
722         0, /*tp_setattro*/
723         0, /*tp_as_buffer*/
724         Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC, /*tp_flags*/
725         "eTimer objects", /* tp_doc */
726         (traverseproc)eSocketNotifierPy_traverse, /* tp_traverse */
727         (inquiry)eSocketNotifierPy_clear, /* tp_clear */
728         0, /* tp_richcompare */
729         offsetof(eSocketNotifierPy, in_weakreflist), /* tp_weaklistoffset */
730         0, /* tp_iter */
731         0, /* tp_iternext */
732         eSocketNotifierPy_methods, /* tp_methods */
733         0, /* tp_members */
734         eSocketNotifierPy_getseters, /* tp_getset */
735         0, /* tp_base */
736         0, /* tp_dict */
737         0, /* tp_descr_get */
738         0, /* tp_descr_set */
739         0, /* tp_dictoffset */
740         0, /* tp_init */
741         0, /* tp_alloc */
742         eSocketNotifierPy_new, /* tp_new */
743 };
744
745 static PyMethodDef module_methods[] = {
746         {NULL}  /* Sentinel */
747 };
748
749 void eBaseInit(void)
750 {
751         PyObject* m;
752
753         m = Py_InitModule3("eBaseImpl", module_methods,
754                 "Module that implements some enigma classes with working cyclic garbage collection.");
755
756         if (m == NULL)
757                 return;
758
759         if (!PyType_Ready(&eTimerPyType))
760         {
761                 Org_Py_INCREF((PyObject*)&eTimerPyType);
762                 PyModule_AddObject(m, "eTimer", (PyObject*)&eTimerPyType);
763         }
764         if (!PyType_Ready(&eSocketNotifierPyType))
765         {
766                 Org_Py_INCREF((PyObject*)&eSocketNotifierPyType);
767                 PyModule_AddObject(m, "eSocketNotifier", (PyObject*)&eSocketNotifierPyType);
768         }
769 }
770 }