suppress compiler warns and more cosmetics

git-svn-id: https://swig.svn.sourceforge.net/svnroot/swig/trunk@5830 626c5289-ae23-0410-ae9c-e8d60b6d4f22

SWIG/Lib/python/pycontainer.i

@@ -19,8 +19,104 @@
 #endif
 %}
 
+%fragment("PySequence_Base","header")
+%{
+namespace swigpy {
+  inline size_t
+  sequence_index(ptrdiff_t i, size_t size) {
+    if ( i < 0 ) {
+      if ((size_t) (-i) <= size) return (size_t) (i + size);
+    } else if ( (size_t) i < size ) {
+      return (size_t) i;
+    }
+    throw std::out_of_range("index out of range");
+  }
+
+  inline size_t
+  slice_index(ptrdiff_t i, size_t size) {
+    if ( i < 0 ) {
+      return ((size_t) (-i) <= size) ? (size_t) (i + size) : 0;
+    } else {
+      return ( (size_t) i < size ) ? ((size_t) i) 
+	: (size ? (size_t)(size - 1) : 0);
+    }
+  }
+
+  template <class Sequence, class Difference>
+  inline Sequence*
+  getslice(const Sequence* self, Difference i, Difference j) { 
+    typename Sequence::size_type size = self->size();
+    typename Sequence::size_type ii = swigpy::slice_index(i, size);
+    typename Sequence::size_type jj = swigpy::slice_index(j, size);
+    if (jj > ii) {
+      typename Sequence::const_iterator beg = self->begin(); 
+      std::advance(beg, ii);
+      typename Sequence::const_iterator end = self->begin();
+      std::advance(end, jj);
+      return new Sequence(beg, end);
+    } else {
+      return new Sequence();
+    }
+  }
+
+  template <class Sequence, class Difference, class InputSeq>
+  inline void
+  setslice(Sequence* self, Difference i, Difference j, const InputSeq& v) {
+    typename Sequence::size_type size = self->size();
+    typename Sequence::size_type ii = swigpy::slice_index(i, size);
+    typename Sequence::size_type jj = swigpy::slice_index(j, size);
+    if (jj < ii) jj = ii;
+    typename Sequence::iterator beg = self->begin();
+    std::advance(beg,ii);
+    typename InputSeq::const_iterator vmid = v.begin();
+    std::advance(vmid, jj - ii);
+    self->insert(std::copy(v.begin(), vmid, beg), vmid, v.end());
+  }
+ 
+  template <class Sequence, class Difference>
+  inline void
+  delslice(Sequence* self, Difference i, Difference j) {
+    typename Sequence::size_type size = self->size();
+    typename Sequence::size_type ii = swigpy::slice_index(i, size);
+    typename Sequence::size_type jj = swigpy::slice_index(j, size);
+    if (jj > ii) {
+      typename Sequence::iterator beg = self->begin();
+      std::advance(beg, ii);
+      typename Sequence::iterator end = self->begin();
+      std::advance(end, jj);
+      self->erase(beg, end);
+    }
+  }
+
+  template <class Sequence, class Difference>
+  inline void
+  delitem(Sequence* self, Difference i) {
+    typename Sequence::iterator pos = self->begin();
+    std::advance(pos, swigpy::sequence_index(i, self->size()));
+    self->erase(pos);
+  }
+
+  template <class Sequence, class Difference>
+  inline const typename Sequence::value_type& 
+  getitem(const Sequence* self, Difference i)  {
+    typename Sequence::const_iterator pos = self->begin(); 
+    std::advance(pos, swigpy::sequence_index(i, self->size()));
+    return *(pos);
+  }
+
+  template <class Sequence, class Difference, class Value>
+  inline void
+  setitem(Sequence* self, Difference i, const Value& x) {
+    typename Sequence::iterator pos = self->begin();
+    std::advance(pos, swigpy::sequence_index(i, self->size()));
+    *(pos) = x;
+  }
+}
+%}
+
 %fragment("PySequence_Cont","header",
 	  fragment="StdTraits",
+	  fragment="PySequence_Base",
 	  fragment="PyObject_var")
 %{
 #include <iterator>
@@ -243,8 +339,8 @@ namespace swigpy
   private:
     PyObject* _seq;
   };
