Changeset 402

Timestamp:

06/13/15 21:51:27 (10 years ago)

Author:

epyon

Message:

• cleanups of clang warnings (gotta love them all)
• only nv-core for now (this will take a while for the whole source)
• mainly C++ casts instead of C-style casts, but also a few bugs fixed!

Location:

trunk

Files:

• nv/base/assert.hh (modified) (1 diff)
• nv/base/capi.hh (modified) (2 diffs)
• nv/base/common.hh (modified) (4 diffs)
• nv/base/rtti_support.hh (modified) (2 diffs)
• nv/core/library.hh (modified) (1 diff)
• nv/core/logging.hh (modified) (2 diffs)
• nv/stl/algorithm/fill.hh (modified) (2 diffs)
• nv/stl/algorithm/raw.hh (modified) (8 diffs)
• nv/stl/container/hash_table.hh (modified) (6 diffs)
• nv/stl/container/hash_table_policy.hh (modified) (1 diff)
• nv/stl/functional/hash.hh (modified) (3 diffs)
• nv/stl/limits.hh (modified) (1 diff)
• nv/stl/memory.hh (modified) (6 diffs)
• nv/stl/string.hh (modified) (11 diffs)
• nv/stl/type_traits.hh (modified) (1 diff)
• nv/stl/type_traits/common.hh (modified) (1 diff)
• nv/stl/type_traits/function.hh (modified) (3 diffs)
• nv/stl/type_traits/primary.hh (modified) (1 diff)
• nv/stl/type_traits/properties.hh (modified) (2 diffs)
• src/core/library.cc (modified) (6 diffs)
• src/core/logger.cc (modified) (5 diffs)
• src/core/profiler.cc (modified) (1 diff)
• src/core/random.cc (modified) (22 diffs)
• src/core/time.cc (modified) (3 diffs)
• src/stl/assert.cc (modified) (1 diff)
• src/stl/hash_table.cc (modified) (1 diff)
• src/stl/string.cc (modified) (13 diffs)

trunk/nv/base/assert.hh

@@ -39 +39 @@
 #endif
 
+// TODO: assert levels
 #if NV_DEBUG
 #define NV_ASSERT(cond, msg) NV_ASSERT_IMPL( (cond) && "assertion failed:" msg )
+#define NV_DEBUG_ASSERT(cond, msg) NV_ASSERT_IMPL( (cond) && "assertion failed:" msg )
 #else  
-#define NV_ASSERT(cond, msg)     ((void)0)
+#define NV_ASSERT(cond, msg) ((void)0)
+#define NV_DEBUG_ASSERT(cond, msg) ((void)0)
 #endif 
 

trunk/nv/base/capi.hh

@@ -12 +12 @@
  * This header is temporary
  */
+
+// TODO: sanity checking with NV_DEBUG_ASSERT
 
 #ifndef NV_BASE_CAPI_HH
@@ -110 +112 @@
         inline void* nvmemset( void *dest, unsigned char value, size_t count )
         {
-                return NV_CAPI_CALL( memset )( dest, (int)value, count );
+                return NV_CAPI_CALL( memset )( dest, static_cast<int>( value ), count );
         }
 
         inline void* nvmemchr( const void *src, unsigned char value, size_t max_count )
         {
-                return NV_CAPI_CALL( memchr )( src, (int)value, max_count );
+                return NV_CAPI_CALL( memchr )( src, static_cast<int>( value ), max_count );
         }
 

trunk/nv/base/common.hh

@@ -7 +7 @@
 #ifndef NV_BASE_COMMON_HH
 #define NV_BASE_COMMON_HH
-
-#define _ITERATOR_DEBUG_LEVEL 0
 
 // NV Library version
@@ -199 +197 @@
         using size_t    = decltype( sizeof(0) );
 #endif
-        using ptrdiff_t = decltype((int*)0 - (int*)0);
+        using ptrdiff_t = decltype( static_cast<int*>(0) - static_cast<int*>(0) );
         using nullptr_t = decltype( nullptr );
         
@@ -256 +254 @@
         inline size_t offset_of( T OBJ::*ptr )
         {
-                return ( ( size_t )&( ( (OBJ*)0 )->*ptr ) );
+                return static_cast<size_t>( &( ( static_cast<OBJ*>(0) )->*ptr ) );
         }
 
@@ -262 +260 @@
         constexpr T narrow_cast( const U& a )
         {
-                return static_cast<T>( a & T( -1 ) );
+                return static_cast<T>( a & static_cast<T>( -1 ) );
         }
 
 } // namespace nv
 
-static_assert( nv::size_t( -1 ) > 0,      "size_t is signed!" );
+static_assert( static_cast<nv::size_t>( -1 ) > 0, "size_t is signed!" );
 static_assert( sizeof( nv::size_t ) >= 4, "size_t is smaller than 4 bytes!" );
 static_assert( sizeof( nv::sint8 ) == 1, "sint8 size isn't 1 bytes" );

trunk/nv/base/rtti_support.hh

@@ -49 +49 @@
                 constexpr uint64 rtti_hash_impl( char c, const char* remain, uint64 value )
                 {
-                        return c == 0 ? value : rtti_hash_impl( remain[0], remain + 1, (uint64)(uint64)( value ^ (uint64)c ) * rtti_hash_prime );
+                        return c == 0 ? value : rtti_hash_impl( remain[0], remain + 1, static_cast<uint64>( value ^ static_cast<uint64>(c) ) * rtti_hash_prime );
                 }
 
@@ -66 +66 @@
                 static uint64 hash()
                 {
-                        static_assert( NV_TYPE_FAIL(T), "Type not registered!" );
+                        static_assert( NV_TYPE_FAIL( T ), "Type not registered!" );
                         return 0;
                 }

trunk/nv/core/library.hh

@@ -127 +127 @@
 
                 /**
-                 * Destructor.
-                 *
-                 * It must not throw any exceptions because of the inheritance
-                 */
-                ~library_error() throw() {}
-
-                /**
                  * Returns library name
                  */

trunk/nv/core/logging.hh

@@ -78 +78 @@
                 static bool can_log( log_level level )
                 {
-                        return logger_base::is_valid() && (unsigned int)reference().get_level() >= (unsigned int)level;
+                        return logger_base::is_valid() && static_cast<unsigned int>( reference().get_level() ) >= static_cast<unsigned int>( level );
                 }
 
@@ -84 +84 @@
                 {
                         *m_pos = '\0';
-                        log( level, string_view( m_message, (size_t)( m_pos - m_message ) ) );
+                        log( level, string_view( m_message, static_cast<size_t>( m_pos - m_message ) ) );
                         m_pos = m_message;
                 }

trunk/nv/stl/algorithm/fill.hh

@@ -35 +35 @@
                 void fill_impl( BlockAccessIterator first, BlockAccessIterator last, T value, true_type, block_access_iterator_tag )
                 {
-                        raw_fill( first, last, (unsigned char)value );
+                        raw_fill( first, last, narrow_cast<unsigned char>( value ) );
                 }
 
@@ -49 +49 @@
                 BlockAccessIterator fill_n_impl( BlockAccessIterator first, size_t count, T value, true_type, block_access_iterator_tag )
                 {
-                        return BlockAccessIterator( raw_fill_n( first, count, (unsigned char)value ) );
+                        return BlockAccessIterator( raw_fill_n( first, count, narrow_cast<unsigned char>( value ) ) );
                 }
 

