TheCloud/panda3d
1
0
Fork 0
mirror of https://github.com/panda3d/panda3d.git synced 2025-10-03 10:22:45 -04:00
Code Issues Packages Projects Releases Wiki Activity

interrogate changes: respect const, use Python names in diagnostic messages

Browse Source
This commit is contained in:
David Rose 2007-02-08 20:15:54 +00:00
parent c1091e7b4a
commit 0be53cccf6
10 changed files with 255 additions and 113 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
direct/src/interval/IntervalManager.py
View File

@ -27,7 +27,7 @@ class IntervalManager(CIntervalManager):
##self.dd = self ##self.dd = self
if globalPtr: if globalPtr:
self.cObj = CIntervalManager.getGlobalPtr() self.cObj = CIntervalManager.getGlobalPtr()
Dtool_BarrowThisRefrence(self, self.cObj) Dtool_BorrowThisReference(self, self.cObj)
self.dd = self self.dd = self
else: else:
CIntervalManager.__init__(self) CIntervalManager.__init__(self)

5
dtool/src/interrogate/functionRemap.cxx
View File

@ -47,6 +47,7 @@ FunctionRemap(const InterrogateType &itype, const InterrogateFunction &ifunc,
_void_return = true; _void_return = true;
_ForcedVoidReturn = false; _ForcedVoidReturn = false;
_has_this = false; _has_this = false;
_const_method = false;
_first_true_parameter = 0; _first_true_parameter = 0;
_num_default_parameters = num_default_parameters; _num_default_parameters = num_default_parameters;
_type = T_normal; _type = T_normal;
@ -444,6 +445,7 @@ setup_properties(const InterrogateFunction &ifunc, InterfaceMaker *interface_mak
// If this is a method, but not a static method, and not a // If this is a method, but not a static method, and not a
// constructor, then we need a "this" parameter. // constructor, then we need a "this" parameter.
_has_this = true; _has_this = true;
_const_method = (_ftype->_flags & CPPFunctionType::F_const_method) != 0;
if (interface_maker->synthesize_this_parameter()) { if (interface_maker->synthesize_this_parameter()) {
// If the interface_maker demands it, the "this" parameter is treated // If the interface_maker demands it, the "this" parameter is treated
@ -452,8 +454,7 @@ setup_properties(const InterrogateFunction &ifunc, InterfaceMaker *interface_mak
Parameter param; Parameter param;
param._name = "this"; param._name = "this";
param._has_name = true; param._has_name = true;
bool is_const = (_ftype->_flags & CPPFunctionType::F_const_method) != 0; param._remap = new ParameterRemapThis(_cpptype, _const_method);
param._remap = new ParameterRemapThis(_cpptype, is_const);
_parameters.push_back(param); _parameters.push_back(param);
_first_true_parameter = 1; _first_true_parameter = 1;
} }

1
dtool/src/interrogate/functionRemap.h
View File

@ -89,6 +89,7 @@ public:
bool _void_return; bool _void_return;
bool _ForcedVoidReturn; bool _ForcedVoidReturn;
bool _has_this; bool _has_this;
bool _const_method;
int _first_true_parameter; int _first_true_parameter;
int _num_default_parameters; int _num_default_parameters;
Type _type; Type _type;

129
dtool/src/interrogate/interfaceMakerPythonNative.cxx
View File

@ -411,7 +411,7 @@ void InterfaceMakerPythonNative::GetValideChildClasses( std::map< std::string
// Function : WriteReturnInstance // Function : WriteReturnInstance
// //
/////////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////////
void InterfaceMakerPythonNative::WriteReturnInstance(ostream &out, int indent_level, std::string &return_expr, std::string &ows_memory_flag, const std::string &class_name, CPPType *ctype, bool inplace) void InterfaceMakerPythonNative::WriteReturnInstance(ostream &out, int indent_level, std::string &return_expr, std::string &ows_memory_flag, const std::string &class_name, CPPType *ctype, bool inplace, const std::string &const_flag)
{ {
if(inplace == true) if(inplace == true)
{ {
@ -430,15 +430,14 @@ void InterfaceMakerPythonNative::WriteReturnInstance(ostream &out, int indent_le
if(IsPandaTypedObject(ctype->as_struct_type())) if(IsPandaTypedObject(ctype->as_struct_type()))
{ {
std::string typestr = "(" + return_expr + ")->as_typed_object()->get_type_index()"; std::string typestr = "(" + return_expr + ")->as_typed_object()->get_type_index()";
indent(out, indent_level)<<"return DTool_CreatePyInstanceTyped((void *)" << return_expr <<"," << CLASS_PREFEX << make_safe_name(class_name) << ","<< ows_memory_flag << ", " << const_flag << ", " << typestr << ");\n";
indent(out, indent_level)<<"return DTool_CreatePyInstanceTyped((void *)" << return_expr <<"," << CLASS_PREFEX << make_safe_name(class_name) << ","<< ows_memory_flag<<","<<typestr<<");\n";
} }
else else
{ {
// indent(out, indent_level)<< "if(" << return_expr <<"!= NULL)\n"; // indent(out, indent_level)<< "if(" << return_expr <<"!= NULL)\n";
indent(out, indent_level) indent(out, indent_level)
<<"return DTool_CreatePyInstance((void *)" << return_expr <<"," << CLASS_PREFEX << make_safe_name(class_name) << ","<<ows_memory_flag<<");\n"; <<"return DTool_CreatePyInstance((void *)" << return_expr <<"," << CLASS_PREFEX << make_safe_name(class_name) << ","<<ows_memory_flag << ", " << const_flag <<");\n";
} }
} }
} }
@ -892,8 +891,8 @@ void InterfaceMakerPythonNative::write_module_support(ostream &out,ostream *out_
if(force_base_functions) if(force_base_functions)
{ {
out << " //Support Function For Dtool_types ... for know in each module ??\n"; out << " //Support Function For Dtool_types ... for now in each module ??\n";
out << " {\"Dtool_BarrowThisRefrence\", &Dtool_BarrowThisRefrence,METH_VARARGS,\"Used to barrow 'this' poiner ( to, from)\\n Assumes no ownership\"}, \n"; out << " {\"Dtool_BorrowThisReference\", &Dtool_BorrowThisReference,METH_VARARGS,\"Used to borrow 'this' poiner ( to, from)\\n Assumes no ownership\"}, \n";
out << " {\"Dtool_AddToDictionary\", &Dtool_AddToDictionary,METH_VARARGS,\"Used to Items Into a types (tp_dict)\"}, \n"; out << " {\"Dtool_AddToDictionary\", &Dtool_AddToDictionary,METH_VARARGS,\"Used to Items Into a types (tp_dict)\"}, \n";
} }
@ -1730,7 +1729,7 @@ write_function_for_name(ostream &out1, InterfaceMaker::Function *func,
indent(out,8)<< "{\n"; indent(out,8)<< "{\n";
indent(out,12) indent(out,12)
<< "PyErr_Format(PyExc_TypeError, \"" << "PyErr_Format(PyExc_TypeError, \""
<< func->_remaps[0]->_cppfunc->get_local_name(&parser) << methodNameFromCppName(func, "")
<< "() takes "; << "() takes ";
// We add one to the parameter count for "self", following the // We add one to the parameter count for "self", following the
@ -1920,7 +1919,7 @@ std::vector< FunctionRemap * > SortFunctionSet(std::set< FunctionRemap *> &rema
/////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////
// Function : write_function_forset // Function : write_function_forset
// //
// A set is defined as all rempas that have the same number of paramaters.. // A set is defined as all remaps that have the same number of paramaters..
/////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////
void InterfaceMakerPythonNative::write_function_forset(ostream &out, InterfaceMaker::Function *func, void InterfaceMakerPythonNative::write_function_forset(ostream &out, InterfaceMaker::Function *func,
std::set< FunctionRemap *> &remapsin, string &expected_params, int indent_level,ostream &forward_decl, const std::string &functionname, bool is_inplace) std::set< FunctionRemap *> &remapsin, string &expected_params, int indent_level,ostream &forward_decl, const std::string &functionname, bool is_inplace)
@ -1937,8 +1936,17 @@ void InterfaceMakerPythonNative::write_function_forset(ostream &out, InterfaceMa
FunctionRemap *remap = (*sii); FunctionRemap *remap = (*sii);
if(isRemapLegal(*remap)) if(isRemapLegal(*remap))
{ {
if (remap->_has_this && !remap->_const_method) {
// If it's a non-const method, we only allow a
// non-const this.
indent(out,indent_level)
<< "if (!((Dtool_PyInstDef *)self)->_is_const) {\n";
} else {
indent(out, indent_level)
<< "{\n";
}
indent(out,indent_level)<< "{ // -2 " ; indent(out,indent_level) << " // -2 " ;
remap->write_orig_prototype(out, 0); out << "\n" ; remap->write_orig_prototype(out, 0); out << "\n" ;
write_function_instance(out, func, remap,expected_params,indent_level+4,false,forward_decl, func->_name, is_inplace); write_function_instance(out, func, remap,expected_params,indent_level+4,false,forward_decl, func->_name, is_inplace);
@ -1954,13 +1962,40 @@ void InterfaceMakerPythonNative::write_function_forset(ostream &out, InterfaceMa
for(sii = remapsin.begin(); sii != remapsin.end(); sii ++) for(sii = remapsin.begin(); sii != remapsin.end(); sii ++)
{ {
FunctionRemap *remap = (*sii); FunctionRemap *remap = (*sii);
if(isRemapLegal(*remap)) if(isRemapLegal(*remap)) {
{ if (remap->_has_this && !remap->_const_method) {
// If it's a non-const method, we only allow a
// non-const this.
indent(out, indent_level)
<< "if (!((Dtool_PyInstDef *)self)->_is_const) {\n";
} else {
indent(out, indent_level)
<< "{\n";
}
indent(out,indent_level)<< "// 1-" ;remap->write_orig_prototype(out, 0); out << "\n" ; indent(out,indent_level + 2)
// indent(out,indent_level)<< "do{\n"; << "// 1-" ;remap->write_orig_prototype(out, 0); out << "\n" ;
write_function_instance(out, func, remap,expected_params,indent_level+4,true,forward_decl, func->_name, is_inplace); write_function_instance(out, func, remap,expected_params,indent_level+4,true,forward_decl, func->_name, is_inplace);
// indent(out,indent_level)<< "}while(false);\n";
if (remap->_has_this && !remap->_const_method) {
indent(out, indent_level)
<< "} else {\n";
indent(out, indent_level + 2)
<< "PyErr_SetString(PyExc_TypeError,\n";
string class_name = remap->_cpptype->get_simple_name();
indent(out, indent_level + 2)
<< " \"Cannot call "
<< classNameFromCppName(class_name)
<< "." << methodNameFromCppName(func, class_name)
<< "() on a const object.\");\n";
indent(out, indent_level + 2)
<< "return (PyObject *) NULL;\n";
indent(out,indent_level)
<< "}\n\n";
} else {
indent(out,indent_level)
<< "}\n\n";
}
} }
} }
} }
@ -1997,7 +2032,7 @@ void InterfaceMakerPythonNative::write_function_instance(ostream &out, Interface
// simultaneously building the ParseTuple() function call and also // simultaneously building the ParseTuple() function call and also
// the parameter expression list for call_function(). // the parameter expression list for call_function().
expected_params += remap->_cppfunc->get_simple_name(); expected_params += methodNameFromCppName(func1, "");
expected_params += "("; expected_params += "(";
int pn; int pn;
@ -2098,7 +2133,7 @@ void InterfaceMakerPythonNative::write_function_instance(ostream &out, Interface
indent(out,indent_level) << "double " << param_name; indent(out,indent_level) << "double " << param_name;
format_specifiers += "d"; format_specifiers += "d";
parameter_list += ", &" + param_name; parameter_list += ", &" + param_name;
expected_params += "float "; expected_params += "float";
} else if (TypeManager::is_char_pointer(type)) { } else if (TypeManager::is_char_pointer(type)) {
indent(out,indent_level) << "char *" << param_name; indent(out,indent_level) << "char *" << param_name;
@ -2112,10 +2147,19 @@ void InterfaceMakerPythonNative::write_function_instance(ostream &out, Interface
parameter_list += ", &" + param_name; parameter_list += ", &" + param_name;
pexpr_string = param_name; pexpr_string = param_name;
pname_for_pyobject += param_name; pname_for_pyobject += param_name;
expected_params += "PyObject"; expected_params += "any";
} else if (TypeManager::is_pointer(type)) { } else if (TypeManager::is_pointer(type)) {
expected_params += type->get_preferred_name(); CPPType *obj_type = TypeManager::unwrap(TypeManager::resolve_type(type));
bool const_ok = !TypeManager::is_non_const_pointer_or_ref(orig_type);
if (const_ok) {
expected_params += "const ";
} else {
expected_params += "non-const ";
}
expected_params += classNameFromCppName(obj_type->get_simple_name());
if (!remap->_has_this || pn != 0) { if (!remap->_has_this || pn != 0) {
indent(out, indent_level) indent(out, indent_level)
<< "PyObject *" << param_name; << "PyObject *" << param_name;
@ -2123,7 +2167,7 @@ void InterfaceMakerPythonNative::write_function_instance(ostream &out, Interface
parameter_list += ", &" + param_name; parameter_list += ", &" + param_name;
pname_for_pyobject += param_name; pname_for_pyobject += param_name;
TypeIndex p_type_index = builder.get_type(TypeManager::unwrap(TypeManager::resolve_type(type)),false); TypeIndex p_type_index = builder.get_type(obj_type,false);
InterrogateDatabase *idb = InterrogateDatabase::get_ptr(); InterrogateDatabase *idb = InterrogateDatabase::get_ptr();
const InterrogateType &p_itype = idb->get_type(p_type_index); const InterrogateType &p_itype = idb->get_type(p_type_index);
@ -2135,12 +2179,19 @@ void InterfaceMakerPythonNative::write_function_instance(ostream &out, Interface
//ForwardDeclrs << "IMPORT_THIS struct Dtool_PyTypedObject Dtool_" << make_safe_name(p_itype.get_scoped_name()) << ";\n"; //ForwardDeclrs << "IMPORT_THIS struct Dtool_PyTypedObject Dtool_" << make_safe_name(p_itype.get_scoped_name()) << ";\n";
} }
string class_name;
string method_prefix;
if (remap->_cpptype) {
class_name = remap->_cpptype->get_simple_name();
method_prefix = classNameFromCppName(class_name) + string(".");
}
ostringstream str; ostringstream str;
str << "DTOOL_Call_GetPointerThisClass(" << param_name str << "DTOOL_Call_GetPointerThisClass(" << param_name
<< ", &Dtool_" << make_safe_name(p_itype.get_scoped_name()) << ", &Dtool_" << make_safe_name(p_itype.get_scoped_name())
<< ", " << pn << ", \"" << ", " << pn << ", \""
<< remap->_cppfunc->get_local_name(&parser) << method_prefix << methodNameFromCppName(func1, class_name)
<< "\");\n"; << "\", " << const_ok << ");\n";
extra_convert += str.str(); extra_convert += str.str();
extra_param_check += "|| (" + param_name + "_this == NULL)"; extra_param_check += "|| (" + param_name + "_this == NULL)";
@ -2173,7 +2224,8 @@ void InterfaceMakerPythonNative::write_function_instance(ostream &out, Interface
// If we got what claimed to be a unary operator, don't check for // If we got what claimed to be a unary operator, don't check for
// parameters, since we won't be getting any anyway. // parameters, since we won't be getting any anyway.
if (!func1->_ifunc.is_unary_op()) { if (!func1->_ifunc.is_unary_op()) {
std::string format_specifiers1 = format_specifiers + ":" + remap->_cppfunc->get_local_name(&parser); std::string format_specifiers1 = format_specifiers + ":" +
methodNameFromCppName(func1, "");
indent(out,indent_level) indent(out,indent_level)
<< "static char * key_word_list[] = {" << keyword_list << "NULL};\n"; << "static char * key_word_list[] = {" << keyword_list << "NULL};\n";
@ -2343,6 +2395,13 @@ void InterfaceMakerPythonNative::pack_return_value(ostream &out, int indent_leve
} }
else if (TypeManager::is_pointer(type)) else if (TypeManager::is_pointer(type))
{ {
string const_flag;
if (TypeManager::is_const_pointer_to_anything(type)) {
const_flag = "true";
} else {
const_flag = "false";
}
if (TypeManager::is_struct(orig_type) || TypeManager::is_ref_to_anything(orig_type)) if (TypeManager::is_struct(orig_type) || TypeManager::is_ref_to_anything(orig_type))
{ {
if( TypeManager::is_ref_to_anything(orig_type)) if( TypeManager::is_ref_to_anything(orig_type))
@ -2352,10 +2411,10 @@ void InterfaceMakerPythonNative::pack_return_value(ostream &out, int indent_leve
const InterrogateType &itype = idb->get_type(type_index); const InterrogateType &itype = idb->get_type(type_index);
std::string ows_memory_flag("true"); std::string ows_memory_flag("true");
if(remap->_return_value_needs_management) if(remap->_return_value_needs_management)
ows_memory_flag = "true"; ows_memory_flag = "true";
else else
ows_memory_flag = "false"; ows_memory_flag = "false";
if(!isExportThisRun(itype._cpptype)) if(!isExportThisRun(itype._cpptype))
{ {
@ -2363,9 +2422,7 @@ void InterfaceMakerPythonNative::pack_return_value(ostream &out, int indent_leve
//ForwardDeclrs << "IMPORT_THIS struct Dtool_PyTypedObject Dtool_" << make_safe_name(itype.get_scoped_name()) << ";\n"; //ForwardDeclrs << "IMPORT_THIS struct Dtool_PyTypedObject Dtool_" << make_safe_name(itype.get_scoped_name()) << ";\n";
} }
WriteReturnInstance(out,indent_level,return_expr,ows_memory_flag,itype.get_scoped_name(),itype._cpptype,is_inplace); WriteReturnInstance(out,indent_level,return_expr,ows_memory_flag,itype.get_scoped_name(),itype._cpptype,is_inplace, const_flag);
// indent(out, indent_level)
// <<"return DTool_CreatePyInstance((void *)" << return_expr <<"," << CLASS_PREFEX << make_safe_name(itype.get_scoped_name()) << ","<<ows_memory_flag<<");\n";
} }
else else
@ -2380,7 +2437,7 @@ void InterfaceMakerPythonNative::pack_return_value(ostream &out, int indent_leve
InterrogateDatabase *idb = InterrogateDatabase::get_ptr(); InterrogateDatabase *idb = InterrogateDatabase::get_ptr();
const InterrogateType &itype = idb->get_type(type_index); const InterrogateType &itype = idb->get_type(type_index);
indent(out, indent_level) indent(out, indent_level)
<<"return DTool_PyInit_Finalize(self, " << return_expr <<",&"<<CLASS_PREFEX << make_safe_name(itype.get_scoped_name()) << ",true);\n"; <<"return DTool_PyInit_Finalize(self, " << return_expr <<",&"<<CLASS_PREFEX << make_safe_name(itype.get_scoped_name()) << ",true,false);\n";
} }
else else
{ {
@ -2404,9 +2461,7 @@ void InterfaceMakerPythonNative::pack_return_value(ostream &out, int indent_leve
} }
// ForwardDeclrs << "extern \"C\" struct Dtool_PyTypedObject Dtool_" << make_safe_name(itype.get_scoped_name()) << ";\n"; // ForwardDeclrs << "extern \"C\" struct Dtool_PyTypedObject Dtool_" << make_safe_name(itype.get_scoped_name()) << ";\n";
WriteReturnInstance(out,indent_level,return_expr,ows_memory_flag,itype.get_scoped_name(),itype._cpptype,is_inplace); WriteReturnInstance(out,indent_level,return_expr,ows_memory_flag,itype.get_scoped_name(),itype._cpptype,is_inplace, const_flag);
//indent(out, indent_level)
// <<"return DTool_CreatePyInstance((void *)" << return_expr <<"," << CLASS_PREFEX << make_safe_name(itype.get_scoped_name()) << ","<<ows_memory_flag<<");\n";
} }
else else
{ {
@ -2421,9 +2476,7 @@ void InterfaceMakerPythonNative::pack_return_value(ostream &out, int indent_leve
} }
// ForwardDeclrs << "extern \"C\" struct Dtool_PyTypedObject Dtool_" << make_safe_name(itype.get_scoped_name()) << ";\n"; // ForwardDeclrs << "extern \"C\" struct Dtool_PyTypedObject Dtool_" << make_safe_name(itype.get_scoped_name()) << ";\n";
//indent(out, indent_level) WriteReturnInstance(out,indent_level,return_expr,ows_memory_flag,itype.get_scoped_name(),itype._cpptype,is_inplace, const_flag);
// <<"return DTool_CreatePyInstance((void *)" << return_expr <<"," << CLASS_PREFEX << make_safe_name(itype.get_scoped_name()) << ","<<ows_memory_flag<<");\n";
WriteReturnInstance(out,indent_level,return_expr,ows_memory_flag,itype.get_scoped_name(),itype._cpptype,is_inplace);
} }
} }
@ -2448,10 +2501,8 @@ void InterfaceMakerPythonNative::pack_return_value(ostream &out, int indent_leve
} }
// ForwardDeclrs << "extern \"C\" struct Dtool_PyTypedObject Dtool_" << make_safe_name(itype.get_scoped_name()) << ";\n"; // ForwardDeclrs << "extern \"C\" struct Dtool_PyTypedObject Dtool_" << make_safe_name(itype.get_scoped_name()) << ";\n";
WriteReturnInstance(out,indent_level,return_expr,ows_memory_flag,itype.get_scoped_name(),itype._cpptype,is_inplace); WriteReturnInstance(out,indent_level,return_expr,ows_memory_flag,itype.get_scoped_name(),itype._cpptype,is_inplace, const_flag);
//indent(out, indent_level)
// << "return DTool_CreatePyInstance((void *)" << return_expr <<","<<CLASS_PREFEX << make_safe_name(itype.get_scoped_name()) <<","<< ows_memory_flag<< ");\n";
} }
else else
{ {

2
dtool/src/interrogate/interfaceMakerPythonNative.h
View File

@ -106,7 +106,7 @@ public:
void GetValideChildClasses( std::map< std::string ,CastDetails > &answer, CPPStructType * inclass, const std::string &up_cast_seed = "", bool downcastposible = true); void GetValideChildClasses( std::map< std::string ,CastDetails > &answer, CPPStructType * inclass, const std::string &up_cast_seed = "", bool downcastposible = true);
bool DoesInheritFromIsClass( const CPPStructType * inclass, const std::string &name); bool DoesInheritFromIsClass( const CPPStructType * inclass, const std::string &name);
bool IsPandaTypedObject(CPPStructType * inclass) { return DoesInheritFromIsClass(inclass,"TypedObject"); }; bool IsPandaTypedObject(CPPStructType * inclass) { return DoesInheritFromIsClass(inclass,"TypedObject"); };
void WriteReturnInstance(ostream &out, int indent_level, std::string &return_expr, std::string &ows_memory_flag,const std::string &class_name, CPPType *ctype, bool inplace); void WriteReturnInstance(ostream &out, int indent_level, std::string &return_expr, std::string &ows_memory_flag,const std::string &class_name, CPPType *ctype, bool inplace, const std::string &const_flag);
bool HasAGetKeyFunction(const InterrogateType &itype_class); bool HasAGetKeyFunction(const InterrogateType &itype_class);
int NeedsAStrFunction(const InterrogateType &itype_class); int NeedsAStrFunction(const InterrogateType &itype_class);
int NeedsAReprFunction(const InterrogateType &itype_class); int NeedsAReprFunction(const InterrogateType &itype_class);

1
dtool/src/interrogate/parameterRemapThis.cxx
View File

@ -38,6 +38,7 @@ ParameterRemapThis(CPPType *type, bool is_const) :
} else { } else {
_new_type = TypeManager::wrap_pointer(type); _new_type = TypeManager::wrap_pointer(type);
} }
_orig_type = _new_type;
} }
//////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////

47
dtool/src/interrogate/typeManager.cxx
View File

@ -166,6 +166,49 @@ is_const_ref_to_anything(CPPType *type) {
} }
} }
////////////////////////////////////////////////////////////////////
// Function: TypeManager::is_const_pointer_to_anything
// Access: Public, Static
// Description: Returns true if the indicated type is a const
// pointer to something, false otherwise.
////////////////////////////////////////////////////////////////////
bool TypeManager::
is_const_pointer_to_anything(CPPType *type) {
switch (type->get_subtype()) {
case CPPDeclaration::ST_const:
return is_const_pointer_to_anything(type->as_const_type()->_wrapped_around);
case CPPDeclaration::ST_pointer:
return is_const(type->as_pointer_type()->_pointing_at);
default:
return false;
}
}
////////////////////////////////////////////////////////////////////
// Function: TypeManager::is_non_const_pointer_or_ref
// Access: Public, Static
// Description: Returns true if the indicated type is a non-const
// pointer or reference to something, false otherwise.
////////////////////////////////////////////////////////////////////
bool TypeManager::
is_non_const_pointer_or_ref(CPPType *type) {
switch (type->get_subtype()) {
case CPPDeclaration::ST_const:
return is_non_const_pointer_or_ref(type->as_const_type()->_wrapped_around);
case CPPDeclaration::ST_pointer:
return !is_const(type->as_pointer_type()->_pointing_at);
case CPPDeclaration::ST_reference:
return !is_const(type->as_reference_type()->_pointing_at);
default:
return false;
}
}
//////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////
// Function: TypeManager::is_pointer // Function: TypeManager::is_pointer
// Access: Public, Static // Access: Public, Static
@ -1586,13 +1629,13 @@ bool TypeManager::IsExported(CPPType *in_type)
if (type->get_subtype() == CPPDeclaration::ST_struct) if (type->get_subtype() == CPPDeclaration::ST_struct)
{ {
CPPStructType *struct_type =type->as_type()->resolve_type(&parser, &parser)->as_struct_type(); CPPStructType *struct_type =type->as_type()->resolve_type(&parser, &parser)->as_struct_type();
CPPScope *scope = struct_type->_scope; //CPPScope *scope = struct_type->_scope;
return IsExported(struct_type); return IsExported(struct_type);
} }
else if (type->get_subtype() == CPPDeclaration::ST_enum) else if (type->get_subtype() == CPPDeclaration::ST_enum)
{ {
CPPEnumType *enum_type = type->as_type()->resolve_type(&parser, &parser)->as_enum_type(); //CPPEnumType *enum_type = type->as_type()->resolve_type(&parser, &parser)->as_enum_type();
if (type->_vis <= min_vis) if (type->_vis <= min_vis)
return true; return true;
} }

2
dtool/src/interrogate/typeManager.h
View File

@ -53,6 +53,8 @@ public:
static bool is_reference(CPPType *type); static bool is_reference(CPPType *type);
static bool is_ref_to_anything(CPPType *type); static bool is_ref_to_anything(CPPType *type);
static bool is_const_ref_to_anything(CPPType *type); static bool is_const_ref_to_anything(CPPType *type);
static bool is_const_pointer_to_anything(CPPType *type);
static bool is_non_const_pointer_or_ref(CPPType *type);
static bool is_pointer(CPPType *type); static bool is_pointer(CPPType *type);
static bool is_const(CPPType *type); static bool is_const(CPPType *type);
static bool is_struct(CPPType *type); static bool is_struct(CPPType *type);

95
dtool/src/interrogatedb/py_panda.cxx
View File

@ -22,11 +22,12 @@
#ifdef HAVE_PYTHON #ifdef HAVE_PYTHON
PyMemberDef standard_type_members[] = { PyMemberDef standard_type_members[] = {
{"this", T_INT, offsetof(Dtool_PyInstDef,_ptr_to_object),READONLY,"C++ This if any"}, {"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_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_const", T_INT, offsetof(Dtool_PyInstDef, _is_const), READONLY,"C++ 'this' const flag"},
{"this_metatype", T_OBJECT, offsetof(Dtool_PyInstDef, _My_Type), READONLY,"The dtool meta object"}, {"this_signature", T_INT, offsetof(Dtool_PyInstDef, _signature), READONLY,"A type check signature"},
{NULL} /* Sentinel */ {"this_metatype", T_OBJECT, offsetof(Dtool_PyInstDef, _My_Type), READONLY,"The dtool meta object"},
{NULL} /* Sentinel */
}; };
@ -39,7 +40,7 @@ bool DtoolCanThisBeAPandaInstance(PyObject *self)
if(self->ob_type->tp_basicsize >= (int)sizeof(Dtool_PyInstDef)) if(self->ob_type->tp_basicsize >= (int)sizeof(Dtool_PyInstDef))
{ {
Dtool_PyInstDef * pyself = (Dtool_PyInstDef *) self; Dtool_PyInstDef * pyself = (Dtool_PyInstDef *) self;
if(pyself->_signiture == PY_PANDA_SIGNITURE) if(pyself->_signature == PY_PANDA_SIGNATURE)
return true; return true;
} }
return false; return false;
@ -47,8 +48,8 @@ bool DtoolCanThisBeAPandaInstance(PyObject *self)
//////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////
// Function : DTOOL_Call_ExtractThisPointerForType // Function : DTOOL_Call_ExtractThisPointerForType
// //
// These are the rapers that allow for down and upcast from type .. // These are the wrappers that allow for down and upcast from type ..
// needed by the Dtool py interface.. Be very carefull if you muck with these // needed by the Dtool py interface.. Be very careful if you muck with these
// as the generated code depends on how this is set up.. // as the generated code depends on how this is set up..
//////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////
void DTOOL_Call_ExtractThisPointerForType(PyObject *self, Dtool_PyTypedObject * classdef, void ** answer) void DTOOL_Call_ExtractThisPointerForType(PyObject *self, Dtool_PyTypedObject * classdef, void ** answer)
@ -61,25 +62,58 @@ void DTOOL_Call_ExtractThisPointerForType(PyObject *self, Dtool_PyTypedObject *
void * void *
DTOOL_Call_GetPointerThisClass(PyObject *self, Dtool_PyTypedObject *classdef, DTOOL_Call_GetPointerThisClass(PyObject *self, Dtool_PyTypedObject *classdef,
int param, const string &function_name) { int param, const string &function_name, bool const_ok) {
if (self != NULL) { if (self != NULL) {
if (DtoolCanThisBeAPandaInstance(self)) { if (DtoolCanThisBeAPandaInstance(self)) {
Dtool_PyTypedObject *my_type = ((Dtool_PyInstDef *)self)->_My_Type; Dtool_PyTypedObject *my_type = ((Dtool_PyInstDef *)self)->_My_Type;
void *result = my_type->_Dtool_UpcastInterface(self, classdef); void *result = my_type->_Dtool_UpcastInterface(self, classdef);
if (result != NULL) { if (result != NULL) {
return result; if (const_ok || !((Dtool_PyInstDef *)self)->_is_const) {
} return result;
}
ostringstream str; ostringstream str;
str << function_name << "() argument " << param << " must be " str << function_name << "() argument " << param << " may not be const";
<< classdef->_name << ", not " << my_type->_name; string msg = str.str();
string msg = str.str(); PyErr_SetString(PyExc_TypeError, msg.c_str());
PyErr_SetString(PyExc_TypeError, msg.c_str());
} else {
ostringstream str;
str << function_name << "() argument " << param << " must be ";
PyObject *fname = PyObject_GetAttrString((PyObject *)classdef->_PyType.ob_type, "__name__");
if (fname != (PyObject *)NULL) {
str << PyString_AsString(fname);
Py_DECREF(fname);
} else {
str << classdef->_name;
}
PyObject *tname = PyObject_GetAttrString((PyObject *)self->ob_type, "__name__");
if (tname != (PyObject *)NULL) {
str << ", not " << PyString_AsString(tname);
Py_DECREF(tname);
} else {
str << ", not " << my_type->_name;
}
string msg = str.str();
PyErr_SetString(PyExc_TypeError, msg.c_str());
}
} else { } else {
ostringstream str; ostringstream str;
str << function_name << "() argument " << param << " must be " str << function_name << "() argument " << param << " must be ";
<< classdef->_name;
PyObject *fname = PyObject_GetAttrString((PyObject *)classdef->_PyType.ob_type, "__name__");
if (fname != (PyObject *)NULL) {
str << PyString_AsString(fname);
Py_DECREF(fname);
} else {
str << classdef->_name;
}
PyObject *tname = PyObject_GetAttrString((PyObject *)self->ob_type, "__name__"); PyObject *tname = PyObject_GetAttrString((PyObject *)self->ob_type, "__name__");
if (tname != (PyObject *)NULL) { if (tname != (PyObject *)NULL) {
str << ", not " << PyString_AsString(tname); str << ", not " << PyString_AsString(tname);
@ -116,7 +150,7 @@ void * DTOOL_Call_GetPointerThis(PyObject *self)
// this function relies on the behavior of typed objects in the panda system. // this function relies on the behavior of typed objects in the panda system.
// //
//////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////
PyObject * DTool_CreatePyInstanceTyped(void * local_this_in, Dtool_PyTypedObject & known_class_type, bool memory_rules, int RunTimeType) PyObject * DTool_CreatePyInstanceTyped(void * local_this_in, Dtool_PyTypedObject & known_class_type, bool memory_rules, bool is_const, int RunTimeType)
{ {
if(local_this_in == NULL ) if(local_this_in == NULL )
{ {
@ -149,7 +183,8 @@ PyObject * DTool_CreatePyInstanceTyped(void * local_this_in, Dtool_PyTypedObject
{ {
self->_ptr_to_object = new_local_this; self->_ptr_to_object = new_local_this;
self->_memory_rules = memory_rules; self->_memory_rules = memory_rules;
self->_signiture = PY_PANDA_SIGNITURE; self->_is_const = is_const;
self->_signature = PY_PANDA_SIGNATURE;
self->_My_Type = target_class; self->_My_Type = target_class;
return (PyObject *)self; return (PyObject *)self;
} }
@ -166,7 +201,8 @@ PyObject * DTool_CreatePyInstanceTyped(void * local_this_in, Dtool_PyTypedObject
{ {
self->_ptr_to_object = local_this_in; self->_ptr_to_object = local_this_in;
self->_memory_rules = memory_rules; self->_memory_rules = memory_rules;
self->_signiture = PY_PANDA_SIGNITURE; self->_is_const = is_const;
self->_signature = PY_PANDA_SIGNATURE;
self->_My_Type = &known_class_type; self->_My_Type = &known_class_type;
} }
return (PyObject *)self; return (PyObject *)self;
@ -176,7 +212,7 @@ PyObject * DTool_CreatePyInstanceTyped(void * local_this_in, Dtool_PyTypedObject
// DTool_CreatePyInstance .. wrapper function to finalize the existance of a general // DTool_CreatePyInstance .. wrapper function to finalize the existance of a general
// dtool py instance.. // dtool py instance..
//////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////
PyObject * DTool_CreatePyInstance(void * local_this, Dtool_PyTypedObject & in_classdef, bool memory_rules) PyObject * DTool_CreatePyInstance(void * local_this, Dtool_PyTypedObject & in_classdef, bool memory_rules, bool is_const)
{ {
if(local_this == NULL) if(local_this == NULL)
{ {
@ -190,6 +226,7 @@ PyObject * DTool_CreatePyInstance(void * local_this, Dtool_PyTypedObject & in_cl
{ {
self->_ptr_to_object = local_this; self->_ptr_to_object = local_this;
self->_memory_rules = memory_rules; self->_memory_rules = memory_rules;
self->_is_const = is_const;
self->_My_Type = classdef; self->_My_Type = classdef;
} }
return (PyObject *)self; return (PyObject *)self;
@ -198,7 +235,7 @@ PyObject * DTool_CreatePyInstance(void * local_this, Dtool_PyTypedObject & in_cl
/////////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////////
/// Th Finalizer for simple instances.. /// Th Finalizer for simple instances..
/////////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////////
int DTool_PyInit_Finalize(PyObject * self, void * This, Dtool_PyTypedObject *type, bool memory_rules) int DTool_PyInit_Finalize(PyObject * self, void * This, Dtool_PyTypedObject *type, bool memory_rules, bool is_const)
{ {
// lets put some code in here that checks to see the memory is properly configured.. // lets put some code in here that checks to see the memory is properly configured..
// prior to my call .. // prior to my call ..
@ -206,6 +243,7 @@ int DTool_PyInit_Finalize(PyObject * self, void * This, Dtool_PyTypedObject *ty
((Dtool_PyInstDef *)self)->_My_Type = type; ((Dtool_PyInstDef *)self)->_My_Type = type;
((Dtool_PyInstDef *)self)->_ptr_to_object = This; ((Dtool_PyInstDef *)self)->_ptr_to_object = This;
((Dtool_PyInstDef *)self)->_memory_rules = memory_rules; ((Dtool_PyInstDef *)self)->_memory_rules = memory_rules;
((Dtool_PyInstDef *)self)->_is_const = is_const;
return 0; return 0;
} }
@ -313,12 +351,12 @@ void Dtool_PyModuleInitHelper( LibrayDef *defs[], char * modulename)
/////////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////////
/// HACK.... Be carefull /// HACK.... Be carefull
// //
// Dtool_BarrowThisRefrence // Dtool_BorrowThisReference
// This function can be used to grab the "THIS" pointer from an object and use it // 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".. // Required to support historical inheritance in the form of "is this instance of"..
// //
/////////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////////
PyObject * Dtool_BarrowThisRefrence(PyObject * self, PyObject * args ) PyObject * Dtool_BorrowThisReference(PyObject * self, PyObject * args )
{ {
PyObject *from_in = NULL; PyObject *from_in = NULL;
PyObject *to_in = NULL; PyObject *to_in = NULL;
@ -332,13 +370,14 @@ PyObject * Dtool_BarrowThisRefrence(PyObject * self, PyObject * args )
if(from->_My_Type == to->_My_Type) if(from->_My_Type == to->_My_Type)
{ {
to->_memory_rules = false; to->_memory_rules = false;
to->_is_const = from->_is_const;
to->_ptr_to_object = from->_ptr_to_object; to->_ptr_to_object = from->_ptr_to_object;
return Py_BuildValue(""); return Py_BuildValue("");
} }
PyErr_SetString(PyExc_TypeError, "Must Be Same Type??"); PyErr_SetString(PyExc_TypeError, "Must Be Same Type??");
} }
else else
PyErr_SetString(PyExc_TypeError, "One of thesee does not appear to be DTOOL Instance ??"); PyErr_SetString(PyExc_TypeError, "One of these does not appear to be DTOOL Instance ??");
} }
return (PyObject *) NULL; return (PyObject *) NULL;
} }
@ -446,7 +485,7 @@ int DTOOL_PyObject_Compare_old(PyObject *v1, PyObject *v2)
}; };
// CompareTo Failed some how :( // CompareTo Failed some how :(
// do a this compare .. if Posible... // do a this compare .. if Possible...
if(v1_this < v2_this) if(v1_this < v2_this)
return -1; return -1;

84
dtool/src/interrogatedb/py_panda.h
View File

@ -84,7 +84,7 @@ EXPCL_DTOOLCONFIG RunTimeTypeList & GetRunTimeTypeList();
////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////
// used to stamp dtool instance.. // used to stamp dtool instance..
#define PY_PANDA_SIGNITURE 0xdeadbeaf #define PY_PANDA_SIGNATURE 0xdeadbeaf
typedef void * ( * ConvertFunctionType )(PyObject *,Dtool_PyTypedObject * ); typedef void * ( * ConvertFunctionType )(PyObject *,Dtool_PyTypedObject * );
typedef void * ( * ConvertFunctionType1 )(void *, Dtool_PyTypedObject *); typedef void * ( * ConvertFunctionType1 )(void *, Dtool_PyTypedObject *);
typedef void ( *FreeFunction )(PyObject *); typedef void ( *FreeFunction )(PyObject *);
@ -96,37 +96,38 @@ inline void Dtool_Deallocate_General(PyObject * self);
//////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////
// THIS IS THE INSTANCE CONTAINER FOR ALL panda py objects.... // THIS IS THE INSTANCE CONTAINER FOR ALL panda py objects....
//////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////
struct Dtool_PyInstDef struct Dtool_PyInstDef {
{ PyObject_HEAD
PyObject_HEAD void *_ptr_to_object;
void * _ptr_to_object; int _memory_rules; // true if we own the pointer and should delete it or unref it
bool _memory_rules; int _is_const; // true if this is a "const" pointer.
unsigned long _signiture; unsigned long _signature;
struct Dtool_PyTypedObject * _My_Type; struct Dtool_PyTypedObject *_My_Type;
}; };
//////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////
// A Offset Dictionary Definign How to read the Above Object.. // A Offset Dictionary Defining How to read the Above Object..
//////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////
extern EXPCL_DTOOLCONFIG PyMemberDef standard_type_members[]; extern EXPCL_DTOOLCONFIG PyMemberDef standard_type_members[];
//////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////
// The Class Definition Structor For a Dtool python type. // The Class Definition Structor For a Dtool python type.
//////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////
struct Dtool_PyTypedObject struct Dtool_PyTypedObject {
{ // Standard Python Features..
// Standard Python Fearures.. PyTypeObject _PyType;
PyTypeObject _PyType;
// My Class Level Features.. // My Class Level Features..
char * _name; // cpp name for the object const char *_name; // cpp name for the object
bool _Dtool_IsRunTimeCapable; // derived from TypedObject bool _Dtool_IsRunTimeCapable; // derived from TypedObject
ConvertFunctionType _Dtool_UpcastInterface; // The Upcast Function By Slot ConvertFunctionType _Dtool_UpcastInterface; // The Upcast Function By Slot
ConvertFunctionType1 _Dtool_DowncastInterface; // The Downcast Function By Slot ConvertFunctionType1 _Dtool_DowncastInterface; // The Downcast Function By Slot
FreeFunction _Dtool_FreeInstance; FreeFunction _Dtool_FreeInstance;
PyModuleClassInit _Dtool_ClassInit; // The init function pointer PyModuleClassInit _Dtool_ClassInit; // The init function pointer
// some convience functions..
inline PyTypeObject & As_PyTypeObject(void) { return _PyType; }; // some convenience functions..
inline PyObject & As_PyObject(void) { return (PyObject &)_PyType; }; inline PyTypeObject &As_PyTypeObject() { return _PyType; };
inline PyObject &As_PyObject() { return (PyObject &)_PyType; };
}; };
@ -234,24 +235,26 @@ EXPORT_THIS Dtool_PyTypedObject Dtool_##CLASS_NAME = {\
//////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////
// The Fast Deallocator.. for Our instances.. // The Fast Deallocator.. for Our instances..
//////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////
inline void Dtool_Deallocate_General(PyObject * self) inline void Dtool_Deallocate_General(PyObject * self) {
{ ((Dtool_PyInstDef *)self)->_My_Type->_Dtool_FreeInstance(self);
((Dtool_PyInstDef *)self)->_My_Type->_Dtool_FreeInstance(self); self->ob_type->tp_free(self);
self->ob_type->tp_free(self);
} }
//////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////
// More Macro(s) to Implement class functions.. Usally used if C++ needs type information // More Macro(s) to Implement class functions.. Usually used if C++ needs type information
//////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////
#define Define_Dtool_new(CLASS_NAME,CNAME)\ #define Define_Dtool_new(CLASS_NAME,CNAME)\
PyObject *Dtool_new_##CLASS_NAME(PyTypeObject *type, PyObject *args, PyObject *kwds)\ PyObject *Dtool_new_##CLASS_NAME(PyTypeObject *type, PyObject *args, PyObject *kwds)\
{\ {\
PyObject * self = type->tp_alloc(type, 0);\ PyObject *self = type->tp_alloc(type, 0);\
((Dtool_PyInstDef *)self)->_signiture = PY_PANDA_SIGNITURE;\ ((Dtool_PyInstDef *)self)->_signature = PY_PANDA_SIGNATURE;\
((Dtool_PyInstDef *)self)->_ptr_to_object = NULL;\ ((Dtool_PyInstDef *)self)->_ptr_to_object = NULL;\
((Dtool_PyInstDef *)self)->_memory_rules = false;\ ((Dtool_PyInstDef *)self)->_memory_rules = false;\
((Dtool_PyInstDef *)self)->_is_const = false;\
((Dtool_PyInstDef *)self)->_My_Type = &Dtool_##CLASS_NAME;\ ((Dtool_PyInstDef *)self)->_My_Type = &Dtool_##CLASS_NAME;\
return self;\ return self;\
}\ }
//////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////
/// Delete functions.. /// Delete functions..
//////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////
@ -301,14 +304,15 @@ EXPCL_DTOOLCONFIG bool DtoolCanThisBeAPandaInstance(PyObject *self);
//////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////
// Function : DTOOL_Call_ExtractThisPointerForType // Function : DTOOL_Call_ExtractThisPointerForType
// //
// These are the rapers that allow for down and upcast from type .. // These are the wrappers that allow for down and upcast from type ..
// needed by the Dtool py interface.. Be very carefull if you muck with these // needed by the Dtool py interface.. Be very careful if you muck
// as the generated code depends on how this is set up.. // with these as the generated code depends on how this is set
// up..
//////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////
EXPCL_DTOOLCONFIG void DTOOL_Call_ExtractThisPointerForType(PyObject *self, Dtool_PyTypedObject * classdef, void ** answer); EXPCL_DTOOLCONFIG void DTOOL_Call_ExtractThisPointerForType(PyObject *self, Dtool_PyTypedObject * classdef, void ** answer);
EXPCL_DTOOLCONFIG void * DTOOL_Call_GetPointerThisClass(PyObject *self, Dtool_PyTypedObject *classdef, int param, const string &function_name); EXPCL_DTOOLCONFIG void * DTOOL_Call_GetPointerThisClass(PyObject *self, Dtool_PyTypedObject *classdef, int param, const string &function_name, bool const_ok);
EXPCL_DTOOLCONFIG void * DTOOL_Call_GetPointerThis(PyObject *self); EXPCL_DTOOLCONFIG void * DTOOL_Call_GetPointerThis(PyObject *self);
@ -318,13 +322,13 @@ EXPCL_DTOOLCONFIG void * DTOOL_Call_GetPointerThis(PyObject *self);
// this function relies on the behavior of typed objects in the panda system. // this function relies on the behavior of typed objects in the panda system.
// //
//////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////
EXPCL_DTOOLCONFIG PyObject * DTool_CreatePyInstanceTyped(void * local_this_in, Dtool_PyTypedObject & known_class_type, bool memory_rules, int RunTimeType); EXPCL_DTOOLCONFIG PyObject *DTool_CreatePyInstanceTyped(void *local_this_in, Dtool_PyTypedObject &known_class_type, bool memory_rules, bool is_const, int RunTimeType);
//////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////
// DTool_CreatePyInstance .. wrapper function to finalize the existance of a general // DTool_CreatePyInstance .. wrapper function to finalize the existance of a general
// dtool py instance.. // dtool py instance..
//////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////
EXPCL_DTOOLCONFIG PyObject * DTool_CreatePyInstance(void * local_this, Dtool_PyTypedObject & in_classdef, bool memory_rules); EXPCL_DTOOLCONFIG PyObject *DTool_CreatePyInstance(void *local_this, Dtool_PyTypedObject &in_classdef, bool memory_rules, bool is_const);
/////////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////////
// Macro(s) class definition .. Used to allocate storage and // Macro(s) class definition .. Used to allocate storage and
@ -374,7 +378,7 @@ Define_Dtool_Class(MODULE_NAME,CLASS_NAME,PUBLIC_NAME)
/////////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////////
/// Th Finalizer for simple instances.. /// Th Finalizer for simple instances..
/////////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////////
EXPCL_DTOOLCONFIG int DTool_PyInit_Finalize(PyObject * self, void * This, Dtool_PyTypedObject *type, bool memory_rules); EXPCL_DTOOLCONFIG int DTool_PyInit_Finalize(PyObject *self, void *This, Dtool_PyTypedObject *type, bool memory_rules, bool is_const);
/////////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////////
/// A heler function to glu methed definition together .. that can not be done at /// A heler function to glu methed definition together .. that can not be done at
@ -417,12 +421,12 @@ EXPCL_DTOOLCONFIG void Dtool_PyModuleInitHelper( LibrayDef *defs[], char * mo
/////////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////////
/// HACK.... Be carefull /// HACK.... Be carefull
// //
// Dtool_BarrowThisRefrence // Dtool_BorrowThisReference
// This function can be used to grab the "THIS" pointer from an object and use it // 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".. // Required to support fom historical inharatence in the for of "is this instance of"..
// //
/////////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////////
EXPCL_DTOOLCONFIG PyObject * Dtool_BarrowThisRefrence(PyObject * self, PyObject * args ); EXPCL_DTOOLCONFIG PyObject * Dtool_BorrowThisReference(PyObject * self, PyObject * args );
////////////////////////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////////////////////////
// We do expose a dictionay for dtool classes .. this should be removed at some point.. // We do expose a dictionay for dtool classes .. this should be removed at some point..