TSE Python module

static PyObject* PyTSEObject_getattr(PyTSEObject *self, char *attr)
{
   StringTableEntry fieldName = StringTable->insert(attr);

   const AbstractClassRep::Field* field = self->simObject->getClassRep()->findField(fieldName);

   if (field)
   {
      //XXX: Handle Arrays
      return PyString_FromString(self->simObject->getDataField(fieldName,NULL));
   }

   //not a field, could be a function
   gFunctionNameSpace=self->simObject->getClassRep()->getNameSpace();
   AssertISV(gFunctionNameSpace,"SimObject with no namespace");

   gFunctionString = fieldName;

   gFunctionEntry = gFunctionNameSpace->lookup(gFunctionString);
   if (!gFunctionEntry)
   {
      PyErr_Format(gTSEException, "TSEObject of class %s has no field or function %s",self->simObject->getClassName(),gFunctionString);
      return NULL;
   }

   //XXX: increase ref count on self here?
   return (PyObject *)self;
}

static int PyTSEObject_setattr(PyTSEObject* self, char* attr, PyObject* value)
{
   StringTableEntry fieldName = StringTable->insert(attr);

   const AbstractClassRep::Field* field = self->simObject->getClassRep()->findField(fieldName);

   if (!field)
   {
      PyErr_Format(gTSEException, "TSEObject of class %s has no field %s",self->simObject->getClassName(),fieldName);
      return NULL;
   }

   if (PyString_Check(value))
   {
      self->simObject->setDataField(fieldName,NULL,PyString_AsString(value));
      return 0;
   }

   self->simObject->setDataField(fieldName,NULL,PyString_AsString(PyObject_Str(value)));

   return 0;
}

static PyTypeObject PyTSEObject_Type = {
   PyObject_HEAD_INIT(NULL)
      0,                         /*ob_size*/
      "pytse.TSEObject",         /*tp_name*/
      sizeof(PyTSEObject),       /*tp_basicsize*/
      0,                         /*tp_itemsize*/
      0,                         /*tp_dealloc*/
      0,                         /*tp_print*/
      (getattrfunc) PyTSEObject_getattr, /*tp_getattr*/
      (setattrfunc) PyTSEObject_setattr,                         /*tp_setattr*/
      0,                         /*tp_compare*/
      0,                         /*tp_repr*/
      0,                         /*tp_as_number*/
      0,                         /*tp_as_sequence*/
      0,    /*tp_as_mapping*/
      0,                         /*tp_hash */
      (ternaryfunc) PyTSEObject_call,          /*tp_call*/
      0,                         /*tp_str*/
      0,                         /*tp_getattro*/
      0,                         /*tp_setattro*/
      0,                         /*tp_as_buffer*/
      Py_TPFLAGS_DEFAULT,        /*tp_flags*/
      "TSEObject",               /* tp_doc */
};

//pytse Module

static PyObject* pytse_init(PyObject* self,PyObject* args)
{
   TSE_Initialize();
   Py_INCREF(Py_None);
   return Py_None;
}

static PyObject* pytse_tick(PyObject* self,PyObject* args)
{
   if (TSE_Tick())
   {
      //still going
      Py_INCREF(Py_True);
      return Py_True;
   }

   Py_INCREF(Py_False);
   return Py_False;
}

static PyObject* pytse_shutdown(PyObject* self,PyObject* args)
{
   TSE_Shutdown();
   Py_INCREF(Py_None);
   return Py_None;
}

static PyMethodDef pytse_methods[] = {
   {"initialize", pytse_init, METH_VARARGS, NULL},
   {"tick", pytse_tick, METH_VARARGS, NULL},
   {"shutdown", pytse_shutdown, METH_VARARGS, NULL},

   {NULL,NULL,0,NULL}    /* Sentinel */
};

extern "C" __declspec(dllexport) void initpytse(void)
{

   //initialize the python module
   PyObject *m;  

   m = Py_InitModule("pytse",  pytse_methods);

   //initialize the TSEObject type
   PyTSEObject_Type.tp_new = PyTSEObject_new;
   if (PyType_Ready(&PyTSEObject_Type) < 0)
      AssertISV(0,"There was an error reading the PyTSEObject_Type");

   Py_INCREF(&PyTSEObject_Type);

   PyModule_AddObject(m, "TSEObject", (PyObject *)&PyTSEObject_Type);

   gTSEException = PyErr_NewException("pytse.exception", NULL, NULL);
   Py_INCREF(gTSEException);

   PyModule_AddObject(m, "TSEException", gTSEException);

}

} //extern "C" 

//TSE 

extern void createFontInit();
extern void createFontShutdown();
extern bool LinkConsoleFunctions;

//--------------------------------------
static int TSE_Initialize()
{

   Vector<char *> argv;
   char moduleName[256];

   LPSTR lpszCmdLine =GetCommandLineA();

   GetModuleFileNameA(NULL, moduleName, sizeof(moduleName));
   argv.push_back(moduleName);

   //ensure that console functions link
   LinkConsoleFunctions = true;

   for (const char* word,*ptr = lpszCmdLine; *ptr; )  {
      // Eat white space
      for (; dIsspace(*ptr) && *ptr; ptr++)
         ;
      // Pick out the next word
      for (word = ptr; !dIsspace(*ptr) && *ptr; ptr++)
         ;
      // Add the word to the argument list.
      if (*word) {
         int len = ptr - word;
         char *arg = (char *) dMalloc(len + 1);
         dStrncpy(arg, word, len);
         arg[len] = 0;
         argv.push_back(arg);
      }
   }

   winState.appInstance = GetModuleHandle(NULL);

   //S32 retVal = run(argv.size(), (const char **) argv.address());

   createFontInit();

   S32 ret = Game->initialize(argv.size(), (const char **) argv.address());

   for(U32 j = 1; j < argv.size(); j++)
      dFree(argv[j]);

   return 1;
}

static int TSE_Tick()
{
   return Game->tick();
}

static int TSE_Shutdown()
{
   int ret = Game->shutdown();
   createFontShutdown();
   return ret;
}