trunk/nv/stl/algorithm/raw.hh

@@ -19 +19 @@
 namespace nv
 {
+        
+        // TODO: better debug macros, both here as well as in nv*funcs
+        namespace detail
+        {
+                template< typename T >
+                constexpr size_t byte_distance( const T* first, const T* last )
+                {
+                        return static_cast<size_t>( reinterpret_cast<uintptr_t>( last ) - reinterpret_cast<uintptr_t>( first ) );
+                }
+
+        }
 
         template< typename T >
         T* raw_copy( const T* first, const T* last, T* out )
         {
-                return (T*)nvmemcpy( out, first, (size_t)( (uintptr_t)last - (uintptr_t)first ) ) + ( last - first );
+                NV_DEBUG_ASSERT( last - first > 0, "raw_copy range fail!" );
+                return static_cast<T*>( nvmemcpy( out, first, detail::byte_distance( first, last ) ) ) + ( last - first );
         }
 
@@ -29 +41 @@
         T* raw_copy_n( const T* ptr, size_t n, T* out )
         {
-                return (T*)nvmemcpy( out, ptr, n * sizeof( T ) ) + n;
+                return static_cast<T*>( nvmemcpy( out, ptr, n * sizeof( T ) ) ) + n;
         }
 
@@ -35 +47 @@
         T* raw_alias_copy( const T* first, const T* last, T* out )
         {
-                return (T*)nvmemmove( out, first, (size_t)( (uintptr_t)last - (uintptr_t)first ) ) + ( last - first );
+                NV_DEBUG_ASSERT( last - first > 0, "raw_alias_copy range fail!" );
+                return static_cast<T*>( nvmemmove( out, first, detail::byte_distance( first, last ) ) ) + ( last - first );
         }
 
@@ -41 +54 @@
         T* raw_alias_copy_n( const T* ptr, size_t n, T* out )
         {
-                return (T*)nvmemmove( out, ptr, n * sizeof( T ) ) + n;
+                return static_cast<T*>( nvmemmove( out, ptr, n * sizeof( T ) ) ) + n;
         }
 
@@ -47 +60 @@
         T* raw_zero( T* first, T* last )
         {
-                return (T*)nvmemset( first, 0, (size_t)( (uintptr_t)last - (uintptr_t)first ) ) + ( last - first );
+                NV_DEBUG_ASSERT( last - first > 0, "raw_zero range fail!" );
+                return static_cast<T*>( nvmemset( first, 0, detail::byte_distance( first, last ) ) ) + ( last - first );
         }
 
@@ -53 +67 @@
         T* raw_zero_n( T* ptr, size_t n )
         {
-                return (T*)nvmemset( ptr, 0, n * sizeof( T ) ) + n;
+                return static_cast<T*>( nvmemset( ptr, 0, n * sizeof( T ) ) ) + n;
         }
 
@@ -59 +73 @@
         T* raw_fill( T* first, T* last, unsigned char value )
         {
-                return (T*)nvmemset( first, value, (size_t)( (uintptr_t)last - (uintptr_t)first ) ) + ( last - first );
+                NV_DEBUG_ASSERT( last - first > 0, "raw_fill range fail!" );
+                return static_cast<T*>( nvmemset( first, value, detail::byte_distance( first, last ) ) ) + ( last - first );
         }
 
@@ -65 +80 @@
         T* raw_fill_n( T* ptr, size_t n, unsigned char value )
         {
-                return (T*)nvmemset( ptr, value, n * sizeof( T ) ) + n;
+                return static_cast<T*>( nvmemset( ptr, value, n * sizeof( T ) ) ) + n;
         }
 

trunk/nv/stl/container/hash_table.hh

@@ -56 +56 @@
                 public:
                         constexpr iterator_base() : m_node( nullptr ) {}
-                        constexpr iterator_base( const iterator_base& it ) : m_node( it.m_node ) {}
                         const entry_type* entry() const { return m_node;  }
                         reference operator*() const { return m_node->value; }
@@ -72 +71 @@
                         typedef iterator_base< IsConst > base_type;
 
-                        constexpr node_iterator() : base_type( nullptr ) {}
-                        constexpr node_iterator( const node_iterator& it ) : base_type( it.m_node ) {}
-
+                        constexpr node_iterator() = default;
                         template < bool B, typename = enable_if_t< IsConst && !B > >
-                        constexpr node_iterator( const node_iterator< B >& it )
-                                : base_type( it.m_node )
-                        {
-                        }
+                        constexpr node_iterator( const node_iterator< B >& it ) : base_type( it.m_node ) {}
 
                         node_iterator& operator++() { increment(); return *this; }
@@ -236 +230 @@
                 inline size_type max_size() const { return 2147483647; }
                 inline size_type max_bucket_count() const { return 2147483647; }
-                inline float load_factor() const { return (float)m_element_count / (float)m_bucket_count; }
+                inline float load_factor() const { return static_cast<float>( m_element_count ) / static_cast<float>( m_bucket_count ); }
                 inline float max_load_factor() const { return m_max_load_factor; }
                 inline void max_load_factor( float ml ) { m_max_load_factor = ml; }
@@ -312 +306 @@
                 void zero()
                 {
-                        m_buckets       = (node_type**)&g_hash_table_empty[0];
+                        m_buckets       = reinterpret_cast<node_type**>( &g_hash_table_empty[0] );
                         m_bucket_count  = 1;
                         m_element_count = 0;
@@ -343 +337 @@
                 {
                         NV_ASSERT( new_count > 1, "allocate_buckets fail!" );
-                        node_type** buckets = ( node_type** )nvmalloc( ( new_count + 1 ) * sizeof( node_type* ) );
+                        node_type** buckets = reinterpret_cast<node_type**>( nvmalloc( ( new_count + 1 ) * sizeof( node_type* ) ) );
                         nvmemset( buckets, 0, ( new_count + 1 ) * sizeof( node_type* ) );
-                        buckets[ new_count ] = reinterpret_cast<node_type*>( (uintptr_t)~0 ); // sentinel
+                        buckets[ new_count ] = reinterpret_cast<node_type*>( uintptr_t(~0) ); // sentinel
                         return buckets;
                 }
@@ -356 +350 @@
                 node_type* alloc_node()
                 {
-                        return (node_type*)nvmalloc( sizeof( node_type ) );
+                        return static_cast<node_type*>( nvmalloc( sizeof( node_type ) ) );
                 }
 

trunk/nv/stl/container/hash_table_policy.hh

@@ -279 +279 @@
                 static uint32 get_bucket_count( uint32 element_count, float load_factor )
                 {
-                        uint32 min_count = (uint32)( element_count / load_factor );
+                        uint32 min_count = static_cast<uint32>( element_count / load_factor );
                         return get_prime_larger_or_equal_to( min_count );
                 }
                 static uint32 is_rehash_required( uint32 bucket_count, uint32 element_count, float load_factor )
                 {
-                        uint32 min_count = (uint32)( element_count / load_factor );
+                        uint32 min_count = static_cast<uint32>( element_count / load_factor );
                         if ( bucket_count < 2 || min_count > bucket_count )
                         {

trunk/nv/stl/functional/hash.hh

@@ -61 +61 @@
                         static constexpr H str_hash_impl( char c, const char* remain, H value )
                         {
-                                return c == 0 ? value : str_hash_impl( remain[0], remain + 1, (H)(H)( value ^ (H)c ) * hash_prime );
+                                return c == 0 ? value : str_hash_impl( remain[0], remain + 1, static_cast<H>( value ^ static_cast<H>( c ) ) * hash_prime );
                         }
                         static constexpr H hash_impl( const char* current, size_t remain, H value )
                         {
-                                return remain == 0 ? value : hash_impl( current + 1, remain - 1, (H)(H)( value ^ (H)(current[0]) ) * hash_prime );
+                                return remain == 0 ? value : hash_impl( current + 1, remain - 1, static_cast<H>( value ^ static_cast<H>( current[0] ) ) * hash_prime );
                         }
                 };
@@ -119 +119 @@
                 {
                         return value == 0.0f ? detail::fnv_hash<H>( &value, 1 ) : 0;
-                };
+                }
                 inline H operator()( float value ) const { return get( value ); }
         };
@@ -130 +130 @@
                 {
                         return value == 0.0f ? detail::fnv_hash<H>( &value, 1 ) : 0;
-                };
+                }
                 inline H operator()( float value ) const { return get( value ); }
         };

