|
|
@@ -0,0 +1,2874 @@
|
|
|
+// Filename: interfaceMakerPythonNative.cxx
|
|
|
+////////////////////////////////////////////////////////////////////
|
|
|
+//
|
|
|
+// PANDA 3D SOFTWARE
|
|
|
+// Copyright (c) 2001 - 2004, Disney Enterprises, Inc. All rights reserved
|
|
|
+//
|
|
|
+// 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
|
|
|
+// [email protected] .
|
|
|
+//
|
|
|
+////////////////////////////////////////////////////////////////////
|
|
|
+
|
|
|
+#include "interfaceMakerPythonNative.h"
|
|
|
+#include "interrogateBuilder.h"
|
|
|
+#include "interrogate.h"
|
|
|
+#include "functionRemap.h"
|
|
|
+#include "parameterRemapUnchanged.h"
|
|
|
+#include "typeManager.h"
|
|
|
+
|
|
|
+#include "interrogateDatabase.h"
|
|
|
+#include "interrogateType.h"
|
|
|
+#include "interrogateFunction.h"
|
|
|
+#include "cppFunctionType.h"
|
|
|
+#include "cppPointerType.h"
|
|
|
+#include "cppTypeDeclaration.h"
|
|
|
+#include "cppStructType.h"
|
|
|
+#include "vector"
|
|
|
+#include "cppParameterList.h"
|
|
|
+#include "algorithm"
|
|
|
+
|
|
|
+#include <set>
|
|
|
+#include <map>
|
|
|
+
|
|
|
+
|
|
|
+extern bool inside_python_native;
|
|
|
+extern InterrogateType dummy_type;
|
|
|
+extern std::string EXPORT_IMPORT_PREFEX;
|
|
|
+
|
|
|
+#define CLASS_PREFEX "Dtool_"
|
|
|
+#define INSTANCE_PREFEX "Dtool_"
|
|
|
+#define BASE_INSTANCE_NAME "Dtool_PyInstDef"
|
|
|
+#define MAX_COMMENT_SIZE 1024
|
|
|
+
|
|
|
+
|
|
|
+/////////////////////////////////////////////////////////
|
|
|
+// Name Remaper...
|
|
|
+// Snagged from ffi py code....
|
|
|
+/////////////////////////////////////////////////////////
|
|
|
+struct RenameSet
|
|
|
+{
|
|
|
+ char * _from;
|
|
|
+ char * _to;
|
|
|
+ int function_type;
|
|
|
+};
|
|
|
+///////////////////////////////////////////////////////////////////////////////////////
|
|
|
+RenameSet methodRenameDictionary[] = {
|
|
|
+ "operator==" , "eq", 0,
|
|
|
+ "operator!=" , "ne", 0,
|
|
|
+ "operator<<" , "__lshift__", 0,
|
|
|
+ "operator>>" , "__rshift__", 0,
|
|
|
+ "operator<" , "lessThan", 0,
|
|
|
+ "operator>" , "greaterThan", 0,
|
|
|
+ "operator<=" , "lessThanOrEqual", 0,
|
|
|
+ "operator>=" , "greaterThanOrEqual", 0,
|
|
|
+ "operator=" , "assign", 0,
|
|
|
+ "operator()" , "__call__", 0,
|
|
|
+ "operator[]" , "__getitem__", 0,
|
|
|
+ "operator++" , "increment", 0,
|
|
|
+ "operator--" , "decrement", 0,
|
|
|
+ "operator^" , "__xor__", 0,
|
|
|
+ "operator%" , "__mod__", 0,
|
|
|
+ "operator!" , "logicalNot", 0,
|
|
|
+ "operator~" , "bitwiseNot", 0,
|
|
|
+ "operator&" , "__and__", 0,
|
|
|
+ "operator&&" , "logicalAnd", 0,
|
|
|
+ "operator|" , "__or__", 0,
|
|
|
+ "operator||" , "logicalOr", 0,
|
|
|
+ "operator+" , "__add__", 0,
|
|
|
+ "operator-" , "__sub__", 0,
|
|
|
+ "operator*" , "__mul__", 0,
|
|
|
+ "operator/" , "__div__", 0,
|
|
|
+ "operator+=" , "__iadd__", 0,
|
|
|
+ "operator-=" , "__isub__", 0,
|
|
|
+ "operator*=" , "__imul__", 0,
|
|
|
+ "operator/=" , "__idiv__", 0,
|
|
|
+ "operator," , "concatenate", 0,
|
|
|
+ "operator|=" , "__ior__", 0,
|
|
|
+ "operator&=" , "__iand__", 0,
|
|
|
+ "operator^=" , "__ixor__", 0,
|
|
|
+ "operator~=" , "bitwiseNotEqual", 0,
|
|
|
+ "operator->" , "dereference", 0,
|
|
|
+ "operator<<=" , "__ilshift__", 0,
|
|
|
+ "operator>>=" , "__irshift__", 0,
|
|
|
+ "print" , "Cprint", 0,
|
|
|
+ "CInterval.setT" , "_priv__cSetT", 0,
|
|
|
+ NULL,NULL,-1
|
|
|
+ };
|
|
|
+///////////////////////////////////////////////////////////////////////////////////////
|
|
|
+RenameSet classRenameDictionary[] = {
|
|
|
+ "Loader" , "PandaLoader",0,
|
|
|
+ "String" , "CString",0,
|
|
|
+ "LMatrix4f" , "Mat4",0,
|
|
|
+ "LMatrix3f" , "Mat3",0,
|
|
|
+ "LVecBase4f" , "VBase4",0,
|
|
|
+ "LVector4f" , "Vec4",0,
|
|
|
+ "LPoint4f" , "Point4",0,
|
|
|
+ "LVecBase3f" , "VBase3",0,
|
|
|
+ "LVector3f" , "Vec3",0,
|
|
|
+ "LPoint3f" , "Point3",0,
|
|
|
+ "LVecBase2f" , "VBase2",0,
|
|
|
+ "LVector2f" , "Vec2",0,
|
|
|
+ "LPoint2f" , "Point2",0,
|
|
|
+ "LQuaternionf" , "Quat",0,
|
|
|
+ "LMatrix4d" , "Mat4D",0,
|
|
|
+ "LMatrix3d" , "Mat3D",0,
|
|
|
+ "LVecBase4d" , "VBase4D",0,
|
|
|
+ "LVector4d" , "Vec4D",0,
|
|
|
+ "LPoint4d" , "Point4D",0,
|
|
|
+ "LVecBase3d" , "VBase3D",0,
|
|
|
+ "LVector3d" , "Vec3D",0,
|
|
|
+ "LPoint3d" , "Point3D",0,
|
|
|
+ "LVecBase2d" , "VBase2D",0,
|
|
|
+ "LVector2d" , "Vec2D",0,
|
|
|
+ "LPoint2d" , "Point2D",0,
|
|
|
+ "LQuaterniond" , "QuatD",0,
|
|
|
+ "Plane" , "PlaneBase",0,
|
|
|
+ "Planef" , "Plane",0,
|
|
|
+ "Planed" , "PlaneD",0,
|
|
|
+ "Frustum" , "FrustumBase",0,
|
|
|
+ "Frustumf" , "Frustum",0,
|
|
|
+ "Frustumd" , "FrustumD",0,
|
|
|
+ NULL,NULL,-1
|
|
|
+ };
|
|
|
+
|
|
|
+///////////////////////////////////////////////////////////////////////////////////////
|
|
|
+///////////////////////////////////////////////////////////////////////////////////////
|
|
|
+char * pythonKeywords[] = {
|
|
|
+ "and",
|
|
|
+ "del",
|
|
|
+ "for",
|
|
|
+ "is",
|
|
|
+ "raise",
|
|
|
+ "assert",
|
|
|
+ "elif",
|
|
|
+ "from",
|
|
|
+ "lambda",
|
|
|
+ "return",
|
|
|
+ "break",
|
|
|
+ "else",
|
|
|
+ "global",
|
|
|
+ "not",
|
|
|
+ "try",
|
|
|
+ "class",
|
|
|
+ "except",
|
|
|
+ "if",
|
|
|
+ "or",
|
|
|
+ "while",
|
|
|
+ "continue",
|
|
|
+ "exec",
|
|
|
+ "import",
|
|
|
+ "pass",
|
|
|
+ "def",
|
|
|
+ "finally",
|
|
|
+ "in",
|
|
|
+ "print",
|
|
|
+ NULL};
|
|
|
+///////////////////////////////////////////////////////////////////////////////////////
|
|
|
+std::string checkKeyword(std::string & cppName)
|
|
|
+{
|
|
|
+ for(int x = 0; pythonKeywords[x] != NULL; x++)
|
|
|
+ {
|
|
|
+ if(cppName == pythonKeywords[x])
|
|
|
+ {
|
|
|
+ return std::string("_")+cppName;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ return cppName;
|
|
|
+}
|
|
|
+///////////////////////////////////////////////////////////////////////////////////////
|
|
|
+///////////////////////////////////////////////////////////////////////////////////////
|
|
|
+std::string classNameFromCppName(const std::string &cppName)
|
|
|
+{
|
|
|
+ //# initialize to empty string
|
|
|
+ std::string className = "";
|
|
|
+ //# These are the characters we want to strip out of the name
|
|
|
+ const std::string badChars("!@#$%^&*()<>,.-=+~{}? ");
|
|
|
+ int nextCap = 0;
|
|
|
+ int firstChar = 1;
|
|
|
+ for(std::string::const_iterator chr = cppName.begin(); chr != cppName.end(); chr++)
|
|
|
+ {
|
|
|
+ if (badChars.find(*chr) != std::string::npos)
|
|
|
+ {
|
|
|
+ }
|
|
|
+ else if (*chr == '_')
|
|
|
+ {
|
|
|
+ nextCap = 1;
|
|
|
+ }
|
|
|
+ else if (nextCap || firstChar)
|
|
|
+ {
|
|
|
+ className += toupper(*chr);
|
|
|
+ nextCap = 0;
|
|
|
+ firstChar = 0;
|
|
|
+ }
|
|
|
+ else
|
|
|
+ {
|
|
|
+ className += * chr;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ for(int x = 0; classRenameDictionary[x]._from != NULL; x++)
|
|
|
+ {
|
|
|
+ if(className == classRenameDictionary[x]._from)
|
|
|
+ className = classRenameDictionary[x]._to;
|
|
|
+ }
|
|
|
+
|
|
|
+ if (className.empty())
|
|
|
+ {
|
|
|
+ std::string text = "** ERROR ** Renaming class: " + cppName + " to empty string";
|
|
|
+ printf("%s",text.c_str());
|
|
|
+ }
|
|
|
+
|
|
|
+
|
|
|
+ //# FFIConstants.notify.debug('Renaming class: ' + cppName + ' to: ' + className)
|
|
|
+ //# Note we do not have to check for keywords because class name are capitalized
|
|
|
+ return className;
|
|
|
+}
|
|
|
+///////////////////////////////////////////////////////////////////////////////////////
|
|
|
+///////////////////////////////////////////////////////////////////////////////////////
|
|
|
+std::string nonClassNameFromCppName(const std::string &cppName_in)
|
|
|
+{
|
|
|
+ std::string className = classNameFromCppName(cppName_in);
|
|
|
+ //# Make the first character lowercase
|
|
|
+ std::string newName;
|
|
|
+ int pass = 0;
|
|
|
+ for(std::string::const_iterator chr = className.begin(); chr != className.end(); chr++)
|
|
|
+ {
|
|
|
+ if(pass == 0)
|
|
|
+ newName += toupper(*chr);
|
|
|
+ else
|
|
|
+ newName += tolower(*chr);
|
|
|
+ pass++;
|
|
|
+ }
|
|
|
+ //# Mangle names that happen to be python keywords so they are not anymore
|
|
|
+ //newName = checkKeyword(newName)
|
|
|
+ return newName;
|
|
|
+}
|
|
|
+///////////////////////////////////////////////////////////////////////////////////////
|
|
|
+///////////////////////////////////////////////////////////////////////////////////////
|
|
|
+std::string methodNameFromCppName(std::string cppName, const std::string &className)
|
|
|
+{
|
|
|
+ std::string methodName;
|
|
|
+ std::string badChars(" ");
|
|
|
+ int nextCap = 0;
|
|
|
+ for(std::string::const_iterator chr = cppName.begin(); chr != cppName.end(); chr++)
|
|
|
+ {
|
|
|
+ if (badChars.find(*chr) != std::string::npos)
|
|
|
+ {
|
|
|
+ }
|
|
|
+ else if (*chr == '_')
|
|
|
+ {
|
|
|
+ nextCap = 1;
|
|
|
+ }
|
|
|
+ else if (nextCap)
|
|
|
+ {
|
|
|
+ methodName += toupper(*chr);
|
|
|
+ nextCap = 0;
|
|
|
+ }
|
|
|
+ else
|
|
|
+ {
|
|
|
+ methodName += *chr;
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ std::string LookUpName = methodName;
|
|
|
+ for(int x = 0; classRenameDictionary[x]._from != NULL; x++)
|
|
|
+ {
|
|
|
+ if(methodName == methodRenameDictionary[x]._from || (cppName == methodRenameDictionary[x]._from && methodRenameDictionary[x].function_type != 0) )
|
|
|
+ {
|
|
|
+ methodName = methodRenameDictionary[x]._to;
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ if(className.size() > 0)
|
|
|
+ {
|
|
|
+ LookUpName = className + '.' + methodName;
|
|
|
+ for(int x = 0; classRenameDictionary[x]._from != NULL; x++)
|
|
|
+ {
|
|
|
+ if(methodName == methodRenameDictionary[x]._from)
|
|
|
+ methodName = methodRenameDictionary[x]._to;
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+
|
|
|
+// # Mangle names that happen to be python keywords so they are not anymore
|
|
|
+ methodName = checkKeyword(methodName);
|
|
|
+ return methodName;
|
|
|
+}
|
|
|
+///////////////////////////////////////////////////////////////////////////////////////
|
|
|
+///////////////////////////////////////////////////////////////////////////////////////
|
|
|
+
|
|
|
+std::string make_safe_comment(const std::string & name_in)
|
|
|
+{
|
|
|
+ std::string name(name_in.substr(0,MAX_COMMENT_SIZE));
|
|
|
+
|
|
|
+ static const char safe_chars2[] = ",.[](){}:;'`~!@#$%^&*+\\=/abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_- ";
|
|
|
+ std::string result = name;
|
|
|
+
|
|
|
+ size_t pos = result.find_first_of("\\");
|
|
|
+ while (pos != std::string::npos)
|
|
|
+ {
|
|
|
+ result.replace(pos,1,"_");
|
|
|
+ pos = result.find_first_of("\\");
|
|
|
+ }
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+ pos = result.find_first_of("\n");
|
|
|
+ while (pos != std::string::npos)
|
|
|
+ {
|
|
|
+ result.replace(pos,1,"\\n");
|
|
|
+ pos = result.find_first_of("\n");
|
|
|
+ }
|
|
|
+
|
|
|
+
|
|
|
+ pos = result.find_first_not_of(safe_chars2);
|
|
|
+ while (pos != std::string::npos)
|
|
|
+ {
|
|
|
+ result[pos] = ' ';
|
|
|
+ pos = result.find_first_not_of(safe_chars2);
|
|
|
+ }
|
|
|
+
|
|
|
+ return result;
|
|
|
+}
|
|
|
+///////////////////////////////////////////////////////////////////////////////
|
|
|
+///////////////////////////////////////////////////////////////////////////////
|
|
|
+///////////////////////////////////////////////////////////////////////////////
|
|
|
+std::string make_safe_name(const std::string & name)
|
|
|
+{
|
|
|
+ return InterrogateBuilder::clean_identifier(name);
|
|
|
+
|
|
|
+ static const char safe_chars2[] = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_";
|
|
|
+ std::string result = name;
|
|
|
+
|
|
|
+ size_t pos = result.find_first_not_of(safe_chars2);
|
|
|
+ while (pos != std::string::npos)
|
|
|
+ {
|
|
|
+ result[pos] = '_';
|
|
|
+ pos = result.find_first_not_of(safe_chars2);
|
|
|
+ }
|
|
|
+
|
|
|
+ return result;
|
|
|
+}
|
|
|
+
|
|
|
+///////////////////////////////////////////////////////////////////////////////
|
|
|
+///////////////////////////////////////////////////////////////////////////////
|
|
|
+void InterfaceMakerPythonNative::GetValideChildClasses( std::map< std::string ,CastDetails > &answer, CPPStructType * inclass, const std::string &up_cast_seed, bool downcastposible)
|
|
|
+{
|
|
|
+ if(inclass == NULL)
|
|
|
+ return;
|
|
|
+
|
|
|
+ CPPStructType::Derivation::const_iterator bi;
|
|
|
+ for (bi = inclass->_derivation.begin();
|
|
|
+ bi != inclass->_derivation.end();
|
|
|
+ ++bi)
|
|
|
+ {
|
|
|
+
|
|
|
+ const CPPStructType::Base &base = (*bi);
|
|
|
+// if (base._vis <= V_public)
|
|
|
+ // downcastposible = false;
|
|
|
+ CPPStructType *base_type = TypeManager::resolve_type(base._base)->as_struct_type();
|
|
|
+ if(base_type != NULL)
|
|
|
+ {
|
|
|
+ std::string scoped_name = base_type->get_fully_scoped_name();
|
|
|
+
|
|
|
+ if(answer.find(scoped_name) == answer.end())
|
|
|
+ {
|
|
|
+ answer[scoped_name]._can_downcast = downcastposible;
|
|
|
+ answer[scoped_name]._to_class_name = scoped_name;
|
|
|
+ answer[scoped_name]._structType = base_type;
|
|
|
+
|
|
|
+ if(base._is_virtual)
|
|
|
+ answer[scoped_name]._can_downcast = false;
|
|
|
+
|
|
|
+ std::string local_up_cast("( ");
|
|
|
+ local_up_cast += scoped_name + " *)"+ up_cast_seed +"";
|
|
|
+ answer[scoped_name]._up_cast_string = local_up_cast;
|
|
|
+ answer[scoped_name]._is_legal_py_class = isCppTypeLegal(base_type);
|
|
|
+ }
|
|
|
+ else
|
|
|
+ {
|
|
|
+ answer[scoped_name]._can_downcast = false;
|
|
|
+ }
|
|
|
+
|
|
|
+ GetValideChildClasses(answer,base_type, answer[scoped_name]._up_cast_string,answer[scoped_name]._can_downcast);
|
|
|
+ }
|
|
|
+ }
|
|
|
+}
|
|
|
+///////////////////////////////////////////////////////////////////////////////
|
|
|
+// Function : WriteCreateInstance
|
|
|
+//
|
|
|
+///////////////////////////////////////////////////////////////////////////////
|
|
|
+void InterfaceMakerPythonNative::WriteCreateInstance(ostream &out, int indent_level, std::string &return_expr, std::string &ows_memory_flag, const std::string &class_name, CPPType *ctype)
|
|
|
+{
|
|
|
+ indent(out, indent_level)<<"if("<< return_expr<< " == NULL)\n";
|
|
|
+ indent(out, indent_level)<<"{\n";
|
|
|
+ indent(out, indent_level)<<" Py_INCREF(Py_None);\n";
|
|
|
+ indent(out, indent_level)<<" return Py_None;\n";
|
|
|
+ indent(out, indent_level)<<"}\n";
|
|
|
+
|
|
|
+ if(IsPandaTypedObject(ctype->as_struct_type()))
|
|
|
+ {
|
|
|
+ std::string typestr = "((TypedObject *)" + return_expr + ")->get_type_index()";
|
|
|
+
|
|
|
+ indent(out, indent_level)<<"return DTool_CreatePyInstanceTyped((void *)" << return_expr <<"," << CLASS_PREFEX << make_safe_name(class_name) << ","<< ows_memory_flag<<","<<typestr<<");\n";
|
|
|
+
|
|
|
+ }
|
|
|
+ else
|
|
|
+ {
|
|
|
+ // indent(out, indent_level)<< "if(" << return_expr <<"!= NULL)\n";
|
|
|
+ indent(out, indent_level)
|
|
|
+ <<"return DTool_CreatePyInstance((void *)" << return_expr <<"," << CLASS_PREFEX << make_safe_name(class_name) << ","<<ows_memory_flag<<");\n";
|
|
|
+ }
|
|
|
+}
|
|
|
+////////////////////////////////////////////////////////////////////
|
|
|
+// Function: InterfaceMakerPythonNative::Constructor
|
|
|
+// Access: Public
|
|
|
+// Description:
|
|
|
+////////////////////////////////////////////////////////////////////
|
|
|
+InterfaceMakerPythonNative::
|
|
|
+InterfaceMakerPythonNative(InterrogateModuleDef *def) :
|
|
|
+ InterfaceMakerPython(def)
|
|
|
+{
|
|
|
+}
|
|
|
+
|
|
|
+////////////////////////////////////////////////////////////////////
|
|
|
+// Function: InterfaceMakerPythonNative::Destructor
|
|
|
+// Access: Public, Virtual
|
|
|
+// Description:
|
|
|
+////////////////////////////////////////////////////////////////////
|
|
|
+InterfaceMakerPythonNative::
|
|
|
+~InterfaceMakerPythonNative() {
|
|
|
+}
|
|
|
+
|
|
|
+////////////////////////////////////////////////////////////////////
|
|
|
+// Function: InterfaceMakerPythonNative::write_prototypes
|
|
|
+// Access: Public, Virtual
|
|
|
+// Description: Generates the list of function prototypes
|
|
|
+// corresponding to the functions that will be output in
|
|
|
+// write_functions().
|
|
|
+////////////////////////////////////////////////////////////////////
|
|
|
+void InterfaceMakerPythonNative::write_prototypes(ostream &out_code,ostream *out_h)
|
|
|
+{
|
|
|
+ inside_python_native = true;
|
|
|
+
|
|
|
+ Functions::iterator fi;
|
|
|
+
|
|
|
+ if(out_h != NULL)
|
|
|
+ *out_h << "#include \"py_panda.h\"\n\n";
|
|
|
+
|
|
|
+ out_code << "//********************************************************************\n";
|
|
|
+ out_code << "//*** prototypes for .. Glabal\n";
|
|
|
+ out_code << "//********************************************************************\n";
|
|
|
+
|
|
|
+ for (fi = _functions.begin(); fi != _functions.end(); ++fi)
|
|
|
+ {
|
|
|
+
|
|
|
+ Function *func = (*fi);
|
|
|
+ if(!func->_itype.is_global() && isFunctionLegal(func))
|
|
|
+ write_prototype_for(out_code, func);
|
|
|
+ }
|
|
|
+
|
|
|
+ Objects::iterator oi;
|
|
|
+ for (oi = _objects.begin(); oi != _objects.end(); ++oi)
|
|
|
+ {
|
|
|
+ Object *object = (*oi).second;
|
|
|
+ if(object->_itype.is_class() ||object->_itype.is_struct())
|
|
|
+ {
|
|
|
+ if(isCppTypeLegal(object->_itype._cpptype))
|
|
|
+ {
|
|
|
+ if(isExportThisRun(object->_itype._cpptype))
|
|
|
+ {
|
|
|
+ write_prototypes_class(out_code,out_h,object);
|
|
|
+ }
|
|
|
+ else
|
|
|
+ //write_prototypes_class_external(out_code,object);
|
|
|
+ _external_imports.insert(make_safe_name(object->_itype.get_scoped_name()));
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ out_code << "//********************************************************************\n";
|
|
|
+ out_code << "//*** prototypes for .. Extrernal Objects \n";
|
|
|
+ out_code << "//********************************************************************\n";
|
|
|
+
|
|
|
+ for(std::set< std::string >::iterator ii = _external_imports.begin(); ii != _external_imports.end(); ii++)
|
|
|
+ out_code << "IMPORT_THIS struct Dtool_PyTypedObject Dtool_" <<*ii <<";\n";
|
|
|
+
|
|
|
+
|
|
|
+ inside_python_native = false;
|
|
|
+}
|
|
|
+/////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
+// Function : write_prototypes_class_external
|
|
|
+//
|
|
|
+// Description : Output enough enformation to a declartion of a externally
|
|
|
+// generated dtool type object
|
|
|
+/////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
+void InterfaceMakerPythonNative::write_prototypes_class_external(ostream &out, Object * obj)
|
|
|
+{
|
|
|
+ std::string class_name = make_safe_name(obj->_itype.get_scoped_name());
|
|
|
+ std::string c_class_name = obj->_itype.get_true_name();
|
|
|
+
|
|
|
+
|
|
|
+ out << "//********************************************************************\n";
|
|
|
+ out << "//*** prototypes for external.. " << class_name <<"\n";
|
|
|
+ out << "//********************************************************************\n";
|
|
|
+
|
|
|
+ out << "typedef "<< c_class_name <<" "<< class_name <<"_localtype;\n";
|
|
|
+ out << "Define_Module_Class_Forward("<< _def->module_name << ", "<< class_name << "," << class_name <<"_localtype,"<< classNameFromCppName(c_class_name) << ");\n";
|
|
|
+
|
|
|
+}
|
|
|
+///////////////////////////////////////// ////////////////////////////////////////////////////
|
|
|
+// Function : write_prototypes_class
|
|
|
+//
|
|
|
+/////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
+void InterfaceMakerPythonNative::write_prototypes_class(ostream &out_code,ostream *out_h, Object * obj)
|
|
|
+{
|
|
|
+ std::string ClassName = make_safe_name(obj->_itype.get_scoped_name());
|
|
|
+ Functions::iterator fi;
|
|
|
+
|
|
|
+ out_code << "//********************************************************************\n";
|
|
|
+ out_code << "//*** prototypes for .. " << ClassName <<"\n";
|
|
|
+ out_code << "//********************************************************************\n";
|
|
|
+
|
|
|
+ for (fi = obj->_methods.begin(); fi != obj->_methods.end(); ++fi)
|
|
|
+ {
|
|
|
+ Function *func = (*fi);
|
|
|
+ write_prototype_for(out_code, func);
|
|
|
+ }
|
|
|
+
|
|
|
+ for (fi = obj->_constructors.begin(); fi != obj->_constructors.end(); ++fi)
|
|
|
+ {
|
|
|
+ Function *func = (*fi);
|
|
|
+ std::string fname = "int Dtool_Init_"+ClassName+"(PyObject *self, PyObject *args, PyObject *kwds)";
|
|
|
+ write_prototype_for_name(out_code, func,fname);
|
|
|
+
|
|
|
+ }
|
|
|
+ write_ClasseDeclarations(out_code,out_h,obj);
|
|
|
+}
|
|
|
+
|
|
|
+////////////////////////////////////////////////////////////////////
|
|
|
+// Function: InterfaceMakerPythonNative::write_functions
|
|
|
+// Access: Public, Virtual
|
|
|
+// Description: Generates the list of functions that are appropriate
|
|
|
+// for this interface. This function is called *before*
|
|
|
+// write_prototypes(), above.
|
|
|
+////////////////////////////////////////////////////////////////////
|
|
|
+void InterfaceMakerPythonNative::write_functions(ostream &out)
|
|
|
+{
|
|
|
+ inside_python_native = true;
|
|
|
+
|
|
|
+ out << "//********************************************************************\n";
|
|
|
+ out << "//*** Functions for .. Global \n" ;
|
|
|
+ out << "//********************************************************************\n";
|
|
|
+ Functions::iterator fi;
|
|
|
+ for (fi = _functions.begin(); fi != _functions.end(); ++fi)
|
|
|
+ {
|
|
|
+ Function *func = (*fi);
|
|
|
+ if(!func->_itype.is_global() && isFunctionLegal(func))
|
|
|
+ write_function_for_top(out, func,"");
|
|
|
+ }
|
|
|
+
|
|
|
+ Objects::iterator oi;
|
|
|
+ for (oi = _objects.begin(); oi != _objects.end(); ++oi)
|
|
|
+ {
|
|
|
+ Object *object = (*oi).second;
|
|
|
+ if(object->_itype.is_class() ||object->_itype.is_struct())
|
|
|
+ {
|
|
|
+ if(isCppTypeLegal(object->_itype._cpptype))
|
|
|
+ if(isExportThisRun(object->_itype._cpptype))
|
|
|
+ write_ClasseDetails(out,object);
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+// Objects::iterator oi;
|
|
|
+ for (oi = _objects.begin(); oi != _objects.end(); ++oi)
|
|
|
+ {
|
|
|
+ Object *object = (*oi).second;
|
|
|
+ if(!object->_itype.get_outer_class())
|
|
|
+ {
|
|
|
+ if(object->_itype.is_class() ||object->_itype.is_struct())
|
|
|
+ if(isCppTypeLegal(object->_itype._cpptype))
|
|
|
+ if(isExportThisRun(object->_itype._cpptype))
|
|
|
+ write_module_class(out,object);
|
|
|
+ }
|
|
|
+ }
|
|
|
+ inside_python_native = true;
|
|
|
+
|
|
|
+}
|
|
|
+////////////////////////////////////////////////////////////
|
|
|
+// Function : write_ClasseDetails
|
|
|
+////////////////////////////////////////////////////////////
|
|
|
+void InterfaceMakerPythonNative::write_ClasseDetails(ostream &out, Object * obj)
|
|
|
+{
|
|
|
+ Functions::iterator fi;
|
|
|
+
|
|
|
+ //std::string cClassName = obj->_itype.get_scoped_name();
|
|
|
+ std::string ClassName = make_safe_name(obj->_itype.get_scoped_name());
|
|
|
+ std::string cClassName = obj->_itype.get_true_name();
|
|
|
+
|
|
|
+ out << "//********************************************************************\n";
|
|
|
+ out << "//*** Functions for .. "<< cClassName <<" \n" ;
|
|
|
+ out << "//********************************************************************\n";
|
|
|
+
|
|
|
+ for (fi = obj->_methods.begin(); fi != obj->_methods.end(); ++fi)
|
|
|
+ {
|
|
|
+ Function *func = (*fi);
|
|
|
+ if(isFunctionLegal(func))
|
|
|
+ {
|
|
|
+ ostringstream GetThis;
|
|
|
+ GetThis << " "<<cClassName << " * local_this = NULL;\n";
|
|
|
+ GetThis << " DTOOL_Call_ExtractThisPointerForType(self,&Dtool_"<< ClassName<<",(void **)&local_this);\n";
|
|
|
+ GetThis << " if(local_this == NULL)\n";
|
|
|
+ GetThis << " {\n";
|
|
|
+ GetThis << " if(!PyTuple_Check(args))\n";
|
|
|
+ GetThis << " {\n";
|
|
|
+ GetThis << " PyObject * temp = args;\n";
|
|
|
+ GetThis << " args = self;\n";
|
|
|
+ GetThis << " self = temp;\n";
|
|
|
+ GetThis << " DTOOL_Call_ExtractThisPointerForType(self,&Dtool_"<< ClassName<<",(void **)&local_this);\n";
|
|
|
+ GetThis << " }\n";
|
|
|
+ GetThis << " if(local_this == NULL)\n";
|
|
|
+ GetThis << " {\n";
|
|
|
+ GetThis << " PyErr_SetString(PyExc_TypeError, \"Error extracting 'this' pointer. Self is not a " << cClassName << "\");\n";
|
|
|
+ GetThis << " return (PyObject *) NULL;\n" ;
|
|
|
+ GetThis << " }\n";
|
|
|
+ GetThis << " };\n";
|
|
|
+
|
|
|
+ write_function_for_top(out, func,GetThis.str());
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+// bool AnyLeganConstructors;
|
|
|
+
|
|
|
+ if(obj->_constructors.size() == 0)
|
|
|
+ {
|
|
|
+ std::string fname = "int Dtool_Init_"+ClassName+"(PyObject *self, PyObject *args, PyObject *kwds)";
|
|
|
+ out << fname << "\n";
|
|
|
+ out << "{\n";
|
|
|
+ out << " PyErr_SetString(PyExc_TypeError, \"Error Can Not Init Constant Class (" << cClassName << ")\");\n";
|
|
|
+ out << " return -1;\n" ;
|
|
|
+ out << "}\n";
|
|
|
+
|
|
|
+ }
|
|
|
+ else
|
|
|
+ {
|
|
|
+ for (fi = obj->_constructors.begin(); fi != obj->_constructors.end(); ++fi)
|
|
|
+ {
|
|
|
+ Function *func = (*fi);
|
|
|
+ std::string fname = "int Dtool_Init_"+ClassName+"(PyObject *self, PyObject *args, PyObject *kwds) ";
|
|
|
+
|
|
|
+ write_function_for_name(out, func,fname,"",ClassName);
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ InterrogateDatabase *idb = InterrogateDatabase::get_ptr();
|
|
|
+
|
|
|
+ std::map< string ,CastDetails > details;
|
|
|
+ std::map< string ,CastDetails >::iterator di;
|
|
|
+ TypeIndex pp_type_index = builder.get_type(TypeManager::unwrap(TypeManager::resolve_type(obj->_itype._cpptype)),false);
|
|
|
+ GetValideChildClasses(details,obj->_itype._cpptype->as_struct_type());
|
|
|
+ for(di = details.begin(); di != details.end(); di++)
|
|
|
+ {
|
|
|
+ //InterrogateType ptype =idb->get_type(di->first);
|
|
|
+ if(di->second._is_legal_py_class && !isExportThisRun(di->second._structType))
|
|
|
+ _external_imports.insert(make_safe_name(di->second._to_class_name));
|
|
|
+ //out << "IMPORT_THIS struct Dtool_PyTypedObject Dtool_" << make_safe_name(di->second._to_class_name) <<";\n";
|
|
|
+ }
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+ { // the Cast Converter
|
|
|
+
|
|
|
+ out << "inline void * Dtool_UpcastInterface_"<< ClassName << "(PyObject *self, Dtool_PyTypedObject *requested_type)\n";
|
|
|
+ out << "{\n";
|
|
|
+ out << " Dtool_PyTypedObject *SelfType = ((Dtool_PyInstDef *)self)->_My_Type;\n";
|
|
|
+ out << " if(SelfType != &Dtool_" << ClassName <<")\n";
|
|
|
+ out << " {\n";
|
|
|
+ out << " printf(\""<<ClassName<<" ** Bad Source Type-- Requesting Conversion from %s to %s\\n\",((Dtool_PyInstDef *)self)->_My_Type->_name,requested_type->_name);fflush(NULL);\n";;
|
|
|
+ out << " return NULL;\n";
|
|
|
+ out << " }\n";
|
|
|
+ out << " \n";
|
|
|
+ out << " "<<cClassName<<" * local_this = (" << cClassName<<" *)((Dtool_PyInstDef *)self)->_ptr_to_object;\n";
|
|
|
+ out << " if(requested_type == &Dtool_"<<ClassName<<")\n";
|
|
|
+ out << " return local_this;\n";
|
|
|
+
|
|
|
+ InterrogateDatabase *idb = InterrogateDatabase::get_ptr();
|
|
|
+ for(di = details.begin(); di != details.end(); di++)
|
|
|
+ {
|
|
|
+ if(di->second._is_legal_py_class)
|
|
|
+ {
|
|
|
+ out << " if(requested_type == &Dtool_"<<make_safe_name(di->second._to_class_name)<<")\n";
|
|
|
+ out << " return "<< di->second._up_cast_string << " local_this;\n";
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ out << " return NULL;\n";
|
|
|
+ out << "}\n";
|
|
|
+
|
|
|
+ out << "inline void * Dtool_DowncastInterface_"<< ClassName << "(void *from_this, Dtool_PyTypedObject *from_type)\n";
|
|
|
+ out << "{\n";
|
|
|
+ out << " if(from_this == NULL || from_type == NULL)\n";
|
|
|
+ out << " return NULL;\n";
|
|
|
+ out << " if(from_type == &Dtool_" << ClassName<<")\n";
|
|
|
+ out << " return from_this;\n";
|
|
|
+ for(di = details.begin(); di != details.end(); di++)
|
|
|
+ {
|
|
|
+ if(di->second._can_downcast && di->second._is_legal_py_class)
|
|
|
+ {
|
|
|
+ out << " if(from_type == &Dtool_"<<make_safe_name(di->second._to_class_name)<<")\n";
|
|
|
+ out << " {\n";
|
|
|
+ out << " "<< di->second._to_class_name << "* other_this = ("<< di->second._to_class_name << "*)from_this;\n" ;
|
|
|
+ out << " return ("<< cClassName << "*)other_this;\n";
|
|
|
+ out << " }\n";
|
|
|
+ }
|
|
|
+ }
|
|
|
+ out << " return (void *) NULL;\n";
|
|
|
+ out << "}\n";
|
|
|
+
|
|
|
+ }
|
|
|
+
|
|
|
+}
|
|
|
+////////////////////////////////////////////////////////////
|
|
|
+/// Function : write_ClasseDeclarations
|
|
|
+//
|
|
|
+//
|
|
|
+////////////////////////////////////////////////////////////
|
|
|
+void InterfaceMakerPythonNative::write_ClasseDeclarations(ostream &out, ostream *out_h,Object * obj )
|
|
|
+{
|
|
|
+
|
|
|
+ const InterrogateType &itype = obj->_itype;
|
|
|
+ std::string class_name = make_safe_name(obj->_itype.get_scoped_name());
|
|
|
+ std::string c_class_name = itype.get_true_name();
|
|
|
+ std::string class_struct_name = std::string(CLASS_PREFEX) +class_name;
|
|
|
+
|
|
|
+ out << "typedef "<< c_class_name <<" "<< class_name <<"_localtype;\n";
|
|
|
+ if(obj->_constructors.size() >0)
|
|
|
+ {
|
|
|
+ if(TypeManager::is_reference_count(obj->_itype._cpptype))
|
|
|
+ {
|
|
|
+ out << "Define_Module_ClassRef("<< _def->module_name<<"," << class_name << "," << class_name <<"_localtype,"<< classNameFromCppName(c_class_name) <<");\n";
|
|
|
+ }
|
|
|
+ else
|
|
|
+ {
|
|
|
+ out << "Define_Module_Class("<<_def->module_name << "," << class_name << "," <<class_name <<"_localtype,"<< classNameFromCppName(c_class_name) <<");\n";
|
|
|
+ }
|
|
|
+ }
|
|
|
+ else
|
|
|
+ {
|
|
|
+ if(TypeManager::is_reference_count(obj->_itype._cpptype))
|
|
|
+ {
|
|
|
+ out << "Define_Module_ClassRef_Private("<<_def->module_name << "," << class_name << "," << class_name <<"_localtype,"<< classNameFromCppName(c_class_name) <<");\n";
|
|
|
+ }
|
|
|
+ else
|
|
|
+ {
|
|
|
+ out << "Define_Module_Class_Private("<<_def->module_name<< "," << class_name << "," << class_name <<"_localtype,"<< classNameFromCppName(c_class_name) << ");\n";
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+
|
|
|
+ if(out_h != NULL)
|
|
|
+ *out_h << "extern \"C\" " << EXPORT_IMPORT_PREFEX << " struct Dtool_PyTypedObject Dtool_" << class_name <<";\n";
|
|
|
+}
|
|
|
+////////////////////////////////////////////////////////////////////
|
|
|
+// Function: InterfaceMakerPythonNative::write_module
|
|
|
+// Access: Public, Virtual
|
|
|
+// Description: Generates whatever additional code is required to
|
|
|
+// support a module file.
|
|
|
+////////////////////////////////////////////////////////////////////
|
|
|
+void InterfaceMakerPythonNative::write_sub_module(ostream &out, Object *obj)
|
|
|
+{
|
|
|
+ //Object * obj = _objects[_embeded_index] ;
|
|
|
+ std::string ClassName = make_safe_name(obj->_itype.get_scoped_name());
|
|
|
+ out << "//********************************************************************\n";
|
|
|
+ out << "//*** Module Init Updcall .." << obj->_itype.get_scoped_name() << "\n";
|
|
|
+ out << "//********************************************************************\n";
|
|
|
+ out << " Dtool_PyModuleClassInit_"<< ClassName <<"(module);\n";
|
|
|
+}
|
|
|
+/////////////////////////////////////////////////////////////////////////////
|
|
|
+// Function : write_module_support
|
|
|
+/////////////////////////////////////////////////////////////////////////////
|
|
|
+void InterfaceMakerPythonNative::write_module_support(ostream &out,ostream *out_h,InterrogateModuleDef *moduledefdef)
|
|
|
+{
|
|
|
+ out << "//********************************************************************\n";
|
|
|
+ out << "//*** Module Object Linker .. \n";
|
|
|
+ out << "//********************************************************************\n";
|
|
|
+
|
|
|
+ out << "static void BuildInstants(PyObject * module)\n";
|
|
|
+ out << "{\n";
|
|
|
+ Objects::iterator oi;
|
|
|
+ for (oi = _objects.begin(); oi != _objects.end(); ++oi)
|
|
|
+ {
|
|
|
+ Object *object = (*oi).second;
|
|
|
+ if(!object->_itype.get_outer_class())
|
|
|
+ {
|
|
|
+ if(object->_itype.is_enum())
|
|
|
+ {
|
|
|
+ int enum_count = object->_itype.number_of_enum_values();
|
|
|
+ if(enum_count > 0)
|
|
|
+ {
|
|
|
+ out << "//********************************************************************\n";
|
|
|
+ out << "//*** Module Enums .." << object->_itype.get_scoped_name() << "\n";
|
|
|
+ out << "//********************************************************************\n";
|
|
|
+ }
|
|
|
+ for(int xx = 0; xx< enum_count; xx++)
|
|
|
+ out << " PyModule_AddIntConstant(module,\"" << classNameFromCppName(object->_itype.get_enum_value_name(xx)) <<"\","<< object->_itype.get_enum_value(xx) << ");\n";
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ InterrogateDatabase *idb = InterrogateDatabase::get_ptr();
|
|
|
+ int num_manifests = idb->get_num_global_manifests();
|
|
|
+ for (int mi = 0; mi < num_manifests; mi++)
|
|
|
+ {
|
|
|
+ ManifestIndex manifest_index = idb->get_global_manifest(mi);
|
|
|
+ const InterrogateManifest &iman = idb->get_manifest(manifest_index);
|
|
|
+ if (iman.has_getter())
|
|
|
+ {
|
|
|
+ FunctionIndex func_index = iman.get_getter();
|
|
|
+ record_function(dummy_type, func_index);
|
|
|
+ }
|
|
|
+ if(iman.has_int_value())
|
|
|
+ out << " PyModule_AddIntConstant(module,\"" << classNameFromCppName(iman.get_name()) <<"\","<< iman.get_int_value() << ");\n";
|
|
|
+ else
|
|
|
+ out << " PyModule_AddStringConstant(module,\"" << classNameFromCppName(iman.get_name()) <<"\",\""<< iman.get_definition().c_str() << "\");\n";
|
|
|
+
|
|
|
+ }
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+ for (oi = _objects.begin(); oi != _objects.end(); ++oi)
|
|
|
+ {
|
|
|
+ Object *object = (*oi).second;
|
|
|
+ if(!object->_itype.get_outer_class())
|
|
|
+ {
|
|
|
+ if(object->_itype.is_class() ||object->_itype.is_struct())
|
|
|
+ if(isCppTypeLegal(object->_itype._cpptype))
|
|
|
+ if(isExportThisRun(object->_itype._cpptype))
|
|
|
+ write_sub_module(out,object);
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+
|
|
|
+ out << "}\n";
|
|
|
+
|
|
|
+ bool force_base_functions = true;
|
|
|
+
|
|
|
+ out << "static PyMethodDef python_simple_funcs[] = {\n";
|
|
|
+ Functions::iterator fi;
|
|
|
+ for (fi = _functions.begin(); fi != _functions.end(); ++fi)
|
|
|
+ {
|
|
|
+ Function *func = (*fi);
|
|
|
+ if(!func->_itype.is_global() && isFunctionLegal(func))
|
|
|
+ {
|
|
|
+ {
|
|
|
+ out << " { \"" << methodNameFromCppName( func->_ifunc.get_name(),"") << "\", &"
|
|
|
+ << func->_name << ", METH_VARARGS ," << func->_name << "_comment},\n";
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ if(force_base_functions)
|
|
|
+ {
|
|
|
+ out << " //Support Function For Dtool_types ... for know 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_AddToDictionary\", &Dtool_AddToDictionary,METH_VARARGS,\"Used to Items Into a types (tp_dict)\"}, \n";
|
|
|
+ }
|
|
|
+
|
|
|
+ out << " { NULL, NULL ,NULL,NULL}\n" << "};\n\n";
|
|
|
+
|
|
|
+ out << "struct LibrayDef " << moduledefdef->library_name <<"_moddef = {python_simple_funcs,BuildInstants};\n";
|
|
|
+ if(out_h != NULL)
|
|
|
+ *out_h << "extern struct LibrayDef " << moduledefdef->library_name <<"_moddef;\n";
|
|
|
+}
|
|
|
+/////////////////////////////////////////////////////////////////////////////
|
|
|
+///// Function : write_module
|
|
|
+/////////////////////////////////////////////////////////////////////////////
|
|
|
+void InterfaceMakerPythonNative::write_module(ostream &out,ostream *out_h, InterrogateModuleDef *moduledefdef)
|
|
|
+{
|
|
|
+ InterfaceMakerPython::write_module(out,out_h, moduledefdef);
|
|
|
+ Objects::iterator oi;
|
|
|
+
|
|
|
+ out << "//********************************************************************\n";
|
|
|
+ out << "//*** Py Init Code For .. GlobalScope\n" ;
|
|
|
+ out << "//********************************************************************\n";
|
|
|
+
|
|
|
+ out << "#ifdef _WIN32\n"
|
|
|
+ << "extern \"C\" __declspec(dllexport) void init" << moduledefdef->module_name << "();\n"
|
|
|
+ << "#else\n"
|
|
|
+ << "extern \"C\" void init" << moduledefdef->module_name << "();\n"
|
|
|
+ << "#endif\n\n";
|
|
|
+
|
|
|
+ out << "void init" << moduledefdef->module_name << "() {\n";
|
|
|
+ out << " LibrayDef * refs[] = {&" << moduledefdef->library_name << "_moddef,NULL};\n";
|
|
|
+ out << " Dtool_PyModuleInitHelper(refs,\"" << moduledefdef->module_name << "\");\n";
|
|
|
+ out << "}\n\n";
|
|
|
+}
|
|
|
+////////////////////////////////////////////////////////////////////
|
|
|
+/// Function : GetSlotedFunctinDef
|
|
|
+//
|
|
|
+// This function is used to define special behavior for class functions..
|
|
|
+// main use is to encode the slot pointer logic and function call
|
|
|
+// conventions for the slaot interface..
|
|
|
+////////////////////////////////////////////////////////////////////
|
|
|
+bool GetSlotedFunctinDef(const std::string &thimputstring, std::string &answer_location, int &wraper_type)
|
|
|
+{
|
|
|
+ wraper_type = -1;
|
|
|
+
|
|
|
+ if(thimputstring.size() > 4 && thimputstring[0] == '_' && thimputstring[1] == '_')
|
|
|
+ {
|
|
|
+ if(thimputstring == "__add__")
|
|
|
+ {
|
|
|
+ answer_location = "tp_as_number->nb_add";
|
|
|
+ return true;
|
|
|
+ }
|
|
|
+
|
|
|
+ if(thimputstring == "__sub__")
|
|
|
+ {
|
|
|
+ answer_location = "tp_as_number->nb_subtract";
|
|
|
+ return true;
|
|
|
+ }
|
|
|
+
|
|
|
+ if(thimputstring == "__mul__")
|
|
|
+ {
|
|
|
+ answer_location = "tp_as_number->nb_multiply";
|
|
|
+ return true;
|
|
|
+ }
|
|
|
+
|
|
|
+ if(thimputstring == "__div__")
|
|
|
+ {
|
|
|
+ answer_location = "tp_as_number->nb_divide";
|
|
|
+ return true;
|
|
|
+ }
|
|
|
+
|
|
|
+ if(thimputstring == "__mod__")
|
|
|
+ {
|
|
|
+ answer_location = "tp_as_number->nb_remainder";
|
|
|
+ return true;
|
|
|
+ }
|
|
|
+
|
|
|
+ if(thimputstring == "__lshift__")
|
|
|
+ {
|
|
|
+ answer_location = "tp_as_number->nb_lshift";
|
|
|
+ return true;
|
|
|
+ }
|
|
|
+
|
|
|
+ if(thimputstring == "__rshift__")
|
|
|
+ {
|
|
|
+ answer_location = "tp_as_number->nb_rshift";
|
|
|
+ return true;
|
|
|
+ }
|
|
|
+
|
|
|
+
|
|
|
+ if(thimputstring == "__xor__")
|
|
|
+ {
|
|
|
+ answer_location = "tp_as_number->nb_xor";
|
|
|
+ return true;
|
|
|
+ }
|
|
|
+
|
|
|
+
|
|
|
+ if(thimputstring == "__and__")
|
|
|
+ {
|
|
|
+ answer_location = "tp_as_number->nb_and";
|
|
|
+ return true;
|
|
|
+ }
|
|
|
+
|
|
|
+ if(thimputstring == "__or__")
|
|
|
+ {
|
|
|
+ answer_location = "tp_as_number->nb_or";
|
|
|
+ return true;
|
|
|
+ }
|
|
|
+
|
|
|
+
|
|
|
+ if(thimputstring == "__iadd__")
|
|
|
+ {
|
|
|
+ answer_location = "tp_as_number->nb_inplace_add";
|
|
|
+ return true;
|
|
|
+ }
|
|
|
+
|
|
|
+ if(thimputstring == "__isub__")
|
|
|
+ {
|
|
|
+ answer_location = "tp_as_number->nb_inplace_subtract";
|
|
|
+ return true;
|
|
|
+ }
|
|
|
+
|
|
|
+ if(thimputstring == "__imul__")
|
|
|
+ {
|
|
|
+ answer_location = "tp_as_number->nb_inplace_multiply";
|
|
|
+ return true;
|
|
|
+ }
|
|
|
+
|
|
|
+ if(thimputstring == "__idiv__")
|
|
|
+ {
|
|
|
+ answer_location = "tp_as_number->nb_inplace_divide";
|
|
|
+ return true;
|
|
|
+ }
|
|
|
+
|
|
|
+ if(thimputstring == "__imod__")
|
|
|
+ {
|
|
|
+ answer_location = ".tp_as_number->nb_inplace_remainder";
|
|
|
+ return true;
|
|
|
+ }
|
|
|
+
|
|
|
+
|
|
|
+ if(thimputstring == "__ilshift__")
|
|
|
+ {
|
|
|
+ answer_location = "tp_as_number->nb_inplace_lshift";
|
|
|
+ return true;
|
|
|
+ }
|
|
|
+
|
|
|
+ if(thimputstring == "__irshift__")
|
|
|
+ {
|
|
|
+ answer_location = "tp_as_number->nb_inplace_rshift";
|
|
|
+ return true;
|
|
|
+ }
|
|
|
+
|
|
|
+ if(thimputstring == "__iand__")
|
|
|
+ {
|
|
|
+ answer_location = "tp_as_number->nb_inplace_and";
|
|
|
+ return true;
|
|
|
+ }
|
|
|
+
|
|
|
+ if(thimputstring == "__ixor__")
|
|
|
+ {
|
|
|
+ answer_location = "tp_as_number->nb_inplace_xor";
|
|
|
+ return true;
|
|
|
+ }
|
|
|
+
|
|
|
+ if(thimputstring == "__int__")
|
|
|
+ {
|
|
|
+ answer_location = "tp_as_number->nb_int";
|
|
|
+ wraper_type = 2;
|
|
|
+ return true;
|
|
|
+ }
|
|
|
+
|
|
|
+// if(thimputstring == "__coerce__")
|
|
|
+// {
|
|
|
+// answer_location = "tp_as_number->nb_coerce";
|
|
|
+// return true;
|
|
|
+// }
|
|
|
+
|
|
|
+ // mapping methods
|
|
|
+ if(thimputstring == "__getitem__")
|
|
|
+ {
|
|
|
+ answer_location = "tp_as_mapping->mp_subscript";
|
|
|
+ return true;
|
|
|
+ }
|
|
|
+
|
|
|
+ //Direct methods
|
|
|
+ if(thimputstring == "__call__")
|
|
|
+ {
|
|
|
+ answer_location = "tp_call";
|
|
|
+ wraper_type = 1;
|
|
|
+ return true;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ return false;
|
|
|
+};
|
|
|
+/////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
+// Function :write_module_class
|
|
|
+/////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
+void InterfaceMakerPythonNative::write_module_class(ostream &out, Object *obj)
|
|
|
+{
|
|
|
+
|
|
|
+ bool has_local_hash = false;
|
|
|
+ bool has_local_repr = false;
|
|
|
+ bool has_local_str = false;
|
|
|
+
|
|
|
+ {
|
|
|
+ int num_nested = obj->_itype.number_of_nested_types();
|
|
|
+ for (int ni = 0; ni < num_nested; ni++)
|
|
|
+ {
|
|
|
+ TypeIndex nested_index = obj->_itype.get_nested_type(ni);
|
|
|
+ Object * nested_obj = _objects[nested_index];
|
|
|
+ if(nested_obj->_itype.is_class() ||nested_obj->_itype.is_struct())
|
|
|
+ {
|
|
|
+ write_module_class(out,nested_obj);
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ bool is_runtime_typed = IsPandaTypedObject(obj->_itype._cpptype->as_struct_type());
|
|
|
+
|
|
|
+
|
|
|
+ InterrogateDatabase *idb = InterrogateDatabase::get_ptr();
|
|
|
+
|
|
|
+ std::string ClassName = make_safe_name(obj->_itype.get_scoped_name());
|
|
|
+ std::string cClassName = obj->_itype.get_true_name();
|
|
|
+ std::string export_calss_name = classNameFromCppName(obj->_itype.get_name());
|
|
|
+
|
|
|
+ Functions::iterator fi;
|
|
|
+ out << "//********************************************************************\n";
|
|
|
+ out << "//*** Py Init Code For .. "<< ClassName <<" | " << export_calss_name <<"\n" ;
|
|
|
+ out << "//********************************************************************\n";
|
|
|
+ out << "static PyMethodDef Dtool_Methods_"<< ClassName << "[]= {\n";
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+ std::map<int , Function * > static_functions;
|
|
|
+ std::map<Function *, std::string > normal_Operator_functions;
|
|
|
+ std::map<Function *, std::pair< std::string , int> > wraped_Operator_functions;
|
|
|
+ // function Table
|
|
|
+ int x;
|
|
|
+ for (x = 0, fi = obj->_methods.begin(); fi != obj->_methods.end(); ++fi,x++)
|
|
|
+ {
|
|
|
+ Function *func = (*fi);
|
|
|
+ std::string temp0;
|
|
|
+ int temp1;
|
|
|
+ if(!GetSlotedFunctinDef( methodNameFromCppName( func->_ifunc.get_name(),export_calss_name),temp0,temp1))
|
|
|
+ {
|
|
|
+
|
|
|
+ out << " { \"" << methodNameFromCppName( func->_ifunc.get_name(),export_calss_name) << "\", &"
|
|
|
+ << func->_name << ", METH_VARARGS ," << func->_name << "_comment},\n";
|
|
|
+ if(!isFunctionWithThis(func))
|
|
|
+ static_functions[x] = func;
|
|
|
+ }
|
|
|
+ else
|
|
|
+ {
|
|
|
+ if(temp1 > 0)
|
|
|
+ {
|
|
|
+ wraped_Operator_functions[func] = std::pair< std::string, int>(temp0,temp1);
|
|
|
+ out << " { \"" << methodNameFromCppName( func->_ifunc.get_name(),export_calss_name) << "\", &"
|
|
|
+ << func->_name << ", METH_VARARGS ," << func->_name << "_comment},\n";
|
|
|
+ if(!isFunctionWithThis(func))
|
|
|
+ static_functions[x] = func;
|
|
|
+
|
|
|
+ }
|
|
|
+ else
|
|
|
+ {
|
|
|
+ normal_Operator_functions[func] = temp0;
|
|
|
+
|
|
|
+ out << " { \"" << methodNameFromCppName( func->_ifunc.get_name(),export_calss_name) << "\", &"
|
|
|
+ << func->_name << ", METH_VARARGS ," << func->_name << "_comment},\n";
|
|
|
+ if(!isFunctionWithThis(func))
|
|
|
+ static_functions[x] = func;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+ out << " { NULL, NULL }\n"
|
|
|
+ << "};\n\n";
|
|
|
+
|
|
|
+ int num_derivations = obj->_itype.number_of_derivations();
|
|
|
+ for (int di = 0; di < num_derivations; di++)
|
|
|
+ {
|
|
|
+ TypeIndex d_type_Index = obj->_itype.get_derivation(di);
|
|
|
+ if(!interrogate_type_is_unpublished(d_type_Index))
|
|
|
+ {
|
|
|
+ const InterrogateType &d_itype = idb->get_type(d_type_Index);
|
|
|
+ if(isCppTypeLegal(d_itype._cpptype))
|
|
|
+ {
|
|
|
+ if(!isExportThisRun(d_itype._cpptype))
|
|
|
+ {
|
|
|
+ _external_imports.insert(make_safe_name(d_itype.get_scoped_name().c_str()));
|
|
|
+
|
|
|
+ //out << "IMPORT_THIS struct Dtool_PyTypedObject Dtool_" << make_safe_name(d_itype.get_scoped_name().c_str()) <<";\n";
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ std::vector< std::string > bases;
|
|
|
+ for (int di = 0; di < num_derivations; di++)
|
|
|
+ {
|
|
|
+ TypeIndex d_type_Index = obj->_itype.get_derivation(di);
|
|
|
+ if(!interrogate_type_is_unpublished(d_type_Index))
|
|
|
+ {
|
|
|
+
|
|
|
+ const InterrogateType &d_itype = idb->get_type(d_type_Index);
|
|
|
+ if(isCppTypeLegal(d_itype._cpptype))
|
|
|
+ {
|
|
|
+ bases.push_back(make_safe_name(d_itype.get_scoped_name().c_str()));
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+ {
|
|
|
+ std::map<Function *, std::pair< std::string , int> >::iterator rfi; // wraped_Operator_functions;
|
|
|
+ for(rfi = wraped_Operator_functions.begin(); rfi != wraped_Operator_functions.end(); rfi++)
|
|
|
+ {
|
|
|
+ if(rfi->second.second == 1)
|
|
|
+ {
|
|
|
+ Function *func = rfi->first;
|
|
|
+ out << "//////////////////\n";
|
|
|
+ out << "// Required TO Convert the calling Conventions.. \n";
|
|
|
+ out << "// " <<ClassName<< " ..." << rfi->second.first <<" = "<< methodNameFromCppName( func->_ifunc.get_name(),export_calss_name) <<"\n";
|
|
|
+ out << "//////////////////\n";
|
|
|
+ out << "PyObject * " << func->_name << methodNameFromCppName( func->_ifunc.get_name(),export_calss_name) << "( PyObject * self, PyObject * args, PyObject *dict)\n";
|
|
|
+ out << "{\n";
|
|
|
+ out << " return "<< func->_name <<"(self,args);\n";
|
|
|
+ out << "}\n\n";
|
|
|
+ }
|
|
|
+ else if(rfi->second.second == 2)
|
|
|
+ {
|
|
|
+ Function *func = rfi->first;
|
|
|
+ out << "//////////////////\n";
|
|
|
+ out << "// Required TO Convert the calling Conventions.. \n";
|
|
|
+ out << "// " <<ClassName<< " ..." << rfi->second.first <<" = "<< methodNameFromCppName( func->_ifunc.get_name(),export_calss_name) <<"\n";
|
|
|
+ out << "//////////////////\n";
|
|
|
+ out << "PyObject * " << func->_name << methodNameFromCppName( func->_ifunc.get_name(),export_calss_name) << "( PyObject * self)\n";
|
|
|
+ out << "{\n";
|
|
|
+ out << " return "<< func->_name <<"(self,Py_None);\n";
|
|
|
+ out << "}\n\n";
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ if(HasAGetKeyFunction(obj->_itype))
|
|
|
+ {
|
|
|
+ out << "//////////////////\n";
|
|
|
+ out << "// A LocalHash(GetKey) Function for this type";
|
|
|
+ out << "// " <<ClassName << "\n";
|
|
|
+ out << "//////////////////\n";
|
|
|
+ out << "extern \"C\" static long DTool_HashKey_"<<ClassName << "(PyObject * self)\n";
|
|
|
+ out << "{\n";
|
|
|
+ out << " "<<cClassName << " * local_this = NULL;\n";
|
|
|
+ out << " DTOOL_Call_ExtractThisPointerForType(self,&Dtool_"<< ClassName<<",(void **)&local_this);\n";
|
|
|
+ out << " if(local_this == NULL)\n";
|
|
|
+ out << " {\n";
|
|
|
+ out << " return -1;\n";
|
|
|
+ out << " };\n";
|
|
|
+ out << " return local_this->GetKey();\n";
|
|
|
+ out << "}\n\n";
|
|
|
+ has_local_hash = true;
|
|
|
+ }
|
|
|
+ else
|
|
|
+ {
|
|
|
+ if(bases.size() == 0)
|
|
|
+ {
|
|
|
+ out << "//////////////////\n";
|
|
|
+ out << "// A LocalHash(This Pointer) Function for this type";
|
|
|
+ out << "// " <<ClassName << "\n";
|
|
|
+ out << "//////////////////\n";
|
|
|
+ out << "extern \"C\" static long DTool_HashKey_"<<ClassName << "(PyObject * self)\n";
|
|
|
+ out << "{\n";
|
|
|
+ out << " "<<cClassName << " * local_this = NULL;\n";
|
|
|
+ out << " DTOOL_Call_ExtractThisPointerForType(self,&Dtool_"<< ClassName<<",(void **)&local_this);\n";
|
|
|
+ out << " if(local_this == NULL)\n";
|
|
|
+ out << " {\n";
|
|
|
+ out << " return -1;\n";
|
|
|
+ out << " };\n";
|
|
|
+ out << " return (long)local_this;\n";
|
|
|
+ out << "}\n\n";
|
|
|
+ has_local_hash = true;
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ if(NeedsAReprFunction(obj->_itype))
|
|
|
+ {
|
|
|
+ out << "//////////////////\n";
|
|
|
+ out << "// A __repr__ Function\n";
|
|
|
+ out << "// " <<ClassName << "\n";
|
|
|
+ out << "//////////////////\n";
|
|
|
+ out << "extern \"C\" static PyObject * Dtool_Repr_"<<ClassName << "(PyObject * self)\n";
|
|
|
+ out << "{\n";
|
|
|
+ out << " "<<cClassName << " * local_this = NULL;\n";
|
|
|
+ out << " DTOOL_Call_ExtractThisPointerForType(self,&Dtool_"<< ClassName<<",(void **)&local_this);\n";
|
|
|
+ out << " if(local_this != NULL)\n";
|
|
|
+ out << " {\n";
|
|
|
+ out << " ostringstream os;\n";
|
|
|
+ out << " local_this->output(os);\n";
|
|
|
+ out << " return PyString_FromString(os.str().c_str());\n";
|
|
|
+ out << " };\n";
|
|
|
+ out << " return Py_BuildValue(\"\");\n";
|
|
|
+ out << "}\n";
|
|
|
+ has_local_repr = true;
|
|
|
+ }
|
|
|
+
|
|
|
+ if(NeedsAStrFunction(obj->_itype))
|
|
|
+ {
|
|
|
+ out << "//////////////////\n";
|
|
|
+ out << "// A __str__ Function\n";
|
|
|
+ out << "// " <<ClassName << "\n";
|
|
|
+ out << "//////////////////\n";
|
|
|
+ out << "extern \"C\" static PyObject * Dtool_Str_"<<ClassName << "(PyObject * self)\n";
|
|
|
+ out << "{\n";
|
|
|
+ out << " "<<cClassName << " * local_this = NULL;\n";
|
|
|
+ out << " DTOOL_Call_ExtractThisPointerForType(self,&Dtool_"<< ClassName<<",(void **)&local_this);\n";
|
|
|
+ out << " if(local_this != NULL)\n";
|
|
|
+ out << " {\n";
|
|
|
+ out << " ostringstream os;\n";
|
|
|
+ out << " local_this->write(os);\n";
|
|
|
+ out << " return PyString_FromString(os.str().c_str());\n";
|
|
|
+ out << " };\n";
|
|
|
+ out << " return Py_BuildValue(\"\");\n";
|
|
|
+ out << "}\n";
|
|
|
+ has_local_str = true;
|
|
|
+ }
|
|
|
+
|
|
|
+
|
|
|
+ }
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+ out << "void Dtool_PyModuleClassInit_" << ClassName << "(PyObject *module)\n";
|
|
|
+ out << "{\n";
|
|
|
+ out << " static bool initdone = false;\n";
|
|
|
+ out << " if(!initdone)\n";
|
|
|
+ out << " {\n";
|
|
|
+ out << " initdone = true;\n";
|
|
|
+// out << " memset(Dtool_"<< ClassName << ".As_PyTypeObject().tp_as_number,0,sizeof(PyNumberMethods));\n";
|
|
|
+// out << " memset(Dtool_"<< ClassName << ".As_PyTypeObject().tp_as_mapping,0,sizeof(PyMappingMethods));\n";
|
|
|
+// out << " static Dtool_PyTypedObject *InheritsFrom[] = {";
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+ if(bases.size() > 0)
|
|
|
+ {
|
|
|
+ out << " // Dependent Objects \n";
|
|
|
+ std::string format1= "";
|
|
|
+ std::string format2= "";
|
|
|
+ for(std::vector< std::string >::iterator bi = bases.begin(); bi != bases.end(); bi++)
|
|
|
+ {
|
|
|
+ format1 += "O";
|
|
|
+ format2 += ",&Dtool_" + *bi + ".As_PyTypeObject()";
|
|
|
+ out << " Dtool_"<< make_safe_name(*bi) << "._Dtool_ClassInit(NULL);\n";
|
|
|
+ }
|
|
|
+
|
|
|
+ out << " Dtool_"<<ClassName<<".As_PyTypeObject().tp_bases = Py_BuildValue(\"(" << format1 << ")\""<< format2 << ");\n";
|
|
|
+ }
|
|
|
+
|
|
|
+
|
|
|
+ out << " Dtool_" << ClassName << ".As_PyTypeObject().tp_dict = PyDict_New();\n";
|
|
|
+ out << " PyDict_SetItemString(Dtool_"<<ClassName <<".As_PyTypeObject().tp_dict,\"DtoolClassDict\",Dtool_"<<ClassName <<".As_PyTypeObject().tp_dict);\n";
|
|
|
+
|
|
|
+
|
|
|
+ // static function into dictionary with bogus self..
|
|
|
+ //
|
|
|
+ std::map<int , Function * >::iterator sfi;
|
|
|
+ for(sfi= static_functions.begin(); sfi != static_functions.end(); sfi++)
|
|
|
+ {
|
|
|
+ out << " // Static Method " << methodNameFromCppName( sfi->second->_ifunc.get_name(),export_calss_name) << "\n";
|
|
|
+ out << " PyDict_SetItemString(Dtool_" << ClassName << ".As_PyTypeObject().tp_dict,\"" ;
|
|
|
+ out << methodNameFromCppName( sfi->second->_ifunc.get_name(),export_calss_name) ;
|
|
|
+ out << "\",PyCFunction_New(&Dtool_Methods_"<< ClassName <<"[" << sfi->first << "],&Dtool_"<< ClassName<< ".As_PyObject()));\n";
|
|
|
+ }
|
|
|
+
|
|
|
+
|
|
|
+ // the standard call functions
|
|
|
+ std::map<Function *, std::string >::iterator ofi;
|
|
|
+ for(ofi = normal_Operator_functions.begin(); ofi != normal_Operator_functions.end(); ofi++)
|
|
|
+ {
|
|
|
+ Function *func = ofi->first;
|
|
|
+ out << " // " << ofi->second <<" = "<< methodNameFromCppName( func->_ifunc.get_name(),export_calss_name) <<"\n";
|
|
|
+ out << " Dtool_" << ClassName <<".As_PyTypeObject()." << ofi->second <<" = &" << func->_name <<";\n";
|
|
|
+ }
|
|
|
+
|
|
|
+
|
|
|
+ // wraped functions...
|
|
|
+ {
|
|
|
+ std::map<Function *, std::pair< std::string , int> >::iterator rfi; // wraped_Operator_functions;
|
|
|
+ for(rfi = wraped_Operator_functions.begin(); rfi != wraped_Operator_functions.end(); rfi++)
|
|
|
+ {
|
|
|
+ Function *func = rfi->first;
|
|
|
+ out << " // " << rfi->second.first <<" = "<< methodNameFromCppName( func->_ifunc.get_name(),export_calss_name) <<"\n";
|
|
|
+ out << " Dtool_" << ClassName <<".As_PyTypeObject()." << rfi->second.first <<" = &" << func->_name << methodNameFromCppName( func->_ifunc.get_name(),export_calss_name)<<";\n";
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ // __hash__
|
|
|
+ if(has_local_hash == true)
|
|
|
+ {
|
|
|
+ out << " // __hash__\n";
|
|
|
+ out << " Dtool_" << ClassName <<".As_PyTypeObject().tp_hash = &DTool_HashKey_"<<ClassName <<";\n";
|
|
|
+
|
|
|
+ }
|
|
|
+
|
|
|
+ if(has_local_repr == true)
|
|
|
+ {
|
|
|
+ out << " // __repr__\n";
|
|
|
+ out << " Dtool_" << ClassName <<".As_PyTypeObject().tp_repr = & Dtool_Repr_"<<ClassName <<";\n";
|
|
|
+ }
|
|
|
+
|
|
|
+ if(has_local_str == true)
|
|
|
+ {
|
|
|
+ out << " // __str__\n";
|
|
|
+ out << " Dtool_" << ClassName <<".As_PyTypeObject().tp_str = & Dtool_Str_"<<ClassName <<";\n";
|
|
|
+
|
|
|
+ }
|
|
|
+ else if(has_local_repr == true)
|
|
|
+ {
|
|
|
+ out << " // __str__ Repr Proxy\n";
|
|
|
+ out << " Dtool_" << ClassName <<".As_PyTypeObject().tp_repr = & Dtool_Repr_"<<ClassName <<";\n";
|
|
|
+ }
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+ int num_nested = obj->_itype.number_of_nested_types();
|
|
|
+ for (int ni = 0; ni < num_nested; ni++)
|
|
|
+ {
|
|
|
+ TypeIndex nested_index = obj->_itype.get_nested_type(ni);
|
|
|
+ Object * nested_obj = _objects[nested_index];
|
|
|
+ if(nested_obj->_itype.is_class() ||nested_obj->_itype.is_struct())
|
|
|
+ {
|
|
|
+ std::string ClassName1 = make_safe_name(nested_obj->_itype.get_scoped_name());
|
|
|
+ std::string ClassName2 = make_safe_name(nested_obj->_itype.get_name());
|
|
|
+ out << " // Nested Object "<< ClassName1 << ";\n";
|
|
|
+ out << " Dtool_" << ClassName1 << "._Dtool_ClassInit(NULL);\n";
|
|
|
+ out << " PyDict_SetItemString(Dtool_" << ClassName << ".As_PyTypeObject().tp_dict,\"" << classNameFromCppName(ClassName2) <<"\",(PyObject *)&Dtool_" << ClassName1 << ".As_PyTypeObject());\n";
|
|
|
+ }
|
|
|
+ else
|
|
|
+ {
|
|
|
+ if(nested_obj->_itype.is_enum())
|
|
|
+ {
|
|
|
+ out << " // Enum "<< nested_obj->_itype.get_scoped_name() << ";\n";
|
|
|
+ int enum_count = nested_obj->_itype.number_of_enum_values();
|
|
|
+ for(int xx = 0; xx< enum_count; xx++)
|
|
|
+ out << " PyDict_SetItemString(Dtool_" << ClassName << ".As_PyTypeObject().tp_dict,\"" << classNameFromCppName(nested_obj->_itype.get_enum_value_name(xx)) <<"\",PyInt_FromLong("<< nested_obj->_itype.get_enum_value(xx) << "));\n";
|
|
|
+
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ out << " PyType_Ready(&Dtool_"<< ClassName << ".As_PyTypeObject());\n";
|
|
|
+ out << " PyDict_SetItemString(Dtool_"<<ClassName <<".As_PyTypeObject().tp_dict,\""<<export_calss_name<< "\",&Dtool_"<<ClassName <<".As_PyObject());\n";
|
|
|
+
|
|
|
+ if(is_runtime_typed)
|
|
|
+ out << " RegisterRuntimeClass(&Dtool_"<<ClassName<<","<< cClassName <<"::get_class_type().get_index());\n";
|
|
|
+ else
|
|
|
+ out << " RegisterRuntimeClass(&Dtool_"<<ClassName<<",-1);\n";
|
|
|
+
|
|
|
+
|
|
|
+ out << " }\n";
|
|
|
+
|
|
|
+ out << " if(module != NULL)\n";
|
|
|
+ out << " {\n";
|
|
|
+ out << " Py_INCREF(&Dtool_"<< ClassName << ".As_PyTypeObject());\n";
|
|
|
+ out << " PyModule_AddObject(module, \""<<export_calss_name<<"\",(PyObject *)&Dtool_"<< ClassName << ".As_PyTypeObject());\n";
|
|
|
+ out << " }\n";
|
|
|
+ out << "}\n";
|
|
|
+
|
|
|
+}
|
|
|
+////////////////////////////////////////////////////////////////////
|
|
|
+// Function: InterfaceMakerPythonNative::synthesize_this_parameter
|
|
|
+// Access: Public, Virtual
|
|
|
+// Description: This method should be overridden and redefined to
|
|
|
+// return true for interfaces that require the implicit
|
|
|
+// "this" parameter, if present, to be passed as the
|
|
|
+// first parameter to any wrapper functions.
|
|
|
+////////////////////////////////////////////////////////////////////
|
|
|
+bool InterfaceMakerPythonNative::
|
|
|
+synthesize_this_parameter() {
|
|
|
+ return true;
|
|
|
+}
|
|
|
+
|
|
|
+////////////////////////////////////////////////////////////////////
|
|
|
+// Function: InterfaceMakerPythonNative::get_wrapper_prefix
|
|
|
+// Access: Protected, Virtual
|
|
|
+// Description: Returns the prefix string used to generate wrapper
|
|
|
+// function names.
|
|
|
+////////////////////////////////////////////////////////////////////
|
|
|
+string InterfaceMakerPythonNative::
|
|
|
+get_wrapper_prefix() {
|
|
|
+ return "Dtool_";
|
|
|
+}
|
|
|
+
|
|
|
+////////////////////////////////////////////////////////////////////
|
|
|
+// Function: InterfaceMakerPythonNative::get_unique_prefix
|
|
|
+// Access: Protected, Virtual
|
|
|
+// Description: Returns the prefix string used to generate unique
|
|
|
+// symbolic names, which are not necessarily C-callable
|
|
|
+// function names.
|
|
|
+////////////////////////////////////////////////////////////////////
|
|
|
+string InterfaceMakerPythonNative::get_unique_prefix()
|
|
|
+{
|
|
|
+ return "Dtool_";
|
|
|
+}
|
|
|
+
|
|
|
+////////////////////////////////////////////////////////////////////
|
|
|
+// Function: InterfaceMakerPythonNative::record_function_wrapper
|
|
|
+// Access: Protected, Virtual
|
|
|
+// Description: Associates the function wrapper with its function in
|
|
|
+// the appropriate structures in the database.
|
|
|
+////////////////////////////////////////////////////////////////////
|
|
|
+void InterfaceMakerPythonNative::record_function_wrapper(InterrogateFunction &ifunc, FunctionWrapperIndex wrapper_index)
|
|
|
+{
|
|
|
+ ifunc._python_wrappers.push_back(wrapper_index);
|
|
|
+}
|
|
|
+
|
|
|
+////////////////////////////////////////////////////////////////////
|
|
|
+// Function: InterfaceMakerPythonNative::write_prototype_for
|
|
|
+// Access: Private
|
|
|
+// Description: Writes the prototype for the indicated function.
|
|
|
+////////////////////////////////////////////////////////////////////
|
|
|
+void InterfaceMakerPythonNative::write_prototype_for(ostream &out, InterfaceMaker::Function *func)
|
|
|
+{
|
|
|
+ std::string fname = "PyObject *"+func->_name+"(PyObject *self, PyObject *args)";
|
|
|
+
|
|
|
+
|
|
|
+ write_prototype_for_name(out,func,fname);
|
|
|
+}
|
|
|
+////////////////////////////////////////////////////////////////////
|
|
|
+////////////////////////////////////////////////////////////////////
|
|
|
+////////////////////////////////////////////////////////////////////
|
|
|
+void InterfaceMakerPythonNative::write_prototype_for_name(ostream &out, InterfaceMaker::Function *func, const std::string &function_namename)
|
|
|
+{
|
|
|
+ Function::Remaps::const_iterator ri;
|
|
|
+
|
|
|
+// for (ri = func->_remaps.begin(); ri != func->_remaps.end(); ++ri) {
|
|
|
+// FunctionRemap *remap = (*ri);
|
|
|
+ if (!output_function_names) {
|
|
|
+ // If we're not saving the function names, don't export it from
|
|
|
+ // the library.
|
|
|
+ out << "static ";
|
|
|
+ } else {
|
|
|
+ out << "extern \"C\" ";
|
|
|
+ }
|
|
|
+ out << function_namename <<";\n";
|
|
|
+// }
|
|
|
+}
|
|
|
+
|
|
|
+////////////////////////////////////////////////////////////////////
|
|
|
+// Function: InterfaceMakerPythonNative::write_function_for
|
|
|
+// Access: Private
|
|
|
+// Description: Writes the definition for a function that will call
|
|
|
+// the indicated C++ function or method.
|
|
|
+////////////////////////////////////////////////////////////////////
|
|
|
+void InterfaceMakerPythonNative::write_function_for_top(ostream &out, InterfaceMaker::Function *func, const std::string &PreProcess)
|
|
|
+{
|
|
|
+ std::string fname = "PyObject *"+func->_name+"(PyObject *self, PyObject *args)";
|
|
|
+
|
|
|
+
|
|
|
+ write_function_for_name(out,func,fname,PreProcess,"");
|
|
|
+}
|
|
|
+////////////////////////////////////////////////////////////////////
|
|
|
+/// Function : write_function_for_name
|
|
|
+//
|
|
|
+// Wrap a complete name override function for Py.....
|
|
|
+////////////////////////////////////////////////////////////////////
|
|
|
+void InterfaceMakerPythonNative::write_function_for_name(
|
|
|
+ ostream &out1,
|
|
|
+ InterfaceMaker::Function *func,
|
|
|
+ const std::string &function_name,
|
|
|
+ const std::string &PreProcess,
|
|
|
+ const std::string &ClassName)
|
|
|
+{
|
|
|
+ ostringstream forward_decl;
|
|
|
+ ostringstream out;
|
|
|
+
|
|
|
+ std::map<int , std::set<FunctionRemap *> > MapSets;
|
|
|
+ std::map<int , std::set<FunctionRemap *> >::iterator mii;
|
|
|
+ std::set<FunctionRemap *>::iterator sii;
|
|
|
+
|
|
|
+
|
|
|
+ Function::Remaps::const_iterator ri;
|
|
|
+ out1 << "/************************************\n" << " * Python type method wrapper for\n";
|
|
|
+ for (ri = func->_remaps.begin(); ri != func->_remaps.end(); ++ri)
|
|
|
+ {
|
|
|
+ FunctionRemap *remap = (*ri);
|
|
|
+ if(isRemapLegal(*remap))
|
|
|
+ {
|
|
|
+ int parameter_size = remap->_parameters.size();
|
|
|
+ if(remap->_has_this && remap->_type != FunctionRemap::T_constructor)
|
|
|
+ parameter_size --;
|
|
|
+
|
|
|
+ MapSets[parameter_size].insert(remap);
|
|
|
+ out1 << " * ";
|
|
|
+ remap->write_orig_prototype(out1, 0);
|
|
|
+ out1 << "\n";
|
|
|
+ }
|
|
|
+ else
|
|
|
+ {
|
|
|
+ out1 << " * Rejected Remap [";
|
|
|
+ remap->write_orig_prototype(out1, 0);
|
|
|
+ out1 << "]\n";
|
|
|
+ }
|
|
|
+
|
|
|
+ }
|
|
|
+ out1 << " *************************************/\n";
|
|
|
+ out << function_name << " {\n";
|
|
|
+ if(isFunctionWithThis(func))
|
|
|
+ out << PreProcess;
|
|
|
+
|
|
|
+
|
|
|
+ if(MapSets.empty())
|
|
|
+ return;
|
|
|
+
|
|
|
+
|
|
|
+ std::string FunctionComment = func->_ifunc._comment;
|
|
|
+ if(FunctionComment.size() > 2)
|
|
|
+ FunctionComment += "\n";
|
|
|
+
|
|
|
+
|
|
|
+ if(MapSets.size() > 1)
|
|
|
+ {
|
|
|
+ string expected_params;
|
|
|
+ std::string argString;
|
|
|
+
|
|
|
+ for(mii = MapSets.begin(); mii != MapSets.end(); mii ++)
|
|
|
+ {
|
|
|
+
|
|
|
+ if(MapSets.begin() != mii)
|
|
|
+ argString += ",";
|
|
|
+ char buffer[30];
|
|
|
+ sprintf(buffer,"%d",mii->first);
|
|
|
+ argString += buffer;
|
|
|
+ }
|
|
|
+
|
|
|
+ indent(out,4) << "int parameter_count = 1;\n";
|
|
|
+ indent(out,4) << "if(PyTuple_Check(args))\n";
|
|
|
+ indent(out,4) << " parameter_count = PyTuple_Size(args);\n" ;
|
|
|
+ indent(out,4) << "switch(parameter_count)\n";
|
|
|
+ indent(out,4) << "{\n";
|
|
|
+ bool constructor = false;
|
|
|
+ for(mii = MapSets.begin(); mii != MapSets.end(); mii ++)
|
|
|
+ {
|
|
|
+ indent(out,4) << "case(" << mii->first << "):\n";
|
|
|
+ indent(out,8) << "{\n";
|
|
|
+
|
|
|
+ write_function_forset(out,func,mii->second,expected_params,8,forward_decl,ClassName + function_name);
|
|
|
+ if((*mii->second.begin())->_type == FunctionRemap::T_constructor)
|
|
|
+ constructor = true;
|
|
|
+
|
|
|
+
|
|
|
+ indent(out,8)<< "}\n";
|
|
|
+ indent(out,8)<< "break;\n";
|
|
|
+ }
|
|
|
+
|
|
|
+ indent(out,4)<< "default:\n";
|
|
|
+ indent(out,8)<< "{\n";
|
|
|
+ //indent(out,12)<< "PyString_FromFormat(\"("<<methodNameFromCppName( func->_ifunc.get_name(),"") <<") Wrong Number Of Arguments(%d) must be: " << argString <<"\",parameter_count);\n";
|
|
|
+ indent(out,12)<< "PyErr_Format(PyExc_TypeError, \"("<<methodNameFromCppName( func->_ifunc.get_name(),"") <<") Wrong Number Of Arguments(%d) must be: " << argString <<"\",parameter_count);\n";
|
|
|
+ if (constructor)
|
|
|
+ indent(out,12) << "return -1;\n";
|
|
|
+ else
|
|
|
+ indent(out,12) << "return (PyObject *) NULL; \n";
|
|
|
+
|
|
|
+ indent(out,8)<< "}\n";
|
|
|
+ indent(out,8)<< "break;\n";
|
|
|
+ indent(out,4)<< "}\n";
|
|
|
+
|
|
|
+ out << " if(!PyErr_Occurred()) // let error pass on \n";
|
|
|
+ out << " PyErr_SetString(PyExc_TypeError, \"Arguments must match one of:\\n" << expected_params << " \"); \n";
|
|
|
+ if (constructor)
|
|
|
+ indent(out,4) << "return -1;\n";
|
|
|
+ else
|
|
|
+ indent(out,4) << "return (PyObject *) NULL; \n";
|
|
|
+
|
|
|
+ FunctionComment += expected_params;
|
|
|
+ }
|
|
|
+ else
|
|
|
+ {
|
|
|
+ string expected_params = "";
|
|
|
+ bool constructor = false;
|
|
|
+ for(mii = MapSets.begin(); mii != MapSets.end(); mii ++)
|
|
|
+ {
|
|
|
+ write_function_forset(out,func,mii->second,expected_params,4,forward_decl,ClassName + function_name);
|
|
|
+ if((*mii->second.begin())->_type == FunctionRemap::T_constructor)
|
|
|
+ constructor = true;
|
|
|
+ }
|
|
|
+
|
|
|
+ out << " if(!PyErr_Occurred())\n";
|
|
|
+ out << " PyErr_SetString(PyExc_TypeError, \"Must Match :\\n" << expected_params << " \"); \n";
|
|
|
+ if (constructor)
|
|
|
+ indent(out,4) << "return -1;\n";
|
|
|
+ else
|
|
|
+ indent(out,4) << "return (PyObject *) NULL; \n";
|
|
|
+ FunctionComment += expected_params;
|
|
|
+ }
|
|
|
+
|
|
|
+ out << "}\n\n";
|
|
|
+
|
|
|
+ out << "#ifndef NDEBUG\n";
|
|
|
+ out << "static char * " << func->_name << "_comment = \"" << make_safe_comment(FunctionComment) << " \";\n";
|
|
|
+ out << "#else\n";
|
|
|
+ out << "static char * " << func->_name << "_comment = \"" << "\";\n";
|
|
|
+ out << "#endif\n";
|
|
|
+
|
|
|
+ out << "\n";
|
|
|
+
|
|
|
+
|
|
|
+ out1 << forward_decl.str();
|
|
|
+ out1 << out.str();
|
|
|
+}
|
|
|
+////////////////////////////////////////////////////////
|
|
|
+// Function : GetParnetDepth
|
|
|
+//
|
|
|
+// Support Function used to Sort the name based overrides.. For know must be complex to simple
|
|
|
+////////////////////////////////////////////////////////
|
|
|
+int GetParnetDepth(CPPType *type)
|
|
|
+{
|
|
|
+ InterrogateDatabase *idb = InterrogateDatabase::get_ptr();
|
|
|
+ int answer = 0;
|
|
|
+// printf(" %s\n",type->get_local_name().c_str());
|
|
|
+
|
|
|
+ if (TypeManager::is_basic_string_char(type)) {
|
|
|
+ } else if (TypeManager::is_bool(type)) {
|
|
|
+ } else if (TypeManager::is_unsigned_longlong(type)) {
|
|
|
+ } else if (TypeManager::is_longlong(type)) {
|
|
|
+ } else if (TypeManager::is_integer(type)) {
|
|
|
+ } else if (TypeManager::is_float(type)) {
|
|
|
+ } else if (TypeManager::is_char_pointer(type)) {
|
|
|
+ } else if (TypeManager::is_pointer_to_PyObject(type)) {
|
|
|
+ } else if (TypeManager::is_pointer(type) ||TypeManager::is_reference(type) || TypeManager::is_struct(type) )
|
|
|
+ {
|
|
|
+ answer ++;
|
|
|
+ int deepest = 0;
|
|
|
+ TypeIndex type_index = builder.get_type(TypeManager::unwrap(type),false);
|
|
|
+ InterrogateDatabase *idb = InterrogateDatabase::get_ptr();
|
|
|
+ const InterrogateType &itype = idb->get_type(type_index);
|
|
|
+
|
|
|
+ if(itype.is_class() ||itype.is_struct())
|
|
|
+ {
|
|
|
+
|
|
|
+ int num_derivations = itype.number_of_derivations();
|
|
|
+ for (int di = 0; di < num_derivations; di++)
|
|
|
+ {
|
|
|
+ TypeIndex d_type_Index = itype.get_derivation(di);
|
|
|
+ const InterrogateType &d_itype = idb->get_type(d_type_Index);
|
|
|
+ int this_one = GetParnetDepth(d_itype._cpptype);
|
|
|
+ if(this_one > deepest)
|
|
|
+ deepest = this_one;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ answer += deepest;
|
|
|
+// printf(" Class Name %s %d\n",itype.get_name().c_str(),answer);
|
|
|
+ } else
|
|
|
+ {
|
|
|
+ int yy = 0;
|
|
|
+ }
|
|
|
+
|
|
|
+
|
|
|
+// printf(" Class Name %s %d\n",itype.get_name().c_str(),answer);
|
|
|
+ return answer;
|
|
|
+}
|
|
|
+////////////////////////////////////////////////////////
|
|
|
+// The Core sort function for remap calling orders..
|
|
|
+//////////////////////////////////////////////////////////
|
|
|
+int RemapCompareLesss(FunctionRemap * in1 , FunctionRemap * in2)
|
|
|
+{
|
|
|
+ if(in1->_parameters.size() != in2->_parameters.size())
|
|
|
+ return (in1->_parameters.size() > in2->_parameters.size());
|
|
|
+
|
|
|
+ int pcount = in1->_parameters.size();
|
|
|
+ for(int x = 0; x< pcount; x++)
|
|
|
+ {
|
|
|
+ CPPType *orig_type1 = in1->_parameters[x]._remap->get_orig_type();
|
|
|
+ CPPType *orig_type2 = in2->_parameters[x]._remap->get_orig_type();
|
|
|
+
|
|
|
+ int pd1 = GetParnetDepth(orig_type1);
|
|
|
+ int pd2 = GetParnetDepth(orig_type2);
|
|
|
+ if(pd1 != pd2)
|
|
|
+ return pd1> pd2;
|
|
|
+ }
|
|
|
+
|
|
|
+ // ok maybe something to do with return strength..
|
|
|
+
|
|
|
+ return false;
|
|
|
+}
|
|
|
+//////////////////////////////////////////////////////////
|
|
|
+// Convience for the sort behavior..
|
|
|
+///////////////////////////////////////////////////////////
|
|
|
+std::vector< FunctionRemap * > SortFunctionSet(std::set< FunctionRemap *> &remaps)
|
|
|
+{
|
|
|
+ std::vector< FunctionRemap * > out;
|
|
|
+ for(std::set< FunctionRemap *>::iterator ii = remaps.begin(); ii!= remaps.end(); ii++)
|
|
|
+ out.push_back(*ii);
|
|
|
+
|
|
|
+
|
|
|
+ std::sort(out.begin(), out.end(), RemapCompareLesss);
|
|
|
+
|
|
|
+ return out;
|
|
|
+}
|
|
|
+///////////////////////////////////////////////////////////
|
|
|
+// Function : write_function_forset
|
|
|
+//
|
|
|
+// A set is defined as all rempas that have the same number of paramaters..
|
|
|
+///////////////////////////////////////////////////////////
|
|
|
+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)
|
|
|
+{
|
|
|
+
|
|
|
+ if(remapsin.size() > 1)
|
|
|
+ {
|
|
|
+// printf("---------------------------- Start Sort ----- %s , %s\n",func->_name.c_str(),functionname.c_str());
|
|
|
+ std::vector<FunctionRemap *> remaps = SortFunctionSet(remapsin);
|
|
|
+
|
|
|
+ std::vector<FunctionRemap *>::iterator sii;
|
|
|
+ for(sii = remaps.begin(); sii != remaps.end(); sii ++)
|
|
|
+ {
|
|
|
+ FunctionRemap *remap = (*sii);
|
|
|
+ if(isRemapLegal(*remap))
|
|
|
+ {
|
|
|
+
|
|
|
+ indent(out,indent_level)<< "{ // -2 " ;
|
|
|
+ remap->write_orig_prototype(out, 0); out << "\n" ;
|
|
|
+
|
|
|
+ write_function_instance(out, func, remap,expected_params,indent_level,false,forward_decl,functionname);
|
|
|
+
|
|
|
+ indent(out,indent_level+4)<< "PyErr_Clear(); \n";
|
|
|
+ indent(out,indent_level)<< "}\n\n";
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+ else
|
|
|
+ {
|
|
|
+ std::set<FunctionRemap *>::iterator sii;
|
|
|
+ for(sii = remapsin.begin(); sii != remapsin.end(); sii ++)
|
|
|
+ {
|
|
|
+ FunctionRemap *remap = (*sii);
|
|
|
+ if(isRemapLegal(*remap))
|
|
|
+ {
|
|
|
+
|
|
|
+ indent(out,indent_level)<< "// 1-" ;remap->write_orig_prototype(out, 0); out << "\n" ;
|
|
|
+// indent(out,indent_level)<< "do{\n";
|
|
|
+ write_function_instance(out, func, remap,expected_params,indent_level,true,forward_decl,functionname);
|
|
|
+ // indent(out,indent_level)<< "}while(false);\n";
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+
|
|
|
+////////////////////////////////////////////////////////////////////
|
|
|
+// Function: InterfaceMakerPythonNative::write_function_instance
|
|
|
+// Access: Private
|
|
|
+// Description: Writes out the particular function that handles a
|
|
|
+// single instance of an overloaded function.
|
|
|
+////////////////////////////////////////////////////////////////////
|
|
|
+void InterfaceMakerPythonNative::write_function_instance(ostream &out, InterfaceMaker::Function *func1,
|
|
|
+ FunctionRemap *remap, string &expected_params, int indent_level, bool errors_fatal, ostream &ForwardDeclrs, const std::string &functionnamestr)
|
|
|
+{
|
|
|
+ string format_specifiers;
|
|
|
+ string parameter_list;
|
|
|
+ string container;
|
|
|
+ vector_string pexprs;
|
|
|
+ string extra_convert;
|
|
|
+ string extra_param_check;
|
|
|
+ string extra_cleanup;
|
|
|
+ string pname_for_pyobject;
|
|
|
+
|
|
|
+ bool isconstructor = false;
|
|
|
+ if (remap->_type == FunctionRemap::T_constructor )
|
|
|
+ isconstructor = true;
|
|
|
+
|
|
|
+ // Make one pass through the parameter list. We will output a
|
|
|
+ // one-line temporary variable definition for each parameter, while
|
|
|
+ // simultaneously building the ParseTuple() function call and also
|
|
|
+ // the parameter expression list for call_function().
|
|
|
+
|
|
|
+
|
|
|
+ expected_params += remap->_cppfunc->get_simple_name();
|
|
|
+ expected_params += "(";
|
|
|
+
|
|
|
+ int pn;
|
|
|
+ for (pn = 0; pn < (int)remap->_parameters.size(); pn++)
|
|
|
+ {
|
|
|
+ if(pn > 0)
|
|
|
+ expected_params += ",";
|
|
|
+
|
|
|
+ //indent(out, 2);
|
|
|
+ CPPType *orig_type = remap->_parameters[pn]._remap->get_orig_type();
|
|
|
+ CPPType *type = remap->_parameters[pn]._remap->get_new_type();
|
|
|
+ string param_name = remap->get_parameter_name(pn);
|
|
|
+
|
|
|
+ // This is the string to convert our local variable to the
|
|
|
+ // appropriate C++ type. Normally this is just a cast.
|
|
|
+ string pexpr_string =
|
|
|
+ "(" + type->get_local_name(&parser) + ")" + param_name;
|
|
|
+
|
|
|
+ if (remap->_parameters[pn]._remap->new_type_is_atomic_string())
|
|
|
+ {
|
|
|
+ if (TypeManager::is_char_pointer(orig_type)) {
|
|
|
+ indent(out,indent_level+4)<< "char *" << param_name;
|
|
|
+ format_specifiers += "s";
|
|
|
+ parameter_list += ", &" + param_name;
|
|
|
+ }
|
|
|
+ else
|
|
|
+ {
|
|
|
+ indent(out,indent_level+4) << "char *" << param_name
|
|
|
+ << "_str; int " << param_name << "_len";
|
|
|
+ format_specifiers += "s#";
|
|
|
+ parameter_list += ", &" + param_name
|
|
|
+ + "_str, &" + param_name + "_len";
|
|
|
+ pexpr_string = "basic_string<char>(" +
|
|
|
+ param_name + "_str, " +
|
|
|
+ param_name + "_len)";
|
|
|
+ }
|
|
|
+ expected_params += "string";
|
|
|
+
|
|
|
+ } else if (TypeManager::is_bool(type)) {
|
|
|
+ indent(out,indent_level+4) << "PyObject *" << param_name;
|
|
|
+ format_specifiers += "O";
|
|
|
+ parameter_list += ", &" + param_name;
|
|
|
+ pexpr_string = "(PyObject_IsTrue(" + param_name + ")!=0)";
|
|
|
+ expected_params += "bool";
|
|
|
+ pname_for_pyobject += param_name;
|
|
|
+
|
|
|
+
|
|
|
+ } else if (TypeManager::is_unsigned_longlong(type)) {
|
|
|
+ indent(out,indent_level+4) << "PyObject *" << param_name;
|
|
|
+ format_specifiers += "O";
|
|
|
+ parameter_list += ", &" + param_name;
|
|
|
+ extra_convert += " PyObject *" + param_name + "_long = PyNumber_Long(" + param_name + ");";
|
|
|
+ extra_param_check += "|| (" + param_name + "_long == NULL)";
|
|
|
+ pexpr_string = "PyLong_AsUnsignedLongLong(" + param_name + "_long)";
|
|
|
+ extra_cleanup += " Py_XDECREF(" + param_name + "_long);";
|
|
|
+ expected_params += "unsigned long long";
|
|
|
+ pname_for_pyobject += param_name;
|
|
|
+
|
|
|
+
|
|
|
+ } else if (TypeManager::is_longlong(type)) {
|
|
|
+ indent(out,indent_level+4) << "PyObject *" << param_name;
|
|
|
+ format_specifiers += "O";
|
|
|
+ parameter_list += ", &" + param_name;
|
|
|
+ extra_convert += " PyObject *" + param_name + "_long = PyNumber_Long(" + param_name + ");";
|
|
|
+ extra_param_check += "|| (" + param_name + "_long == NULL)";
|
|
|
+ pexpr_string = "PyLong_AsLongLong(" + param_name + "_long)";
|
|
|
+ extra_cleanup += " Py_XDECREF(" + param_name + "_long);";
|
|
|
+ expected_params += "long long";
|
|
|
+ pname_for_pyobject += param_name;
|
|
|
+
|
|
|
+ } else if (TypeManager::is_integer(type)) {
|
|
|
+ indent(out,indent_level+4) << "int " << param_name;
|
|
|
+ format_specifiers += "i";
|
|
|
+ parameter_list += ", &" + param_name;
|
|
|
+ expected_params += "int";
|
|
|
+
|
|
|
+ } else if (TypeManager::is_float(type)) {
|
|
|
+ indent(out,indent_level+4) << "double " << param_name;
|
|
|
+ format_specifiers += "d";
|
|
|
+ parameter_list += ", &" + param_name;
|
|
|
+ expected_params += "float ";
|
|
|
+
|
|
|
+ } else if (TypeManager::is_char_pointer(type)) {
|
|
|
+ indent(out,indent_level+4) << "char *" << param_name;
|
|
|
+ format_specifiers += "s";
|
|
|
+ parameter_list += ", &" + param_name;
|
|
|
+ expected_params += "string";
|
|
|
+
|
|
|
+ }
|
|
|
+ else if (TypeManager::is_pointer_to_PyObject(type))
|
|
|
+ {
|
|
|
+ indent(out,indent_level+4) << "PyObject *" << param_name;
|
|
|
+ format_specifiers += "O";
|
|
|
+ parameter_list += ", &" + param_name;
|
|
|
+ pexpr_string = param_name;
|
|
|
+ pname_for_pyobject += param_name;
|
|
|
+ expected_params += "PyObject";
|
|
|
+ }
|
|
|
+ else if (TypeManager::is_pointer(type))
|
|
|
+ {
|
|
|
+ expected_params += type->get_preferred_name();
|
|
|
+ if (!remap->_has_this || pn != 0 )
|
|
|
+ {
|
|
|
+ indent(out,indent_level+4) << "PyObject *" << param_name;
|
|
|
+ format_specifiers += "O";
|
|
|
+ parameter_list += ", &" + param_name;
|
|
|
+ pname_for_pyobject += param_name;
|
|
|
+
|
|
|
+ TypeIndex p_type_index = builder.get_type(TypeManager::unwrap(type),false);
|
|
|
+ InterrogateDatabase *idb = InterrogateDatabase::get_ptr();
|
|
|
+ const InterrogateType &p_itype = idb->get_type(p_type_index);
|
|
|
+
|
|
|
+ //make_safe_name(itype.get_scoped_name())
|
|
|
+ extra_convert += p_itype.get_scoped_name()+" *" + param_name + "_this = ("+p_itype.get_scoped_name()+" *)";
|
|
|
+ // need to a forward scope for this class..
|
|
|
+ if(!isExportThisRun(p_itype._cpptype))
|
|
|
+ {
|
|
|
+ _external_imports.insert(make_safe_name(p_itype.get_scoped_name()));
|
|
|
+ //ForwardDeclrs << "IMPORT_THIS struct Dtool_PyTypedObject Dtool_" << make_safe_name(p_itype.get_scoped_name()) << ";\n";
|
|
|
+ }
|
|
|
+
|
|
|
+ extra_convert += "DTOOL_Call_GetPointerThisClass(" + param_name + ",&Dtool_"+make_safe_name(p_itype.get_scoped_name())+");\n";
|
|
|
+ extra_param_check += "|| (" + param_name + "_this == NULL)";
|
|
|
+ pexpr_string = param_name + "_this";
|
|
|
+ }
|
|
|
+
|
|
|
+ }
|
|
|
+ else
|
|
|
+ {
|
|
|
+ // Ignore a parameter.
|
|
|
+ indent(out,indent_level+4) << "PyObject *" << param_name;
|
|
|
+ format_specifiers += "O";
|
|
|
+ parameter_list += ", &" + param_name;
|
|
|
+ expected_params += "any";
|
|
|
+ pname_for_pyobject += param_name;
|
|
|
+
|
|
|
+ }
|
|
|
+
|
|
|
+ if (remap->_parameters[pn]._has_name) {
|
|
|
+ expected_params += " " + remap->_parameters[pn]._name;
|
|
|
+ }
|
|
|
+
|
|
|
+ if (remap->_has_this && pn == 0)
|
|
|
+ {
|
|
|
+ container = "local_this";
|
|
|
+ }
|
|
|
+ else
|
|
|
+ {
|
|
|
+ out << ";\n";
|
|
|
+ }
|
|
|
+
|
|
|
+
|
|
|
+ pexprs.push_back(pexpr_string);
|
|
|
+ }
|
|
|
+ expected_params += ")\\n";
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+ if(!format_specifiers.empty())
|
|
|
+ {
|
|
|
+ std::string format_specifiers1 = format_specifiers + ":" + functionnamestr;
|
|
|
+
|
|
|
+ if(remap->_parameters.size() == 1 || (remap->_has_this && remap->_parameters.size() == 2))
|
|
|
+ {
|
|
|
+ indent(out,indent_level+4) << "// Special Case to Make operator work \n";
|
|
|
+ indent(out,indent_level+4) << "if(PyTuple_Check(args))\n";
|
|
|
+ indent(out,indent_level+4) << " (PyArg_ParseTuple(args, \"" << format_specifiers1<< "\"" << parameter_list << "));\n";
|
|
|
+ indent(out,indent_level+4) << "else\n";
|
|
|
+ indent(out,indent_level+4) << " (PyArg_Parse(args, \"" << format_specifiers1<< "\"" << parameter_list << "));\n";
|
|
|
+ indent(out,indent_level+4) << "if(!PyErr_Occurred())\n";
|
|
|
+ }
|
|
|
+ else
|
|
|
+ indent(out,indent_level+4) << "if (PyArg_ParseTuple(args, \"" << format_specifiers1 << "\"" << parameter_list << "))\n";
|
|
|
+ }
|
|
|
+ indent(out,indent_level+4) << "{\n";
|
|
|
+
|
|
|
+ if (!extra_convert.empty())
|
|
|
+ {
|
|
|
+ indent(out,indent_level+8) << extra_convert << "\n";
|
|
|
+ }
|
|
|
+
|
|
|
+ int extra_indent_level =indent_level+8;
|
|
|
+
|
|
|
+ if (!extra_param_check.empty())
|
|
|
+ {
|
|
|
+ indent(out,extra_indent_level) << "if (!(" << extra_param_check.substr(3) << "))\n";
|
|
|
+ indent(out,extra_indent_level) <<"{\n";
|
|
|
+ extra_indent_level+=4;
|
|
|
+ }
|
|
|
+
|
|
|
+
|
|
|
+ if (!remap->_void_return && remap->_return_type->new_type_is_atomic_string())
|
|
|
+ {
|
|
|
+ // Treat strings as a special case. We don't want to format the
|
|
|
+ // return expression.
|
|
|
+ string tt;
|
|
|
+ string return_expr = remap->call_function(out, extra_indent_level, false, container, pexprs);
|
|
|
+ CPPType *type = remap->_return_type->get_orig_type();
|
|
|
+ indent(out,extra_indent_level);
|
|
|
+ type->output_instance(out, "return_value", &parser);
|
|
|
+ // type->output_instance(tt, "return_value", &parser);
|
|
|
+ out << " = " << return_expr << ";\n";
|
|
|
+
|
|
|
+ if (track_interpreter) {
|
|
|
+ indent(out,extra_indent_level) << "in_interpreter = 1;\n";
|
|
|
+ }
|
|
|
+ if (!extra_cleanup.empty()) {
|
|
|
+ indent(out,extra_indent_level) << extra_cleanup << "\n";
|
|
|
+ }
|
|
|
+
|
|
|
+ return_expr = manage_return_value(out, 4, remap, "return_value");
|
|
|
+ do_assert_init(out, extra_indent_level,isconstructor);
|
|
|
+ pack_return_value(out, extra_indent_level, remap, return_expr,ForwardDeclrs);
|
|
|
+
|
|
|
+ }
|
|
|
+ else
|
|
|
+ {
|
|
|
+ string return_expr = remap->call_function(out, extra_indent_level, true, container, pexprs);
|
|
|
+ if (return_expr.empty())
|
|
|
+ {
|
|
|
+ if (track_interpreter) {
|
|
|
+ indent(out,extra_indent_level) << "in_interpreter = 1;\n";
|
|
|
+ }
|
|
|
+ if (!extra_cleanup.empty()) {
|
|
|
+ indent(out,extra_indent_level) << extra_cleanup << "\n";
|
|
|
+ }
|
|
|
+ do_assert_init(out, extra_indent_level,isconstructor);
|
|
|
+ indent(out,extra_indent_level) << "return Py_BuildValue(\"\");\n";
|
|
|
+
|
|
|
+ }
|
|
|
+ else
|
|
|
+ {
|
|
|
+ CPPType *type = remap->_return_type->get_temporary_type();
|
|
|
+ indent(out,extra_indent_level);
|
|
|
+ type->output_instance(out, "return_value", &parser);
|
|
|
+ out << " = " << return_expr << ";\n";
|
|
|
+ if (track_interpreter) {
|
|
|
+ indent(out,extra_indent_level) << "in_interpreter = 1;\n";
|
|
|
+ }
|
|
|
+ if (!extra_cleanup.empty()) {
|
|
|
+ indent(out,extra_indent_level) << extra_cleanup << "\n";
|
|
|
+ }
|
|
|
+
|
|
|
+ return_expr = manage_return_value(out, extra_indent_level, remap, "return_value");
|
|
|
+ do_assert_init(out, extra_indent_level,isconstructor);
|
|
|
+ pack_return_value(out, extra_indent_level, remap, remap->_return_type->temporary_to_return(return_expr),ForwardDeclrs);
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ if (!extra_param_check.empty())
|
|
|
+ {
|
|
|
+ extra_indent_level-=4;
|
|
|
+ indent(out,extra_indent_level)<< "}\n";
|
|
|
+ }
|
|
|
+
|
|
|
+ indent(out,indent_level+4) << "}\n";
|
|
|
+}
|
|
|
+
|
|
|
+////////////////////////////////////////////////////////////////////
|
|
|
+// Function: InterfaceMakerPythonNative::pack_return_value
|
|
|
+// Access: Private
|
|
|
+// Description: Outputs a command to pack the indicated expression,
|
|
|
+// of the return_type type, as a Python return value.
|
|
|
+////////////////////////////////////////////////////////////////////
|
|
|
+
|
|
|
+void InterfaceMakerPythonNative::pack_return_value(ostream &out, int indent_level,
|
|
|
+ FunctionRemap *remap, string return_expr, ostream &ForwardDeclrs)
|
|
|
+{
|
|
|
+ CPPType *orig_type = remap->_return_type->get_orig_type();
|
|
|
+ CPPType *type = remap->_return_type->get_new_type();
|
|
|
+
|
|
|
+ if (remap->_return_type->new_type_is_atomic_string()) {
|
|
|
+ if (TypeManager::is_char_pointer(orig_type)) {
|
|
|
+ indent(out, indent_level)
|
|
|
+ << "return PyString_FromString(" << return_expr << ");\n";
|
|
|
+
|
|
|
+ } else {
|
|
|
+ indent(out, indent_level)
|
|
|
+ << "return PyString_FromStringAndSize("
|
|
|
+ << return_expr << ".data(), (int)" << return_expr << ".length());\n";
|
|
|
+ }
|
|
|
+
|
|
|
+ } else if (TypeManager::is_unsigned_longlong(type)) {
|
|
|
+ indent(out, indent_level)
|
|
|
+ << "return PyLong_FromUnsignedLongLong(" << return_expr << ");\n";
|
|
|
+
|
|
|
+ } else if (TypeManager::is_longlong(type)) {
|
|
|
+ indent(out, indent_level)
|
|
|
+ << "return PyLong_FromLongLong(" << return_expr << ");\n";
|
|
|
+
|
|
|
+ } else if (TypeManager::is_integer(type)) {
|
|
|
+ indent(out, indent_level)
|
|
|
+ << "return PyInt_FromLong(" << return_expr << ");\n";
|
|
|
+
|
|
|
+ } else if (TypeManager::is_float(type)) {
|
|
|
+ indent(out, indent_level)
|
|
|
+ << "return PyFloat_FromDouble(" << return_expr << ");\n";
|
|
|
+
|
|
|
+ } else if (TypeManager::is_char_pointer(type)) {
|
|
|
+ indent(out, indent_level)
|
|
|
+ << "return PyString_FromString(" << return_expr << ");\n";
|
|
|
+
|
|
|
+ }
|
|
|
+ else if (TypeManager::is_pointer_to_PyObject(type))
|
|
|
+ {
|
|
|
+ indent(out, indent_level)
|
|
|
+ << "return "<< return_expr << ";\n";
|
|
|
+
|
|
|
+ }
|
|
|
+ else if (TypeManager::is_pointer(type))
|
|
|
+ {
|
|
|
+ if (TypeManager::is_struct(orig_type) || TypeManager::is_ref_to_anything(orig_type))
|
|
|
+ {
|
|
|
+ if( TypeManager::is_ref_to_anything(orig_type))
|
|
|
+ {
|
|
|
+ TypeIndex type_index = builder.get_type(TypeManager::unwrap(type),false);
|
|
|
+ InterrogateDatabase *idb = InterrogateDatabase::get_ptr();
|
|
|
+ const InterrogateType &itype = idb->get_type(type_index);
|
|
|
+ std::string ows_memory_flag("true");
|
|
|
+
|
|
|
+ if(remap->_return_value_needs_management)
|
|
|
+ ows_memory_flag = "true";
|
|
|
+ else
|
|
|
+ ows_memory_flag = "false";
|
|
|
+
|
|
|
+ if(!isExportThisRun(itype._cpptype))
|
|
|
+ {
|
|
|
+ _external_imports.insert(make_safe_name(itype.get_scoped_name()));
|
|
|
+ //ForwardDeclrs << "IMPORT_THIS struct Dtool_PyTypedObject Dtool_" << make_safe_name(itype.get_scoped_name()) << ";\n";
|
|
|
+ }
|
|
|
+
|
|
|
+ WriteCreateInstance(out,indent_level,return_expr,ows_memory_flag,itype.get_scoped_name(),itype._cpptype);
|
|
|
+ // indent(out, indent_level)
|
|
|
+ // <<"return DTool_CreatePyInstance((void *)" << return_expr <<"," << CLASS_PREFEX << make_safe_name(itype.get_scoped_name()) << ","<<ows_memory_flag<<");\n";
|
|
|
+
|
|
|
+ }
|
|
|
+ else
|
|
|
+ {
|
|
|
+ if (remap->_type == FunctionRemap::T_constructor )
|
|
|
+ {
|
|
|
+ // should only reach this in the INIT function a a Class .. IE the PY exists before the CPP object
|
|
|
+ // this is were we type to returned a class/struct.. ie CPP TYpe
|
|
|
+
|
|
|
+
|
|
|
+ TypeIndex type_index = builder.get_type(TypeManager::unwrap(orig_type),false);
|
|
|
+ InterrogateDatabase *idb = InterrogateDatabase::get_ptr();
|
|
|
+ const InterrogateType &itype = idb->get_type(type_index);
|
|
|
+ indent(out, indent_level)
|
|
|
+ <<"return DTool_PyInit_Finalize(self, " << return_expr <<",&"<<CLASS_PREFEX << make_safe_name(itype.get_scoped_name()) << ",true);\n";
|
|
|
+ }
|
|
|
+ else
|
|
|
+ {
|
|
|
+
|
|
|
+ std::string ows_memory_flag("true");
|
|
|
+ if(remap->_return_value_needs_management)
|
|
|
+ ows_memory_flag = "true";
|
|
|
+ else
|
|
|
+ ows_memory_flag = "false";
|
|
|
+
|
|
|
+ if(remap->_manage_reference_count)
|
|
|
+ {
|
|
|
+ TypeIndex type_index = builder.get_type(TypeManager::unwrap(type),false);
|
|
|
+ InterrogateDatabase *idb = InterrogateDatabase::get_ptr();
|
|
|
+ const InterrogateType &itype = idb->get_type(type_index);
|
|
|
+
|
|
|
+ if(!isExportThisRun(itype._cpptype))
|
|
|
+ {
|
|
|
+ _external_imports.insert(make_safe_name(itype.get_scoped_name()));
|
|
|
+ //ForwardDeclrs << "IMPORT_THIS 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";
|
|
|
+ WriteCreateInstance(out,indent_level,return_expr,ows_memory_flag,itype.get_scoped_name(),itype._cpptype);
|
|
|
+ //indent(out, indent_level)
|
|
|
+ // <<"return DTool_CreatePyInstance((void *)" << return_expr <<"," << CLASS_PREFEX << make_safe_name(itype.get_scoped_name()) << ","<<ows_memory_flag<<");\n";
|
|
|
+ }
|
|
|
+ else
|
|
|
+ {
|
|
|
+ TypeIndex type_index = builder.get_type(TypeManager::unwrap(orig_type),false);
|
|
|
+ InterrogateDatabase *idb = InterrogateDatabase::get_ptr();
|
|
|
+ const InterrogateType &itype = idb->get_type(type_index);
|
|
|
+
|
|
|
+ if(!isExportThisRun(itype._cpptype))
|
|
|
+ {
|
|
|
+ _external_imports.insert(make_safe_name(itype.get_scoped_name()));
|
|
|
+ //ForwardDeclrs << "IMPORT_THIS 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)
|
|
|
+ // <<"return DTool_CreatePyInstance((void *)" << return_expr <<"," << CLASS_PREFEX << make_safe_name(itype.get_scoped_name()) << ","<<ows_memory_flag<<");\n";
|
|
|
+ WriteCreateInstance(out,indent_level,return_expr,ows_memory_flag,itype.get_scoped_name(),itype._cpptype);
|
|
|
+
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+ else if( TypeManager::is_struct(orig_type->as_pointer_type()->_pointing_at) )
|
|
|
+ {
|
|
|
+ TypeIndex type_index = builder.get_type(TypeManager::unwrap(orig_type),false);
|
|
|
+ InterrogateDatabase *idb = InterrogateDatabase::get_ptr();
|
|
|
+ const InterrogateType &itype = idb->get_type(type_index);
|
|
|
+
|
|
|
+ std::string ows_memory_flag("true");
|
|
|
+ if(remap->_return_value_needs_management)
|
|
|
+ ows_memory_flag ="true";
|
|
|
+ else
|
|
|
+ ows_memory_flag = "false";
|
|
|
+
|
|
|
+ if(!isExportThisRun(itype._cpptype))
|
|
|
+ {
|
|
|
+ _external_imports.insert(make_safe_name(itype.get_scoped_name()));
|
|
|
+ //ForwardDeclrs << "IMPORT_THIS 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";
|
|
|
+ WriteCreateInstance(out,indent_level,return_expr,ows_memory_flag,itype.get_scoped_name(),itype._cpptype);
|
|
|
+
|
|
|
+ //indent(out, indent_level)
|
|
|
+ // << "return DTool_CreatePyInstance((void *)" << return_expr <<","<<CLASS_PREFEX << make_safe_name(itype.get_scoped_name()) <<","<< ows_memory_flag<< ");\n";
|
|
|
+ }
|
|
|
+ else
|
|
|
+ {
|
|
|
+ indent(out, indent_level)<<" Shouln Never Reach This InterfaceMakerPythonNative::pack_return_value";
|
|
|
+ //<< "return PyInt_FromLong((int)" << return_expr << ");\n";
|
|
|
+ }
|
|
|
+
|
|
|
+ } else {
|
|
|
+ // Return None.
|
|
|
+ indent(out, indent_level)
|
|
|
+ << "return Py_BuildValue(\"\");\n";
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+////////////////////////////////////////////////////////////////////
|
|
|
+////////////////////////////////////////////////////////////////////
|
|
|
+// Function: InterfaceMakerPythonNative::record_object
|
|
|
+// Access: Protected
|
|
|
+// Description: Records the indicated type, which may be a struct
|
|
|
+// type, along with all of its associated methods, if
|
|
|
+// any.
|
|
|
+////////////////////////////////////////////////////////////////////
|
|
|
+InterfaceMaker::Object *InterfaceMakerPythonNative::record_object(TypeIndex type_index)
|
|
|
+{
|
|
|
+
|
|
|
+ if (type_index == 0) {
|
|
|
+ return (Object *)NULL;
|
|
|
+ }
|
|
|
+
|
|
|
+ Objects::iterator oi = _objects.find(type_index);
|
|
|
+ if (oi != _objects.end()) {
|
|
|
+ return (*oi).second;
|
|
|
+ }
|
|
|
+
|
|
|
+ InterrogateDatabase *idb = InterrogateDatabase::get_ptr();
|
|
|
+ const InterrogateType &itype = idb->get_type(type_index);
|
|
|
+
|
|
|
+ if(!isCppTypeLegal(itype._cpptype))
|
|
|
+ {
|
|
|
+ return (Object *)NULL;
|
|
|
+ }
|
|
|
+
|
|
|
+ Object *object = new Object(itype);
|
|
|
+ bool inserted = _objects.insert(Objects::value_type(type_index, object)).second;
|
|
|
+ assert(inserted);
|
|
|
+
|
|
|
+ Function *function;
|
|
|
+
|
|
|
+ int num_constructors = itype.number_of_constructors();
|
|
|
+ for (int ci = 0; ci < num_constructors; ci++)
|
|
|
+ {
|
|
|
+ function = record_function(itype, itype.get_constructor(ci));
|
|
|
+ if(isFunctionLegal(function))
|
|
|
+ object->_constructors.push_back(function);
|
|
|
+ }
|
|
|
+
|
|
|
+// destructor are handled in a much difrent fashion..
|
|
|
+// if (itype.has_destructor() && !itype.destructor_is_inherited())
|
|
|
+// {
|
|
|
+// function = record_function(itype, itype.get_destructor());
|
|
|
+// object->_destructor = function;
|
|
|
+// }
|
|
|
+
|
|
|
+ int num_methods = itype.number_of_methods();
|
|
|
+ int mi;
|
|
|
+ for (mi = 0; mi < num_methods; mi++)
|
|
|
+ {
|
|
|
+ function = record_function(itype, itype.get_method(mi));
|
|
|
+ if(isFunctionLegal(function))
|
|
|
+ object->_methods.push_back(function);
|
|
|
+
|
|
|
+ }
|
|
|
+
|
|
|
+ int num_casts = itype.number_of_casts();
|
|
|
+ for (mi = 0; mi < num_casts; mi++)
|
|
|
+ {
|
|
|
+ function = record_function(itype, itype.get_cast(mi));
|
|
|
+ if(isFunctionLegal(function))
|
|
|
+ object->_methods.push_back(function);
|
|
|
+ }
|
|
|
+
|
|
|
+ int num_derivations = itype.number_of_derivations();
|
|
|
+ for (int di = 0; di < num_derivations; di++)
|
|
|
+ {
|
|
|
+ TypeIndex d_type_Index = itype.get_derivation(di);
|
|
|
+ const InterrogateType &d_itype = idb->get_type(d_type_Index);
|
|
|
+
|
|
|
+ if(!interrogate_type_is_unpublished(d_type_Index))
|
|
|
+ {
|
|
|
+ if (itype.derivation_has_upcast(di))
|
|
|
+ {
|
|
|
+ function = record_function(itype, itype.derivation_get_upcast(di));
|
|
|
+ if(isFunctionLegal(function))
|
|
|
+ object->_methods.push_back(function);
|
|
|
+ }
|
|
|
+ if (itype.derivation_has_downcast(di))
|
|
|
+ {
|
|
|
+ // Downcasts are methods of the base class, not the child class.
|
|
|
+ TypeIndex base_type_index = itype.get_derivation(di);
|
|
|
+
|
|
|
+ const InterrogateType &base_type = idb->get_type(base_type_index);
|
|
|
+ function = record_function(base_type, itype.derivation_get_downcast(di));
|
|
|
+
|
|
|
+ if(isFunctionLegal(function))
|
|
|
+ {
|
|
|
+ Object * pobject = record_object(base_type_index);
|
|
|
+ if(pobject != NULL)
|
|
|
+ pobject->_methods.push_back(function);
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ int num_elements = itype.number_of_elements();
|
|
|
+ for (int ei = 0; ei < num_elements; ei++)
|
|
|
+ {
|
|
|
+ ElementIndex element_index = itype.get_element(ei);
|
|
|
+ const InterrogateElement &ielement = idb->get_element(element_index);
|
|
|
+ if (ielement.has_getter())
|
|
|
+ {
|
|
|
+ FunctionIndex func_index = ielement.get_getter();
|
|
|
+ record_function(itype, func_index);
|
|
|
+ }
|
|
|
+ if (ielement.has_setter())
|
|
|
+ {
|
|
|
+ FunctionIndex func_index = ielement.get_setter();
|
|
|
+ record_function(itype, func_index);
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ int num_nested = itype.number_of_nested_types();
|
|
|
+ for (int ni = 0; ni < num_nested; ni++)
|
|
|
+ {
|
|
|
+ TypeIndex nested_index = itype.get_nested_type(ni);
|
|
|
+ record_object(nested_index);
|
|
|
+ }
|
|
|
+ return object;
|
|
|
+}
|
|
|
+////////////////////////////////////////////////////////////////////
|
|
|
+// Function: InterfaceMaker::generate_wrappers
|
|
|
+// Access: Public, Virtual
|
|
|
+// Description: Walks through the set of functions in the database
|
|
|
+// and generates wrappers for each function, storing
|
|
|
+// these in the database. No actual code should be
|
|
|
+// output yet; this just updates the database with the
|
|
|
+// wrapper information.
|
|
|
+////////////////////////////////////////////////////////////////////
|
|
|
+void InterfaceMakerPythonNative::generate_wrappers()
|
|
|
+{
|
|
|
+ inside_python_native = true;
|
|
|
+ InterrogateDatabase *idb = InterrogateDatabase::get_ptr();
|
|
|
+
|
|
|
+ // We use a while loop rather than a simple for loop, because we
|
|
|
+ // might increase the number of types recursively during the
|
|
|
+ // traversal.
|
|
|
+
|
|
|
+ int ti = 0;
|
|
|
+ while (ti < idb->get_num_all_types())
|
|
|
+ {
|
|
|
+ TypeIndex type_index = idb->get_all_type(ti);
|
|
|
+ record_object(type_index);
|
|
|
+ ++ti;
|
|
|
+ }
|
|
|
+
|
|
|
+ int gi = 0;
|
|
|
+ while( gi = idb->get_num_global_elements())
|
|
|
+ {
|
|
|
+ printf(" Global Type = %d",gi);
|
|
|
+ TypeIndex type_index = idb->get_global_element(gi);
|
|
|
+ record_object(type_index);
|
|
|
+
|
|
|
+ }
|
|
|
+
|
|
|
+ int num_functions = idb->get_num_global_functions();
|
|
|
+ for (int fi = 0; fi < num_functions; fi++)
|
|
|
+ {
|
|
|
+ FunctionIndex func_index = idb->get_global_function(fi);
|
|
|
+ record_function(dummy_type, func_index);
|
|
|
+ }
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+ int num_manifests = idb->get_num_global_manifests();
|
|
|
+ for (int mi = 0; mi < num_manifests; mi++)
|
|
|
+ {
|
|
|
+ ManifestIndex manifest_index = idb->get_global_manifest(mi);
|
|
|
+ const InterrogateManifest &iman = idb->get_manifest(manifest_index);
|
|
|
+ if (iman.has_getter())
|
|
|
+ {
|
|
|
+ FunctionIndex func_index = iman.get_getter();
|
|
|
+ record_function(dummy_type, func_index);
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ int num_elements = idb->get_num_global_elements();
|
|
|
+ for (int ei = 0; ei < num_elements; ei++)
|
|
|
+ {
|
|
|
+ printf(" Element %d\n",ei);
|
|
|
+
|
|
|
+ ElementIndex element_index = idb->get_global_element(ei);
|
|
|
+ const InterrogateElement &ielement = idb->get_element(element_index);
|
|
|
+ if (ielement.has_getter())
|
|
|
+ {
|
|
|
+ FunctionIndex func_index = ielement.get_getter();
|
|
|
+ record_function(dummy_type, func_index);
|
|
|
+ }
|
|
|
+ if (ielement.has_setter())
|
|
|
+ {
|
|
|
+ FunctionIndex func_index = ielement.get_setter();
|
|
|
+ record_function(dummy_type, func_index);
|
|
|
+ }
|
|
|
+ }
|
|
|
+ inside_python_native = false;
|
|
|
+}
|
|
|
+//////////////////////////////////////////////
|
|
|
+// Function :isCppTypeLegal
|
|
|
+//
|
|
|
+// is the cpp object supported by by the dtool_py interface..
|
|
|
+//////////////////////////////////////////////
|
|
|
+bool InterfaceMakerPythonNative::isCppTypeLegal(CPPType *ctype)
|
|
|
+{
|
|
|
+ if(ctype == NULL)
|
|
|
+ return false;
|
|
|
+
|
|
|
+ if(builder.in_ignoretype(ctype->get_local_name(&parser)))
|
|
|
+ return false;
|
|
|
+
|
|
|
+ bool answer = false;
|
|
|
+ CPPType *type = TypeManager::unwrap(ctype);
|
|
|
+ //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)))
|
|
|
+ {
|
|
|
+ return true;
|
|
|
+ }
|
|
|
+ else if(TypeManager::IsExported(type) == true)
|
|
|
+ {
|
|
|
+ answer = true;
|
|
|
+ }
|
|
|
+ else if(TypeManager::is_pointer_to_PyObject(ctype) == true)
|
|
|
+ {
|
|
|
+ return true;
|
|
|
+ }
|
|
|
+
|
|
|
+ return answer;
|
|
|
+}
|
|
|
+//////////////////////////////////////////////
|
|
|
+// Function :isExportThisRun
|
|
|
+//
|
|
|
+//////////////////////////////////////////////
|
|
|
+bool InterfaceMakerPythonNative::isExportThisRun(CPPType *ctype)
|
|
|
+{
|
|
|
+ CPPType *type = TypeManager::unwrap(ctype);
|
|
|
+ if(TypeManager::IsLocal(ctype))
|
|
|
+ return true;
|
|
|
+
|
|
|
+ if(builder.in_forcetype(ctype->get_local_name(&parser)))
|
|
|
+ return true;
|
|
|
+
|
|
|
+ return false;
|
|
|
+}
|
|
|
+
|
|
|
+//////////////////////////////////////////////
|
|
|
+// Function : isExportThisRun
|
|
|
+/////////////////////////////////////////////
|
|
|
+bool InterfaceMakerPythonNative::isExportThisRun(Function *func)
|
|
|
+{
|
|
|
+ if(func == NULL || !isFunctionLegal(func))
|
|
|
+ return false;
|
|
|
+
|
|
|
+ Function::Remaps::const_iterator ri;
|
|
|
+ for (ri = func->_remaps.begin(); ri != func->_remaps.end(); ++ri)
|
|
|
+ {
|
|
|
+ FunctionRemap *remap = (*ri);
|
|
|
+ return isExportThisRun(remap->_cpptype);
|
|
|
+ }
|
|
|
+
|
|
|
+ return false;
|
|
|
+}
|
|
|
+//////////////////////////////////////////////
|
|
|
+// Function : isRemapLegal
|
|
|
+//////////////////////////////////////////////
|
|
|
+bool InterfaceMakerPythonNative::isRemapLegal( FunctionRemap &remap)
|
|
|
+{
|
|
|
+ // return must be legal and managable..
|
|
|
+ if(!isCppTypeLegal(remap._return_type->get_orig_type()))
|
|
|
+ return false;
|
|
|
+
|
|
|
+ // ouch .. bad things will happen here .. do not even try..
|
|
|
+ if(remap._ForcedVoidReturn)
|
|
|
+ return false;
|
|
|
+
|
|
|
+ // all params must be legal
|
|
|
+ for (int pn = 0; pn < (int)remap._parameters.size(); pn++)
|
|
|
+ {
|
|
|
+ CPPType *orig_type = remap._parameters[pn]._remap->get_orig_type();
|
|
|
+ if(!isCppTypeLegal(orig_type))
|
|
|
+ return false;
|
|
|
+ }
|
|
|
+
|
|
|
+ // ok all looks ok.
|
|
|
+ return true;
|
|
|
+}
|
|
|
+////////////////////////////////////////////////////////////////////////
|
|
|
+// Function : isFunctionLegal
|
|
|
+////////////////////////////////////////////////////////////////////////
|
|
|
+bool InterfaceMakerPythonNative::isFunctionLegal( Function *func)
|
|
|
+{
|
|
|
+ Function::Remaps::const_iterator ri;
|
|
|
+ for (ri = func->_remaps.begin(); ri != func->_remaps.end(); ++ri)
|
|
|
+ {
|
|
|
+ FunctionRemap *remap = (*ri);
|
|
|
+ if(isRemapLegal(*remap))
|
|
|
+ return true;
|
|
|
+ }
|
|
|
+
|
|
|
+ return false;
|
|
|
+}
|
|
|
+////////////////////////////////////////////////////////////////////////
|
|
|
+// Function : isFunctionWithThis
|
|
|
+//
|
|
|
+// If any rempas have a this .. this function has a this..( of self) to python..
|
|
|
+////////////////////////////////////////////////////////////////////////
|
|
|
+bool InterfaceMakerPythonNative::isFunctionWithThis( Function *func)
|
|
|
+{
|
|
|
+ Function::Remaps::const_iterator ri;
|
|
|
+ for (ri = func->_remaps.begin(); ri != func->_remaps.end(); ++ri)
|
|
|
+ {
|
|
|
+ FunctionRemap *remap = (*ri);
|
|
|
+ if(remap->_has_this)
|
|
|
+ return true;
|
|
|
+ }
|
|
|
+ return false;
|
|
|
+}
|
|
|
+
|
|
|
+////////////////////////////////////////////////////////////////////
|
|
|
+// Function: InterfaceMakerPython::test_assert
|
|
|
+// Access: Protected
|
|
|
+// Description: Outputs code to check to see if an assertion has
|
|
|
+// failed while the C++ code was executing, and report
|
|
|
+// this failure back to Python.
|
|
|
+////////////////////////////////////////////////////////////////////
|
|
|
+void InterfaceMakerPythonNative::do_assert_init(ostream &out, int indent_level, bool constructor) const {
|
|
|
+ if (watch_asserts) {
|
|
|
+ out << "#ifndef NDEBUG\n";
|
|
|
+ indent(out, indent_level)
|
|
|
+ << "Notify *notify = Notify::ptr();\n";
|
|
|
+ indent(out, indent_level)
|
|
|
+ << "if (notify->has_assert_failed()) {\n";
|
|
|
+ indent(out, indent_level + 2)
|
|
|
+ << "PyErr_SetString(PyExc_AssertionError, notify->get_assert_error_message().c_str());\n";
|
|
|
+ indent(out, indent_level + 2)
|
|
|
+ << "notify->clear_assert_failed();\n";
|
|
|
+ if(constructor)
|
|
|
+ indent(out, indent_level + 2) << "return -1;\n";
|
|
|
+ else
|
|
|
+ indent(out, indent_level + 2) << "return (PyObject *)NULL;\n";
|
|
|
+ indent(out, indent_level)
|
|
|
+ << "}\n";
|
|
|
+ indent(out, indent_level)
|
|
|
+ << "if (PyErr_Occurred()) {\n";
|
|
|
+ if(constructor)
|
|
|
+ indent(out, indent_level + 2) << "return -1;\n";
|
|
|
+ else
|
|
|
+ indent(out, indent_level + 2) << "return (PyObject *)NULL;\n";
|
|
|
+ indent(out, indent_level)
|
|
|
+ << "}\n";
|
|
|
+ out << "#endif\n";
|
|
|
+ }
|
|
|
+}
|
|
|
+////////////////////////////////////////////////////////
|
|
|
+// Function : IsRunTimeTyped
|
|
|
+///////////////////////////////////////////////////////
|
|
|
+bool InterfaceMakerPythonNative::IsRunTimeTyped(const InterrogateType &itype)
|
|
|
+{
|
|
|
+ TypeIndex ptype_id = itype.get_outer_class();
|
|
|
+ if(ptype_id > 0)
|
|
|
+ {
|
|
|
+ InterrogateDatabase *idb = InterrogateDatabase::get_ptr();
|
|
|
+
|
|
|
+ InterrogateType ptype = idb->get_type(ptype_id);
|
|
|
+ return IsRunTimeTyped(ptype);
|
|
|
+ }
|
|
|
+
|
|
|
+
|
|
|
+ if(itype.get_name() == "TypedObject")
|
|
|
+ return true;
|
|
|
+
|
|
|
+ return false;
|
|
|
+};
|
|
|
+
|
|
|
+//////////////////////////////////////////////////////////
|
|
|
+// Function : DoesInheritFromIsClass
|
|
|
+//
|
|
|
+// Helper function to check cpp class inharatience..
|
|
|
+///////////////////////////////////////////////////////////
|
|
|
+bool InterfaceMakerPythonNative::DoesInheritFromIsClass( const CPPStructType * inclass, const std::string &name)
|
|
|
+{
|
|
|
+ if(inclass == NULL)
|
|
|
+ return false;
|
|
|
+
|
|
|
+ CPPStructType::Derivation::const_iterator bi;
|
|
|
+ for (bi = inclass->_derivation.begin();
|
|
|
+ bi != inclass->_derivation.end();
|
|
|
+ ++bi)
|
|
|
+ {
|
|
|
+
|
|
|
+ const CPPStructType::Base &base = (*bi);
|
|
|
+
|
|
|
+ CPPStructType *base_type = TypeManager::resolve_type(base._base)->as_struct_type();
|
|
|
+ if(base_type != NULL)
|
|
|
+ {
|
|
|
+ std::string scoped_name = base_type->get_fully_scoped_name();
|
|
|
+ if(scoped_name == name)
|
|
|
+ return true;
|
|
|
+
|
|
|
+ if(DoesInheritFromIsClass(base_type,name) == true)
|
|
|
+ return true;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ return false;
|
|
|
+}
|
|
|
+
|
|
|
+////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
+// Function : HasAGetKeyFunction
|
|
|
+//
|
|
|
+// does the class have a supportable GetKey for hash usage..
|
|
|
+//////////////////////////////////////////////////////////////////////////////////////////
|
|
|
+bool InterfaceMakerPythonNative::HasAGetKeyFunction(const InterrogateType &itype_class)
|
|
|
+{
|
|
|
+ InterrogateDatabase *idb = InterrogateDatabase::get_ptr();
|
|
|
+
|
|
|
+ int num_methods = itype_class.number_of_methods();
|
|
|
+ int mi;
|
|
|
+ for (mi = 0; mi < num_methods; mi++)
|
|
|
+ {
|
|
|
+ FunctionIndex func_index = itype_class.get_method(mi);
|
|
|
+ const InterrogateFunction &ifunc = idb->get_function(func_index);
|
|
|
+ if(ifunc.get_name() == "GetKey")
|
|
|
+ {
|
|
|
+ if (ifunc._instances != (InterrogateFunction::Instances *)NULL)
|
|
|
+ {
|
|
|
+ InterrogateFunction::Instances::const_iterator ii;
|
|
|
+ for (ii = ifunc._instances->begin();ii != ifunc._instances->end();++ii)
|
|
|
+ {
|
|
|
+ CPPInstance *cppinst = (*ii).second;
|
|
|
+ CPPFunctionType *cppfunc = cppinst->_type->as_function_type();
|
|
|
+
|
|
|
+ if(cppfunc != NULL)
|
|
|
+ {
|
|
|
+ if(cppfunc->_parameters != NULL && cppfunc->_return_type != NULL && TypeManager::is_integer(cppfunc->_return_type))
|
|
|
+ {
|
|
|
+ if(cppfunc->_parameters->_parameters.size() == 0)
|
|
|
+ {
|
|
|
+ return true;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+ return false;
|
|
|
+};
|
|
|
+////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
+// Function : NeedsAStrFunction
|
|
|
+//
|
|
|
+// Can we generate a __str__ function for this class
|
|
|
+//////////////////////////////////////////////////////////////////////////////////////////
|
|
|
+bool InterfaceMakerPythonNative::NeedsAStrFunction(const InterrogateType &itype_class)
|
|
|
+{
|
|
|
+ InterrogateDatabase *idb = InterrogateDatabase::get_ptr();
|
|
|
+
|
|
|
+ int num_methods = itype_class.number_of_methods();
|
|
|
+ int mi;
|
|
|
+ for (mi = 0; mi < num_methods; mi++)
|
|
|
+ {
|
|
|
+ FunctionIndex func_index = itype_class.get_method(mi);
|
|
|
+ const InterrogateFunction &ifunc = idb->get_function(func_index);
|
|
|
+ if(ifunc.get_name() == "write")
|
|
|
+ {
|
|
|
+ if (ifunc._instances != (InterrogateFunction::Instances *)NULL)
|
|
|
+ {
|
|
|
+ InterrogateFunction::Instances::const_iterator ii;
|
|
|
+ for (ii = ifunc._instances->begin();ii != ifunc._instances->end();++ii)
|
|
|
+ {
|
|
|
+ CPPInstance *cppinst = (*ii).second;
|
|
|
+ CPPFunctionType *cppfunc = cppinst->_type->as_function_type();
|
|
|
+
|
|
|
+ if(cppfunc != NULL)
|
|
|
+ {
|
|
|
+ if(cppfunc->_parameters != NULL && cppfunc->_return_type != NULL && TypeManager::is_void(cppfunc->_return_type))
|
|
|
+ {
|
|
|
+ if(cppfunc->_parameters->_parameters.size() == 1)
|
|
|
+ {
|
|
|
+
|
|
|
+ CPPInstance *inst1 = cppfunc->_parameters->_parameters[0];
|
|
|
+ if(TypeManager::is_pointer_to_ostream(inst1->_type))
|
|
|
+ return true;
|
|
|
+ }
|
|
|
+
|
|
|
+ if(cppfunc->_parameters->_parameters.size() == 2)
|
|
|
+ {
|
|
|
+
|
|
|
+ CPPInstance *inst1 = cppfunc->_parameters->_parameters[0];
|
|
|
+ if(TypeManager::is_pointer_to_ostream(inst1->_type))
|
|
|
+ {
|
|
|
+ inst1 = cppfunc->_parameters->_parameters[0];
|
|
|
+ if(inst1->_initializer != NULL)
|
|
|
+ return true;
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+ return false;
|
|
|
+};
|
|
|
+
|
|
|
+////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
+// Function : NeedsAReprFunction
|
|
|
+//
|
|
|
+// Can we generate a __repr__ function for this class
|
|
|
+//////////////////////////////////////////////////////////////////////////////////////////
|
|
|
+bool InterfaceMakerPythonNative::NeedsAReprFunction(const InterrogateType &itype_class)
|
|
|
+{
|
|
|
+ InterrogateDatabase *idb = InterrogateDatabase::get_ptr();
|
|
|
+
|
|
|
+ int num_methods = itype_class.number_of_methods();
|
|
|
+ int mi;
|
|
|
+ for (mi = 0; mi < num_methods; mi++)
|
|
|
+ {
|
|
|
+ FunctionIndex func_index = itype_class.get_method(mi);
|
|
|
+ const InterrogateFunction &ifunc = idb->get_function(func_index);
|
|
|
+ if(ifunc.get_name() == "output")
|
|
|
+ {
|
|
|
+ if (ifunc._instances != (InterrogateFunction::Instances *)NULL)
|
|
|
+ {
|
|
|
+ InterrogateFunction::Instances::const_iterator ii;
|
|
|
+ for (ii = ifunc._instances->begin();ii != ifunc._instances->end();++ii)
|
|
|
+ {
|
|
|
+ CPPInstance *cppinst = (*ii).second;
|
|
|
+ CPPFunctionType *cppfunc = cppinst->_type->as_function_type();
|
|
|
+
|
|
|
+ if(cppfunc != NULL)
|
|
|
+ {
|
|
|
+ if(cppfunc->_parameters != NULL && cppfunc->_return_type != NULL && TypeManager::is_void(cppfunc->_return_type))
|
|
|
+ {
|
|
|
+ if(cppfunc->_parameters->_parameters.size() == 1)
|
|
|
+ {
|
|
|
+
|
|
|
+ CPPInstance *inst1 = cppfunc->_parameters->_parameters[0];
|
|
|
+ if(TypeManager::is_pointer_to_ostream(inst1->_type))
|
|
|
+ return true;
|
|
|
+ }
|
|
|
+
|
|
|
+ if(cppfunc->_parameters->_parameters.size() == 2)
|
|
|
+ {
|
|
|
+
|
|
|
+ CPPInstance *inst1 = cppfunc->_parameters->_parameters[0];
|
|
|
+ if(TypeManager::is_pointer_to_ostream(inst1->_type))
|
|
|
+ {
|
|
|
+ inst1 = cppfunc->_parameters->_parameters[0];
|
|
|
+ if(inst1->_initializer != NULL)
|
|
|
+ return true;
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+ return false;
|
|
|
+};
|
|
|
+
|
Roger Hughston