First cut. Works for wrapping OpenAccess, but there's plenty

left to do.

Currently, the test suite hurls at director_stl.



git-svn-id: https://swig.svn.sourceforge.net/svnroot/swig/branches/szager-python-builtin@12332 626c5289-ae23-0410-ae9c-e8d60b6d4f22

Lib/python/builtin.swg

@@ -0,0 +1,28 @@
+#ifdef __cplusplus
+
+namespace {
+
+template <typename _Tp> struct PySwigBuiltin : public SwigPyObject {
+
+    typedef PySwigBuiltin<_Tp> this_type;
+    typedef _Tp obj_type;
+    typedef obj_type* pointer;
+    typedef obj_type& reference;
+
+    static PyMethodDef methods[];
+    static PyTypeObject pytype;
+    static SwigPyClientData clientdata;
+};
+
+template <typename _Tp> void py_builtin_dealloc (PyObject *pyobj)
+{
+    typedef PySwigBuiltin<_Tp> builtin_type;
+    builtin_type *obj = (builtin_type*) pyobj;
+    if (obj->own)
+	delete reinterpret_cast<_Tp*>(obj->ptr);
+    (*pyobj->ob_type->tp_free)(pyobj);
+}
+
+} // namespace {
+
+#endif

Lib/python/pycontainer.swg

@@ -580,6 +580,9 @@ namespace swig
 
   %fragment("SwigPySequence_Cont");
 
+# if defined(SWIGPYTHON_BUILTIN)
+  %feature("tp_iter") Sequence "&swig::make_output_iterator_builtin< Sequence >";
+# else
   %newobject iterator(PyObject **PYTHON_SELF);
   %extend  {
     swig::SwigPyIterator* iterator(PyObject **PYTHON_SELF) {
@@ -588,6 +591,8 @@ namespace swig
 
     %pythoncode {def __iter__(self): return self.iterator()}
   }
+# endif // SWIGPYTHON_BUILTIN
+
 #endif //SWIG_EXPORT_ITERATOR_METHODS
 %enddef
 

Lib/python/pyinit.swg

@@ -320,7 +320,8 @@ SWIGEXPORT
   void
 #endif
 SWIG_init(void) {
-  PyObject *m, *d;  
+  PyObject *m, *d, *md;
+  PyTypeObject *builtin_type;
 #if PY_VERSION_HEX >= 0x03000000
   static struct PyModuleDef SWIG_module = {
     PyModuleDef_HEAD_INIT,
@@ -335,6 +336,13 @@ SWIG_init(void) {
   };
 #endif
 
+#if defined(SWIGPYTHON_BUILTIN)
+  PyTypeObject *builtin_pytype = 0;
+  swig_type_info *builtin_basetype = 0;
+
+  SWIG_Python_builtin_imports();
+#endif
+
   /* Fix SwigMethods to carry the callback ptrs when needed */
   SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_type_initial);
 
@@ -343,7 +351,7 @@ SWIG_init(void) {
 #else
   m = Py_InitModule((char *) SWIG_name, SwigMethods);
 #endif
-  d = PyModule_GetDict(m);
+  md = d = PyModule_GetDict(m);
   
   SWIG_InitializeModule(0);
   SWIG_InstallConstants(d,swig_const_table);

Lib/python/pyiterators.swg

@@ -302,6 +302,24 @@ namespace swig {
   {
     return new SwigPyIteratorOpen_T<OutIter>(current, seq);
   }
+
+  template <typename Sequence>
+  inline PyObject* make_output_iterator_builtin (PyObject *pyself)
+  {
+      SwigPyObject *builtin_obj = (SwigPyObject*) pyself;
+      Sequence *seq = reinterpret_cast< Sequence * >(builtin_obj->ptr);
+      if (!seq)
+        return SWIG_Py_Void();
+      SwigPyIterator *iter = make_output_iterator(seq->begin(), seq->begin(), seq->end(), pyself);
+      return SWIG_NewPointerObj(iter, SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_OWN);
+  }
+
+  template <>
+  inline PyObject* make_output_iterator_builtin<SwigPyIterator> (PyObject *pyself)
+  {
+    Py_INCREF(pyself);
+    return pyself;
+  }
 }
 }
 
@@ -329,9 +347,14 @@ namespace swig
   %newobject SwigPyIterator::operator - (ptrdiff_t n) const;
 
   %nodirector SwigPyIterator;
+
+#if defined(SWIGPYTHON_BUILTIN)
+  %feature("tp_iter") SwigPyIterator "&swig::make_output_iterator_builtin<swig::SwigPyIterator>";
+#else
   %extend SwigPyIterator {
   %pythoncode {def __iter__(self): return self}
   }
+#endif
 
   %catches(swig::stop_iteration) SwigPyIterator::value() const;
   %catches(swig::stop_iteration) SwigPyIterator::incr(size_t n = 1);

Lib/python/pyrun.swg

@@ -244,6 +244,7 @@ typedef struct {
   PyObject *destroy;
   int delargs;
   int implicitconv;
+  PyTypeObject *pytype;
 } SwigPyClientData;
 
 SWIGRUNTIMEINLINE int 
@@ -310,6 +311,7 @@ SwigPyClientData_New(PyObject* obj)
       data->delargs = 0;
     }
     data->implicitconv = 0;
+    data->pytype = 0;
     return data;
   }
 }