trunk/nv/stl/limits.hh

@@ -36 +36 @@
                 static constexpr int sc_bit = sizeof( signed char ) * 8;
                 static constexpr char c_min = ( char( 0 ) < char( -1 ) ? 0 : -128 );
-                static constexpr char c_max = ( char( 0 ) < char( -1 ) ? 255 : 127 );
+                static constexpr char c_max = ( char( 0 ) < char( -1 ) ? narrow_cast<char>( 255 ) : 127 );
                 static constexpr int c_bit = sizeof( char ) * 8;
                 static constexpr unsigned short us_min = 0;

trunk/nv/stl/memory.hh

@@ -163 +163 @@
         }
 
-        template <typename TYPE>
+        template < typename T >
         void raw_destroy_object( void* object )
         {
-                ( (TYPE*)object )->TYPE::~TYPE();
+                static_cast<T*>( object )->T::~T();
         }
 
@@ -183 +183 @@
                         ForwardIterator it( first );
                         for ( ; it != last; ++it )
-                                ::new( (void*)&*it ) value_type( value );
+                                ::new( static_cast<void*>( addressof( *it ) ) ) value_type( value );
                 }
 
@@ -198 +198 @@
                         ForwardIterator it( first );
                         for ( ; count > 0; --count, ++it )
-                                ::new ( (void*)&*it ) value_type( value );
+                                ::new ( static_cast<void*>( addressof( *it ) ) ) value_type( value );
                         return it;
                 }
@@ -214 +214 @@
                         ForwardIterator it( first );
                         for ( ; it != last; ++it )
-                                ::new( (void*)&*it ) value_type;
+                                ::new( static_cast<void*>( addressof( *it ) ) ) value_type;
                 }
 
@@ -229 +229 @@
                         ForwardIterator it( first );
                         for ( ; count > 0; --count, ++it )
-                                ::new( (void*)&*it ) value_type;
+                                ::new( static_cast<void*>( addressof( *it ) ) ) value_type;
                 }
 
@@ -323 +323 @@
                 ForwardIterator it( first );
                 for ( ; it != last; ++it )
-                        ::new( (void*)&*it ) value_type( forward<Args>( params )... );
+                        ::new( static_cast<void*>( addressof( *it ) ) ) value_type( forward<Args>( params )... );
         }
 

trunk/nv/stl/string.hh

@@ -168 +168 @@
                 size_type reverse_distance( ReverseIterator first, ReverseIterator last ) const
                 {
-                        return this->size() - 1 - (size_t)nv::distance( first, last );
+                        return this->size() - 1 - static_cast<size_t>( nv::distance( first, last ) );
                 }
         };
@@ -252 +252 @@
         {
                 size_type this_size = this->size();
-                int cmp = nvmemcmp( this->data(), rhs.data(), ( nv::min )( this_size, rhs.size() ) );
+                int cmp = nvmemcmp( this->data(), rhs.data(), nv::min( this_size, rhs.size() ) );
                 return cmp != 0 ? cmp : ( this_size == rhs.size() ? 0 : this_size < rhs.size() ? -1 : 1 );
         }
@@ -282 +282 @@
         {
                 if ( pos >= this->size() ) return npos;
-                const_iterator it = nv::find_if( this->cbegin() + (difference_type)pos, this->cend(), [=] ( value_type val ) { return val == c; } );
-                return it == this->cend() ? npos : (size_type)nv::distance( this->cbegin(), it );
+                const_iterator it = nv::find_if( this->cbegin() + static_cast<difference_type>( pos ), this->cend(), [=] ( value_type val ) { return val == c; } );
+                return it == this->cend() ? npos : static_cast<size_type>( nv::distance( this->cbegin(), it ) );
         }
         template < typename Storage >
@@ -289 +289 @@
         {
                 if ( pos >= this->size() ) return npos;
-                const_iterator it = nv::search( this->cbegin() + (difference_type)pos, this->cend(), s.cbegin(), s.cend() );
-                return it == this->cend() ? npos : (size_type)nv::distance( this->cbegin(), it );
+                const_iterator it = nv::search( this->cbegin() + static_cast<difference_type>( pos ), this->cend(), s.cbegin(), s.cend() );
+                return it == this->cend() ? npos : static_cast<size_type>( nv::distance( this->cbegin(), it ) );
         }
 
@@ -297 +297 @@
         {
                 if ( pos >= this->size() ) return npos;
-                const_reverse_iterator it = nv::find_if( this->crbegin() + (difference_type)pos, this->crend(), [=] ( value_type val ) { return val == c; } );
+                const_reverse_iterator it = nv::find_if( this->crbegin() + static_cast<difference_type>( pos ), this->crend(), [=] ( value_type val ) { return val == c; } );
                 return it == this->crend() ? npos : this->reverse_distance( this->crbegin(), it );
         }
@@ -304 +304 @@
         {
                 if ( pos >= this->size() ) return npos;
-                const_reverse_iterator it = nv::search( this->crbegin() + (difference_type)pos, this->crend(), s.crbegin(), s.crend() );
+                const_reverse_iterator it = nv::search( this->crbegin() + static_cast<difference_type>( pos ), this->crend(), s.crbegin(), s.crend() );
                 return it == this->crend() ? npos : this->reverse_distance( this->crbegin(), it );
         }
@@ -317 +317 @@
         {
                 const_iterator it = nv::find_first_of( this->cbegin(), this->cend(), s.cbegin(), s.cend() );
-                return it == this->cend() ? npos : (size_type)nv::distance( this->cbegin(), it );
+                return it == this->cend() ? npos : static_cast<size_type>( nv::distance( this->cbegin(), it ) );
         }
 
@@ -337 +337 @@
                 for ( const_iterator it = this->cbegin(); it != this->cend(); ++it )
                         if ( c != *it )
-                        return (size_type)distance( this->cbegin(), it );
+                        return static_cast<size_type>( nv::distance( this->cbegin(), it ) );
                 return npos;
         }
@@ -344 +344 @@
         {
                 for ( const_iterator it = this->cbegin(); it != this->cend(); ++it )
-                        if ( 0 == nvmemchr( s.data(), (uchar8)*it, s.size() ) )
-                        return (size_type)distance( this->cbegin(), it );
+                        if ( 0 == nvmemchr( s.data(), static_cast<uchar8>( *it ), s.size() ) )
+                        return static_cast<size_type>( nv::distance( this->cbegin(), it ) );
                 return npos;
         }
