Initial commit from Polytechnique Montreal

1 files changed, 528 insertions, 0 deletions

diff --git a/PyGan/src/lifomodule.c b/PyGan/src/lifomodule.c
new file mode 100644
index 0000000..a71f949
--- /dev/null
+++ b/PyGan/src/lifomodule.c
@@ -0,0 +1,528 @@
+
+/*--------------------------------*/
+/* Python3-Lifo bindings          */
+/* author: A. Hebert (03/07/2020) */
+/*--------------------------------*/
+
+/*
+Copyright (C) 2020 Ecole Polytechnique de Montreal
+
+This library is free software; you can redistribute it and/or
+modify it under the terms of the GNU Lesser General Public
+License as published by the Free Software Foundation; either
+version 2.1 of the License, or (at your option) any later version.
+*/
+#include <Python.h>
+#include <structmember.h>
+#include "pylcm.h"
+
+static char AbortString[132];
+static PyObject *PyLifoError = NULL;
+static PyTypeObject LifoType;     /* shared type-descriptor */
+
+static PyObject *lifo_new(PyTypeObject *type, PyObject *args, PyObject *kwds) {
+     int_32 impx = 0;
+  
+     /* Parse arguments */
+     static char *kwlist[] = {"impx", NULL};
+     if (!PyArg_ParseTupleAndKeywords(args, kwds, "|l", kwlist, &impx)) {
+         return NULL;
+     }
+
+    lifoobject *self = (lifoobject*)PyObject_New(lifoobject, type);
+    self->impx_lifo = impx;
+    cleopn(&(self->stack));
+    return (PyObject *)self;
+}
+
+static void lifo_dealloc(lifoobject *self)
+{
+   char *nomsub="lifo_dealloc";
+   if (self->impx_lifo > 0) printf("%s: deallocate a lifo object\n",nomsub);
+   PyObject_DEL(self);
+}
+
+static PyObject *lifo_lib(lifoobject *self) {
+   fflush(stdout);
+   clelib(&(self->stack));
+   fflush(stdout);
+   return Py_BuildValue("O",Py_None);
+}
+
+static PyObject *lifo_push(lifoobject *self, PyObject *args) {
+   char *nomsub="lifo_push";
+   PyObject *item=NULL;
+   lifo_node *my_node;
+  
+   /* Parse arguments */
+   if(!PyArg_ParseTuple(args, "O", &item)) {
+       return NULL;
+   }
+
+   PyObject *module = PyImport_ImportModule("lcm");
+   if (module == NULL) {
+     sprintf(AbortString,"%s: module lcm should be installed first",nomsub);
+     PyErr_SetString(PyLifoError, AbortString);
+     return NULL;
+   }
+   PyObject *moduleDict = PyModule_GetDict(module);
+   PyObject *protocolClass = PyDict_GetItemString(moduleDict, "new");
+   if (protocolClass == NULL) {
+     sprintf(AbortString,"%s: unable to find class new in module lcm",nomsub);
+     PyErr_SetString(PyLifoError, AbortString);
+     return NULL;
+   }
+
+   lifo *my_lifo = self->stack;
+   int ipos = my_lifo->nup;
+   my_node = (lifo_node *) malloc(sizeof(lifo_node));
+   sprintf(my_node->name,"inpu_val%04d", ipos+1);
+   if (PyObject_IsInstance(item, (PyObject *)&PyLong_Type)) {
+     long my_int = (long)PyLong_AsLong(item);
+     if (self->impx_lifo > 1) printf("item %d is an integer --> %ld\n", ipos, my_int);
+     my_node->type = 11; my_node->value.ival = my_int;
+   } else if (PyObject_IsInstance(item, (PyObject *)&PyFloat_Type)) {
+     double my_double = (double)PyFloat_AsDouble(item);
+     if (self->impx_lifo > 1) printf("item %d is a double floating point number --> %e\n", ipos, my_double);
+     my_node->type = 14; my_node->value.dval = my_double;
+   } else if (PyObject_IsInstance(item, (PyObject *)&PyBool_Type)) {
+     long my_int = 1;
+     if (item == Py_False) my_int = -1;
+     if (self->impx_lifo > 0) printf("%s: unique item is a boolean number --> %ld\n", nomsub, my_int);
+     my_node->type = 15; my_node->value.ival = my_int;
+   } else if (PyObject_IsInstance(item, (PyObject *)&PyUnicode_Type)) {
+     int len = PyUnicode_GET_LENGTH(item);
+     if (len > 72) {
+       sprintf(AbortString,"%s: character data overflow",nomsub);
+       PyErr_SetString(PyLifoError, AbortString);
+       return NULL;
+     }
+     int kind = PyUnicode_KIND(item);
+     void *data = PyUnicode_DATA(item);
+     char* my_string;
+     my_string = (char *)malloc(len+1);
+     int n;
+     for (n=0; n<len; n++) {
+       my_string[n] = (Py_UCS4)PyUnicode_READ(kind, data, n);
+     }
+     my_string[len] = '\0';
+     if (self->impx_lifo > 1) printf("item %d is a string --> %s\n", ipos, my_string);
+     my_node->type = 13;
+     strcpy(my_node->value.hval, my_string);
+     free(my_string);
+   } else if (PyObject_IsInstance(item, protocolClass)) {
+     pylcmobject *lcm_object = (pylcmobject *)item;
+     char *pytype = lcm_object->type_lcm;
+     if (strcmp(pytype,"LCM") == 0) {
+       my_node->type = 3;
+     } else if (strcmp(pytype,"XSM") == 0) {
+       my_node->type = 4;
+     } else if (strcmp(pytype,"BINARY") == 0) {
+       my_node->type = 5;
+     } else if (strcmp(pytype,"ASCII") == 0) {
+       my_node->type = 6;
+     } else if (strcmp(pytype,"DA")== 0) {
+       my_node->type = 7;
+       my_node->lparam = lcm_object->lrda_lcm;
+     } else if (strcmp(pytype,"HDF5") == 0) {
+       my_node->type = 8;
+     } else {
+       sprintf(AbortString,"%s: invalid type=%s",nomsub,pytype);
+       PyErr_SetString(PyLifoError, AbortString);
+       return NULL;
+     }
+     if (self->impx_lifo > 1) printf("item %d is a lcm object named %s (type=%d)\n", ipos, lcm_object->name_lcm, my_node->type);
+     strcpy(my_node->OSname, lcm_object->name_lcm);
+     my_node->access = lcm_object->iact_lcm;
+     my_node->value.mylcm = lcm_object->iplist;
+   } else {
+     /* Create an empty slot in the lifo */
+     sprintf(my_node->name,"outp_val%04d", ipos+1);
+     PyObject* objectsRepresentation = PyObject_Repr(item);
+     int len = PyUnicode_GET_LENGTH(objectsRepresentation);
+     int kind = PyUnicode_KIND(objectsRepresentation);
+     void *data = PyUnicode_DATA(objectsRepresentation);
+     char* my_string;
+     my_string = (char *)malloc(len+1);
+     int n;
+     for (n=0; n<len; n++) {
+       my_string[n] = (Py_UCS4)PyUnicode_READ(kind, data, n);
+     }
+     my_string[len] = '\0';
+     if (self->impx_lifo > 1) printf("item %d is a %s\n", ipos, my_string);
+     if (strcmp(my_string, "<class 'int'>") == 0) {
+       my_node->type = -11;
+     } else if (strcmp(my_string, "<class 'str'>") == 0) {
+       my_node->type = -13;
+     } else if (strcmp(my_string, "<class 'float'>") == 0) {
+       my_node->type = -14;
+     } else if (strcmp(my_string, "<class 'bool'>") == 0) {
+       my_node->type = -15;
+     }
+     free(my_string);
+   }
+   clepush(&my_lifo, my_node);
+   return Py_BuildValue("O",Py_None);
+}
+
+static PyObject *lifo_pushEmpty(lifoobject *self, PyObject *args) {
+   char *nomsub="lifo_pushEmpty";
+   lifo_node *my_node;
+   char *OSname = NULL;
+   char *htype = NULL;
+  
+   /* Parse arguments */
+   if(!PyArg_ParseTuple(args, "s|s", &OSname, &htype)) {
+       return NULL;
+   }
+   
+   lifo *my_lifo = self->stack;
+   int ipos = my_lifo->nup;
+   my_node = (lifo_node *) malloc(sizeof(lifo_node));
+   if (self->impx_lifo > 1) printf("item %d is an empty %s object\n", ipos, htype);
+   if (strlen(OSname) > 72) {
+      sprintf(AbortString,"%s: character OSname overflow",nomsub);
+      PyErr_SetString(PyLifoError, AbortString);
+      return NULL;
+   }
+   strcpy(my_node->OSname, OSname);
+   sprintf(my_node->name,"outp_val%04d", ipos+1);
+   my_node->access = 0;
+   if (htype == NULL) {
+       my_node->type = -3;
+   } else {
+     if (strcmp(htype,"LCM") == 0) {
+       my_node->type = -3;
+     } else if (strcmp(htype,"XSM") == 0) {
+       my_node->type = -4;
+     } else if (strcmp(htype,"BINARY") == 0) {
+       my_node->type = -5;
+     } else if (strcmp(htype,"ASCII") == 0) {
+       my_node->type = -6;
+     } else if (strcmp(htype,"DA")== 0) {
+       my_node->type = -7;
+     } else if (strcmp(htype,"HDF5")== 0) {
+       my_node->type = -8;
+     } else if (strcmp(htype,"I")== 0) {
+       my_node->type = -11;
+     } else if (strcmp(htype,"S")== 0) {
+       my_node->type = -13;
+     } else if (strcmp(htype,"D")== 0) {
+       my_node->type = -14;
+     } else if (strcmp(htype,"B")== 0) {
+       my_node->type = -15;
+     } else {
+       sprintf(AbortString,"%s: invalid type=%s",nomsub,htype);
+       PyErr_SetString(PyLifoError, AbortString);
+       return NULL;
+     }
+   }
+   clepush(&my_lifo, my_node);
+   return Py_BuildValue("O",Py_None);
+}
+
+static PyObject *lifo_pop(lifoobject *self) {
+   char *nomsub="lifo_pop";
+   PyObject *item=NULL;
+   pylcmobject *rv = NULL;
+   char lcm_type[8];
+   lifo *my_lifo = self->stack;
+
+   PyObject *module = PyImport_ImportModule("lcm");
+   if (module == NULL) {
+     sprintf(AbortString,"%s: module lcm should be installed first",nomsub);
+     PyErr_SetString(PyLifoError, AbortString);
+     return NULL;
+   }
+   PyObject *moduleDict = PyModule_GetDict(module);
+   PyTypeObject *protocolClass = (PyTypeObject *)PyDict_GetItemString(moduleDict, "new");
+   if (protocolClass == NULL) {
+     sprintf(AbortString,"%s: unable to find class new in module lcm",nomsub);
+     PyErr_SetString(PyLifoError, AbortString);
+     return NULL;
+   }
+
+   lifo_node *my_node = clepop(&my_lifo);
+   if(!my_node) {
+     sprintf(AbortString,"%s: empty stack",nomsub);
+     PyErr_SetString(PyLifoError, AbortString);
+     return NULL;
+   }
+   if(my_node->type < 0) {
+     free(my_node);
+     return Py_BuildValue("O",Py_None);
+   }
+   switch (my_node->type) {
+   case 3 :
+     strcpy(lcm_type, "LCM");
+     goto c37;
+   case 4 :
+     strcpy(lcm_type, "XSM");
+     goto c37;
+   case 5 :
+     strcpy(lcm_type, "BINARY");
+     goto c37;
+   case 6 :
+     strcpy(lcm_type, "ASCII");
+     goto c37;
+   case 7 :
+     strcpy(lcm_type, "DA");
+     goto c37;
+   case 8 :
+     strcpy(lcm_type, "HDF5");
+     c37: 
+     rv = (pylcmobject*)PyObject_New(pylcmobject, protocolClass);
+     rv->iplist = my_node->value.mylcm;
+     rv->impx_lcm = self->impx_lifo;
+     strcpy(rv->type_lcm, lcm_type);
+     strcpy(rv->name_lcm, my_node->OSname);
+     rv->iact_lcm = my_node->access;
+     rv->lrda_lcm = my_node->lparam;
+     item = (PyObject *) rv;
+     Py_INCREF(item);
+     break;
+   case 11 :
+     item = Py_BuildValue("i", my_node->value.ival);
+     break;
+   case 13 :
+     item = Py_BuildValue("s", my_node->value.hval);
+     break;
+   case 14 :
+     item = Py_BuildValue("d", my_node->value.dval);
+     break;
+   case 15 :
+     if (my_node->value.ival == -1) {
+       item = Py_False;
+     } else {
+       item = Py_True;
+     }
+     break;
+   default :
+     sprintf(AbortString,"%s: undefined node (%d) - use node method",nomsub,my_node->type);
+     PyErr_SetString(PyLifoError, AbortString);
+     return NULL;
+   }
+   free(my_node);
+   return item;
+}
+
+static PyObject *lifo_pos(lifoobject *self, PyObject *args) {
+   char *nomsub="lifo_pos";
+   PyObject *item=NULL;
+   pylcmobject *rv = NULL;
+   long ipos = 0;
+   char lcm_type[8];
+   /* Parse arguments */
+   if(!PyArg_ParseTuple(args, "O", &item)) {
+       return NULL;
+   }
+   lifo *my_lifo = self->stack;
+   if (PyObject_IsInstance(item, (PyObject *)&PyLong_Type)) {
+     ipos = (long)PyLong_AsLong(item);
+     if (self->impx_lifo > 0) printf("%s: recover node at position %ld\n", nomsub, ipos);
+   } else if (PyObject_IsInstance(item, (PyObject *)&PyUnicode_Type)) {
+     int len = PyUnicode_GET_LENGTH(item);
+     if (len > 72) {
+       sprintf(AbortString,"%s: CHARACTER DATA OVERFLOW.",nomsub);
+       PyErr_SetString(PyLifoError, AbortString);
+       return NULL;
+     }
+     int kind = PyUnicode_KIND(item);
+     void *data = PyUnicode_DATA(item);
+     char* my_string;
+     my_string = (char *)malloc(len+1);
+     int n;
+     for (n=0; n<len; n++) {
+       my_string[n] = (Py_UCS4)PyUnicode_READ(kind, data, n);
+     }
+     my_string[len] = '\0';
+     for (n=0; n<my_lifo->nup; n++) {
+       lifo_node *my_node = clepos(&my_lifo, n);
+       if (strcmp(my_string, my_node->OSname) == 0) {
+         ipos = n;
+         goto findit;
+       }
+     }
+     sprintf(AbortString,"%s: unable to find a node with OSname=%s",nomsub, my_string);
+     PyErr_SetString(PyLifoError, AbortString);
+     return NULL;
+
+     findit:
+     if (self->impx_lifo > 0) printf("%s: recover node %s at position %ld\n", nomsub, my_string, ipos);
+     free(my_string);
+   }
+   if (ipos+1 > my_lifo->nup) {
+     sprintf(AbortString,"%s: node index %ld overflow the stack length=%d",nomsub, ipos, my_lifo->nup);
+     PyErr_SetString(PyLifoError, AbortString);
+     return NULL;
+   }
+       
+   PyObject *module = PyImport_ImportModule("lcm");
+   if (module == NULL) {
+     sprintf(AbortString,"%s: module lcm should be installed first",nomsub);
+     PyErr_SetString(PyLifoError, AbortString);
+     return NULL;
+   }
+   PyObject *moduleDict = PyModule_GetDict(module);
+   PyTypeObject *protocolClass = (PyTypeObject *)PyDict_GetItemString(moduleDict, "new");
+   if (protocolClass == NULL) {
+     sprintf(AbortString,"%s: unable to find class new in module lcm",nomsub);
+     PyErr_SetString(PyLifoError, AbortString);
+     return NULL;
+   }
+
+   lifo_node *my_node = clepos(&my_lifo, ipos);
+   switch (my_node->type) {
+   case 3 :
+     strcpy(lcm_type, "LCM");
+     goto c37;
+   case 4 :
+     strcpy(lcm_type, "XSM");
+     goto c37;
+   case 5 :
+     strcpy(lcm_type, "BINARY");
+     goto c37;
+   case 6 :
+     strcpy(lcm_type, "ASCII");
+     goto c37;
+   case 7 :
+     strcpy(lcm_type, "DA");
+     goto c37;
+   case 8 :
+     strcpy(lcm_type, "HDF5");
+     c37: 
+     rv = (pylcmobject*)PyObject_New(pylcmobject, protocolClass);
+     rv->iplist = my_node->value.mylcm;
+     rv->impx_lcm = self->impx_lifo;
+     strcpy(rv->type_lcm, lcm_type);
+     strcpy(rv->name_lcm, my_node->OSname);
+     rv->iact_lcm = my_node->access;
+     rv->lrda_lcm = my_node->lparam;
+     item = (PyObject *) rv;
+     Py_INCREF(item);
+     break;
+   case 11 :
+     item = Py_BuildValue("i", my_node->value.ival);
+     break;
+   case 13 :
+     item = Py_BuildValue("s", my_node->value.hval);
+     break;
+   case 14 :
+     item = Py_BuildValue("d", my_node->value.dval);
+     break;
+   case 15 :
+     if (my_node->value.ival == -1) {
+       item = Py_False;
+     } else {
+       item = Py_True;
+     }
+     break;
+   default :
+     sprintf(AbortString,"%s: node %ld is undefined",nomsub, ipos);
+     PyErr_SetString(PyLifoError, AbortString);
+     return NULL;
+   }
+   return item;
+}
+
+static PyObject *lifo_len(lifoobject *self) {
+   lifo *my_lifo = self->stack;
+   return Py_BuildValue("i", my_lifo->nup);
+}
+
+static PyObject *lifo_osname(lifoobject *self, PyObject *args) {
+   char *nomsub="lifo_osname";
+   long ipos = 0;
+   /* Parse arguments */
+   if(!PyArg_ParseTuple(args, "l", &ipos)) {
+       return NULL;
+   }
+   if (self->impx_lifo > 0) printf("%s: recover node OSname at position %ld\n", nomsub, ipos);
+       
+   lifo *my_lifo = self->stack;
+   lifo_node *my_node = clepos(&my_lifo, ipos);
+   return Py_BuildValue("s", my_node->OSname);
+}
+
+static PyMethodDef lifo_methods[] = {
+    {"lib", (PyCFunction)lifo_lib, METH_NOARGS, "Print the table-of-content of the stack"},
+    {"push", (PyCFunction)lifo_push, METH_VARARGS, "Push an entry in the stack"},
+    {"pushEmpty", (PyCFunction)lifo_pushEmpty, METH_VARARGS, "Push an empty Lcm object in the stack"},
+    {"pop", (PyCFunction)lifo_pop, METH_NOARGS, "Pop an entry from the stack"},
+    {"node", (PyCFunction)lifo_pos, METH_VARARGS, "Recover an entry from the stack"},
+    {"getMax", (PyCFunction)lifo_len, METH_NOARGS, "Return the length of the stack"},
+    {"OSName", (PyCFunction)lifo_osname, METH_VARARGS, "Return the OSname of a node"},
+    {NULL}  /* Sentinel */
+};
+
+static PyMemberDef lifo_members[] = {
+    {"_impx", T_INT, offsetof(lifoobject, impx_lifo), 0, "print index"},
+    {NULL}  /* Sentinel */
+};
+
+static PyTypeObject LifoType = {
+    PyVarObject_HEAD_INIT(NULL, 0)
+    "lifo.new",                /*tp_name*/
+    sizeof(lifoobject),        /*tp_basicsize*/
+    0,                         /*tp_itemsize*/
+    (destructor)lifo_dealloc,  /*tp_dealloc*/
+    (printfunc) lifo_lib,      /*tp_print*/
+    0,                         /*tp_getattr*/
+    0,                         /*tp_setattr*/
+    0,                         /*tp_compare*/
+    0,                         /*tp_repr*/
+    0,                         /*tp_as_number*/
+    0,                         /*tp_as_sequence*/
+    0,                         /*tp_as_mapping*/
+    0,                         /*tp_hash */
+    0,                         /*tp_call*/
+    0,                         /*tp_str*/
+    0,                         /*tp_getattro*/
+    0,                         /*tp_setattro*/
+    0,                         /*tp_as_buffer*/
+    Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,  /*tp_flags*/
+    "Custom objects",          /*tp_doc*/
+    0,                         /* tp_traverse */
+    0,                         /* tp_clear */
+    0,                         /* tp_richcompare */
+    0,                         /* tp_weaklistoffset */
+    0,                         /* tp_iter */
+    0,                         /* tp_iternext */
+    lifo_methods,              /* tp_methods */
+    lifo_members,              /* tp_members */
+    0,                         /* tp_getset */
+    0,                         /* tp_base */
+    0,                         /* tp_dict */
+    0,                         /* tp_descr_get */
+    0,                         /* tp_descr_set */
+    0,                         /* tp_dictoffset */
+    0,                         /* tp_init */
+    0,                         /* tp_alloc */
+    lifo_new,                  /* tp_new */
+};
+
+static PyModuleDef lifomodule = {
+    PyModuleDef_HEAD_INIT,
+    "lifo",
+    "A Python module for accessing the lifo stack from C code.",
+    -1,
+    NULL, NULL, NULL, NULL, NULL
+};
+PyMODINIT_FUNC PyInit_lifo(void) {
+    PyObject* m;
+
+    Py_Initialize();
+    if (PyType_Ready(&LifoType) < 0) return NULL;
+
+    m = PyModule_Create(&lifomodule);
+    if (m == NULL) return NULL;
+
+    PyModule_AddObject(m, "new", (PyObject *)&LifoType);
+
+    /* Initialize new exception object */
+    PyLifoError = PyErr_NewException("lifo.PyLifoError", NULL, NULL);
+
+    /* Add exception object to your module */
+    PyModule_AddObject(m, "PyLifoError", PyLifoError);
+    return m;
+}