Enable detection of c++11. Replace throw() with noexcept.

Author: msharov

bktrace.cc

@@ -16,7 +16,7 @@
 namespace ustl {
 
 /// Default constructor. The backtrace is obtained here.
-CBacktrace::CBacktrace (void) throw()
+CBacktrace::CBacktrace (void) noexcept
 : m_Symbols (NULL),
   m_nFrames (0),
   m_SymbolsSize (0)
@@ -26,7 +26,7 @@ CBacktrace::CBacktrace (void) throw()
 }
 
 /// Copy constructor.
-CBacktrace::CBacktrace (const CBacktrace& v) throw()
+CBacktrace::CBacktrace (const CBacktrace& v) noexcept
 : m_Symbols (NULL),
   m_nFrames (0),
   m_SymbolsSize (0)
@@ -35,7 +35,7 @@ CBacktrace::CBacktrace (const CBacktrace& v) throw()
 }
 
 /// Copy operator.
-const CBacktrace& CBacktrace::operator= (const CBacktrace& v) throw()
+const CBacktrace& CBacktrace::operator= (const CBacktrace& v) noexcept
 {
     memcpy (m_Addresses, v.m_Addresses, sizeof(m_Addresses));
     m_Symbols = strdup (v.m_Symbols);
@@ -45,7 +45,7 @@ const CBacktrace& CBacktrace::operator= (const CBacktrace& v) throw()
 }
 
 /// Converts a string returned by backtrace_symbols into readable form.
-static size_t ExtractAbiName (const char* isym, char* nmbuf) throw()
+static size_t ExtractAbiName (const char* isym, char* nmbuf) noexcept
 {
     // Prepare the demangled name, if possible
     size_t nmSize = 0;
@@ -68,7 +68,7 @@ static size_t ExtractAbiName (const char* isym, char* nmbuf) throw()
 }
 
 /// Tries to get symbol information for the addresses.