@@ -361 +361 @@
         {
                 for ( const_reverse_iterator it = this->crbegin(); it != this->crend(); ++it )
-                        if ( 0 == nvmemchr( s.data(), (uchar8)*it, s.size() ) )
+                        if ( 0 == nvmemchr( s.data(), static_cast<uchar8>( *it ), s.size() ) )
                         return this->reverse_distance( this->crbegin(), it );
                 return npos;
@@ -434 +434 @@
 #undef NV_STRING_REF_CAST_OPERATORS
 
-size_t sint32_to_buffer( sint32 n, char* str );
-size_t sint64_to_buffer( sint64 n, char* str );
-size_t uint32_to_buffer( uint32 n, char* str );
-size_t uint64_to_buffer( uint64 n, char* str );
-size_t f32_to_buffer( f32 n, char* str );
-size_t f64_to_buffer( f64 n, char* str );
+        size_t sint32_to_buffer( sint32 n, char* str );
+        size_t sint64_to_buffer( sint64 n, char* str );
+        size_t uint32_to_buffer( uint32 n, char* str );
+        size_t uint64_to_buffer( uint64 n, char* str );
+        size_t f32_to_buffer( f32 n, char* str );
+        size_t f64_to_buffer( f64 n, char* str );
+        sint32 buffer_to_sint32( const char* str, char** end );
+        sint64 buffer_to_sint64( const char* s, char** end );
+        uint32 buffer_to_uint32( const char* s, char** end );
+        uint64 buffer_to_uint64( const char* s, char** end );
+        float buffer_to_f32( const char* s, char** end );
+        double buffer_to_f64( const char* s, char** end );
 
         // const string is movable but not copyable

trunk/nv/stl/type_traits.hh

@@ -11 +11 @@
  */
 
- // TODO : "......" function match version?
+ // TODO : "..., ..." function match version?
 // TODO : the following symbols are unimplemented:
 //  * is_constructible, is_trivially_constructible, is_nothrow_constructible

trunk/nv/stl/type_traits/common.hh

@@ -182 +182 @@
         constexpr typename remove_reference<T>::type&& move( T&& arg ) noexcept
         {
-                return ( ( typename remove_reference<T>::type&& )arg );
+                return static_cast<typename remove_reference<T>::type&&>( arg );
         }
 

trunk/nv/stl/type_traits/function.hh

@@ -10 +10 @@
  * @brief type traits - function traits
  */
-// TODO: remove_cv? call traits? support "......"?
+// TODO: remove_cv? call traits? 
 
 #ifndef NV_STL_TRAITS_FUNCTION_HH
@@ -114 +114 @@
                 template < typename R, typename C, typename... Args > struct weak_result_type_impl< R( CALLDECL C::* )( Args... ) const > { typedef R result_type; }; \
                 template < typename R, typename C, typename... Args > struct weak_result_type_impl< R( CALLDECL C::* )( Args... ) volatile > { typedef R result_type; }; \
-                template < typename R, typename C, typename... Args > struct weak_result_type_impl< R( CALLDECL C::* )( Args... ) const volatile > { typedef R result_type; };
-
+                template < typename R, typename C, typename... Args > struct weak_result_type_impl< R( CALLDECL C::* )( Args... ) const volatile > { typedef R result_type; }; \
+                
+//NV_EMIT_WEAK_RESULT_TYPE_CALLDECL()
 NV_EMIT_WEAK_RESULT_TYPE_CALLDECL( __cdecl )
 NV_EMIT_WEAK_RESULT_TYPE_CALLDECL( __fastcall )
 NV_EMIT_WEAK_RESULT_TYPE_CALLDECL( __vectorcall )
+template < typename R, typename... Args > struct weak_result_type_impl< R __cdecl ( Args..., ... ) > { typedef R result_type; }; \
+template < typename R, typename... Args > struct weak_result_type_impl< R( __cdecl & )( Args..., ... ) > { typedef R result_type; }; \
+template < typename R, typename... Args > struct weak_result_type_impl< R( __cdecl * )( Args..., ... ) > { typedef R result_type; }; \
+template < typename R, typename C, typename... Args > struct weak_result_type_impl< R( __cdecl C::* )( Args..., ... ) > { typedef R result_type; }; \
+template < typename R, typename C, typename... Args > struct weak_result_type_impl< R( __cdecl C::* )( Args..., ... ) const > { typedef R result_type; }; \
+template < typename R, typename C, typename... Args > struct weak_result_type_impl< R( __cdecl C::* )( Args..., ... ) volatile > { typedef R result_type; }; \
+template < typename R, typename C, typename... Args > struct weak_result_type_impl< R( __cdecl C::* )( Args..., ... ) const volatile > { typedef R result_type; }; \
+
 #       if NV_ARCHITECTURE == NV_32BIT
 NV_EMIT_WEAK_RESULT_TYPE_CALLDECL( __stdcall )
 template < typename R, typename C, typename... Args > struct weak_result_type_impl< R( __thiscall C::* )( Args... ) > { typedef R result_type; };
-template < typename R, typename C, typename... Args > struct weak_result_type_impl< R( __thiscall C::* )( Args... ) const > { typedef R result_type; }; \
-template < typename R, typename C, typename... Args > struct weak_result_type_impl< R( __thiscall C::* )( Args... ) volatile > { typedef R result_type; }; \
+template < typename R, typename C, typename... Args > struct weak_result_type_impl< R( __thiscall C::* )( Args... ) const > { typedef R result_type; }; 
+template < typename R, typename C, typename... Args > struct weak_result_type_impl< R( __thiscall C::* )( Args... ) volatile > { typedef R result_type; }; 
 template < typename R, typename C, typename... Args > struct weak_result_type_impl< R( __thiscall C::* )( Args... ) const volatile > { typedef R result_type; };
 #       endif
@@ -129 +138 @@
 #else
                 template < typename R, typename... Args > struct weak_result_type_impl< R( Args... ) > { typedef R result_type; };
-                template < typename R, typename... Args > struct weak_result_type_impl< R( Args...... ) > { typedef R result_type; };
+                template < typename R, typename... Args > struct weak_result_type_impl< R( Args..., ... ) > { typedef R result_type; };
                 template < typename R, typename... Args > struct weak_result_type_impl< R( Args... ) const > { typedef R result_type; };
-                template < typename R, typename... Args > struct weak_result_type_impl< R( Args...... ) const > { typedef R result_type; };
+                template < typename R, typename... Args > struct weak_result_type_impl< R( Args..., ... ) const > { typedef R result_type; };
                 template < typename R, typename... Args > struct weak_result_type_impl< R( Args... ) volatile > { typedef R result_type; };
-                template < typename R, typename... Args > struct weak_result_type_impl< R( Args...... ) volatile > { typedef R result_type; };
+                template < typename R, typename... Args > struct weak_result_type_impl< R( Args..., ... ) volatile > { typedef R result_type; };
                 template < typename R, typename... Args > struct weak_result_type_impl< R( Args... ) const volatile > { typedef R result_type; };
-                template < typename R, typename... Args > struct weak_result_type_impl< R( Args...... ) const volatile > { typedef R result_type; };
+                template < typename R, typename... Args > struct weak_result_type_impl< R( Args..., ... ) const volatile > { typedef R result_type; };
                 template < typename R, typename... Args > struct weak_result_type_impl< R( & )( Args... ) > { typedef R result_type; };
-                template < typename R, typename... Args > struct weak_result_type_impl< R( & )( Args...... ) > { typedef R result_type; };
+                template < typename R, typename... Args > struct weak_result_type_impl< R( & )( Args..., ... ) > { typedef R result_type; };
                 template < typename R, typename... Args > struct weak_result_type_impl< R( * )( Args... ) > { typedef R result_type; };
-                template < typename R, typename... Args > struct weak_result_type_impl< R( * )( Args...... ) > { typedef R result_type; };
+                template < typename R, typename... Args > struct weak_result_type_impl< R( * )( Args..., ... ) > { typedef R result_type; };
                 template < typename R, typename C, typename... Args > struct weak_result_type_impl< R( C::* )( Args... ) > { typedef R result_type; };
-                template < typename R, typename C, typename... Args > struct weak_result_type_impl< R( C::* )( Args...... ) > { typedef R result_type; };
+                template < typename R, typename C, typename... Args > struct weak_result_type_impl< R( C::* )( Args..., ... ) > { typedef R result_type; };
                 template < typename R, typename C, typename... Args > struct weak_result_type_impl< R( C::* )( Args... ) const > { typedef R result_type; };
-                template < typename R, typename C, typename... Args > struct weak_result_type_impl< R( C::* )( Args...... ) const > { typedef R result_type; };
+                template < typename R, typename C, typename... Args > struct weak_result_type_impl< R( C::* )( Args..., ... ) const > { typedef R result_type; };
                 template < typename R, typename C, typename... Args > struct weak_result_type_impl< R( C::* )( Args... ) volatile > { typedef R result_type; };
-                template < typename R, typename C, typename... Args > struct weak_result_type_impl< R( C::* )( Args...... ) volatile > { typedef R result_type; };
+                template < typename R, typename C, typename... Args > struct weak_result_type_impl< R( C::* )( Args..., ... ) volatile > { typedef R result_type; };
                 template < typename R, typename C, typename... Args > struct weak_result_type_impl< R( C::* )( Args... ) const volatile > { typedef R result_type; };
-                template < typename R, typename C, typename... Args > struct weak_result_type_impl< R( C::* )( Args...... ) const volatile > { typedef R result_type; };
+                template < typename R, typename C, typename... Args > struct weak_result_type_impl< R( C::* )( Args..., ... ) const volatile > { typedef R result_type; };
 #endif
         }