-}
 
+}
 %}
 
 
@@ -304,6 +400,7 @@ namespace swigpy
 
 %define %pysequence_methods_common(Sequence)
   %pycontainer_methods(SWIG_arg(Sequence))
+  %fragment("PySequence_Base");
 
   %extend {
     value_type pop() {
@@ -314,90 +411,33 @@ namespace swigpy
       return x;
     }
 
-    Sequence* __getslice__(difference_type i, difference_type j) const {
+    Sequence* __getslice__(difference_type i, difference_type j) {
-      Sequence::size_type size = self->size();
+      return swigpy::getslice(self, i, j);
-      if (i<0) i +=size;
-      if (j<0) j +=size;
-      if (i<0) i = 0;
-      if (j>size) j = size;
-      Sequence::const_iterator beg = self->begin();
-      Sequence::const_iterator end = self->begin();
-      std::advance(beg,i);
-      std::advance(end,j);
-      Sequence *tmp = new Sequence(beg,end);
-      return tmp;
     }
 
-    void __setslice__(difference_type i, difference_type j,
+    void __setslice__(difference_type i, difference_type j, const Sequence& v) {
-		      const Sequence& v) {
+      swigpy::setslice(self, i, j, v);
-      Sequence::size_type size = self->size();
-      if (i<0) i += size;
-      if (i<0) i = 0;
-      j = i + v.size();
-      Sequence::iterator beg = self->begin();
-      std::advance(beg,i);
-
-      Sequence::const_iterator vmid = v.begin();      
-      std::advance(vmid, ((j > size ? size : j) - i));
-
-      self->insert(std::copy(v.begin(), vmid, beg),vmid, v.end());
-    }
-
-    void __delitem__(difference_type i) {
-      Sequence::size_type size = self->size();
-      if (i<0) i+= size;
-      if (i>=0 && i<size) {
-	Sequence::iterator pos = self->begin();
-	std::advance(pos,i);
-	self->erase(pos);
-      }
-      
-      else
-	throw std::out_of_range("index out of range");
     }
 
     void __delslice__(difference_type i, difference_type j) {
-      Sequence::size_type size = self->size();
+      swigpy::delslice(self, i, j);
-      if (i<0) i +=size;
-      if (j<0) j +=size;
-      if (i<0) i = 0;
-      if (j>size) j = size;
-      Sequence::iterator beg = self->begin();
-      Sequence::iterator end = self->begin();
-      std::advance(beg, i);
-      std::advance(end, j);
-      self->erase(beg, end);
     }
 
+    void __delitem__(difference_type i) {
+      swigpy::delitem(self,i);
+    }
   }
 %enddef
 
 %define %pysequence_methods(Sequence)
   %pysequence_methods_common(SWIG_arg(Sequence))
   %extend {
-
     const value_type& __getitem__(difference_type i) const {
-      Sequence::size_type size = self->size();
+      return swigpy::getitem(self, i);
-      if (i<0) i += size;
-      if (i>=0 && i<size) {
-	Sequence::const_iterator pos = self->begin();
-	std::advance(pos, i);	
-	return *(pos);
-      } else {
-	throw std::out_of_range("index out of range");
-      }
     }
 
     void __setitem__(difference_type i, const value_type& x) {
-      Sequence::size_type size = self->size();
+      swigpy::setitem(self, i, x);
-      if (i<0) i+= size;
-      if (i>=0 && i<size) {
-	Sequence::iterator pos = self->begin();
-	std::advance(pos, i);	
-	*(pos) = x;
-      } else {
-	throw std::out_of_range("index out of range");
-      }
     }
 
     void append(const value_type& x) {
@@ -410,45 +450,16 @@ namespace swigpy
   %pysequence_methods_common(SWIG_arg(Sequence))
   %extend {
     value_type __getitem__(difference_type i)  {
-      Sequence::size_type size = self->size();
+      return swigpy::getitem(self, i);
-      if (i<0) i += size;
-      if (i>=0 && i<size) {
-	Sequence::iterator pos = self->begin();
-	std::advance(pos, i);	
-	return *(pos);
-      } else {
-	throw std::out_of_range("index out of range");
-      }
-    }
-
-    value_type __getitem__(difference_type i) const {
-      Sequence::size_type size = self->size();
-      if (i<0) i += size;
-      if (i>=0 && i<size) {
-	Sequence::const_iterator pos = self->begin();
-	std::advance(pos, i);	
-	return *(pos);
-      } else {
-	throw std::out_of_range("index out of range");
-      }
     }
 
     void __setitem__(difference_type i, value_type x) {
-      Sequence::size_type size = self->size();
+      swigpy::setitem(self, i, x);
-      if (i<0) i+= size;
-      if (i>=0 && i<size) {
-	Sequence::iterator pos = self->begin();
-	std::advance(pos, i);	
-	*(pos) = x;
-      } else {
-	throw std::out_of_range("index out of range");
-      }
     }
 
     void append(value_type x) {
       self->push_back(x);
     }
-
  }
 %enddef
 
@@ -491,7 +502,6 @@ namespace swigpy
 	Py_INCREF(Py_None);
 	return Py_None;
       }
-      
       PyObject* keyList = PyList_New(pysize);
       Dict::const_iterator i = self->begin();
       for (int j = 0; j < pysize; ++i, ++j) {
@@ -509,7 +519,6 @@ namespace swigpy
 	Py_INCREF(Py_None);
 	return Py_None;
       }
-      
       PyObject* valList = PyTuple_New(pysize);
       Dict::const_iterator i = self->begin();
       for (int j = 0; j < pysize; ++i, ++j) {
@@ -540,7 +549,6 @@ namespace swigpy
       return self->find(key) != self->end();
     }
 
-
     PyObject* __iter__() {
       Dict::size_type size = self->size();
       int pysize = size <= INT_MAX ? (int) size : 0;
@@ -550,7 +558,6 @@ namespace swigpy
 	Py_INCREF(Py_None);
 	return Py_None;
       }
-      
       PyObject* keyList = PyList_New(pysize);
       Dict::const_iterator i = self->begin();
       for (int j = 0; j < pysize; ++i, ++j) {

SWIG/Lib/python/pyprimtypes.swg

@@ -313,7 +313,7 @@ SWIGSTATICINLINE(int)
     PyErr_Clear();
   }
   if (val) {
-    PyErr_SetString(PyExc_TypeError, "a int is expected");
+    PyErr_SetString(PyExc_TypeError, "an int is expected");
   }
   return 0;    
 }
@@ -331,7 +331,7 @@ SWIGSTATICINLINE(int)
 	  fragment=SWIG_AsVal_frag(unsigned long)) {
 %#if UINT_MAX != ULONG_MAX
 SWIGSTATICINLINE(int)
-SWIG_AsVal(unsigned int)(PyObject *obj, unsigned int *val)
+  SWIG_AsVal(unsigned int)(PyObject *obj, unsigned int *val)
 { 
   const char* errmsg = val ? "unsigned int" : 0;
   unsigned long v;
@@ -420,7 +420,6 @@ SWIGSTATICINLINE(int)
 
 %fragment("SWIG_CheckDoubleInRange","header") {
 %#include <float.h>
-
 SWIGSTATICINLINE(int)
   SWIG_CheckDoubleInRange(double value, double min_value, 
 			  double max_value, const char* errmsg)

SWIG/Lib/python/std_common.i

@@ -1,3 +1,13 @@
+//
+// Use the following macro with modern STL implementations
+//
+//#define SWIG_STD_MODERN_STL
+//
+// Use this to deactive the previous definition, when using gcc-2.95
+// or similar old compilers.
+//
+//#define SWIG_STD_NOMODERN_STL
+
 //
 // Define or uncomment the following macro to instantiate by default
 // all the basic std typemaps (std::pair<T,U>, std::vector<T>, etc)
@@ -43,25 +53,12 @@
 
 %fragment("PyObject_var","header") 
 %{
-  namespace swigpy 
+  namespace swigpy {
-  {
+    struct PyObject_var {
-    struct PyObject_var 
-    {
       PyObject* ptr;
-      PyObject_var(PyObject* obj = 0)
+      PyObject_var(PyObject* obj = 0) : ptr(obj) { }      
-	: ptr(obj)
+      ~PyObject_var() { if (ptr) Py_DECREF(ptr); }      
-      {
+      operator PyObject*() { return ptr; }
-      }
-      
-      ~PyObject_var()
-      {
-	if (ptr) Py_DECREF(ptr);
-      }
-      
-      operator PyObject*() 
-      {
-	return ptr;
-      }
     };
   }
 %}
@@ -69,22 +66,16 @@
 %fragment("StdTraits","header") 
 %{
 namespace swigpy {  
+  /*
+    type categories
+  */
+  struct pointer_category { };  
+  struct value_category { };
+
   /*
     General traits that provides type_name and type_info
   */
-  template <class Type> struct traits
+  template <class Type> struct traits { };
-  {
-  };
-  /*
-    type category
-  */
-  struct pointer_category
-  {
-  };
-  
-  struct value_category
-  {
-  };
 
   template <class Type>
   inline const char* type_name() {
@@ -92,13 +83,11 @@ namespace swigpy {
   }
 
   template <class Type> 
-  struct traits_info
+  struct traits_info {
-  {
     static swig_type_info *type_query(std::string name) {
       name += " *";
       return SWIG_TypeQuery(name.c_str());
     }    
-    
     static swig_type_info *type_info() {
       static swig_type_info *info = type_query(type_name<Type>());
       return info;
@@ -110,6 +99,22 @@ namespace swigpy {
     return traits_info<Type>::type_info();
   }
 
+  /*
+    Partial specialization for pointers
+  */
+  template <class Type> struct traits <Type *> {
+    typedef pointer_category category;
+    static std::string make_ptr_name(const char* name) {
+      std::string ptrname = name;
+      ptrname += " *";
+      return ptrname;
+    }    
+    static const char* type_name() {
+      static std::string name = make_ptr_name(swigpy::type_name<Type>());
+      return name.c_str();
+    }
+  };
+
   /*
     Traits that provides the from method
   */
@@ -166,21 +171,17 @@ namespace swigpy {
   }
 
   template <class Type>
-  struct noconst_traits 
+  struct noconst_traits {
-  {
-    typedef Type noconst_type;
-  };
-  
-
-  template <class Type>
-  struct noconst_traits<const Type>
-  {
     typedef Type noconst_type;
   };
 
   template <class Type>
-  struct traits_asval
+  struct noconst_traits<const Type> {
-  {
+    typedef Type noconst_type;
+  };
+  
+  template <class Type> 
+  struct traits_asval {
     static bool asval(PyObject *obj, Type *val) {
       if (val) {
 	Type *p = 0;
@@ -199,9 +200,7 @@ namespace swigpy {
     }
   };
 
-
+  template <class Type> struct traits_asval<Type*> {
-  template <class Type> struct traits_asval<Type*>
-  {
     static bool asval(PyObject *obj, Type **val) {
       if (val) {
 	Type *p = 0;
@@ -219,20 +218,16 @@ namespace swigpy {
     }
   };
   
-  
   template <class Type>
   inline bool asval(PyObject *obj, Type *val) {
     return traits_asval<Type>::asval(obj, val);
   }
 
   template <class Type, class Category> 
-  struct traits_as
+  struct traits_as { };
-  {
-  };
 
   template <class Type> 
-  struct traits_as<Type, value_category>
+  struct traits_as<Type, value_category> {
-  {
     static Type as(PyObject *obj, bool throw_error) {
       Type v;
       if (!obj || !asval(obj, &v)) {
@@ -249,8 +244,7 @@ namespace swigpy {
   };
 
   template <class Type> 
-  struct traits_as<Type, pointer_category>
+  struct traits_as<Type, pointer_category> {
-  {
     static Type as(PyObject *obj, bool throw_error) {
       Type *v = 0;
       int res = (obj ? asptr(obj, &v) : 0) && v;
@@ -283,21 +277,17 @@ namespace swigpy {
   }
 
   template <class Type, class Category> 
-  struct traits_check
+  struct traits_check { };
-  {
-  };
 
   template <class Type> 
-  struct traits_check<Type, value_category>
+  struct traits_check<Type, value_category> {
-  {
     static bool check(PyObject *obj) {
       return obj && asval(obj, (Type *)(0));
     }
   };
 
   template <class Type> 
-  struct traits_check<Type, pointer_category>
+  struct traits_check<Type, pointer_category> {
-  {
     static bool check(PyObject *obj) {
       return obj && asptr(obj, (Type **)(0));
     }
@@ -307,26 +297,6 @@ namespace swigpy {
   inline bool check(PyObject *obj) {
     return traits_check<Type, typename traits<Type>::category>::check(obj);
   }
-
-  /*
-    Partial specialization for pointers
-  */
-  template <class Type> struct traits <Type *> {
-    typedef pointer_category category;
-
-    static std::string make_ptr_name(const char* name) 
-    {
-      std::string ptrname = name;
-      ptrname += " *";
-      return ptrname;
-    }
-    
-    static const char* type_name() 
-    {
-      static std::string name = make_ptr_name(swigpy::type_name<Type>());
-      return name.c_str();
-    }
-  };
 }
 %}
 
@@ -356,27 +326,25 @@ namespace swigpy {
 	    fragment=SWIG_AsVal_frag(__VA_ARGS__),
 	    fragment=SWIG_From_frag(__VA_ARGS__),
 	    fragment="StdTraits") {
-  namespace swigpy {
+namespace swigpy {
   template <> struct traits<__VA_ARGS__ > {
     typedef value_category category;
     static const char* type_name() { return  #__VA_ARGS__; }
   };  
-    
   template <>  struct traits_asval<__VA_ARGS__ > {   
     typedef __VA_ARGS__ value_type;
     static int asval(PyObject *obj, value_type *val) { 
       return SWIG_AsVal(__VA_ARGS__)(obj, val);
     }
   };
-    
   template <>  struct traits_from<__VA_ARGS__ > {
     typedef __VA_ARGS__ value_type;
     static PyObject *from(const value_type& val) {
       return SWIG_From(__VA_ARGS__)(val);
     }
   };
-  }
+}
- }
+}
 %enddef
 
 %apply_cpptypes(%traits_ptypen);
@@ -513,7 +481,6 @@ namespace swigpy {
 %swig_order_type(double);
 %swig_order_type(char);
 
-
 //
 // Backward compatibility
 //

SWIG/Lib/python/std_container.i

@@ -103,7 +103,8 @@
 %{
   namespace swigpy {
     template <class PySeq, class Seq> 
-    void assign(const PySeq& pyseq, Seq* seq) {
+    inline void
+    assign(const PySeq& pyseq, Seq* seq) {
       seq->assign(pyseq.begin(), pyseq.end());
     }
 

SWIG/Lib/python/std_map.i

@@ -85,7 +85,8 @@
 {
   namespace swigpy {
     template <class PySeq, class K, class T >
-    void assign(const PySeq& pyseq, std::map<K,T > *map) {
+    inline void
+    assign(const PySeq& pyseq, std::map<K,T > *map) {
       typedef typename std::map<K,T>::value_type value_type;
       typename PySeq::const_iterator it = pyseq.begin();
       for (;it != pyseq.end(); ++it) {

SWIG/Lib/python/std_vector.i

@@ -73,6 +73,10 @@
 
 // exported classes
 
+#if !defined(SWIG_STD_MODERN_STL) || defined(SWIG_STD_NOMODERN_STL) 
+%ignore std::vector<bool>::flip();
+#endif
+
 namespace std {
 
   template<class T > class vector {