-void CBacktrace::GetSymbols (void) throw()
+void CBacktrace::GetSymbols (void) noexcept
 {
     char** symbols = backtrace_symbols (m_Addresses, m_nFrames);
     if (!symbols)

bktrace.h

@@ -28,16 +28,16 @@ class ostream;
 ///
 class CBacktrace {
 public:
-			CBacktrace (void) throw();
-			CBacktrace (const CBacktrace& v) throw();
-    inline		~CBacktrace (void) throw()	{ if (m_Symbols) free (m_Symbols); }
-    const CBacktrace&	operator= (const CBacktrace& v) throw();
+			CBacktrace (void) noexcept;
+			CBacktrace (const CBacktrace& v) noexcept;
+    inline		~CBacktrace (void) noexcept	{ if (m_Symbols) free (m_Symbols); }
+    const CBacktrace&	operator= (const CBacktrace& v) noexcept;
     void		text_write (ostringstream& os) const;
     void		read (istream& is);
     void		write (ostream& os) const;
     size_t		stream_size (void) const;
 private:
-    void		GetSymbols (void) throw() DLL_LOCAL;
+    void		GetSymbols (void) noexcept DLL_LOCAL;
 private:
     void*		m_Addresses [64];	///< Addresses of each function on the stack.
     char*		m_Symbols;		///< Symbols corresponding to each address.

cmemlink.h

@@ -53,12 +53,12 @@ class cmemlink {
     inline		cmemlink (void)				: m_Data (NULL), m_Size (0) { }
     inline		cmemlink (const void* p, size_type n)	: m_Data (const_pointer(p)), m_Size (n) { assert (p || !n); }
     inline		cmemlink (const cmemlink& l)		: m_Data (l.m_Data), m_Size (l.m_Size) {}
-    inline virtual     ~cmemlink (void) throw()			{}
+    inline virtual     ~cmemlink (void) noexcept			{}
     void		link (const void* p, size_type n);
     inline void		link (const cmemlink& l)	{ link (l.begin(), l.size()); }
     inline void		link (const void* first, const void* last)	{ link (first, distance (first, last)); }
     inline void		relink (const void* p, size_type n);
-    virtual void	unlink (void) throw()		{ m_Data = NULL; m_Size = 0; }
+    virtual void	unlink (void) noexcept		{ m_Data = NULL; m_Size = 0; }
     inline rcself_t	operator= (const cmemlink& l)	{ link (l); return (*this); }
     bool		operator== (const cmemlink& l) const;
     inline void		swap (cmemlink& l)		{ ::ustl::swap (m_Data, l.m_Data); ::ustl::swap (m_Size, l.m_Size); }

config.h.in

@@ -20,7 +20,7 @@
 ///
 #define WANT_STREAM_BOUNDS_CHECKING 1
 
-#if !defined(WANT_STREAM_BOUNDS_CHECKING) && !defined(NDEBUG)
+#if !WANT_STREAM_BOUNDS_CHECKING && !defined(NDEBUG)
     #define WANT_STREAM_BOUNDS_CHECKING 1
 #endif
 
@@ -30,7 +30,7 @@
 /// even more). By default only the debug build does this.
 #undef WANT_NAME_DEMANGLING
 
-#if !defined(WANT_NAME_DEMANGLING) && !defined(NDEBUG)
+#if !WANT_NAME_DEMANGLING && !defined(NDEBUG)
     #define WANT_NAME_DEMANGLING 1
 #endif
 
@@ -47,7 +47,7 @@
 	#define __attribute__(p)
     #endif
 #endif
-#if defined(__GNUC__) && __GNUC__ >= 4
+#if __GNUC__ >= 4
     #define DLL_EXPORT		__attribute__((visibility("default")))
     #define DLL_LOCAL		__attribute__((visibility("hidden")))
     #define INLINE		__attribute__((always_inline))
@@ -56,13 +56,19 @@
     #define DLL_LOCAL
     #define INLINE
 #endif
-#if defined(__GNUC__) && __GNUC__ >= 3 && (__i386__ || __x86_64__)
+#if __cplusplus >= 201103L && (!__GNUC__ || __GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6))
+    #define HAVE_CPP11 1
+#endif
+#if !HAVE_CPP11
+    #define noexcept		throw()
+#endif
+#if __GNUC__ >= 3 && (__i386__ || __x86_64__)
     /// GCC 3+ supports the prefetch directive, which some CPUs use to improve caching
     #define prefetch(p,rw,loc)	__builtin_prefetch(p,rw,loc)
 #else
     #define prefetch(p,rw,loc)
 #endif
-#if !defined(__GNUC__) || __GNUC__ < 3
+#if __GNUC__ < 3
     /// __alignof__ returns the recommended alignment for the type
     #define __alignof__(v)	min(sizeof(v), sizeof(void*))
     /// This macro returns 1 if the value of x is known at compile time.
@@ -168,19 +174,16 @@
 #undef HAVE_RINTF
 
 // STDC_HEADERS is defined to 1 on sane systems.
-#if defined(HAVE_ASSERT_H) && defined(HAVE_CTYPE_H) &&\
-    defined(HAVE_ERRNO_H) && defined(HAVE_FLOAT_H) &&\
-    defined(HAVE_LIMITS_H) && defined(HAVE_LOCALE_H) &&\
-    defined(HAVE_MATH_H) && defined(HAVE_SIGNAL_H) &&\
-    defined(HAVE_STDARG_H) && defined(HAVE_STDDEF_H) &&\
-    defined(HAVE_STDIO_H) && defined(HAVE_STDLIB_H) &&\
-    defined(HAVE_STRING_H) && defined(HAVE_TIME_H)
-#define STDC_HEADERS 1
+#if HAVE_ASSERT_H && HAVE_CTYPE_H  && HAVE_ERRNO_H && HAVE_FLOAT_H &&\
+    HAVE_LIMITS_H && HAVE_LOCALE_H && HAVE_MATH_H  && HAVE_SIGNAL_H &&\
+    HAVE_STDARG_H && HAVE_STDDEF_H && HAVE_STDIO_H && HAVE_STDLIB_H &&\
+    HAVE_STRING_H && HAVE_TIME_H
+    #define STDC_HEADERS 1
 #endif
 
 // STDC_HEADERS is defined to 1 on unix systems.
-#if defined(HAVE_FCNTL_H) && defined(HAVE_SYS_STAT_H) && defined(HAVE_UNISTD_H)
-#define STDUNIX_HEADERS 1
+#if HAVE_FCNTL_H && HAVE_SYS_STAT_H && HAVE_UNISTD_H
+    #define STDUNIX_HEADERS 1
 #endif
 
 // Define to 1 if your compiler treats char as a separate type along with
@@ -237,11 +240,11 @@
 #endif
 
 // GCC vector extensions
-#if (defined(CPU_HAS_MMX) || defined(CPU_HAS_SSE)) && __GNUC__ >= 3
+#if (CPU_HAS_MMX || CPU_HAS_SSE) && __GNUC__ >= 3
     #undef HAVE_VECTOR_EXTENSIONS
 #endif
 
-#if CPU_HAS_SSE && defined(__GNUC__)
+#if CPU_HAS_SSE && __GNUC__
     #define __sse_align	__attribute__((aligned(16)))
 #else
     #define __sse_align	

configure

@@ -230,6 +230,9 @@ int main (void)
 	    printf (SET(CPU_HAS_%s,1), s_CpuCaps[i].name);
 #if __GNUC__ >= 3
     printf ("s/ \\?@PROCESSOR_OPTS@/");
+    #if __GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6)
+	printf (" -std=c++11");
+    #endif
     if (caps & (1<<23))
 	printf (" -mmmx");
     if (caps & ((1<<22)|(1<<25)))

fstream.cc

@@ -45,7 +45,7 @@ fstream::fstream (int nfd, const char* filename)
 }
 
 /// Destructor. Closes if still open, but without throwing.
-fstream::~fstream (void) throw()
+fstream::~fstream (void) noexcept
 {
     clear (goodbit);
     exceptions (goodbit);

fstream.h

@@ -27,7 +27,7 @@ class fstream : public ios_base {
 			fstream (void);
     explicit		fstream (const char* filename, openmode mode = in | out);
     explicit		fstream (int nfd, const char* filename = "");
-		       ~fstream (void) throw();
+		       ~fstream (void) noexcept;
     void		open (const char* filename, openmode mode, mode_t perms = 0644);
     void		attach (int nfd, const char* filename = "");
     void		detach (void);

memblock.cc

@@ -18,9 +18,9 @@ memblock::memblock (size_type n)		: memlink (), m_Capacity (0) { resize (n); }
 memblock::memblock (const cmemlink& b)		: memlink (), m_Capacity (0) { assign (b); }
 memblock::memblock (const memlink& b)		: memlink (), m_Capacity (0) { assign (b); }
 memblock::memblock (const memblock& b)		: memlink (), m_Capacity (0) { assign (b); }
-memblock::~memblock (void) throw()		{ deallocate(); }
+memblock::~memblock (void) noexcept		{ deallocate(); }
 
-void memblock::unlink (void) throw()
+void memblock::unlink (void) noexcept
 {
     m_Capacity = 0;
     memlink::unlink();
@@ -35,7 +35,7 @@ void memblock::resize (size_type newSize, bool bExact)
 }
 
 /// Frees internal data.
-void memblock::deallocate (void) throw()
+void memblock::deallocate (void) noexcept
 {
     if (m_Capacity) {
 	assert (cdata() && "Internal error: space allocated, but the pointer is NULL");
@@ -147,6 +147,6 @@ void memblock::read_file (const char* filename)
     resize (fsize);
 }
 
-memblock::size_type memblock::minimumFreeCapacity (void) const throw() { return (0); }
+memblock::size_type memblock::minimumFreeCapacity (void) const noexcept { return (0); }
 
 } // namespace ustl

memblock.h

@@ -28,8 +28,8 @@ class memblock : public memlink {
     explicit			memblock (const cmemlink& b);
     explicit			memblock (const memlink& b);
 				memblock (const memblock& b);
-    virtual			~memblock (void) throw();
-    virtual void		unlink (void) throw();
+    virtual			~memblock (void) noexcept;
+    virtual void		unlink (void) noexcept;
     inline void			assign (const cmemlink& l)	{ assign (l.cdata(), l.readable_size()); }
     inline const memblock&	operator= (const cmemlink& l)	{ assign (l); return (*this); }
     inline const memblock&	operator= (const memlink& l)	{ assign (l); return (*this); }
@@ -45,13 +45,13 @@ class memblock : public memlink {
     inline bool			is_linked (void) const		{ return (!capacity()); }
     inline size_type		max_size (void) const		{ return (is_linked() ? memlink::max_size() : SIZE_MAX); }
     inline void			manage (memlink& l)		{ manage (l.begin(), l.size()); }
-    void			deallocate (void) throw();
+    void			deallocate (void) noexcept;
     void			manage (void* p, size_type n);
     void			copy_link (void);
     void			read (istream& is);
     void			read_file (const char* filename);
 protected:
-    virtual size_type		minimumFreeCapacity (void) const throw() __attribute__((const));
+    virtual size_type		minimumFreeCapacity (void) const noexcept __attribute__((const));
 private:
     size_type			m_Capacity;	///< Number of bytes allocated by Resize.
 };

mistream.cc

@@ -28,8 +28,8 @@ istream::istream (const ostream& source)
 {
 }
 
-void istream::unlink (void) throw()			{ cmemlink::unlink(); m_Pos = 0; }
-void ostream::unlink (void) throw()		{ memlink::unlink(); m_Pos = 0; }
+void istream::unlink (void) noexcept			{ cmemlink::unlink(); m_Pos = 0; }
+void ostream::unlink (void) noexcept		{ memlink::unlink(); m_Pos = 0; }
 
 /// Writes all unread bytes into \p os.
 void istream::write (ostream& os) const