trunk/nv/stl/type_traits/primary.hh

@@ -60 +60 @@
         // is_function_pointer / is_member_function pointer - extension
         // TODO: sanity check - this is very different - http://en.cppreference.com/w/cpp/types/is_function
-        // TODO: "......" function match version?
+        // TODO: "..., ..." function match version?
         // TODO: call conventions really needed?
 

trunk/nv/stl/type_traits/properties.hh

@@ -160 +160 @@
                 template < typename R, typename... Args >
                 struct is_referenceable < R( Args... ) > : true_type {};
-#if NV_COMPILER != NV_MSVC
                 template < typename R, typename... Args >
-                struct is_referenceable < R( Args...... ) > : true_type {};
-#endif
+                struct is_referenceable < R( Args..., ... ) > : true_type {};
 
                 template < typename To, typename From >
@@ -293 +291 @@
                         static size_two test( ... );
                 public:
-                        static constexpr bool value = sizeof( test<T>( 0 ) ) == 1;
+                        static constexpr bool value = sizeof( test( static_cast<T*>( nullptr ) ) ) == 1;
                 };
         }

trunk/src/core/library.cc

@@ -11 +11 @@
 #   include <windows.h>
 #   define NV_LIB_EXT ".dll"
-#   define NV_LIB_HANDLE HMODULE
-#   define NV_LIB_OPEN( name ) LoadLibraryEx( name, NULL, LOAD_WITH_ALTERED_SEARCH_PATH )
-#   define NV_LIB_GET( handle, name ) GetProcAddress( handle, name )
-#   define NV_LIB_CLOSE( name ) !FreeLibrary( name )
+#   define NV_LIB_OPEN( name ) static_cast<void*>( LoadLibraryEx( name, NULL, LOAD_WITH_ALTERED_SEARCH_PATH ) )
+#   define NV_LIB_GET( handle, name ) reinterpret_cast<void*>( GetProcAddress( static_cast<HMODULE>( handle ), name ) )
+#   define NV_LIB_CLOSE( handle ) ( FreeLibrary( static_cast<HMODULE>( handle ) ) != 0 )
 #elif NV_PLATFORM == NV_LINUX || NV_PLATFORM == NV_APPLE
 #   include <dlfcn.h>
 #   define NV_LIB_EXT ".so"
-#   define NV_LIB_HANDLE void*
 #   define NV_LIB_OPEN( name ) dlopen( name, RTLD_LAZY | RTLD_GLOBAL)
-#   define NV_LIB_GET( handle, name ) dlsym( handle, name )
-#   define NV_LIB_CLOSE( name ) dlclose( name )
+#   define NV_LIB_GET( handle, name ) dlsym( static_cast<void*>( handle ), name )
+#   define NV_LIB_CLOSE( handle ) ( dlclose( static_cast<void*>( handle ) ) == 0 )
 #elif NV_PLATFORM == NV_APPLE
 #   include "macUtils.h"
 #   include <dlfcn.h>
 #   define NV_LIB_EXT ".dylib"
-#   define NV_LIB_HANDLE CFBundleRef
 #   define NV_LIB_OPEN( name ) mac_loadExeBundle( name )
 #   define NV_LIB_GET( handle, name ) mac_getBundleSym( handle, name )
-#   define NV_LIB_CLOSE( name ) mac_unloadExeBundle( name )
+#   define NV_LIB_CLOSE( handle ) ( mac_unloadExeBundle( handle ) == 0 )
 #endif
 
@@ -83 +80 @@
     }
 
-    m_handle = (void*)NV_LIB_OPEN( name.c_str() );
+    m_handle = NV_LIB_OPEN( name.c_str() );
 
     if ( m_handle == NULL )
@@ -96 +93 @@
 void* library::get( string_view symbol )
 {
-        void* result = (void*) NV_LIB_GET( (NV_LIB_HANDLE) m_handle, symbol.data() );
+        void* result = NV_LIB_GET( m_handle, symbol.data() );
     if ( !result )
     {
@@ -106 +103 @@
 void* nv::library::try_get( string_view symbol )
 {
-        return (void*) NV_LIB_GET( (NV_LIB_HANDLE) m_handle, symbol.data() );
+        return NV_LIB_GET( m_handle, symbol.data() );
 }
 
@@ -116 +113 @@
 void library::close()
 {
-    if ( NV_LIB_CLOSE( (NV_LIB_HANDLE)m_handle ) )
+    if ( ! NV_LIB_CLOSE( m_handle ) )
     {
         NV_LOG_ERROR( "library : can't close library '", m_name, "'!" );
     }
-    m_handle = NULL;
+    m_handle = nullptr;
 }
 
 library::~library()
 {
-    if ( m_handle != NULL )
+    if ( m_handle != nullptr )
     {
         close();
@@ -135 +132 @@
 #if NV_PLATFORM == NV_WINDOWS
     // We do hate WinAPI for code like this, don't we?
-    LPTSTR buffer = NULL;
+    LPTSTR buffer = nullptr;
     FormatMessage( FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS,
-        NULL, GetLastError(), MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), (LPTSTR) &buffer, 0, NULL );
-    std::string msg( (char*)buffer );
+        NULL, GetLastError(), MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), reinterpret_cast<LPTSTR>( &buffer ), 0, NULL );
+    std::string msg( reinterpret_cast<char*>( buffer ) );
     LocalFree( buffer );
     return msg;
 #elif NV_PLATFORM == NV_LINUX || NV_PLATFORM == NV_APPLE
-    return string(dlerror());
+    return std::string( dlerror() );
 #else
-    return string("");
+    return std::string("");
 #endif
 }

