From ac19f256205bb1e454dfcee1277499d128d0bae3 Mon Sep 17 00:00:00 2001 From: Roger Hughston Date: Fri, 27 May 2005 01:20:46 +0000 Subject: [PATCH] *** empty log message *** --- .../interfaceMakerPythonNative.cxx | 67 +++++++++----- dtool/src/interrogate/interrogateBuilder.cxx | 13 ++- dtool/src/interrogate/typeManager.cxx | 21 +++-- dtool/src/interrogatedb/py_panda.h | 87 ++++++++++++++++++- 4 files changed, 154 insertions(+), 34 deletions(-) diff --git a/dtool/src/interrogate/interfaceMakerPythonNative.cxx b/dtool/src/interrogate/interfaceMakerPythonNative.cxx index f64c0ce6ab..3e3d29f526 100755 --- a/dtool/src/interrogate/interfaceMakerPythonNative.cxx +++ b/dtool/src/interrogate/interfaceMakerPythonNative.cxx @@ -660,7 +660,7 @@ void InterfaceMakerPythonNative::write_ClasseDetails(ostream &out, Object * obj) for (fi = obj->_methods.begin(); fi != obj->_methods.end(); ++fi) { Function *func = (*fi); - if(isFunctionLegal(func)) + if( (func)) { ostringstream GetThis; GetThis << " "<::iterator ii = _external_imports.begin(); ii != _external_imports.end(); ii++) + out << "Dtool_" <<*ii <<"._Dtool_ClassInit(NULL);\n"; + out << "}\n"; @@ -1267,7 +1274,7 @@ void InterfaceMakerPythonNative::write_module_class(ostream &out, Object *obj) if(HasAGetKeyFunction(obj->_itype)) { out << "//////////////////\n"; - out << "// A LocalHash(GetKey) Function for this type"; + out << "// A LocalHash(getKey) Function for this type"; out << "// " <GetKey();\n"; + out << " return local_this->get_key();\n"; out << "}\n\n"; has_local_hash = true; } @@ -1480,7 +1487,7 @@ void InterfaceMakerPythonNative::write_module_class(ostream &out, Object *obj) else out << " RegisterRuntimeClass(&Dtool_"<get_type(type_index); @@ -2010,7 +2017,7 @@ void InterfaceMakerPythonNative::write_function_instance(ostream &out, Interface parameter_list += ", &" + param_name; pname_for_pyobject += param_name; - TypeIndex p_type_index = builder.get_type(TypeManager::unwrap(type),false); + TypeIndex p_type_index = builder.get_type(TypeManager::unwrap(TypeManager::resolve_type(type)),false); InterrogateDatabase *idb = InterrogateDatabase::get_ptr(); const InterrogateType &p_itype = idb->get_type(p_type_index); @@ -2220,7 +2227,7 @@ void InterfaceMakerPythonNative::pack_return_value(ostream &out, int indent_leve { if( TypeManager::is_ref_to_anything(orig_type)) { - TypeIndex type_index = builder.get_type(TypeManager::unwrap(type),false); + TypeIndex type_index = builder.get_type(TypeManager::unwrap(TypeManager::resolve_type(type)),false); InterrogateDatabase *idb = InterrogateDatabase::get_ptr(); const InterrogateType &itype = idb->get_type(type_index); std::string ows_memory_flag("true"); @@ -2249,7 +2256,7 @@ void InterfaceMakerPythonNative::pack_return_value(ostream &out, int indent_leve // this is were we type to returned a class/struct.. ie CPP TYpe - TypeIndex type_index = builder.get_type(TypeManager::unwrap(orig_type),false); + TypeIndex type_index = builder.get_type(TypeManager::unwrap(TypeManager::resolve_type(orig_type)),false); InterrogateDatabase *idb = InterrogateDatabase::get_ptr(); const InterrogateType &itype = idb->get_type(type_index); indent(out, indent_level) @@ -2266,7 +2273,7 @@ void InterfaceMakerPythonNative::pack_return_value(ostream &out, int indent_leve if(remap->_manage_reference_count) { - TypeIndex type_index = builder.get_type(TypeManager::unwrap(type),false); + TypeIndex type_index = builder.get_type(TypeManager::unwrap(TypeManager::resolve_type(type)),false); InterrogateDatabase *idb = InterrogateDatabase::get_ptr(); const InterrogateType &itype = idb->get_type(type_index); @@ -2283,7 +2290,7 @@ void InterfaceMakerPythonNative::pack_return_value(ostream &out, int indent_leve } else { - TypeIndex type_index = builder.get_type(TypeManager::unwrap(orig_type),false); + TypeIndex type_index = builder.get_type(TypeManager::unwrap(TypeManager::resolve_type(orig_type)),false); InterrogateDatabase *idb = InterrogateDatabase::get_ptr(); const InterrogateType &itype = idb->get_type(type_index); @@ -2304,7 +2311,7 @@ void InterfaceMakerPythonNative::pack_return_value(ostream &out, int indent_leve } else if( TypeManager::is_struct(orig_type->as_pointer_type()->_pointing_at) ) { - TypeIndex type_index = builder.get_type(TypeManager::unwrap(orig_type),false); + TypeIndex type_index = builder.get_type(TypeManager::unwrap(TypeManager::resolve_type(orig_type)),false); InterrogateDatabase *idb = InterrogateDatabase::get_ptr(); const InterrogateType &itype = idb->get_type(type_index); @@ -2544,42 +2551,46 @@ void InterfaceMakerPythonNative::generate_wrappers() // // is the cpp object supported by by the dtool_py interface.. ////////////////////////////////////////////// -bool InterfaceMakerPythonNative::isCppTypeLegal(CPPType *ctype) +bool InterfaceMakerPythonNative::isCppTypeLegal(CPPType *in_ctype) { - if(ctype == NULL) + if(in_ctype == NULL) return false; - if(builder.in_ignoretype(ctype->get_local_name(&parser))) + if(builder.in_ignoretype(in_ctype->get_local_name(&parser))) + { return false; + } - bool answer = false; - CPPType *type = TypeManager::unwrap(ctype); + //bool answer = false; + CPPType *type = TypeManager::unwrap(TypeManager::resolve_type(in_ctype)); + type = TypeManager::unwrap(type); //CPPType *type = ctype; if(TypeManager::is_basic_string_char(type)) { return true; - answer = true; } else if(TypeManager::is_simple(type)) { return true; - answer = true; } - else if(builder.in_forcetype(ctype->get_local_name(&parser))) + else if(builder.in_forcetype(in_ctype->get_local_name(&parser))) { return true; } else if(TypeManager::IsExported(type) == true) { - answer = true; + return true; } - else if(TypeManager::is_pointer_to_PyObject(ctype) == true) + else if(TypeManager::is_pointer_to_PyObject(in_ctype) == true) { return true; } - return answer; + //if(answer == false) +// printf(" -------------------- Bad Type ?? %s \n",type->get_local_name().c_str()); + + return false; } ////////////////////////////////////////////// // Function :isExportThisRun @@ -2621,7 +2632,10 @@ bool InterfaceMakerPythonNative::isRemapLegal( FunctionRemap &remap) { // return must be legal and managable.. if(!isCppTypeLegal(remap._return_type->get_orig_type())) + { +// printf(" isRemapLegal Return Is Bad %s\n",remap._return_type->get_orig_type()->get_fully_scoped_name().c_str()); return false; + } // ouch .. bad things will happen here .. do not even try.. if(remap._ForcedVoidReturn) @@ -2648,9 +2662,14 @@ bool InterfaceMakerPythonNative::isFunctionLegal( Function *func) { FunctionRemap *remap = (*ri); if(isRemapLegal(*remap)) + { +// printf(" Function Is Marked Legal %s\n",func->_name.c_str()); + return true; + } } +// printf(" Function Is Marked Illegal %s\n",func->_name.c_str()); return false; } //////////////////////////////////////////////////////////////////////// @@ -2773,7 +2792,7 @@ bool InterfaceMakerPythonNative::HasAGetKeyFunction(const InterrogateType &itype { FunctionIndex func_index = itype_class.get_method(mi); const InterrogateFunction &ifunc = idb->get_function(func_index); - if(ifunc.get_name() == "GetKey") + if(ifunc.get_name() == "get_key") { if (ifunc._instances != (InterrogateFunction::Instances *)NULL) { @@ -2918,3 +2937,5 @@ bool InterfaceMakerPythonNative::NeedsAReprFunction(const InterrogateType &itype return false; }; + + diff --git a/dtool/src/interrogate/interrogateBuilder.cxx b/dtool/src/interrogate/interrogateBuilder.cxx index bdc4869105..03d59966b4 100644 --- a/dtool/src/interrogate/interrogateBuilder.cxx +++ b/dtool/src/interrogate/interrogateBuilder.cxx @@ -130,7 +130,18 @@ read_command_file(istream &in) { //////////////////////////////////////////////////////////////////// void InterrogateBuilder:: do_command(const string &command, const string ¶ms) { - if (command == "forcetype") { + + if(command == "forcevisible") + { + CPPType *type = parser.parse_type(params); + if (type == (CPPType *)NULL) { + nout << "Unknown type: allowtype " << params << "\n"; + } else { + type = type->resolve_type(&parser, &parser); + type->_vis = min_vis; + } + } + else if (command == "forcetype") { // forcetype explicitly exports the given type. CPPType *type = parser.parse_type(params); if (type == (CPPType *)NULL) { diff --git a/dtool/src/interrogate/typeManager.cxx b/dtool/src/interrogate/typeManager.cxx index bc7bb4a40e..f62864eebd 100644 --- a/dtool/src/interrogate/typeManager.cxx +++ b/dtool/src/interrogate/typeManager.cxx @@ -1429,8 +1429,13 @@ bool TypeManager::IsExported(CPPType *in_type) CPPScope::Declarations::const_iterator di; for (di = scope->_declarations.begin();di != scope->_declarations.end(); di++) + { if ((*di)->_vis <= min_vis) return true; + } + + + } else if (base_type->get_subtype() == CPPDeclaration::ST_instance) { @@ -1477,14 +1482,14 @@ bool TypeManager::IsExported(CPPType *in_type) } } - -// printf("---------------------> Visibility Failed %s %d Vis=%d, Minvis=%d\n", -// base_type->get_fully_scoped_name().c_str(), -// base_type->get_subtype(), -// base_type->_vis, -// min_vis); - - return false; +/* + printf("---------------------> Visibility Failed %s %d Vis=%d, Minvis=%d\n", + base_type->get_fully_scoped_name().c_str(), + base_type->get_subtype(), + base_type->_vis, + min_vis); +*/ + return false; }; bool TypeManager::IsLocal(CPPType *in_type) diff --git a/dtool/src/interrogatedb/py_panda.h b/dtool/src/interrogatedb/py_panda.h index a016553f94..6a07523cff 100755 --- a/dtool/src/interrogatedb/py_panda.h +++ b/dtool/src/interrogatedb/py_panda.h @@ -89,7 +89,7 @@ typedef void ( *PyModuleClassInit)(PyObject *module); //DTOOL_C_LINKAGE inline long DTool_HashKey(PyObject * inst); inline Dtool_PyTypedObject * Dtool_RuntimeTypeDtoolType(int type); inline void Dtool_Deallocate_General(PyObject * self); - +inline int DTOOL_PyObject_Compare(PyObject *v1, PyObject *v2); // //////////////////////////////////////////////////////////////////////// // THIS IS THE INSTANCE CONTAINER FOR ALL panda py objects.... @@ -208,7 +208,7 @@ EXPORT_THIS Dtool_PyTypedObject Dtool_##CLASS_NAME = {\ 0, /*tp_print*/\ 0, /*tp_getattr*/\ 0, /*tp_setattr*/\ - 0, /*tp_compare*/\ + &DTOOL_PyObject_Compare, /*tp_compare*/\ 0, /*tp_repr*/\ &Dtool_PyNumberMethods_##CLASS_NAME, /*tp_as_number*/\ 0, /*tp_as_sequence*/\ @@ -343,6 +343,21 @@ DTOOL_C_LINKAGE inline void * DTOOL_Call_GetPointerThisClass(PyObject *self, Dto return NULL; }; + +DTOOL_C_LINKAGE inline void * DTOOL_Call_GetPointerThis(PyObject *self) +{ + if(self != NULL) + { + if(DtoolCanThisBeAPandaInstance(self)) + { + Dtool_PyInstDef * pyself = (Dtool_PyInstDef *) self; + return pyself->_ptr_to_object; + } + } + + return NULL; +}; + //////////////////////////////////////////////////////////////////////// // Function : DTool_CreatePyInstanceTyped // @@ -586,6 +601,13 @@ inline void Dtool_PyModuleInitHelper( LibrayDef *defs[], char * modulename) PyObject * module = Py_InitModule(modulename,newdef); + if(module == NULL) + { + PyErr_SetString(PyExc_TypeError, "Py_InitModule Returned NULL ???"); + return; + } + + // the constant inits... enums, classes ... for(int y = 0; defs[y] != NULL; y++) defs[y]->_constants(module); @@ -683,6 +705,67 @@ inline long DTool_HashKey(PyObject * inst) } */ +/* Compare v to w. Return + -1 if v < w or exception (PyErr_Occurred() true in latter case). + 0 if v == w. + 1 if v > w. + XXX The docs (C API manual) say the return value is undefined in case + XXX of error. +*/ + +inline int DTOOL_PyObject_Compare(PyObject *v1, PyObject *v2) +{ + // if we are related.. + if(PyType_IsSubtype(v1->ob_type, v2->ob_type)) + { + void * v1_this = DTOOL_Call_GetPointerThis(v1); + void * v2_this = DTOOL_Call_GetPointerThis(v2); + if(v1_this != NULL && v2_this != NULL) // both are our types... + { + PyObject * func = PyObject_GetAttrString(v1, "compareTo"); + if (func == NULL) + { + PyErr_Clear(); + } + else + { + PyObject * res = NULL; + PyObject * args = Py_BuildValue("(O)", v2); + if (args != NULL) + { + res = PyObject_Call(func, args, NULL); + Py_DECREF(args); + } + Py_DECREF(func); + PyErr_Clear(); // just in case the function threw an error + // only use if the cuntion return an INT... hmm + if(res != NULL && PyInt_Check(res)) + { + int answer = PyInt_AsLong(res); + Py_DECREF(res); + return answer; + } + if(res != NULL) + Py_DECREF(res); + + }; + // CompareTo Failed some how :( + // do a this compare .. if Posible... + if(v1_this < v2_this) + return -1; + + if(v1_this > v2_this) + return 1; + return 0; + } + // ok drop to a basic object compare hmmmmmm + } + if(v1 < v2) + return -1; + if(v1 > v2) + return 1; + return 0; +} #endif // PY_PANDA_H_