@@ -1068,7 +1070,18 @@ SWIG_Python_ConvertPtrAndOwn(PyObject *obj, void **ptr, swig_type_info *ty, int
     if (obj == Py_None) {
 	if (ptr) *ptr = 0;
 	return SWIG_OK;
-  } else {
+    }
+    if (ty && ty->clientdata && ((SwigPyClientData*) ty->clientdata)->pytype) {
+	PyTypeObject *target_tp = ((SwigPyClientData*) ty->clientdata)->pytype;
+	PyTypeObject *obj_tp;
+	for (obj_tp = obj->ob_type; obj_tp; obj_tp = obj_tp->tp_base) {
+	    if (obj_tp == target_tp) {
+	        if (ptr)
+		    *ptr = ((SwigPyObject*) obj)->ptr;
+		return SWIG_OK;
+	    }
+	}
+    }
     SwigPyObject *sobj = SWIG_Python_GetSwigThis(obj);
     if (own)
 	*own = 0;
@@ -1148,7 +1161,6 @@ SWIG_Python_ConvertPtrAndOwn(PyObject *obj, void **ptr, swig_type_info *ty, int
 	}
 	return res;
     }
-  }
 }
 
 /* Convert a function ptr value */
@@ -1319,12 +1331,24 @@ SWIG_Python_InitShadowInstance(PyObject *args) {
 
 SWIGRUNTIME PyObject *
 SWIG_Python_NewPointerObj(void *ptr, swig_type_info *type, int flags) {
-  if (!ptr) {
+    if (!ptr)
 	return SWIG_Py_Void();
-  } else {
+
-    int own = (flags & SWIG_POINTER_OWN) ? SWIG_POINTER_OWN : 0;
-    PyObject *robj = SwigPyObject_New(ptr, type, own);
     SwigPyClientData *clientdata = type ? (SwigPyClientData *)(type->clientdata) : 0;
+    int own = (flags & SWIG_POINTER_OWN) ? SWIG_POINTER_OWN : 0;
+    if (clientdata && clientdata->pytype) {
+	SwigPyObject *newobj = PyObject_New(SwigPyObject, clientdata->pytype);
+	if (newobj) {
+	    newobj->ptr = ptr;
+	    newobj->ty = type;
+	    newobj->own = own;
+	    newobj->next = 0;
+	    return (PyObject*) newobj;
+	}
+	return SWIG_Py_Void();
+    }
+
+    PyObject *robj = SwigPyObject_New(ptr, type, own);
     if (clientdata && !(flags & SWIG_POINTER_NOSHADOW)) {
 	PyObject *inst = SWIG_Python_NewShadowInstance(clientdata, robj);
 	if (inst) {
@@ -1333,7 +1357,6 @@ SWIG_Python_NewPointerObj(void *ptr, swig_type_info *type, int flags) {
 	}
     }
     return robj;
-  }
 }
 
 /* Create a new packed object */
@@ -1343,6 +1366,19 @@ SWIG_Python_NewPackedObj(void *ptr, size_t sz, swig_type_info *type) {
   return ptr ? SwigPyPacked_New((void *) ptr, sz, type) : SWIG_Py_Void();
 }
 
+SWIGRUNTIME int
+SWIG_Python_NewBuiltinObj(PyObject *self, void *ptr, swig_type_info *type, int flags) {
+    assert(self);
+    SwigPyClientData *clientdata = (SwigPyClientData *)(type->clientdata);
+    assert(clientdata);
+    assert(clientdata->pytype);
+    int own = (flags & SWIG_POINTER_OWN) ? SWIG_POINTER_OWN : 0;
+    SwigPyObject *newobj = (SwigPyObject*) self;
+    newobj->ptr = ptr;
+    newobj->own = own;
+    return 0;
+}
+
 /* -----------------------------------------------------------------------------*
  *  Get type list 
  * -----------------------------------------------------------------------------*/

Lib/python/pyruntime.swg

@@ -11,3 +11,4 @@
 %insert(runtime) "pyapi.swg";           /* Python API */
 %insert(runtime) "pyrun.swg";           /* Python run-time code */
 
+%insert(runtime) "builtin.swg";		/* Specialization for classes with single inheritance */

Lib/python/pytypemaps.swg

@@ -96,3 +96,20 @@
 }
 
 
+/* -------------------------------------------------------------
+ * Output typemap for the __init__ method of a built-in type.
+ * ------------------------------------------------------------ */
+
+/* Pointers, references */
+%typemap(builtin_init,noblock=1) SWIGTYPE *, SWIGTYPE &, SWIGTYPE[] {
+  %set_output(SWIG_Python_NewBuiltinObj(self, %as_voidptr($1), $descriptor, $owner | %newpointer_flags));
+}
+
+%typemap(builtin_init, noblock=1) SWIGTYPE *const& {
+  %set_output(SWIG_Python_NewBuiltinObj(self, %as_voidptr(*$1), $*descriptor, $owner | %newpointer_flags));
+}
+
+/* Return by value */
+%typemap(builtin_init, noblock=1) SWIGTYPE {
+  %set_output(SWIG_Python_NewBuiltinObj(self, %new_copy($1, $ltype), $&descriptor, SWIG_POINTER_OWN | %newpointer_flags));
+}