trunk/src/core/logger.cc

@@ -89 +89 @@
         for ( auto& sink_info : m_log_sinks )
         {
-                if ( sink_info.sink && (sink_info.level >= (uint32)level) )
+                if ( sink_info.sink && (sink_info.level >= static_cast<uint32>( level ) ) )
                 {
                         // log and iterate
@@ -106 +106 @@
                 {
                         sink_info.sink  = sink;
-                        sink_info.level = (uint32)level;
+                        sink_info.level = static_cast<uint32>( level );
                         return;
                 }
@@ -194 +194 @@
         //if ( m_flush ) FlushFileBuffers( m_handle );
 #else
-        fwrite( stamp, ssize, 1, (FILE*)m_handle );
-        fwrite( " [", 2, 1, (FILE*)m_handle );
-        fwrite( NV_LOG_LEVEL_NAME_PAD( level ), 8, 1, (FILE*)m_handle );
-        fwrite( "] ", 2, 1, (FILE*)m_handle );
-        fwrite( message.data(), message.size(), 1, (FILE*)m_handle );
-        fwrite( "\n", 1, 1, (FILE*)m_handle );
-        if ( m_flush ) fflush( (FILE*)m_handle );
+        FILE* file = static_cast<FILE*>( m_handle );
+        fwrite( stamp, ssize, 1, file );
+        fwrite( " [", 2, 1, file );
+        fwrite( NV_LOG_LEVEL_NAME_PAD( level ), 8, 1, file );
+        fwrite( "] ", 2, 1, file );
+        fwrite( message.data(), message.size(), 1, file );
+        fwrite( "\n", 1, 1, file );
+        if ( m_flush ) fflush( file );
 #endif
 }
@@ -226 +227 @@
         CloseHandle( m_handle );
 #else
-        fclose( (FILE*) m_handle );
+        fclose( static_cast<FILE*>( m_handle ) );
 #endif
 }
