source: trunk/src/stl/string.cc @ 379

// Copyright (C) 2015 ChaosForge Ltd
// http://chaosforge.org/
//
// This file is part of NV Libraries.
// For conditions of distribution and use, see copyright notice in nv.hh
//
// TODO: speedup conversion by doing divisions by 100

#include "nv/stl/string.hh"

#include <cstdio>
#include <cstdlib>
#include <fstream> // for slurp only

using namespace nv;

static const double s_power_10[] = { 1, 10, 100, 1000, 10000, 100000, 1000000,
10000000, 100000000, 1000000000 };

std::string nv::slurp( const std::string& filename )
{
        std::ifstream input( filename );
        //              if ( !input.is_open() ) NV_THROW( std::runtime_error, "File "+filename+" not found!");
        std::stringstream sstr;
        while ( input >> sstr.rdbuf() );
        return sstr.str();
}

static inline void string_reverse( char* begin, char* end )
{
        char temp;
        while ( end > begin )
        {
                temp = *end;
                *end-- = *begin;
                *begin++ = temp;
        }
}

nv::size_t nv::sint32_to_buffer( sint32 n, char* str )
{
        char* s = str;
        uint32 abs = ( n < 0 ) ? (uint32)( -n ) : (uint32)( n );
        do
        {
                *s++ = (char)( '0' + ( abs % 10 ) );
                abs /= 10;
        } while ( abs > 0 );
        if ( n < 0 ) *s++ = '-';
        *s = '\0';
        string_reverse( str, s - 1 );
        return (size_t)( s - str );
}

nv::size_t nv::sint64_to_buffer( sint64 n, char* str )
{
        char* s = str;
        uint64 abs = ( n < 0 ) ? (uint64)( -n ) : (uint64)( n );
        do
        {
                *s++ = (char)( '0' + ( abs % 10 ) );
                abs /= 10;
        } while ( abs > 0 );
        if ( n < 0 ) *s++ = '-';
        *s = '\0';
        string_reverse( str, s - 1 );
        return (size_t)( s - str );
}

nv::size_t nv::uint32_to_buffer( uint32 n, char* str )
{
        char* s = str;
        do
        {
                *s++ = (char)( '0' + ( n % 10 ) );
                n /= 10;
        } while ( n > 0 );
        *s = '\0';
        string_reverse( str, s - 1 );
        return (size_t)( s - str );
}

nv::size_t nv::uint64_to_buffer( uint64 n, char* str )
{
        char* s = str;
        do
        {
                *s++ = (char)( '0' + ( n % 10 ) );
                n /= 10;
        } while ( n > 0 );
        *s = '\0';
        string_reverse( str, s - 1 );
        return (size_t)( s - str );
}

nv::size_t nv::f32_to_buffer( f32 n, char* str )
{
#if NV_COMPILER == NV_MSVC
        sprintf_s( str, 64, "%.*g", 6, n );
#else
        snprintf( str, 64, "%.*g", 6, n );
#endif
        sprintf( str, "%g", n );
        return strlen( str );
}

nv::size_t nv::f64_to_buffer( f64 n, char* str )
{
#if NV_COMPILER == NV_MSVC
        sprintf_s( str, 64, "%.*g", 6, n );
#else
        snprintf( str, 64, "%.*g", 6, n );
#endif
        return strlen( str );
}

sint32 buffer_to_sint32( const char* str, char** end )
{
        const char* s = str;
        while ( *s == ' ' ) ++s;
        sint32 result = 0;
        bool positive = true;
        switch ( *s )
        {
        case '-': ++s; positive = false; break;
        case '+': ++s; break;
        default: break;
        }
        while ( *s >= '0' && *s <= '9' )
        {
                result = ( result * 10 ) + ( *s - '0' );
                ++s;
        }
        if ( end != nullptr ) *end = (char*)s;
        return positive ? result : -result;
}

sint64 buffer_to_sint64( const char* s, char** end )
{
        while ( *s == ' ' ) ++s;
        sint64 result = 0;
        bool positive = true;
        switch ( *s )
        {
        case '-': ++s; positive = false; break;
        case '+': ++s; break;
        default: break;
        }
        while ( *s >= '0' && *s <= '9' )
        {
                result = ( result * 10 ) + ( *s - '0' );
                ++s;
        }
        if ( end != nullptr ) *end = (char*)s;
        return positive ? result : -result;
}

uint32 buffer_to_uint32( const char* s, char** end )
{
        while ( *s == ' ' ) ++s;
        uint32 result = 0;
        while ( *s >= '0' && *s <= '9' )
        {
                result = ( result * 10 ) + ( *s - '0' );
                ++s;
        }
        if ( end != nullptr ) *end = (char*)s;
        return result;
}

uint64 buffer_to_uint64( const char* s, char** end )
{
        while ( *s == ' ' ) ++s;
        uint64 result = 0;
        while ( *s >= '0' && *s <= '9' )
        {
                result = ( result * 10 ) + ( *s - '0' );
                ++s;
        }
        if ( end != nullptr ) *end = (char*)s;
        return result;
}

float buffer_to_f32( const char* s, char** end )
{
        return strtof( s, end );
}

double buffer_to_f64( const char* s, char** end )
{
        return strtod( s, end );
}