bindings/PySCLang/PySCLang_Module.cpp

   1 /*
   2  * File: PYSCLang_Module.cpp
   3  * Project : Psycollider
   4  *
   5  * by:
   6  * Benjamin Golinvaux
   7  * benjamin.golinvaux@euresys.com
   8  * messenger: bgolinvaux@hotmail.com
   9  *
  10  * currently maintained by:
  11  * Christopher Frauenberger
  12  * frauenberger@iem.at
  13  *
  14  *  This program is free software; you can redistribute it and/or
  15  *  modify it under the terms of the GNU General Public License as
  16  *  published by the Free Software Foundation; either version 2 of the
  17  *  License, or (at your option) any later version.
  18  *
  19  *  This program is distributed in the hope that it will be useful, but
  20  *  WITHOUT ANY WARRANTY; without even the implied warranty of
  21  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  22  *  General Public License for more details.
  23  *
  24  *  You should have received a copy of the GNU General Public License
  25  *  along with this program; if not, write to the Free Software
  26  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301
  27  *  USA
  28  *
  29  */
  30
  31 #ifndef SC_WIN32
  32 #include "CXX/Objects.hxx"
  33 #include "CXX/Extensions.hxx"
  34 #else
  35 #include "stdafx.h"
  36 #endif
  37
  38 #include "PySCLang_Module.h"
  39
  40 extern "C" {
  41   void initPySCLang()
  42         {
  43 #if defined(PY_WIN32_DELAYLOAD_PYTHON_DLL)
  44         Py::InitialisePythonIndirectInterface();
  45 #endif
  46   static PySCLang_Module* thePySCLang_Module = new PySCLang_Module;
  47         }
  48 }
  49
  50 ChangeCounter gUIChangeCounter;
  51
  52 extern bool compiledOK;
  53 extern pthread_mutex_t gLangMutex;
  54 extern PyrSymbol *s_tick;
  55
  56 PyrString* newPyrStringN(class PyrGC *gc, long length, long flags, bool collect);
  57 void dumpByteCodes(PyrBlock *theBlock);
  58
  59 void flushPostBuf();
  60 // void SetupHomeDirectory();
  61 double elapsedTime();
  62
  63 extern char *gHomePath;
  64
  65 #ifdef SC_WIN32
  66 void PySCLang_InitNetwork( )
  67 {
  68 #ifdef SC_WIN32_STATIC_PTHREADS
  69   // initialize statically linked pthreads library
  70   pthread_win32_process_attach_np();
  71 #endif
  72
  73   // initialize winsock
  74   WSAData wsaData;
  75   int nCode;
  76
  77   if ((nCode = WSAStartup(MAKEWORD(1, 1), &wsaData)) != 0) {
  78     char msg[1024];
  79     sprintf(msg, "WSAStartup() failed with error code %d.\n", nCode );
  80     ::MessageBox(NULL,msg,"Error",MB_OK);
  81   }
  82 }
  83 #endif
  84
  85 // triggered for app clock ticks
  86 extern "C" void *appClockTimer(void * pymod) {
  87         ((PySCLang_Module *)pymod)->appClock();
  88         return NULL;
  89 }
  90
  91 void PySCLang_Module::appClock() {
  92         while(true) {
  93                 pthread_mutex_lock(&gLangMutex);
  94                 if (compiledOK) runLibrary(getsym("tick"));
  95                 pthread_mutex_unlock(&gLangMutex);
  96
  97 #ifdef SC_WIN32
  98                 Sleep(20);      // Sleep (windows) takes a time in milliseconds
  99 #else
 100                 usleep(20000);  // usleep (posix) takes a time in microseconds
 101 #endif
 102         }
 103 }
 104
 105   PySCLang_Module::PySCLang_Module() : ExtensionModule<PySCLang_Module>( "PySCLang" )
 106   {
 107 #ifdef SC_WIN32
 108     PySCLang_InitNetwork( );
 109 #endif
 110     add_varargs_method("sendMain", &PySCLang_Module::sendMain, "sendMain");
 111     add_varargs_method("compileLibrary", &PySCLang_Module::compileLibrary, "compileLibrary");
 112     add_varargs_method("setCmdLine", &PySCLang_Module::setCmdLine, "setCmdLine");
 113     add_varargs_method("start", &PySCLang_Module::start, "start");
 114     add_varargs_method("setSCLogSink", &PySCLang_Module::setSCLogSink, "setSCLogSink");
 115     add_varargs_method("compiledOK", &PySCLang_Module::compiledOK__, "compiledOK");
 116     add_varargs_method("setPyPrOpenWinTextFile", &PySCLang_Module::setPyPrOpenWinTextFile, "setPyPrOpenWinTextFile callable with (path,startRange,rangeSize)");
 117
 118     initialize( "<documentation for the PySCLang_Module forthcoming>" );
 119   }
 120
 121
 122
 123 // symbol required for the debug version
 124 extern "C" {
 125   void initPySCLang_d() {
 126     initPySCLang();
 127   }
 128 }
 129
 130 Py::Object PySCLang_Module::sendMain(const Py::Tuple &a)
 131 {
 132   if(a.size() != 1) {
 133     PyErr_SetString(PyExc_IndexError,"requires 1 string argument");
 134     return Py::Object(Py::Null());
 135   }
 136   if (!compiledOK) {
 137         PyErr_SetString(PyExc_RuntimeError,"PySCLang: The library has not been compiled successfully");
 138         return Py::Object(Py::Null());
 139   }
 140   Py::String pystr(a[0]);
 141   std::string str = pystr;
 142   const char* methodName = str.c_str();
 143   pthread_mutex_lock(&gLangMutex);
 144   runLibrary(getsym(methodName));
 145   pthread_mutex_unlock(&gLangMutex);
 146   if (PyErr_Occurred( ) != NULL) // there might be python calls from within sclang
 147     return Py::Object(Py::Null());
 148   return Py::Nothing();
 149 }
 150
 151 Py::Object PySCLang_Module::compileLibrary(const Py::Tuple &a)
 152 {
 153   if(a.size() != 0) {
 154     PyErr_SetString(PyExc_IndexError,"requires 0 args");
 155     return Py::Object(Py::Null());
 156   }
 157   ::compileLibrary( );
 158   return Py::Nothing();
 159 }
 160
 161 Py::Object PySCLang_Module::setCmdLine(const Py::Tuple &a)
 162 {
 163   if(a.size() != 1) {
 164     PyErr_SetString(PyExc_IndexError,"requires 1 string argument");
 165     return Py::Object(Py::Null());
 166   }
 167   Py::String pystr(a[0]);
 168   const char* text = ::PyString_AsString(pystr.ptr());
 169   int length = strlen(text);
 170
 171   if (!compiledOK) {
 172         PyErr_SetString(PyExc_RuntimeError,"PySCLang: The library has not been compiled successfully");
 173         return Py::Object(Py::Null());
 174   }
 175   pthread_mutex_lock(&gLangMutex);
 176
 177   if (compiledOK) {
 178                 VMGlobals *g = gMainVMGlobals;
 179
 180                         int textlen = length;
 181                 PyrString* strobj = newPyrStringN(g->gc, textlen, 0, true);
 182                 memcpy(strobj->s, (char*)text, textlen);
 183
 184                 SetObject(&slotRawInterpreter(&g->process->interpreter)->cmdLine, strobj);
 185                 g->gc->GCWrite(slotRawObject(&g->process->interpreter), strobj);
 186         }
 187         pthread_mutex_unlock(&gLangMutex);
 188   return Py::Nothing();
 189 }
 190
 191 Py::Object PySCLang_Module::compiledOK__(const Py::Tuple &a)
 192 {
 193   if(a.size() != 0) {
 194     PyErr_SetString(PyExc_IndexError,"requires 0 args");
 195     return Py::Object(Py::Null());
 196   }
 197   if( compiledOK )
 198     return Py::Int(1);
 199   else
 200     return Py::Int(0);
 201 }
 202
 203 Py::Object PySCLang_Module::start(const Py::Tuple &a)
 204 {
 205         if(a.size() != 0) {
 206                 PyErr_SetString(PyExc_IndexError,"requires 0 args");
 207                 return Py::Object(Py::Null());
 208         }
 209         pyr_init_mem_pools( 2*1024*1024, 256*1024 );
 210         init_OSC(57120);
 211         schedInit();
 212         ::compileLibrary();
 213
 214         // appClock timer
 215         pthread_t t;
 216         pthread_create(&t, NULL, &appClockTimer, (void *)this);
 217
 218         // deferred task timer still missing... (cf, 16 May 2006)
 219
 220 //!!!
 221 // Rendezvous is broken in a way that makes SC become unusable
 222 //      // CR ADDED
 223 //      [[RendezvousClient sharedClient] findOSCServices];
 224 //!!!
 225   return Py::Nothing();
 226 }
 227
 228 PyObject* PySCLang_Module::scLogSink_s = NULL;
 229 PyObject* PySCLang_Module::PyPrOpenWinTextFile_s = NULL;
 230
 231 Py::Object PySCLang_Module::setPyPrOpenWinTextFile(const Py::Tuple &a)
 232 {
 233   if(a.size() != 1) {
 234     PyErr_SetString(PyExc_IndexError,"requires 1 callable argument");
 235     return Py::Object(Py::Null());
 236   }
 237   PyObject* openTextFile = a[0].ptr();
 238   if( PyCallable_Check( openTextFile ) == 0)
 239     PyErr_SetString(PyExc_TypeError,"object must be callable");
 240   else {
 241     PyPrOpenWinTextFile_s = openTextFile;
 242     Py_INCREF(openTextFile);
 243   }
 244   return Py::Nothing();
 245 }
 246
 247
 248 Py::Object PySCLang_Module::setSCLogSink(const Py::Tuple &a)
 249 {
 250   if(a.size() != 1) {
 251     PyErr_SetString(PyExc_IndexError,"requires 1 callable argument");
 252     return Py::Object(Py::Null());
 253   }
 254   PyObject* logSink = a[0].ptr();
 255   if( PyCallable_Check( logSink ) == 0)
 256     PyErr_SetString(PyExc_TypeError,"object must be callable");
 257   else {
 258     scLogSink_s = logSink;
 259     Py_INCREF(logSink);
 260   }
 261   return Py::Nothing();
 262 }
 263
 264