@@ -244 +245 @@
 {
         uint32 ms = get_system_ms();
-        unsigned int secs = (unsigned int)(ms / 1000);
-        unsigned int mm   = (unsigned int)( ms * 100 / 1000 ) % 100;
-        unsigned int h    = (unsigned int)(secs / (60*60));
-        unsigned int m    = (unsigned int)(secs / 60) % 60;
+        unsigned int secs = static_cast<unsigned int>( ms / 1000 );
+        unsigned int mm   = static_cast<unsigned int>( ms * 100 / 1000 ) % 100;
+        unsigned int h    = static_cast<unsigned int>( secs / (60*60) );
+        unsigned int m    = static_cast<unsigned int>( secs / 60 ) % 60;
         unsigned int s    = secs % 60;
 #if NV_COMPILER == NV_MSVC 

trunk/src/core/profiler.cc

@@ -124 +124 @@
                 if ( c->m_calls > 0 )
                 {
-                        f64 pparent = ( (f64)c->m_total_time_us / (f64)c->m_parent->m_total_time_us ) * 100.f;
+                        f64 ftotal_time_us = static_cast<f64>( c->m_total_time_us );
+                        f64 pparent = ( ftotal_time_us / static_cast<f64>( c->m_parent->m_total_time_us ) ) * 100.f;
                         uint32 calls       = c->m_calls;
-                        f64 total_ms = c->m_total_time_us / 1000.f;
-                        f64 avg_ms = ( (f64)c->m_total_time_us / (f64)c->m_calls ) / 1000.f;
+                        f64 total_ms = ftotal_time_us / 1000.f;
+                        f64 avg_ms = ( ftotal_time_us / static_cast<f64>( c->m_calls ) ) / 1000.f;
                         if ( indent > 0 ) nvmemset( buffer, '-', indent );
                         snprintf( buffer + indent, 128 - indent, "%*.*s %6.2f %6d %9.2f %6.2f", indent - 23, 23 - indent,

trunk/src/core/random.cc

@@ -19 +19 @@
 random::seed_type random::randomize()
 {
-        std::mt19937& rng = *(( std::mt19937* )m_data);
+        std::mt19937& rng = *( reinterpret_cast< std::mt19937* >( m_data ) );
         seed_type seed = randomized_seed();
         rng.seed( seed );
@@ -27 +27 @@
 void random::set_seed( random::seed_type seed /*= 0 */ )
 {
-        std::mt19937& rng = *( ( std::mt19937* )m_data );
+        std::mt19937& rng = *( reinterpret_cast<std::mt19937*>( m_data ) );
         rng.seed( seed == 0 ? randomized_seed() : seed );
 }
@@ -39 +39 @@
 random::result_type random::rand()
 {
-        std::mt19937& rng = *( ( std::mt19937* )m_data );
+        std::mt19937& rng = *( reinterpret_cast<std::mt19937*>( m_data ) );
         return rng();
 }
@@ -45 +45 @@
 sint32 random::srand( sint32 val )
 {
-        std::mt19937& rng = *( ( std::mt19937* )m_data );
+        std::mt19937& rng = *( reinterpret_cast<std::mt19937*>( m_data ) );
         std::uniform_int_distribution<sint32> dist( 0, val - 1 );
         return dist( rng );
@@ -52 +52 @@
 uint32 random::urand( uint32 val )
 {
-        std::mt19937& rng = *( ( std::mt19937* )m_data );
+        std::mt19937& rng = *( reinterpret_cast<std::mt19937*>( m_data ) );
         std::uniform_int_distribution<uint32> dist( 0, val - 1 );
         return dist( rng );
@@ -59 +59 @@
 f32 random::frand( f32 val )
 {
-        std::mt19937& rng = *( ( std::mt19937* )m_data );
+        std::mt19937& rng = *( reinterpret_cast<std::mt19937*>( m_data ) );
         std::uniform_real_distribution<f32> dist( 0, val );
         return dist( rng );
@@ -66 +66 @@
 sint32 random::srange( sint32 min, sint32 max )
 {
-        std::mt19937& rng = *( ( std::mt19937* )m_data );
+        std::mt19937& rng = *( reinterpret_cast<std::mt19937*>( m_data ) );
         std::uniform_int_distribution<sint32> dist( min, max );
         return dist( rng );
@@ -73 +73 @@
 uint32 random::urange( uint32 min, uint32 max )
 {
-        std::mt19937& rng = *( ( std::mt19937* )m_data );
+        std::mt19937& rng = *( reinterpret_cast<std::mt19937*>( m_data ) );
         std::uniform_int_distribution<uint32> dist( min, max );
         return dist( rng );
@@ -80 +80 @@
 f32 random::frange( f32 min, f32 max )
 {
-        std::mt19937& rng = *( ( std::mt19937* )m_data );
+        std::mt19937& rng = *( reinterpret_cast<std::mt19937*>( m_data ) );
         std::uniform_real_distribution<f32> dist( min, max );
         return dist( rng );
@@ -87 +87 @@
 uint32 random::dice( uint32 count, uint32 sides )
 {
-        std::mt19937& rng = *( ( std::mt19937* )m_data );
+        std::mt19937& rng = *( reinterpret_cast<std::mt19937*>( m_data ) );
         std::uniform_int_distribution<uint32> dist( 1, sides );
         uint32 result = 0;
@@ -106 +106 @@
 nv::vec2 nv::random::precise_unit_vec2()
 {
-        std::mt19937& rng = *( ( std::mt19937* )m_data );
+        std::mt19937& rng = *( reinterpret_cast<std::mt19937*>( m_data ) );
         std::uniform_real_distribution<f32> dist( 0, glm::pi<float>() * 2.f );
         float angle = dist( rng );
@@ -114 +114 @@
 nv::vec3 nv::random::precise_unit_vec3()
 {
-        std::mt19937& rng = *( ( std::mt19937* )m_data );
+        std::mt19937& rng = *( reinterpret_cast<std::mt19937*>( m_data ) );
         std::uniform_real_distribution<f32> dist11( -1.0f, 1.0f );
         std::uniform_real_distribution<f32> dist02pi( 0.0f, 2*glm::pi<float>() );
@@ -129 +129 @@
 nv::vec2 nv::random::fast_disk_point()
 {
-        std::mt19937& rng = *( ( std::mt19937* )m_data );
+        std::mt19937& rng = *( reinterpret_cast<std::mt19937*>( m_data ) );
         std::uniform_real_distribution<f32> dist( 0.0f, 1.0f );
         float r1 = dist( rng );
@@ -140 +140 @@
 nv::vec2 nv::random::precise_disk_point()
 {
-        std::mt19937& rng = *( ( std::mt19937* )m_data );
+        std::mt19937& rng = *( reinterpret_cast<std::mt19937*>( m_data ) );
         std::uniform_real_distribution<f32> unit( 0.0f, 1.0f );
         std::uniform_real_distribution<f32> angle( 0.0f, glm::pi<float>() );
@@ -150 +150 @@
 nv::vec3 nv::random::fast_sphere_point()
 {
-        std::mt19937& rng = *( ( std::mt19937* )m_data );
+        std::mt19937& rng = *( reinterpret_cast<std::mt19937*>( m_data ) );
         std::uniform_real_distribution<f32> dist01( 0.0f, 1.0f );
         std::uniform_real_distribution<f32> dist11( -1.0f, 1.0f );
@@ -168 +168 @@
 nv::vec3 nv::random::precise_sphere_point()
 {
-        std::mt19937& rng = *( ( std::mt19937* )m_data );
+        std::mt19937& rng = *( reinterpret_cast<std::mt19937*>( m_data ) );
         std::uniform_real_distribution<f32> dist01( 0.0f, 1.0f );
         std::uniform_real_distribution<f32> dist11( -1.0f, 1.0f );
@@ -185 +185 @@
 nv::vec2 nv::random::precise_ellipse_point( const vec2& radii )
 {
-        std::mt19937& rng = *( ( std::mt19937* )m_data );
+        std::mt19937& rng = *( reinterpret_cast<std::mt19937*>( m_data ) );
         std::uniform_real_distribution<f32> distx( -radii.x, radii.x );
         std::uniform_real_distribution<f32> disty( -radii.y, radii.y );
@@ -204 +204 @@
 nv::vec3 nv::random::precise_ellipsoid_point( const vec3& radii )
 {
-        std::mt19937& rng = *( ( std::mt19937* )m_data );
+        std::mt19937& rng = *( reinterpret_cast<std::mt19937*>( m_data ) );
         std::uniform_real_distribution<f32> distx( -radii.x, radii.x );
         std::uniform_real_distribution<f32> disty( -radii.y, radii.y );
@@ -225 +225 @@
 nv::vec2 nv::random::fast_hollow_disk_point( float iradius, float oradius )
 {
-        std::mt19937& rng = *( ( std::mt19937* )m_data );
+        std::mt19937& rng = *( reinterpret_cast<std::mt19937*>( m_data ) );
         float idist2 = iradius * iradius;
         float odist2 = oradius * oradius;
@@ -239 +239 @@
 nv::vec3 nv::random::fast_hollow_sphere_point( float iradius, float oradius )
 {
-        std::mt19937& rng = *( ( std::mt19937* )m_data );
+        std::mt19937& rng = *( reinterpret_cast<std::mt19937*>( m_data ) );
         float idist3 = iradius * iradius * iradius;
         float odist3 = oradius * oradius * oradius;
@@ -254 +254 @@
 nv::vec2 nv::random::fast_hollow_ellipse_point( const vec2& iradii, const vec2& oradii )
 {
-        std::mt19937& rng = *( ( std::mt19937* )m_data );
+        std::mt19937& rng = *( reinterpret_cast<std::mt19937*>( m_data ) );
         vec2 iradii2 = iradii * iradii;
         vec2 opoint     = ellipse_edge( oradii );
@@ -275 +275 @@
 nv::vec3 nv::random::fast_hollow_ellipsoid_point( const vec3& iradii, const vec3& oradii )
 {
-        std::mt19937& rng = *( ( std::mt19937* )m_data );
+        std::mt19937& rng = *( reinterpret_cast<std::mt19937*>( m_data ) );
         vec3 iradii2 = iradii * iradii;
         vec3 opoint     = ellipsoid_edge( oradii );

trunk/src/core/time.cc

@@ -85 +85 @@
 nv::uint32 nv::get_cpu_ms()
 {
-        return (uint32)( (f32)( clock() - zero_timer.clock_zero ) / ( (f32)CLOCKS_PER_SEC / 1000.0 ) ) ;
+        return static_cast<uint32>( static_cast<f32>( clock() - zero_timer.clock_zero ) / ( static_cast<f32>(CLOCKS_PER_SEC) / 1000.0f ) ) ;
 }
 
 nv::uint64 nv::get_cpu_us()
 {
-        return (uint64)( (f32)( clock() - zero_timer.clock_zero ) / ( (f32)CLOCKS_PER_SEC / 1000000.0 ) ) ;
+        return static_cast<uint64>( static_cast<f32>( clock() - zero_timer.clock_zero ) / ( static_cast<f32>(CLOCKS_PER_SEC) / 1000000.0f ) ) ;
 }
 
@@ -99 +99 @@
         QueryPerformanceCounter(&now);
         LONGLONG result = now.QuadPart - zero_timer.query_zero.QuadPart;
-        return (uint32) (1000.0 * result / (double) zero_timer.frequency.QuadPart);
+        return static_cast<uint32>(1000.0 * result / static_cast<f64>( zero_timer.frequency.QuadPart ) );
 #else
         struct timeval now;
         gettimeofday(&now, NULL);
-        return (uint32)( (now.tv_sec - zero_timer.timeval_zero.tv_sec)*1000+(now.tv_usec-zero_timer.timeval_zero.tv_usec)/1000 );
+        return static_cast<uint32>( (now.tv_sec - zero_timer.timeval_zero.tv_sec)*1000+(now.tv_usec-zero_timer.timeval_zero.tv_usec)/1000 );
 #endif
 }
@@ -113 +113 @@
         QueryPerformanceCounter(&now);
         LONGLONG result = now.QuadPart - zero_timer.query_zero.QuadPart;
-        return (uint64) (1000000.0 * result / (double) zero_timer.frequency.QuadPart);
+        return static_cast<uint64>(1000000.0 * result / static_cast<f64>( zero_timer.frequency.QuadPart ) );
 #else
         struct timeval now;
         gettimeofday(&now, NULL);
-        return (uint32)( (now.tv_sec - zero_timer.timeval_zero.tv_sec)*1000000+(now.tv_usec - zero_timer.timeval_zero.tv_usec) );
+        return static_cast<uint64>( (now.tv_sec - zero_timer.timeval_zero.tv_sec)*1000000+(now.tv_usec - zero_timer.timeval_zero.tv_usec) );
 #endif
 }

trunk/src/stl/assert.cc

@@ -31 +31 @@
 extern "C" {
         extern void __assert(const char *, const char *, unsigned int, const char *)
-                throw() __attribute__ ((__noreturn__));
+                __attribute__ ((__noreturn__));
 }
 #       else
 extern "C" {
         extern void __assert_fail(const char *, const char *, unsigned int, const char *)
-                throw() __attribute__ ((__noreturn__));
+                __attribute__ ((__noreturn__));
 }
 #       endif
-void nv_internal_assert( const char * assertion, const char * file, unsigned int line, const char * function )
+__attribute__( ( __noreturn__ ) ) void nv_internal_assert( const char * assertion, const char * file, unsigned int line, const char * function )
 {
 #       if NV_COMPILER == NV_CLANG

trunk/src/stl/hash_table.cc

@@ -47 +47 @@
 };
 
-static const nv::uint32 s_primes_size = ( sizeof( s_primes ) / sizeof( *s_primes ) );
+//static const nv::uint32 s_primes_size = ( sizeof( s_primes ) / sizeof( *s_primes ) );
 
 namespace nv
 {
-        void* g_hash_table_empty[2] = { nullptr, (void*)uintptr_t( ~0 ) };
+        void* g_hash_table_empty[2] = { nullptr, reinterpret_cast<void*>( uintptr_t( ~0 ) ) };
 }
 

trunk/src/stl/string.cc

@@ -15 +15 @@
 using namespace nv;
 
-static const double s_power_10[] = { 1, 10, 100, 1000, 10000, 100000, 1000000,
-10000000, 100000000, 1000000000 };
+//static const double s_power_10[] = { 1, 10, 100, 1000, 10000, 100000, 1000000, 10000000, 100000000, 1000000000 };
 
 std::string nv::slurp( const std::string& filename )
@@ -41 +40 @@
 {
         char* s = str;
-        uint32 abs = ( n < 0 ) ? (uint32)( -n ) : (uint32)( n );
+        uint32 abs = static_cast< uint32 >( n < 0 ? -n : n );
         do
         {
-                *s++ = (char)( '0' + ( abs % 10 ) );
+                *s++ = static_cast<char>( '0' + ( abs % 10 ) );
                 abs /= 10;
         } while ( abs > 0 );
@@ -50 +49 @@
         *s = '\0';
         string_reverse( str, s - 1 );
-        return (nv::size_t)( s - str );
+        return static_cast<nv::size_t>( s - str );
 }
 
@@ -56 +55 @@
 {
         char* s = str;
-        uint64 abs = ( n < 0 ) ? (uint64)( -n ) : (uint64)( n );
+        uint64 abs = static_cast< uint64 >( n < 0 ? -n : n );
         do
         {
-                *s++ = (char)( '0' + ( abs % 10 ) );
+                *s++ = static_cast<char>( '0' + ( abs % 10 ) );
                 abs /= 10;
         } while ( abs > 0 );
@@ -65 +64 @@
         *s = '\0';
         string_reverse( str, s - 1 );
-        return (nv::size_t)( s - str );
+        return static_cast<nv::size_t>( s - str );
 }
 
@@ -73 +72 @@
         do
         {
-                *s++ = (char)( '0' + ( n % 10 ) );
+                *s++ = static_cast<char>( '0' + ( n % 10 ) );
                 n /= 10;
         } while ( n > 0 );
         *s = '\0';
         string_reverse( str, s - 1 );
-        return (nv::size_t)( s - str );
+        return static_cast<nv::size_t>( s - str );
 }
 
@@ -86 +85 @@
         do
         {
-                *s++ = (char)( '0' + ( n % 10 ) );
+                *s++ = static_cast<char>( '0' + ( n % 10 ) );
                 n /= 10;
         } while ( n > 0 );
         *s = '\0';
         string_reverse( str, s - 1 );
-        return (size_t)( s - str );
+        return static_cast<nv::size_t>( s - str );
 }
 
@@ -101 +100 @@
         int result = snprintf( str, 64, "%.*g", 6, n );
 #endif
-        return result > 0 ? ( nv::size_t )result : 0;
+        return static_cast<nv::size_t>( result > 0 ? result : 0 );
 }
 
@@ -111 +110 @@
         int result = snprintf( str, 64, "%.*g", 6, n );
 #endif
-        return result > 0 ? ( nv::size_t )result : 0;
+        return static_cast<nv::size_t>( result > 0 ? result : 0 );
 }
 
-sint32 buffer_to_sint32( const char* str, char** end )
+sint32 nv::buffer_to_sint32( const char* str, char** end )
 {
         const char* s = str;
@@ -131 +130 @@
                 ++s;
         }
-        if ( end != nullptr ) *end = (char*)s;
+        if ( end != nullptr ) *end = const_cast<char*>( s );
         return positive ? result : -result;
 }
 
-sint64 buffer_to_sint64( const char* s, char** end )
+sint64 nv::buffer_to_sint64( const char* s, char** end )
 {
         while ( *s == ' ' ) ++s;
@@ -151 +150 @@
                 ++s;
         }
-        if ( end != nullptr ) *end = (char*)s;
+        if ( end != nullptr ) *end = const_cast<char*>( s );
         return positive ? result : -result;
 }
 
-uint32 buffer_to_uint32( const char* s, char** end )
+uint32 nv::buffer_to_uint32( const char* s, char** end )
 {
         while ( *s == ' ' ) ++s;
@@ -161 +160 @@
         while ( *s >= '0' && *s <= '9' )
         {
-                result = ( result * 10 ) + (uint32)( *s - '0' );
+                result = ( result * 10 ) + static_cast<uint32>( *s - '0' );
                 ++s;
         }
-        if ( end != nullptr ) *end = (char*)s;
+        if ( end != nullptr ) *end = const_cast<char*>( s );
         return result;
 }
 
-uint64 buffer_to_uint64( const char* s, char** end )
+uint64 nv::buffer_to_uint64( const char* s, char** end )
 {
         while ( *s == ' ' ) ++s;
@@ -174 +173 @@
         while ( *s >= '0' && *s <= '9' )
         {
-                result = ( result * 10 ) + (uint32)( *s - '0' );
+                result = ( result * 10 ) + static_cast<uint32>( *s - '0' );
                 ++s;
         }
-        if ( end != nullptr ) *end = (char*)s;
+        if ( end != nullptr ) *end = const_cast<char*>( s );
         return result;
 }
 
-float buffer_to_f32( const char* s, char** end )
+float nv::buffer_to_f32( const char* s, char** end )
 {
         return strtof( s, end );
 }
 
-double buffer_to_f64( const char* s, char** end )
+double nv::buffer_to_f64( const char* s, char** end )
 {
         return strtod( s, end );