You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
223 lines
8.4 KiB
223 lines
8.4 KiB
/*==LICENSE==* |
|
|
|
CyanWorlds.com Engine - MMOG client, server and tools |
|
Copyright (C) 2011 Cyan Worlds, Inc. |
|
|
|
This program is free software: you can redistribute it and/or modify |
|
it under the terms of the GNU General Public License as published by |
|
the Free Software Foundation, either version 3 of the License, or |
|
(at your option) any later version. |
|
|
|
This program is distributed in the hope that it will be useful, |
|
but WITHOUT ANY WARRANTY; without even the implied warranty of |
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
|
GNU General Public License for more details. |
|
|
|
You should have received a copy of the GNU General Public License |
|
along with this program. If not, see <http://www.gnu.org/licenses/>. |
|
|
|
You can contact Cyan Worlds, Inc. by email legal@cyan.com |
|
or by snail mail at: |
|
Cyan Worlds, Inc. |
|
14617 N Newport Hwy |
|
Mead, WA 99021 |
|
|
|
*==LICENSE==*/ |
|
////////////////////////////////////////////////////////////////////// |
|
// |
|
// PythonInterface - The Python interface to the Python dll |
|
// |
|
// NOTE: Eventually, this will be made into a separate dll, because there should |
|
// only be one instance of this interface. |
|
// |
|
#include "hsTypes.h" |
|
#include "hsStlUtils.h" |
|
#include <python.h> |
|
|
|
#if defined(HAVE_CYPYTHONIDE) && !defined(PLASMA_EXTERNAL_RELEASE) |
|
#include "../../Apps/CyPythonIDE/plCyDebug/plCyDebServer.h" |
|
#endif |
|
|
|
class plStatusLog; |
|
class pyKey; |
|
|
|
class PythonInterface |
|
{ |
|
private: |
|
static Int32 initialized; // count how many times we initialize |
|
// and make sure that many finalize on the way out |
|
static hsBool FirstTimeInit; |
|
static hsBool IsInShutdown; // whether we are _really_ in shutdown mode |
|
|
|
static PyMethodDef* plasmaMethods; |
|
static PyObject* plasmaMod; // python object that holds the Plasma module |
|
static PyObject* plasmaConstantsMod; // python object that holds the PlasmaConstants module |
|
static PyObject* plasmaNetConstantsMod; // python object that holds the PlasmaNetConstants module |
|
static PyObject* plasmaVaultConstantsMod; // python object that holds the PlasmaVaultConstants module |
|
static PyMethodDef* plasmaGameMethods; |
|
static PyObject* plasmaGameMod; // python object that holds the PlasmaGame module |
|
static PyObject* plasmaGameConstantsMod; // python object that holds the PlasmaGameConstants module |
|
static PyObject* stdOut; // python object of the stdout file |
|
static PyObject* stdErr; // python object of the err file |
|
|
|
static hsBool debug_initialized; // has the debug been initialized yet? |
|
static PyObject* dbgMod; // display module for stdout and stderr |
|
static PyObject* dbgOut; |
|
static PyObject* dbgSlice; // time slice function for the debug window |
|
static plStatusLog* dbgLog; |
|
|
|
#if defined(HAVE_CYPYTHONIDE) && !defined(PLASMA_EXTERNAL_RELEASE) |
|
static bool usePythonDebugger; |
|
static bool requestedExit; |
|
static plCyDebServer debugServer; |
|
#endif |
|
|
|
public: |
|
|
|
// set that we are truly shutting down |
|
static void WeAreInShutdown() { IsInShutdown = true; } |
|
|
|
// Initialize the Python dll |
|
static void initPython(); |
|
|
|
// Initialize the Plasma module |
|
static void AddPlasmaMethods(std::vector<PyMethodDef> &methods); |
|
static void AddPlasmaClasses(); |
|
|
|
// Initialize the PlasmaConstants module |
|
static void AddPlasmaConstantsClasses(); |
|
|
|
// Initialize the PlasmaNetConstants module; |
|
static void AddPlasmaNetConstantsClasses(); |
|
|
|
// Initialize the PlasmaVaultConstants module; |
|
static void AddPlasmaVaultConstantsClasses(); |
|
|
|
// Initialize the PlasmaGame module |
|
static void AddPlasmaGameMethods(std::vector<PyMethodDef> &methods); |
|
static void AddPlasmaGameClasses(); |
|
|
|
// Initialize the PlasmaGameConstants module |
|
static void AddPlasmaGameConstantsClasses(); |
|
|
|
// Initialize the Python to Plasma |
|
static void initDebugInterface(); |
|
|
|
// Finalize the Python dll, ie. get ready to shut down |
|
static void finiPython(); |
|
|
|
// give the debug window a time slice |
|
static void debugTimeSlice(); |
|
|
|
// get the stdout PyObject |
|
static PyObject* GetStdOut(); |
|
static PyObject* GetStdErr(); |
|
|
|
// get the Output to the error file to be displayed |
|
static int getOutputAndReset(std::string* output = nil); |
|
|
|
// Writes 'text' to the Python log |
|
static void WriteToLog(const char* text); |
|
|
|
// Writes 'text' to stderr specified in the python interface |
|
static void WriteToStdErr(const char* text); |
|
|
|
// Find module. If it doesn't exist then don't create, return nil. |
|
static PyObject* FindModule(char* module); |
|
|
|
// create a new module with built-ins |
|
static PyObject* CreateModule(char* module); |
|
|
|
// checks to see if a specific function is defined in this module |
|
// get an item (probably a function) from the Plasma module |
|
static PyObject* GetPlasmaItem(char* item); |
|
|
|
// Determine if the module name is unique |
|
static hsBool IsModuleNameUnique(char* module); |
|
// get an item (probably a function) from a specific module |
|
static PyObject* GetModuleItem(char* item, PyObject* module); |
|
|
|
// check a specific module for the define funcitons |
|
static void CheckModuleForFunctions(PyObject* module, char** funcNames, PyObject** funcTable); |
|
|
|
// checks to see if a specific function is defined in this instance of a class |
|
// and will fill out the funcTable with object instances of where the funciton is |
|
// |
|
static void CheckInstanceForFunctions(PyObject* instance, char** funcNames, PyObject** funcTable); |
|
|
|
// run a python string in a specific module name |
|
// PARAMETERS : command - string of commands to execute in the... |
|
// : filename - filename to say where to code came from |
|
static PyObject* CompileString(char *command, char* filename); |
|
|
|
///////////////////////////////////////////////////////////////////////////// |
|
// |
|
// Function : DumpObject |
|
// PARAMETERS : pyobject - string of commands to execute in the... |
|
// |
|
// PURPOSE : marshals an object into a char string |
|
// |
|
static hsBool DumpObject(PyObject* pyobj, char** pickle, Int32* size); |
|
|
|
///////////////////////////////////////////////////////////////////////////// |
|
// |
|
// Function : LoadObject |
|
// PARAMETERS : pickle - the pickled object in char string form |
|
// : size - size of the guts to load into an object |
|
// |
|
// PURPOSE : Load a python object from a pickled object |
|
// |
|
static PyObject* LoadObject(char* pickle, Int32 size); |
|
|
|
|
|
///////////////////////////////////////////////////////////////////////////// |
|
// |
|
// Function : RunStringInteractive |
|
// PARAMETERS : command - string of commands to execute in the... |
|
// : module - module name to run 'command' in |
|
// |
|
// PURPOSE : run a python string in a specific module name |
|
// : Interactive mode (displays results) |
|
// |
|
static hsBool RunStringInteractive(char *command, PyObject* module); |
|
|
|
|
|
///////////////////////////////////////////////////////////////////////////// |
|
// |
|
// Function : RunString |
|
// PARAMETERS : command - string of commands to execute in the... |
|
// : module - module name to run 'command' in |
|
// |
|
// PURPOSE : run a python string in a specific module name |
|
// |
|
static hsBool RunString(char *command, PyObject* module); |
|
|
|
|
|
///////////////////////////////////////////////////////////////////////////// |
|
// |
|
// Function : RunPYC |
|
// PARAMETERS : code - compiled code |
|
// : module - module name to run the code in |
|
// |
|
// PURPOSE : run a compiled python code in a specific module name |
|
// |
|
static hsBool RunPYC(PyObject* code, PyObject* module); |
|
|
|
///////////////////////////////////////////////////////////////////////////// |
|
// |
|
// Function : GetpyKeyFromPython |
|
// PARAMETERS : pkey - python object that is a pyKey (ptKey) class |
|
// |
|
// PURPOSE : turn a PyObject* into a pyKey* |
|
// |
|
static pyKey* GetpyKeyFromPython(PyObject* pkey); |
|
|
|
#if defined(HAVE_CYPYTHONIDE) && !defined(PLASMA_EXTERNAL_RELEASE) |
|
static bool UsePythonDebugger() { return usePythonDebugger; } |
|
static void UsePythonDebugger(bool use) { usePythonDebugger = use; } |
|
|
|
static plCyDebServer* PythonDebugger() {return &debugServer;} |
|
static bool DebuggerRequestedExit() {return requestedExit;} |
|
static void DebuggerRequestedExit(bool reqExit) {requestedExit = reqExit;} |
|
#endif |
|
};
|
|
|