swig,swig-native: add version 1.3.29

4 files changed, 863 insertions, 0 deletions

diff --git a/packages/swig/files/.mtn2git_empty b/packages/swig/files/.mtn2git_empty
new file mode 100644
index 0000000000..e69de29bb2
--- /dev/null
+++ b/packages/swig/files/.mtn2git_empty
diff --git a/packages/swig/files/disable_exceptions.diff b/packages/swig/files/disable_exceptions.diff
new file mode 100644
index 0000000000..dfb8365a01
--- /dev/null
+++ b/packages/swig/files/disable_exceptions.diff
@@ -0,0 +1,839 @@
+diff -Naur swig-1.3.29/Lib/python/pycontainer.swg swig-1.3.29-patched/Lib/python/pycontainer.swg
+--- swig-1.3.29/Lib/python/pycontainer.swg	2006-03-07 01:35:17.000000000 +0100
++++ swig-1.3.29-patched/Lib/python/pycontainer.swg	2005-07-27 22:09:41.000000000 +0200
+@@ -1,184 +1,34 @@
+-/* -----------------------------------------------------------------------------
+- * See the LICENSE file for information on copyright, usage and redistribution
+- * of SWIG, and the README file for authors - http://www.swig.org/release.html.
+- *
+- * pycontainer.swg
+- *
+- * Python sequence <-> C++ container wrapper
+- *
+- * This wrapper, and its iterator, allows a general use (and reuse) of
+- * the the mapping between C++ and Python, thanks to the C++
+- * templates.
+- *
+- * Of course, it needs the C++ compiler to support templates, but
+- * since we will use this wrapper with the STL containers, that should
+- * be the case.
+- * ----------------------------------------------------------------------------- */
+-
++// 
++// Python sequence <-> C++ container wrapper
++// 
++// This wrapper, and its iterator, allows a general use (and reuse) of
++// the the mapping between C++ and Python, thanks to the C++
++// templates.
++//
++// Of course, it needs the C++ compiler to support templates, but
++// since we will use this wrapper with the STL containers, that should
++// be the case.
++//
+ %{
+-#include <iostream>
++#include <iostream>  
+ %}
+ 
+-
+-#if !defined(SWIG_NO_EXPORT_ITERATOR_METHODS)
+-# if !defined(SWIG_EXPORT_ITERATOR_METHODS)
+-#  define SWIG_EXPORT_ITERATOR_METHODS SWIG_EXPORT_ITERATOR_METHODS
+-# endif
+-#endif
+-
+-%include <pyiterators.swg>
+-
+ /**** The PySequence C++ Wrap ***/
+ 
+ %insert(header) %{
++#if PY_VERSION_HEX < 0x02000000
++#define PySequence_Size PySequence_Length
++#endif
+ #include <stdexcept>
+ %}
+ 
+-%include <std_except.i>
+-
+-%fragment(SWIG_Traits_frag(swig::PyObject_ptr),"header",fragment="StdTraits") {
+-namespace swig {
+-  template <>  struct traits<PyObject_ptr > {
+-    typedef value_category category;
+-    static const char* type_name() { return  "PyObject_ptr"; }
+-  };
+-  
+-  template <>  struct traits_from<PyObject_ptr> {
+-    typedef PyObject_ptr value_type;
+-    static PyObject *from(const value_type& val) {
+-      PyObject *obj = static_cast<PyObject *>(val);
+-      Py_XINCREF(obj);
+-      return obj;
+-    }
+-  };
+-  
+-  template <> 
+-  struct traits_check<PyObject_ptr, value_category> {
+-    static bool check(PyObject_ptr) {
+-      return true;
+-    }
+-  };
+-  
+-  template <>  struct traits_asval<PyObject_ptr > {   
+-    typedef PyObject_ptr value_type;
+-    static int asval(PyObject *obj, value_type *val) {
+-      if (val) *val = obj;
+-      return SWIG_OK;
+-    }
+-  };
+-}
+-}
+-
+-%fragment(SWIG_Traits_frag(swig::PyObject_var),"header",fragment="StdTraits") {
+-namespace swig {
+-  template <>  struct traits<PyObject_var > {
+-    typedef value_category category;
+-    static const char* type_name() { return  "PyObject_var"; }
+-  };
+-  
+-  template <>  struct traits_from<PyObject_var> {
+-    typedef PyObject_var value_type;
+-    static PyObject *from(const value_type& val) {
+-      PyObject *obj = static_cast<PyObject *>(val);
+-      Py_XINCREF(obj);
+-      return obj;
+-    }
+-  };
+-  
+-  template <> 
+-  struct traits_check<PyObject_var, value_category> {
+-    static bool check(PyObject_var) {
+-      return true;
+-    }
+-  };
+-  
+-  template <>  struct traits_asval<PyObject_var > {   
+-    typedef PyObject_var value_type;
+-    static int asval(PyObject *obj, value_type *val) {
+-      if (val) *val = obj;
+-      return SWIG_OK;
+-    }
+-  };
+-} 
+-}
+-
+ %fragment("PySequence_Base","header")
+-{
+-%#include <functional>
+-
+-namespace std {
+-  template <>
+-  struct less <PyObject *>: public binary_function<PyObject *, PyObject *, bool>
+-  {
+-    bool
+-    operator()(PyObject * v, PyObject *w) const
+-    { 
+-      bool res;
+-      SWIG_PYTHON_THREAD_BEGIN_BLOCK;
+-      res = PyObject_Compare(v, w) < 0;
+-      SWIG_PYTHON_THREAD_END_BLOCK;
+-      return res;
+-    }
+-  };
+-
+-  template <>
+-  struct less <swig::PyObject_ptr>: public binary_function<swig::PyObject_ptr, swig::PyObject_ptr, bool>
+-  {
+-    bool
+-    operator()(const swig::PyObject_ptr& v, const swig::PyObject_ptr& w) const
+-    {
+-      return std::less<PyObject *>()(v, w);
+-    }
+-  };
+-
+-  template <>
+-  struct less <swig::PyObject_var>: public binary_function<swig::PyObject_var, swig::PyObject_var, bool>
+-  {
+-    bool
+-    operator()(const swig::PyObject_var& v, const swig::PyObject_var& w) const
+-    {
+-      return std::less<PyObject *>()(v, w);
+-    }
+-  };
+-
+-}
+-
+-namespace swig {
+-  template <> struct traits<PyObject *> {
+-    typedef value_category category;
+-    static const char* type_name() { return "PyObject *"; }
+-  };  
+-
+-  template <>  struct traits_asval<PyObject * > {   
+-    typedef PyObject * value_type;
+-    static int asval(PyObject *obj, value_type *val) {
+-      if (val) *val = obj;
+-      return SWIG_OK;
+-    }
+-  };
+-
+-  template <> 
+-  struct traits_check<PyObject *, value_category> {
+-    static bool check(PyObject *) {
+-      return true;
+-    }
+-  };
+-
+-  template <>  struct traits_from<PyObject *> {
+-    typedef PyObject * value_type;
+-    static PyObject *from(const value_type& val) {
+-      Py_XINCREF(val);
+-      return val;
+-    }
+-  };
+-  
+-}
+-
++%{
+ namespace swig {
+   inline size_t
+   check_index(ptrdiff_t i, size_t size, bool insert = false) {
+     if ( i < 0 ) {
+-      if ((size_t) (-i) <= size)
++      if ((size_t) (-i) <= size) 
+ 	return (size_t) (i + size);
+     } else if ( (size_t) i < size ) {
+       return (size_t) i;
+@@ -203,28 +53,28 @@
+   }
+ 
+   template <class Sequence, class Difference>
+-  inline typename Sequence::iterator
++  inline typename Sequence::iterator 
+   getpos(Sequence* self, Difference i)  {
+-    typename Sequence::iterator pos = self->begin();
++    typename Sequence::iterator pos = self->begin(); 
+     std::advance(pos, check_index(i,self->size()));
+     return pos;
+   }
+ 
+   template <class Sequence, class Difference>
+-  inline typename Sequence::const_iterator
++  inline typename Sequence::const_iterator 
+   cgetpos(const Sequence* self, Difference i)  {
+-    typename Sequence::const_iterator pos = self->begin();
++    typename Sequence::const_iterator pos = self->begin(); 
+     std::advance(pos, check_index(i,self->size()));
+     return pos;
+   }
+ 
+   template <class Sequence, class Difference>
+   inline Sequence*
+-  getslice(const Sequence* self, Difference i, Difference j) {
++  getslice(const Sequence* self, Difference i, Difference j) { 
+     typename Sequence::size_type size = self->size();
+     typename Sequence::size_type ii = swig::check_index(i, size);
+     typename Sequence::size_type jj = swig::slice_index(j, size);
+-
++    
+     if (jj > ii) {
+       typename Sequence::const_iterator vb = self->begin();
+       typename Sequence::const_iterator ve = self->begin();
+@@ -243,23 +93,13 @@
+     typename Sequence::size_type ii = swig::check_index(i, size, true);
+     typename Sequence::size_type jj = swig::slice_index(j, size);
+     if (jj < ii) jj = ii;
+-    size_t ssize = jj - ii;
+-    if (ssize <= v.size()) {
+-      typename Sequence::iterator sb = self->begin();
+-      typename InputSeq::const_iterator vmid = v.begin();
+-      std::advance(sb,ii);
+-      std::advance(vmid, jj - ii);
+-      self->insert(std::copy(v.begin(), vmid, sb), vmid, v.end());
+-    } else {
+-      typename Sequence::iterator sb = self->begin();
+-      typename Sequence::iterator se = self->begin();
+-      std::advance(sb,ii);
+-      std::advance(se,jj);
+-      self->erase(sb,se);
+-      self->insert(sb, v.begin(), v.end());
+-    }
++    typename Sequence::iterator sb = self->begin();
++    typename InputSeq::const_iterator vmid = v.begin();
++    std::advance(sb,ii);
++    std::advance(vmid, jj - ii);
++    self->insert(std::copy(v.begin(), vmid, sb), vmid, v.end());
+   }
+-
++ 
+   template <class Sequence, class Difference>
+   inline void
+   delslice(Sequence* self, Difference i, Difference j) {
+@@ -275,64 +115,65 @@
+     }
+   }
+ }
+-}
++%}
+ 
+ %fragment("PySequence_Cont","header",
+ 	  fragment="StdTraits",
+ 	  fragment="PySequence_Base",
+-	  fragment="PySwigIterator_T")
+-{
++	  fragment="PyObject_var")
++%{
++#include <iterator>
+ namespace swig
+ {
+-  template <class T>
++  template <class T> 
+   struct PySequence_Ref
+   {
+-    PySequence_Ref(PyObject* seq, int index)
++    PySequence_Ref(PyObject* seq, int index) 
+       : _seq(seq), _index(index)
+     {
+     }
+-    
+-    operator T () const
++
++    operator T () const 
+     {
+       swig::PyObject_var item = PySequence_GetItem(_seq, _index);
+       try {
+ 	return swig::as<T>(item, true);
+       } catch (std::exception& e) {
+ 	char msg[1024];
+-	sprintf(msg, "in sequence element %d ", _index);
++	PyOS_snprintf(msg, sizeof(msg), "in sequence element %d ", _index);
+ 	if (!PyErr_Occurred()) {
+-	  %type_error(swig::type_name<T>());
++	  SWIG_type_error(swig::type_name<T>(), item);
+ 	}
+-	SWIG_Python_AddErrorMsg(msg);
+-	SWIG_Python_AddErrorMsg(e.what());
++	SWIG_append_errmsg(msg);
++	SWIG_append_errmsg(e.what());
+ 	throw;
+       }
+     }
+-
+-    PySequence_Ref& operator=(const T& v)
++    
++    PySequence_Ref& operator=(const T& v) 
+     {
+       PySequence_SetItem(_seq, _index, swig::from<T>(v));
+       return *this;
+     }
+-
++    
+   private:
+     PyObject* _seq;
+     int _index;
+   };
+ 
+-  template <class T>
+-  struct PySequence_ArrowProxy
++  template <class T> 
++  struct PySequence_ArrowProxy 
+   {
+     PySequence_ArrowProxy(const T& x): m_value(x) {}
+     const T* operator->() const { return &m_value; }
+     operator const T*() const { return &m_value; }
+     T m_value;
+-  };
++  };    
+ 
+-  template <class T, class Reference >
+-  struct PySequence_InputIterator
++  template <class T, class Reference > 
++  struct PySequence_Iter
+   {
+-    typedef PySequence_InputIterator<T, Reference > self;
++    typedef PySequence_Iter<T, Reference > self;
+ 
+     typedef std::random_access_iterator_tag iterator_category;
+     typedef Reference reference;
+@@ -340,17 +181,17 @@
+     typedef T* pointer;
+     typedef int difference_type;
+ 
+-    PySequence_InputIterator()
++    PySequence_Iter()
+     {
+     }
+ 
+-    PySequence_InputIterator(PyObject* seq, int index)
++    PySequence_Iter(PyObject* seq, int index)
+       : _seq(seq), _index(index)
+     {
+     }
+ 
+     reference operator*() const
+-    {
++    { 
+       return reference(_seq, _index);
+     }
+ 
+@@ -359,19 +200,19 @@
+       return PySequence_ArrowProxy<T>(operator*());
+     }
+ 
+-    bool operator==(const self& ri) const
+-    {
++    bool operator==(const self& ri) const 
++    { 
+       return (_index == ri._index) && (_seq == ri._seq);
+     }
+ 
+-    bool operator!=(const self& ri) const
++    bool operator!=(const self& ri) const 
+     {
+       return !(operator==(ri));
+-    }
++    }    
+ 
+     self& operator ++ ()
+     {
+-      ++_index;
++      ++_index;      
+       return *this;
+     }
+ 
+@@ -381,7 +222,7 @@
+       return *this;
+     }
+ 
+-    self& operator += (difference_type n)
++    self& operator += (difference_type n) 
+     {
+       _index += n;
+       return *this;
+@@ -392,7 +233,7 @@
+       return self(_seq, _index + n);
+     }
+ 
+-    self& operator -= (difference_type n)
++    self& operator -= (difference_type n) 
+     {
+       _index -= n;
+       return *this;
+@@ -401,30 +242,25 @@
+     self operator -(difference_type n) const
+     {
+       return self(_seq, _index - n);
+-    }
++    }    
+ 
+     difference_type operator - (const self& ri) const
+     {
+       return _index - ri._index;
+     }
+ 
+-    bool operator < (const self& ri) const
+-    {
+-      return _index < ri._index;
+-    }
+-
+-    reference
+-    operator[](difference_type n) const
+-    {
++    reference 
++    operator[](difference_type n) const 
++    { 
+       return reference(_seq, _index + n);
+     }
+ 
+   private:
+     PyObject* _seq;
+-    difference_type _index;
+-  };
++    int _index;
++  }; 
+ 
+-  template <class T>
++  template <class T> 
+   struct PySequence_Cont
+   {
+     typedef PySequence_Ref<T> reference;
+@@ -434,8 +270,8 @@
+     typedef int difference_type;
+     typedef int size_type;
+     typedef const pointer const_pointer;
+-    typedef PySequence_InputIterator<T, reference> iterator;
+-    typedef PySequence_InputIterator<T, const_reference> const_iterator;
++    typedef PySequence_Iter<T, reference> iterator;
++    typedef PySequence_Iter<T, const_reference> const_iterator;
+ 
+     PySequence_Cont(PyObject* seq) : _seq(0)
+     {
+@@ -446,7 +282,7 @@
+       Py_INCREF(_seq);
+     }
+ 
+-    ~PySequence_Cont()
++    ~PySequence_Cont() 
+     {
+       if (_seq) Py_DECREF(_seq);
+     }
+@@ -459,7 +295,7 @@
+     bool empty() const
+     {
+       return size() == 0;
+-    }
++    }    
+ 
+     iterator begin()
+     {
+@@ -470,24 +306,24 @@
+     {
+       return const_iterator(_seq, 0);
+     }
+-
++    
+     iterator end()
+     {
+       return iterator(_seq, size());
+     }
+-
++    
+     const_iterator end() const
+     {
+       return const_iterator(_seq, size());
+-    }
++    }    
+ 
+-    reference operator[](difference_type n)
+-    {
++    reference operator[](difference_type n) 
++    { 
+       return reference(_seq, n);
+     }
+ 
+     const_reference operator[](difference_type n)  const
+-    {
++    { 
+       return const_reference(_seq, n);
+     }
+ 
+@@ -499,13 +335,14 @@
+ 	if (!swig::check<value_type>(item)) {
+ 	  if (set_err) {
+ 	    char msg[1024];
+-	    sprintf(msg, "in sequence element %d", i);
+-	    SWIG_Error(SWIG_RuntimeError, msg);
++	    PyOS_snprintf(msg, sizeof(msg), "in sequence element %d", i);
++	    SWIG_type_error(swig::type_name<value_type>(), item);
++	    SWIG_append_errmsg(msg);
+ 	  }
+-	  return false;
++	  return 0;
+ 	}
+       }
+-      return true;
++      return 1;  
+     }
+ 
+   private:
+@@ -513,76 +350,7 @@
+   };
+ 
+ }
+-}
+-
+-%define %swig_sequence_iterator(Sequence...)
+-#if defined(SWIG_EXPORT_ITERATOR_METHODS)
+-  class iterator;
+-  class reverse_iterator;
+-  class const_iterator;
+-  class const_reverse_iterator;
+-
+-  %typemap(out,noblock=1,fragment="PySequence_Cont")
+-    iterator, reverse_iterator, const_iterator, const_reverse_iterator {
+-    $result = SWIG_NewPointerObj(swig::make_output_iterator(%static_cast($1,const $type &)),
+-				 swig::PySwigIterator::descriptor(),SWIG_POINTER_OWN);
+-  }
+-  %typemap(out,noblock=1,fragment="PySequence_Cont")
+-    std::pair<iterator, iterator>, std::pair<const_iterator, const_iterator> {
+-    $result = PyTuple_New(2);
+-    PyTuple_SetItem($result,0,SWIG_NewPointerObj(swig::make_output_iterator(%static_cast($1,const $type &).first),
+-						 swig::PySwigIterator::descriptor(),SWIG_POINTER_OWN));
+-    PyTuple_SetItem($result,1,SWIG_NewPointerObj(swig::make_output_iterator(%static_cast($1,const $type &).second),
+-						 swig::PySwigIterator::descriptor(),SWIG_POINTER_OWN));    
+-  }
+-
+-  %fragment("PyPairBoolOutputIterator","header",fragment=SWIG_From_frag(bool),fragment="PySequence_Cont") {}
+-
+-  %typemap(out,noblock=1,fragment="PyPairBoolOutputIterator")
+-    std::pair<iterator, bool>, std::pair<const_iterator, bool> {
+-    $result = PyTuple_New(2);
+-    PyTuple_SetItem($result,0,SWIG_NewPointerObj(swig::make_output_iterator(%static_cast($1,const $type &).first),
+-					       swig::PySwigIterator::descriptor(),SWIG_POINTER_OWN));    
+-    PyTuple_SetItem($result,1,SWIG_From(bool)(%static_cast($1,const $type &).second));
+-  }
+-
+-  %typemap(in,noblock=1,fragment="PySequence_Cont")
+-    iterator(swig::PySwigIterator *iter = 0, int res),
+-    reverse_iterator(swig::PySwigIterator *iter = 0, int res),
+-    const_iterator(swig::PySwigIterator *iter = 0, int res),
+-    const_reverse_iterator(swig::PySwigIterator *iter = 0, int res) {
+-    res = SWIG_ConvertPtr($input, %as_voidptrptr(&iter), swig::PySwigIterator::descriptor(), 0);
+-    if (!SWIG_IsOK(res) || !iter) {
+-      %argument_fail(SWIG_TypeError, "$type", $symname, $argnum);
+-    } else {
+-      swig::PySwigIterator_T<$type > *iter_t = dynamic_cast<swig::PySwigIterator_T<$type > *>(iter);
+-      if (iter_t) {
+-	$1 = iter_t->get_current();
+-      } else {
+-	%argument_fail(SWIG_TypeError, "$type", $symname, $argnum);
+-      }
+-    }
+-  }
+-
+-  %typecheck(%checkcode(ITERATOR),noblock=1,fragment="PySequence_Cont")
+-    iterator, reverse_iterator, const_iterator, const_reverse_iterator {
+-    swig::PySwigIterator *iter = 0;
+-    int res = SWIG_ConvertPtr($input, %as_voidptrptr(&iter), swig::PySwigIterator::descriptor(), 0);
+-    $1 = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::PySwigIterator_T<$type > *>(iter) != 0));
+-  }
+-
+-  %fragment("PySequence_Cont");
+-
+-  %newobject iterator(PyObject **PYTHON_SELF);
+-  %extend  {
+-    swig::PySwigIterator* iterator(PyObject **PYTHON_SELF) {
+-      return swig::make_output_iterator(self->begin(), self->begin(), self->end(), *PYTHON_SELF);
+-    }
+-
+-    %pythoncode {def __iter__(self): return self.iterator()}
+-  }
+-#endif //SWIG_EXPORT_ITERATOR_METHODS
+-%enddef
++%}
+ 
+ 
+ /**** The python container methods  ****/
+@@ -604,9 +372,7 @@
+ %enddef
+ 
+ %define %swig_sequence_methods_common(Sequence...)
+-  %swig_sequence_iterator(%arg(Sequence))
+-  %swig_container_methods(%arg(Sequence))
+-  
++  %swig_container_methods(SWIG_arg(Sequence))
+   %fragment("PySequence_Base");
+ 
+   %extend {
+@@ -622,8 +388,7 @@
+       return swig::getslice(self, i, j);
+     }
+ 
+-    void __setslice__(difference_type i, difference_type j, const Sequence& v) 
+-      throw (std::out_of_range, std::invalid_argument) {
++    void __setslice__(difference_type i, difference_type j, const Sequence& v) throw (std::out_of_range, std::invalid_argument) {
+       swig::setslice(self, i, j, v);
+     }
+ 
+@@ -638,7 +403,7 @@
+ %enddef
+ 
+ %define %swig_sequence_methods(Sequence...)
+-  %swig_sequence_methods_common(%arg(Sequence))
++  %swig_sequence_methods_common(SWIG_arg(Sequence))
+   %extend {
+     const value_type& __getitem__(difference_type i) const throw (std::out_of_range) {
+       return *(swig::cgetpos(self, i));
+@@ -655,7 +420,7 @@
+ %enddef
+ 
+ %define %swig_sequence_methods_val(Sequence...)
+-  %swig_sequence_methods_common(%arg(Sequence))
++  %swig_sequence_methods_common(SWIG_arg(Sequence))
+   %extend {
+     value_type __getitem__(difference_type i) throw (std::out_of_range) {
+       return *(swig::cgetpos(self, i));
+@@ -672,95 +437,92 @@
+ %enddef
+ 
+ 
+-
+ //
+ // Common fragments
+ //
+ 
+ %fragment("StdSequenceTraits","header",
+-	  fragment="StdTraits",
++	  fragment="StdTraits",fragment="PyObject_var",
+ 	  fragment="PySequence_Cont")
+-{
+-namespace swig {
+-  template <class PySeq, class Seq>
+-  inline void
+-  assign(const PySeq& pyseq, Seq* seq) {
+-%#ifdef SWIG_STD_NOASSIGN_STL
+-    typedef typename PySeq::value_type value_type;
+-    typename PySeq::const_iterator it = pyseq.begin();
+-    for (;it != pyseq.end(); ++it) {
+-      seq->insert(seq->end(),(value_type)(*it));
+-    }
+-%#else
+-    seq->assign(pyseq.begin(), pyseq.end());
+-%#endif
+-  }
+-
+-  template <class Seq, class T = typename Seq::value_type >
+-  struct traits_asptr_stdseq {
+-    typedef Seq sequence;
+-    typedef T value_type;
++%{
++  namespace swig {
++    template <class PySeq, class Seq> 
++    inline void
++    assign(const PySeq& pyseq, Seq* seq) {
++#ifdef SWIG_STD_NOASSIGN_STL
++      typedef typename PySeq::value_type value_type;
++      typename PySeq::const_iterator it = pyseq.begin();
++      for (;it != pyseq.end(); ++it) {
++	seq->insert(seq->end(),(value_type)(*it));
++      }
++#else
++      seq->assign(pyseq.begin(), pyseq.end());
++#endif
++    }
+ 
+-    static int asptr(PyObject *obj, sequence **seq) {
+-      if (PySequence_Check(obj)) {
+-	try {
+-	  PySequence_Cont<value_type> pyseq(obj);
+-	  if (seq) {
+-	    sequence *pseq = new sequence();
+-	    assign(pyseq, pseq);
+-	    *seq = pseq;
+-	    return SWIG_NEWOBJ;
+-	  } else {
+-	    return pyseq.check() ? SWIG_OK : SWIG_ERROR;
+-	  }
+-	} catch (std::exception& e) {
+-	  if (seq) {
+-	    if (!PyErr_Occurred()) {
+-	      PyErr_SetString(PyExc_TypeError, e.what());
++    template <class Seq, class T = typename Seq::value_type >
++    struct traits_asptr_stdseq {
++      typedef Seq sequence;
++      typedef T value_type;
++		    
++      static int asptr(PyObject *obj, sequence **seq) {
++	if (PySequence_Check(obj)) {
++	  try {
++	    PySequence_Cont<value_type> pyseq(obj);
++	    if (seq) {
++	      sequence *pseq = new sequence();
++	      assign(pyseq, pseq);
++	      *seq = pseq;
++	      return SWIG_NEWOBJ;
++	    } else {
++	      return pyseq.check();
++	    }
++	  } catch (std::exception& e) {
++	    if (seq) {
++	      if (!PyErr_Occurred())
++		PyErr_SetString(PyExc_TypeError, e.what());
+ 	    }
++	    return 0;
++	  }
++	} else {
++	  sequence *p;
++	  if (SWIG_ConvertPtr(obj,(void**)&p,
++			      swig::type_info<sequence>(),0) != -1) {
++	    if (seq) *seq = p;
++	    return 1;
+ 	  }
+-	  return SWIG_ERROR;
+ 	}
+-      } else {
+-	sequence *p;
+-	if (SWIG_ConvertPtr(obj,(void**)&p,
+-			    swig::type_info<sequence>(),0) == SWIG_OK) {
+-	  if (seq) *seq = p;
+-	  return SWIG_OLDOBJ;
++	if (seq) {
++	  PyErr_Format(PyExc_TypeError, "a %s is expected", 
++		       swig::type_name<sequence>());
+ 	}
++	return 0;	  
+       }
+-      return SWIG_ERROR;
+-    }
+-  };
++    };
+ 
+-  template <class Seq, class T = typename Seq::value_type >
+-  struct traits_from_stdseq {
+-    typedef Seq sequence;
+-    typedef T value_type;
+-    typedef typename Seq::size_type size_type;
+-    typedef typename sequence::const_iterator const_iterator;
+-
+-    static PyObject *from(const sequence& seq) {
+-#ifdef SWIG_PYTHON_EXTRA_NATIVE_CONTAINERS
+-      swig_type_info *desc = swig::type_info<sequence>();
+-      if (desc && desc->clientdata) {
+-	return SWIG_NewPointerObj(new sequence(seq), desc, SWIG_POINTER_OWN);
+-      }
+-#endif
+-      size_type size = seq.size();
+-      if (size <= (size_type)INT_MAX) {
+-	PyObject *obj = PyTuple_New((int)size);
+-	int i = 0;
+-	for (const_iterator it = seq.begin();
+-	     it != seq.end(); ++it, ++i) {
+-	  PyTuple_SetItem(obj,i,swig::from<value_type>(*it));
++    template <class Seq, class T = typename Seq::value_type >
++    struct traits_from_stdseq {
++      typedef Seq sequence;
++      typedef T value_type;
++      typedef typename Seq::size_type size_type;
++      typedef typename sequence::const_iterator const_iterator;
++
++      static PyObject *from(const sequence& seq) {
++	size_type size = seq.size();
++	if (size <= (size_type)INT_MAX) {
++	  PyObject *obj = PyTuple_New((int)size);
++	  int i = 0;
++	  for (const_iterator it = seq.begin();
++	       it != seq.end(); ++it, ++i) {
++	    PyTuple_SetItem(obj,i,swig::from<value_type>(*it));
++	  }
++	  return obj;
++	} else {
++	  PyErr_SetString(PyExc_OverflowError,
++			  "sequence size not valid in python");
++	  return NULL;
+ 	}
+-	return obj;
+-      } else {
+-	PyErr_SetString(PyExc_OverflowError,"sequence size not valid in python");
+-	return NULL;
+       }
+-    }
+-  };
+-}
+-}
++    };
++  }
++%}
+diff -Naur swig-1.3.29/Lib/swig.swg swig-1.3.29-patched/Lib/swig.swg
+--- swig-1.3.29/Lib/swig.swg	2006-03-02 00:30:36.000000000 +0100
++++ swig-1.3.29-patched/Lib/swig.swg	2006-04-08 11:51:21.000000000 +0200
+@@ -104,9 +104,11 @@
+ #define %noexceptionvar    %feature("exceptvar","0")
+ #define %clearexceptionvar %feature("exceptvar","")
+ 
++#if 0
+ /* the %catches directive */
+ #define %catches(tlist...)    %feature("catches","("`tlist`")")
+ #define %clearcatches         %feature("catches","")
++#endif
+ 
+ /* the %exceptionclass directive */
+ #define %exceptionclass      %feature("exceptionclass")
diff --git a/packages/swig/swig-native_1.3.29.bb b/packages/swig/swig-native_1.3.29.bb
new file mode 100644
index 0000000000..3a5ed61c81
--- /dev/null
+++ b/packages/swig/swig-native_1.3.29.bb
@@ -0,0 +1,7 @@
+include swig_${PV}.bb
+inherit native
+
+do_stage() {
+	oe_runmake install PREFIX=${STAGING_BINDIR}/..
+}
+
diff --git a/packages/swig/swig_1.3.29.bb b/packages/swig/swig_1.3.29.bb
new file mode 100644
index 0000000000..e475994fa2
--- /dev/null
+++ b/packages/swig/swig_1.3.29.bb
@@ -0,0 +1,17 @@
+DESCRIPTION = "SWIG - Simplified Wrapper and Interface Generator"
+HOMEPAGE = "http://swig.sourceforge.net/"
+LICENSE = "BSD"
+SECTION = "devel"
+
+SRC_URI = "${SOURCEFORGE_MIRROR}/swig/swig-${PV}.tar.gz \
+	file://disable_exceptions.diff;patch=1;pnum=1"
+S = "${WORKDIR}/swig-${PV}"
+
+inherit autotools
+
+EXTRA_OECONF = "--with-python=${STAGING_BINDIR} --with-swiglibdir=${STAGING_DIR}/${BUILD_SYS}/swig"
+
+do_configure() {
+	oe_runconf
+}
+