RomanNum3ral
/
open_toontown_panda3d
mirror of https://github.com/open-toontown/panda3d.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

*** empty log message ***

This commit is contained in:
Roger Hughston 2005-05-23 21:22:09 +00:00
parent 63290756fe
commit 010cfe3e2b
1 changed files with 682 additions and 0 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

682
dtool/src/interrogatedb/py_panda.h Executable file
View File

@ -0,0 +1,682 @@
#ifndef PY_PANDA_H_
#define PY_PANDA_H_
// Filename: py_panda.h
////////////////////////////////////////////////////////////////////
//
// PANDA 3D SOFTWARE
// Copyright (c) 2001 - 2004, Disney Enterprises, Inc. All rights reserved
//O
// All use of this software is subject to the terms of the Panda 3d
// Software license. You should have received a copy of this license
// along with this source code; you will also find a current copy of
// the license at http://etc.cmu.edu/panda3d/docs/license/ .
//
// To contact the maintainers of this program write to
// panda3d-general@lists.sourceforge.net .
//
////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////////////
// Too do list ..
// We need a better dispatcher for the functions.. The behavior today is
// try one till it works or you run out of possibilities.. This is anything but optimal
// for performance and is treading on thin ice for function python or c++ will
// course there types to other types.
//
// The linking step will produce allot of warnings
// warning LNK4049: locally defined symbol..
//
// Get a second coder to review this file and the generated code ..
//
//////////////////////////////////////////////////////////////////////////////////////////////
#include <set>
#include <map>
#include <string>
#include "pandabase.h"
#include "typedObject.h"
#include "typeRegistry.h"
#ifdef HAVE_LONG_LONG
#undef HAVE_LONG_LONG
#endif
#include "python.h"
#include "structmember.h"
#ifdef HAVE_LONG_LONG
#undef HAVE_LONG_LONG
#endif
using namespace std;
///////////////////////////////////////////////////////////////////////////////////
// this is tempory .. untill this is glued better into the panda build system
///////////////////////////////////////////////////////////////////////////////////
#ifdef __cplusplus
#define DTOOL_C_LINKAGE extern "C"
#else
#define DTOOL_C_LINKAGE
#endif
#ifdef _WIN32
#define EXPORT_THIS DTOOL_C_LINKAGE __declspec(dllexport)
#define IMPORT_THIS DTOOL_C_LINKAGE __declspec(dllimport)
#define IMPORT_FROM_SHARED_LIB __declspec(dllimport)
#else
#define EXPORT_THIS DTOOL_C_LINKAGE
#define IMPORT_THIS DTOOL_C_LINKAGE
#define IMPORT_FROM_SHARED_LIB
#endif
///////////////////////////////////////////////////////////////////////////////////
struct Dtool_PyTypedObject;
typedef std::map< int , Dtool_PyTypedObject *> RunTimeTypeDictionary;
typedef std::set<int > RunTimeTypeList;
DTOOL_C_LINKAGE RunTimeTypeDictionary & GetRunTimeDictionary();
DTOOL_C_LINKAGE RunTimeTypeList & GetRunTimeTypeList();
//////////////////////////////////////////////////////////
// used to stamp dtool instance..
#define PY_PANDA_SIGNITURE 0xdeadbeaf
DTOOL_C_LINKAGE struct Dtool_PyTypedObject;
DTOOL_C_LINKAGE typedef void * ( * ConvertFunctionType )(PyObject *,Dtool_PyTypedObject * );
DTOOL_C_LINKAGE typedef void * ( * ConvertFunctionType1 )(void *, Dtool_PyTypedObject *);
DTOOL_C_LINKAGE typedef void ( *FreeFunction )(PyObject *);
DTOOL_C_LINKAGE typedef void ( *PyModuleClassInit)(PyObject *module);
//DTOOL_C_LINKAGE inline long DTool_HashKey(PyObject * inst);
DTOOL_C_LINKAGE inline Dtool_PyTypedObject * Dtool_RuntimeTypeDtoolType(int type);
DTOOL_C_LINKAGE inline void Dtool_Deallocate_General(PyObject * self);
//
////////////////////////////////////////////////////////////////////////
// THIS IS THE INSTANCE CONTAINER FOR ALL panda py objects....
////////////////////////////////////////////////////////////////////////
struct Dtool_PyInstDef
{
PyObject_HEAD
void * _ptr_to_object;
bool _memory_rules;
unsigned long _signiture;
struct Dtool_PyTypedObject * _My_Type;
};
////////////////////////////////////////////////////////////////////////
// A Offset Dictionary Definign How to read the Above Object..
////////////////////////////////////////////////////////////////////////
static PyMemberDef standard_type_members[] = {
{"this", T_INT, offsetof(Dtool_PyInstDef,_ptr_to_object),READONLY,"C++ This if any"},
{"this_ownership", T_INT, offsetof(Dtool_PyInstDef, _memory_rules), READONLY,"C++ 'this' ownership rules"},
{"this_signiture", T_INT, offsetof(Dtool_PyInstDef, _signiture), READONLY,"A type check signiture"},
{"this_metatype", T_OBJECT, offsetof(Dtool_PyInstDef, _My_Type), READONLY,"The dtool meta object"},
{NULL} /* Sentinel */
};
////////////////////////////////////////////////////////////////////////
// The Class Definition Structor For a Dtool python type.
////////////////////////////////////////////////////////////////////////
struct Dtool_PyTypedObject
{
// Standard Python Fearures..
PyTypeObject _PyType;
// My Class Level Features..
char * _name; // cpp name for the object
bool _Dtool_IsRunTimeCapable; // derived from TypedObject
ConvertFunctionType _Dtool_UpcastInterface; // The Upcast Function By Slot
ConvertFunctionType1 _Dtool_DowncastInterface; // The Downcast Function By Slot
FreeFunction _Dtool_FreeInstance;
PyModuleClassInit _Dtool_ClassInit; // The init function pointer
// some convience functions..
inline PyTypeObject & As_PyTypeObject(void) { return _PyType; };
inline PyObject & As_PyObject(void) { return (PyObject &)_PyType; };
};
////////////////////////////////////////////////////////////////////////
// Flads for the dtool meta definitions..
///////////////////////////////////////////////////////////////////////
#define Py_Dtool_flags ( \
Py_TPFLAGS_HAVE_GETCHARBUFFER | \
Py_TPFLAGS_HAVE_SEQUENCE_IN | \
Py_TPFLAGS_HAVE_INPLACEOPS | \
Py_TPFLAGS_HAVE_RICHCOMPARE | \
Py_TPFLAGS_HAVE_WEAKREFS | \
Py_TPFLAGS_HAVE_ITER | \
Py_TPFLAGS_HAVE_CLASS | \
Py_TPFLAGS_BASETYPE | \
Py_TPFLAGS_CHECKTYPES | \
0)
////////////////////////////////////////////////////////////////////////
// Macro's from Hell.. May want to Just Add this to the Code generator..
////////////////////////////////////////////////////////////////////////
#define Define_Dtool_Class(MODULE_NAME, CLASS_NAME, PUBLIC_NAME) \
static PyNumberMethods Dtool_PyNumberMethods_##CLASS_NAME ={\
0,/*binaryfunc nb_add*/\
0,/*binaryfunc nb_subtract*/\
0,/*binaryfunc nb_multiply*/\
0,/*binaryfunc nb_divide*/\
0,/*binaryfunc nb_remainder*/\
0,/*binaryfunc nb_divmod*/\
0,/*ternaryfunc nb_power*/\
0,/*unaryfunc nb_negative*/\
0,/*unaryfunc nb_positive*/\
0,/*unaryfunc nb_absolute*/\
0,/*inquiry nb_nonzero*/\
0,/*unaryfunc nb_invert*/\
0,/*binaryfunc nb_lshift*/\
0,/*binaryfunc nb_rshift*/\
0,/*binaryfunc nb_and*/\
0,/*binaryfunc nb_xor*/\
0,/*binaryfunc nb_or*/\
0,/*coercion nb_coerce*/\
0,/*unaryfunc nb_int*/\
0,/*unaryfunc nb_long*/\
0,/*unaryfunc nb_float*/\
0,/*unaryfunc nb_oct*/\
0,/*unaryfunc nb_hex*/\
0,/*binaryfunc nb_inplace_add*/\
0,/*binaryfunc nb_inplace_subtract*/\
0,/*binaryfunc nb_inplace_multiply*/\
0,/*binaryfunc nb_inplace_divide*/\
0,/*binaryfunc nb_inplace_remainder*/\
0,/*ternaryfunc nb_inplace_power*/\
0,/*binaryfunc nb_inplace_lshift*/\
0,/*binaryfunc nb_inplace_rshift*/\
0,/*binaryfunc nb_inplace_and*/\
0,/*binaryfunc nb_inplace_xor*/\
0,/*binaryfunc nb_inplace_or*/\
0,/*binaryfunc nb_floor_divide*/\
0,/*binaryfunc nb_true_divide*/\
0,/*binaryfunc nb_inplace_floor_divide*/\
0,/*binaryfunc nb_inplace_true_divide*/\
};\
static PyMappingMethods Dtool_PyMappingMethods_##CLASS_NAME ={\
0,/*inquiry mp_length */\
0,/*binaryfunc mp_subscript */\
0,/*objobjargproc mp_ass_subscript */\
};\
EXPORT_THIS struct Dtool_PyTypedObject Dtool_##CLASS_NAME = {\
{\
PyObject_HEAD_INIT(NULL)\
0,\
#MODULE_NAME "." #PUBLIC_NAME, /*type name with module */ \
sizeof(Dtool_PyInstDef), /* tp_basicsize*/ \
0, /*tp_itemsize*/ \
&Dtool_Deallocate_General, /*Dtool_Deallocate_##CLASS_NAME,*/ /*tp_dealloc*/\
0, /*tp_print*/\
0, /*tp_getattr*/\
0, /*tp_setattr*/\
0, /*tp_compare*/\
0, /*tp_repr*/\
&Dtool_PyNumberMethods_##CLASS_NAME, /*tp_as_number*/\
0, /*tp_as_sequence*/\
&Dtool_PyMappingMethods_##CLASS_NAME, /*tp_as_mapping*/\
0, /*tp_hash */\
0, /* tp_call */\
0, /* tp_str */\
PyObject_GenericGetAttr, /* tp_getattro */\
PyObject_GenericSetAttr, /* tp_setattro */\
0, /* tp_as_buffer */\
Py_Dtool_flags, /* tp_flags */\
0, /* tp_doc */\
0, /* tp_traverse */\
0, /* tp_clear */\
0, /* tp_richcompare */\
0, /* tp_weaklistoffset */\
0, /* tp_iter */\
0, /* tp_iternext */\
Dtool_Methods_##CLASS_NAME, /* tp_methods */\
standard_type_members, /* tp_members */\
0, /* tp_getset */\
0, /* tp_base */\
0, /* tp_dict */\
0, /* tp_descr_get */\
0, /* tp_descr_set */\
0, /* tp_dictoffset */\
Dtool_Init_##CLASS_NAME, /* tp_init */\
PyType_GenericAlloc, /* tp_alloc */\
Dtool_new_##CLASS_NAME, /* tp_new */\
_PyObject_Del, /* tp_free */\
},\
#CLASS_NAME, \
false,\
Dtool_UpcastInterface_##CLASS_NAME, \
Dtool_DowncastInterface_##CLASS_NAME, \
Dtool_FreeInstance_##CLASS_NAME, \
Dtool_PyModuleClassInit_##CLASS_NAME\
};
////////////////////////////////////////////////////////////////////////
// The Fast Deallocator.. for Our instances..
////////////////////////////////////////////////////////////////////////
DTOOL_C_LINKAGE inline void Dtool_Deallocate_General(PyObject * self)
{
((Dtool_PyInstDef *)self)->_My_Type->_Dtool_FreeInstance(self);
self->ob_type->tp_free(self);
}
////////////////////////////////////////////////////////////////////////
// More Macro(s) to Implement class functions.. Usally used if C++ needs type information
////////////////////////////////////////////////////////////////////////
#define Define_Dtool_new(CLASS_NAME,CNAME)\
DTOOL_C_LINKAGE PyObject *Dtool_new_##CLASS_NAME(PyTypeObject *type, PyObject *args, PyObject *kwds)\
{\
PyObject * self = type->tp_alloc(type, 0);\
((Dtool_PyInstDef *)self)->_signiture = PY_PANDA_SIGNITURE;\
((Dtool_PyInstDef *)self)->_ptr_to_object = NULL;\
((Dtool_PyInstDef *)self)->_memory_rules = false;\
((Dtool_PyInstDef *)self)->_My_Type = &Dtool_##CLASS_NAME;\
return self;\
}\
////////////////////////////////////////////////////////////////////////
/// Delete functions..
////////////////////////////////////////////////////////////////////////
#define Define_Dtool_FreeInstance_Private(CLASS_NAME,CNAME)\
DTOOL_C_LINKAGE void Dtool_FreeInstance_##CLASS_NAME(PyObject *self)\
{\
}\
#define Define_Dtool_FreeInstance(CLASS_NAME,CNAME)\
DTOOL_C_LINKAGE void Dtool_FreeInstance_##CLASS_NAME(PyObject *self)\
{\
if(((Dtool_PyInstDef *)self)->_ptr_to_object != NULL)\
if(((Dtool_PyInstDef *)self)->_memory_rules)\
{\
delete ((CNAME *)((Dtool_PyInstDef *)self)->_ptr_to_object);\
}\
}\
#define Define_Dtool_FreeInstanceRef(CLASS_NAME,CNAME)\
DTOOL_C_LINKAGE void Dtool_FreeInstance_##CLASS_NAME(PyObject *self)\
{\
if(((Dtool_PyInstDef *)self)->_ptr_to_object != NULL)\
if(((Dtool_PyInstDef *)self)->_memory_rules)\
{\
unref_delete((CNAME *)((Dtool_PyInstDef *)self)->_ptr_to_object);\
}\
}\
////////////////////////////////////////////////////////////////////////
/// Simple Recognition Functions..
////////////////////////////////////////////////////////////////////////
DTOOL_C_LINKAGE inline bool DtoolCanThisBeAPandaInstance(PyObject *self)
{
// simple sanity check for the class type..size.. will stop basic foobars..
if(self->ob_type->tp_basicsize >= sizeof(Dtool_PyInstDef))
{
Dtool_PyInstDef * pyself = (Dtool_PyInstDef *) self;
if(pyself->_signiture == PY_PANDA_SIGNITURE)
return true;
}
return false;
}
////////////////////////////////////////////////////////////////////////
// Function : DTOOL_Call_ExtractThisPointerForType
//
// These are the rapers that allow for down and upcast from type ..
// needed by the Dtool py interface.. Be very carefull if you muck with these
// as the generated code depends on how this is set up..
////////////////////////////////////////////////////////////////////////
DTOOL_C_LINKAGE inline void DTOOL_Call_ExtractThisPointerForType(PyObject *self, Dtool_PyTypedObject * classdef, void ** answer)
{
if(DtoolCanThisBeAPandaInstance(self))
*answer = ((Dtool_PyInstDef *)self)->_My_Type->_Dtool_UpcastInterface(self,classdef);
else
answer = NULL;
};
DTOOL_C_LINKAGE inline void * DTOOL_Call_GetPointerThisClass(PyObject *self, Dtool_PyTypedObject *classdef)
{
if(self != NULL)
{
if(DtoolCanThisBeAPandaInstance(self))
return ((Dtool_PyInstDef *)self)->_My_Type->_Dtool_UpcastInterface(self,classdef);
else
PyErr_SetString(PyExc_TypeError, "Failed Dtool Type Check ..");
}
else
PyErr_SetString(PyExc_TypeError, "Self Is Null");
return NULL;
};
////////////////////////////////////////////////////////////////////////
// Function : DTool_CreatePyInstanceTyped
//
// this function relies on the behavior of typed objects in the panda system.
//
////////////////////////////////////////////////////////////////////////
DTOOL_C_LINKAGE inline PyObject * DTool_CreatePyInstanceTyped(void * local_this_in, Dtool_PyTypedObject & known_class_type, bool memory_rules, int RunTimeType)
{
if(local_this_in == NULL )
{
// Lets don't be stupid..
PyErr_SetString(PyExc_TypeError, "C Function Return Null 'this'");
return NULL;
}
/////////////////////////////////////////////////////
// IF the calss is posibly a run time typed object
/////////////////////////////////////////////////////
if(RunTimeType > 0)
{
/////////////////////////////////////////////////////
// get best fit class...
/////////////////////////////////////////////////////
Dtool_PyTypedObject * target_class = Dtool_RuntimeTypeDtoolType(RunTimeType);
if(target_class != NULL)
{
/////////////////////////////////////////////////////
// cast to the type...
//////////////////////////////////////////////////////
void * new_local_this = target_class->_Dtool_DowncastInterface(local_this_in,&known_class_type);
if(new_local_this != NULL)
{
/////////////////////////////////////////////
// ask class to allocate a instance..
/////////////////////////////////////////////
Dtool_PyInstDef * self = (Dtool_PyInstDef *) target_class->As_PyTypeObject().tp_new(&target_class->As_PyTypeObject(), NULL,NULL);
if(self != NULL)
{
self->_ptr_to_object = new_local_this;
self->_memory_rules = memory_rules;
self->_signiture = PY_PANDA_SIGNITURE;
self->_My_Type = target_class;
return (PyObject *)self;
}
}
}
}
/////////////////////////////////////////////////////
// if we get this far .. just wrap the thing in the known type ??
// better than aborting...I guess....
/////////////////////////////////////////////////////
Dtool_PyInstDef * self = (Dtool_PyInstDef *) known_class_type.As_PyTypeObject().tp_new(&known_class_type.As_PyTypeObject(), NULL,NULL);
if(self != NULL)
{
self->_ptr_to_object = local_this_in;
self->_memory_rules = memory_rules;
self->_signiture = PY_PANDA_SIGNITURE;
self->_My_Type = &known_class_type;
}
return (PyObject *)self;
};
////////////////////////////////////////////////////////////////////////
// DTool_CreatePyInstance .. wrapper function to finalize the existance of a general
// dtool py instance..
////////////////////////////////////////////////////////////////////////
DTOOL_C_LINKAGE inline PyObject * DTool_CreatePyInstance(void * local_this, Dtool_PyTypedObject & in_classdef, bool memory_rules)
{
if(local_this == NULL)
{
PyErr_SetString(PyExc_TypeError, "C Function Return Null 'this' ");
return NULL;
}
Dtool_PyTypedObject * classdef = &in_classdef;
Dtool_PyInstDef * self = (Dtool_PyInstDef *) classdef->As_PyTypeObject().tp_new(&classdef->As_PyTypeObject(), NULL,NULL);
if(self != NULL)
{
self->_ptr_to_object = local_this;
self->_memory_rules = memory_rules;
self->_My_Type = classdef;
}
return (PyObject *)self;
};
///////////////////////////////////////////////////////////////////////////////
// Macro(s) class definition .. Used to allocate storage and
// init some values for a Dtool Py Type object.
/////////////////////////////////////////////////////////////////////////////////
#define Define_Module_Class_Forward(MODULE_NAME,CLASS_NAME,CNAME,PUBLIC_NAME)\
IMPORT_THIS struct Dtool_PyTypedObject Dtool_##CLASS_NAME; \
DTOOL_C_LINKAGE PyMethodDef Dtool_Methods_##CLASS_NAME[];\
DTOOL_C_LINKAGE int Dtool_Init_##CLASS_NAME(PyObject *self, PyObject *args, PyObject *kwds);\
DTOOL_C_LINKAGE PyObject *Dtool_new_##CLASS_NAME(PyTypeObject *type, PyObject *args, PyObject *kwds);\
DTOOL_C_LINKAGE void * Dtool_UpcastInterface_##CLASS_NAME(PyObject *self, Dtool_PyTypedObject *requested_type);\
DTOOL_C_LINKAGE void * Dtool_DowncastInterface_##CLASS_NAME(void *self,Dtool_PyTypedObject *requested_type);\
DTOOL_C_LINKAGE void Dtool_FreeInstance_##CLASS_NAME(PyObject *self);\
DTOOL_C_LINKAGEvoid Dtool_PyModuleClassInit_##CLASS_NAME(PyObject *module);\
///////////////////////////////////////////////////////////////////////////////
#define Define_Module_Class_Internal(MODULE_NAME,CLASS_NAME,CNAME)\
EXPORT_THIS struct Dtool_PyTypedObject Dtool_##CLASS_NAME; \
DTOOL_C_LINKAGE PyMethodDef Dtool_Methods_##CLASS_NAME[];\
DTOOL_C_LINKAGE int Dtool_Init_##CLASS_NAME(PyObject *self, PyObject *args, PyObject *kwds);\
DTOOL_C_LINKAGE PyObject *Dtool_new_##CLASS_NAME(PyTypeObject *type, PyObject *args, PyObject *kwds);\
DTOOL_C_LINKAGE void * Dtool_UpcastInterface_##CLASS_NAME(PyObject *self, Dtool_PyTypedObject *requested_type);\
DTOOL_C_LINKAGE void * Dtool_DowncastInterface_##CLASS_NAME(void *self, Dtool_PyTypedObject *requested_type);\
DTOOL_C_LINKAGE void Dtool_FreeInstance_##CLASS_NAME(PyObject *self);\
DTOOL_C_LINKAGE void Dtool_PyModuleClassInit_##CLASS_NAME(PyObject *module);\
///////////////////////////////////////////////////////////////////////////////
#define Define_Module_Class(MODULE_NAME,CLASS_NAME,CNAME,PUBLIC_NAME)\
Define_Module_Class_Internal(MODULE_NAME,CLASS_NAME,CNAME)\
Define_Dtool_new(CLASS_NAME,CNAME)\
Define_Dtool_Class(MODULE_NAME,CLASS_NAME,PUBLIC_NAME)\
Define_Dtool_FreeInstance(CLASS_NAME,CNAME)
///////////////////////////////////////////////////////////////////////////////
#define Define_Module_Class_Private(MODULE_NAME,CLASS_NAME,CNAME,PUBLIC_NAME)\
Define_Module_Class_Internal(MODULE_NAME,CLASS_NAME,CNAME)\
Define_Dtool_new(CLASS_NAME,CNAME)\
Define_Dtool_Class(MODULE_NAME,CLASS_NAME,PUBLIC_NAME)\
Define_Dtool_FreeInstance_Private(CLASS_NAME,CNAME)
///////////////////////////////////////////////////////////////////////////////
#define Define_Module_ClassRef_Private(MODULE_NAME,CLASS_NAME,CNAME,PUBLIC_NAME)\
Define_Module_Class_Internal(MODULE_NAME,CLASS_NAME,CNAME)\
Define_Dtool_new(CLASS_NAME,CNAME)\
Define_Dtool_Class(MODULE_NAME,CLASS_NAME,PUBLIC_NAME)\
Define_Dtool_FreeInstance_Private(CLASS_NAME,CNAME)
///////////////////////////////////////////////////////////////////////////////
#define Define_Module_ClassRef(MODULE_NAME,CLASS_NAME,CNAME,PUBLIC_NAME)\
Define_Module_Class_Internal(MODULE_NAME,CLASS_NAME,CNAME)\
Define_Dtool_new(CLASS_NAME,CNAME)\
Define_Dtool_Class(MODULE_NAME,CLASS_NAME,PUBLIC_NAME)\
Define_Dtool_FreeInstanceRef(CLASS_NAME,CNAME)
///////////////////////////////////////////////////////////////////////////////
/// Th Finalizer for simple instances..
///////////////////////////////////////////////////////////////////////////////
DTOOL_C_LINKAGE inline int DTool_PyInit_Finalize(PyObject * self, void * This, Dtool_PyTypedObject *type, bool memory_rules)
{
// lets put some code in here that checks to see the memory is properly configured..
// prior to my call ..
((Dtool_PyInstDef *)self)->_My_Type = type;
((Dtool_PyInstDef *)self)->_ptr_to_object = This;
((Dtool_PyInstDef *)self)->_memory_rules = memory_rules;
return 0;
}
///////////////////////////////////////////////////////////////////////////////
/// A heler function to glu methed definition together .. that can not be done at
// code generation time becouse of multiple generation passes in interigate..
//
///////////////////////////////////////////////////////////////////////////////
typedef std::map<std::string, PyMethodDef * > MethodDefmap;
inline void Dtool_Accum_MethDefs(PyMethodDef in[], MethodDefmap &themap)
{
for(; in->ml_name != NULL; in++)
{
if(themap.find(in->ml_name) == themap.end())
{
themap[in->ml_name] = in;
}
}
}
///////////////////////////////////////////////////////////////////////////////
// ** HACK ** allert..
//
// Need to keep a runtime type dictionary ... that is forward declared of typed object.
// We rely on the fact that typed objects are uniquly defined by an integer.
//
///////////////////////////////////////////////////////////////////////////////
DTOOL_C_LINKAGE inline void RegisterRuntimeClass(Dtool_PyTypedObject * otype, int class_id)
{
if(class_id > 0)
{
GetRunTimeDictionary()[class_id] = otype;
GetRunTimeTypeList().insert(class_id);
otype->_Dtool_IsRunTimeCapable = true;
}
};
///////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////
DTOOL_C_LINKAGE inline Dtool_PyTypedObject * Dtool_RuntimeTypeDtoolType(int type)
{
RunTimeTypeDictionary::iterator di = GetRunTimeDictionary().find(type);
if(di != GetRunTimeDictionary().end())
return di->second;
else
{
int type2 = get_best_parent_from_Set(type,GetRunTimeTypeList());
di = GetRunTimeDictionary().find(type2);
if(di != GetRunTimeDictionary().end())
return di->second;
printf("Looking For RunTime Type %d Failed Reverting to base type\n",type);
}
return NULL;
};
///////////////////////////////////////////////////////////////////////////////
//// We need a way to runtime merge compile units into a python "Module" .. this is done with the
/// fallowing structors and code.. along with the support of interigate_module
///////////////////////////////////////////////////////////////////////////////
DTOOL_C_LINKAGE typedef void ( *ConstantFunction )(PyObject *);
struct LibrayDef
{
PyMethodDef * _methods;
ConstantFunction _constants;
};
///////////////////////////////////////////////////////////////////////////////
inline void Dtool_PyModuleInitHelper( LibrayDef *defs[], char * modulename)
{
// the module level function inits....
MethodDefmap functions;
for(int xx = 0; defs[xx] != NULL; xx++)
Dtool_Accum_MethDefs(defs[xx]->_methods,functions);
PyMethodDef *newdef = new PyMethodDef[functions.size()+1];
MethodDefmap::iterator mi;
int offset = 0;
for(mi = functions.begin(); mi != functions.end(); mi++, offset++)
newdef[offset] = *mi->second;
newdef[offset].ml_doc = NULL;
newdef[offset].ml_name = NULL;
newdef[offset].ml_meth = NULL;
newdef[offset].ml_flags = 0;
PyObject * module = Py_InitModule(modulename,newdef);
// the constant inits... enums, classes ...
for(int y = 0; defs[y] != NULL; y++)
defs[y]->_constants(module);
PyModule_AddIntConstant(module,"Dtool_PyNavtiveInterface",1);
}
///////////////////////////////////////////////////////////////////////////////
/// HACK.... Be carefull
//
// Dtool_BarrowThisRefrence
// This function can be used to grab the "THIS" pointer from an object and use it
// Required to support fom historical inharatence in the for of "is this instance of"..
//
///////////////////////////////////////////////////////////////////////////////
inline PyObject * Dtool_BarrowThisRefrence(PyObject * self, PyObject * args )
{
PyObject *from_in = NULL;
PyObject *to_in = NULL;
if(PyArg_ParseTuple(args, "OO", &to_in, &from_in))
{
if(DtoolCanThisBeAPandaInstance(from_in) && DtoolCanThisBeAPandaInstance(to_in))
{
Dtool_PyInstDef * from = (Dtool_PyInstDef *) from_in;
Dtool_PyInstDef * to = (Dtool_PyInstDef *) to_in;
if(from->_My_Type == to->_My_Type)
{
to->_memory_rules = false;
to->_ptr_to_object = from->_ptr_to_object;
return Py_BuildValue("");
}
PyErr_SetString(PyExc_TypeError, "Must Be Same Type??");
}
else
PyErr_SetString(PyExc_TypeError, "One of thesee does not appear to be DTOOL Instance ??");
}
return (PyObject *) NULL;
}
//////////////////////////////////////////////////////////////////////////////////////////////
// We do expose a dictionay for dtool classes .. this should be removed at some point..
//////////////////////////////////////////////////////////////////////////////////////////////
inline PyObject * Dtool_AddToDictionary(PyObject * self1, PyObject * args )
{
PyObject * self;
PyObject * subject;
PyObject * key;
if(PyArg_ParseTuple(args, "OSO", &self, &key, &subject))
{
PyObject * dict = ((PyTypeObject *)self)->tp_dict;
if(dict == NULL && !PyDict_Check(dict))
PyErr_SetString(PyExc_TypeError, "No dictionary On Object");
else
PyDict_SetItem(dict,key,subject);
}
if(PyErr_Occurred())
return (PyObject *)NULL;
return Py_BuildValue("");
}
///////////////////////////////////////////////////////////////////////////////////
/*
inline long DTool_HashKey(PyObject * inst)
{
long outcome = (long)inst;
PyObject * func = PyObject_GetAttrString(inst, "__hash__");
if (func == NULL)
{
if(DtoolCanThisBeAPandaInstance(inst))
if(((Dtool_PyInstDef *)inst)->_ptr_to_object != NULL)
outcome = (long)((Dtool_PyInstDef *)inst)->_ptr_to_object;
}
else
{
PyObject *res = PyEval_CallObject(func, (PyObject *)NULL);
Py_DECREF(func);
if (res == NULL)
return -1;
if (PyInt_Check(res))
{
outcome = PyInt_AsLong(res);
if (outcome == -1)
outcome = -2;
}
else
{
PyErr_SetString(PyExc_TypeError,
"__hash__() should return an int");
outcome = -1;
}
Py_DECREF(res);
}
return outcome;
}
*/
#endif // PY_PANDA_H_