diff options
Diffstat (limited to 'src/3rdparty/assimp/code/fast_atof.h')
-rw-r--r-- | src/3rdparty/assimp/code/fast_atof.h | 387 |
1 files changed, 0 insertions, 387 deletions
diff --git a/src/3rdparty/assimp/code/fast_atof.h b/src/3rdparty/assimp/code/fast_atof.h deleted file mode 100644 index 058a7ff87..000000000 --- a/src/3rdparty/assimp/code/fast_atof.h +++ /dev/null @@ -1,387 +0,0 @@ -#pragma once - -// Copyright (C) 2002-2007 Nikolaus Gebhardt -// This file is part of the "Irrlicht Engine" and the "irrXML" project. -// For conditions of distribution and use, see copyright notice in irrlicht.h and irrXML.h - -// ------------------------------------------------------------------------------------ -// Original description: (Schrompf) -// Adapted to the ASSIMP library because the builtin atof indeed takes AGES to parse a -// float inside a large string. Before parsing, it does a strlen on the given point. -// Changes: -// 22nd October 08 (Aramis_acg): Added temporary cast to double, added strtoul10_64 -// to ensure long numbers are handled correctly -// ------------------------------------------------------------------------------------ - - -#ifndef __FAST_A_TO_F_H_INCLUDED__ -#define __FAST_A_TO_F_H_INCLUDED__ - -#include <cmath> -#include <limits> -#include <stdint.h> -#include <stdexcept> -#include <assimp/defs.h> - -#include "StringComparison.h" -#include <assimp/DefaultLogger.hpp> - - -#ifdef _MSC_VER -# include <stdint.h> -#else -# include <assimp/Compiler/pstdint.h> -#endif - -namespace Assimp -{ - -const double fast_atof_table[16] = { // we write [16] here instead of [] to work around a swig bug - 0.0, - 0.1, - 0.01, - 0.001, - 0.0001, - 0.00001, - 0.000001, - 0.0000001, - 0.00000001, - 0.000000001, - 0.0000000001, - 0.00000000001, - 0.000000000001, - 0.0000000000001, - 0.00000000000001, - 0.000000000000001 -}; - - -// ------------------------------------------------------------------------------------ -// Convert a string in decimal format to a number -// ------------------------------------------------------------------------------------ -inline unsigned int strtoul10( const char* in, const char** out=0) -{ - unsigned int value = 0; - - bool running = true; - while ( running ) - { - if ( *in < '0' || *in > '9' ) - break; - - value = ( value * 10 ) + ( *in - '0' ); - ++in; - } - if (out)*out = in; - return value; -} - -// ------------------------------------------------------------------------------------ -// Convert a string in octal format to a number -// ------------------------------------------------------------------------------------ -inline unsigned int strtoul8( const char* in, const char** out=0) -{ - unsigned int value = 0; - - bool running = true; - while ( running ) - { - if ( *in < '0' || *in > '7' ) - break; - - value = ( value << 3 ) + ( *in - '0' ); - ++in; - } - if (out)*out = in; - return value; -} - -// ------------------------------------------------------------------------------------ -// Convert a string in hex format to a number -// ------------------------------------------------------------------------------------ -inline unsigned int strtoul16( const char* in, const char** out=0) -{ - unsigned int value = 0; - - bool running = true; - while ( running ) - { - if ( *in >= '0' && *in <= '9' ) - { - value = ( value << 4u ) + ( *in - '0' ); - } - else if (*in >= 'A' && *in <= 'F') - { - value = ( value << 4u ) + ( *in - 'A' ) + 10; - } - else if (*in >= 'a' && *in <= 'f') - { - value = ( value << 4u ) + ( *in - 'a' ) + 10; - } - else break; - ++in; - } - if (out)*out = in; - return value; -} - -// ------------------------------------------------------------------------------------ -// Convert just one hex digit -// Return value is UINT_MAX if the input character is not a hex digit. -// ------------------------------------------------------------------------------------ -inline unsigned int HexDigitToDecimal(char in) -{ - unsigned int out = UINT_MAX; - if (in >= '0' && in <= '9') - out = in - '0'; - - else if (in >= 'a' && in <= 'f') - out = 10u + in - 'a'; - - else if (in >= 'A' && in <= 'F') - out = 10u + in - 'A'; - - // return value is UINT_MAX if the input is not a hex digit - return out; -} - -// ------------------------------------------------------------------------------------ -// Convert a hex-encoded octet (2 characters, i.e. df or 1a). -// ------------------------------------------------------------------------------------ -inline uint8_t HexOctetToDecimal(const char* in) -{ - return ((uint8_t)HexDigitToDecimal(in[0])<<4)+(uint8_t)HexDigitToDecimal(in[1]); -} - - -// ------------------------------------------------------------------------------------ -// signed variant of strtoul10 -// ------------------------------------------------------------------------------------ -inline int strtol10( const char* in, const char** out=0) -{ - bool inv = (*in=='-'); - if (inv || *in=='+') - ++in; - - int value = strtoul10(in,out); - if (inv) { - value = -value; - } - return value; -} - -// ------------------------------------------------------------------------------------ -// Parse a C++-like integer literal - hex and oct prefixes. -// 0xNNNN - hex -// 0NNN - oct -// NNN - dec -// ------------------------------------------------------------------------------------ -inline unsigned int strtoul_cppstyle( const char* in, const char** out=0) -{ - if ('0' == in[0]) - { - return 'x' == in[1] ? strtoul16(in+2,out) : strtoul8(in+1,out); - } - return strtoul10(in, out); -} - -// ------------------------------------------------------------------------------------ -// Special version of the function, providing higher accuracy and safety -// It is mainly used by fast_atof to prevent ugly and unwanted integer overflows. -// ------------------------------------------------------------------------------------ -inline uint64_t strtoul10_64( const char* in, const char** out=0, unsigned int* max_inout=0) -{ - unsigned int cur = 0; - uint64_t value = 0; - - if ( *in < '0' || *in > '9' ) - throw std::invalid_argument(std::string("The string \"") + in + "\" cannot be converted into a value."); - - bool running = true; - while ( running ) - { - if ( *in < '0' || *in > '9' ) - break; - - const uint64_t new_value = ( value * 10 ) + ( *in - '0' ); - - // numeric overflow, we rely on you - if ( new_value < value ) { - DefaultLogger::get()->warn( std::string( "Converting the string \"" ) + in + "\" into a value resulted in overflow." ); - return 0; - } - //throw std::overflow_error(); - - value = new_value; - - ++in; - ++cur; - - if (max_inout && *max_inout == cur) { - - if (out) { /* skip to end */ - while (*in >= '0' && *in <= '9') - ++in; - *out = in; - } - - return value; - } - } - if (out) - *out = in; - - if (max_inout) - *max_inout = cur; - - return value; -} - -// ------------------------------------------------------------------------------------ -// signed variant of strtoul10_64 -// ------------------------------------------------------------------------------------ -inline int64_t strtol10_64(const char* in, const char** out = 0, unsigned int* max_inout = 0) -{ - bool inv = (*in == '-'); - if (inv || *in == '+') - ++in; - - int64_t value = strtoul10_64(in, out, max_inout); - if (inv) { - value = -value; - } - return value; -} - - -// Number of relevant decimals for floating-point parsing. -#define AI_FAST_ATOF_RELAVANT_DECIMALS 15 - -// ------------------------------------------------------------------------------------ -//! Provides a fast function for converting a string into a float, -//! about 6 times faster than atof in win32. -// If you find any bugs, please send them to me, niko (at) irrlicht3d.org. -// ------------------------------------------------------------------------------------ -template <typename Real> -inline const char* fast_atoreal_move(const char* c, Real& out, bool check_comma = true) -{ - Real f = 0; - - bool inv = (*c == '-'); - if (inv || *c == '+') { - ++c; - } - - if ((c[0] == 'N' || c[0] == 'n') && ASSIMP_strincmp(c, "nan", 3) == 0) - { - out = std::numeric_limits<Real>::quiet_NaN(); - c += 3; - return c; - } - - if ((c[0] == 'I' || c[0] == 'i') && ASSIMP_strincmp(c, "inf", 3) == 0) - { - out = std::numeric_limits<Real>::infinity(); - if (inv) { - out = -out; - } - c += 3; - if ((c[0] == 'I' || c[0] == 'i') && ASSIMP_strincmp(c, "inity", 5) == 0) - { - c += 5; - } - return c; - } - - if (!(c[0] >= '0' && c[0] <= '9') && - !((c[0] == '.' || (check_comma && c[0] == ',')) && c[1] >= '0' && c[1] <= '9')) - { - throw std::invalid_argument("Cannot parse string " - "as real number: does not start with digit " - "or decimal point followed by digit."); - } - - if (*c != '.' && (! check_comma || c[0] != ',')) - { - f = static_cast<Real>( strtoul10_64 ( c, &c) ); - } - - if ((*c == '.' || (check_comma && c[0] == ',')) && c[1] >= '0' && c[1] <= '9') - { - ++c; - - // NOTE: The original implementation is highly inaccurate here. The precision of a single - // IEEE 754 float is not high enough, everything behind the 6th digit tends to be more - // inaccurate than it would need to be. Casting to double seems to solve the problem. - // strtol_64 is used to prevent integer overflow. - - // Another fix: this tends to become 0 for long numbers if we don't limit the maximum - // number of digits to be read. AI_FAST_ATOF_RELAVANT_DECIMALS can be a value between - // 1 and 15. - unsigned int diff = AI_FAST_ATOF_RELAVANT_DECIMALS; - double pl = static_cast<double>( strtoul10_64 ( c, &c, &diff )); - - pl *= fast_atof_table[diff]; - f += static_cast<Real>( pl ); - } - // For backwards compatibility: eat trailing dots, but not trailing commas. - else if (*c == '.') { - ++c; - } - - // A major 'E' must be allowed. Necessary for proper reading of some DXF files. - // Thanks to Zhao Lei to point out that this if() must be outside the if (*c == '.' ..) - if (*c == 'e' || *c == 'E') { - - ++c; - const bool einv = (*c=='-'); - if (einv || *c=='+') { - ++c; - } - - // The reason float constants are used here is that we've seen cases where compilers - // would perform such casts on compile-time constants at runtime, which would be - // bad considering how frequently fast_atoreal_move<float> is called in Assimp. - Real exp = static_cast<Real>( strtoul10_64(c, &c) ); - if (einv) { - exp = -exp; - } - f *= std::pow(static_cast<Real>(10.0), exp); - } - - if (inv) { - f = -f; - } - out = f; - return c; -} - -// ------------------------------------------------------------------------------------ -// The same but more human. -inline ai_real fast_atof(const char* c) -{ - ai_real ret(0.0); - fast_atoreal_move<ai_real>(c, ret); - return ret; -} - - -inline ai_real fast_atof( const char* c, const char** cout) -{ - ai_real ret(0.0); - *cout = fast_atoreal_move<ai_real>(c, ret); - - return ret; -} - -inline ai_real fast_atof( const char** inout) -{ - ai_real ret(0.0); - *inout = fast_atoreal_move<ai_real>(*inout, ret); - - return ret; -} - -} // end of namespace Assimp - -#endif |