1 files changed, 364 insertions, 0 deletions
diff --git a/src/others/irrlicht-1.8.1/include/fast_atof.h b/src/others/irrlicht-1.8.1/include/fast_atof.h
new file mode 100644
index 0000000..7d4917a
--- /dev/null
+++ b/src/others/irrlicht-1.8.1/include/fast_atof.h
@@ -0,0 +1,364 @@
+// Copyright (C) 2002-2012 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
+#ifndef __FAST_ATOF_H_INCLUDED__
+#define __FAST_ATOF_H_INCLUDED__
+#include "irrMath.h"
+#include "irrString.h"
+namespace irr
+{
+namespace core
+{
+        //! Selection of characters which count as decimal point in fast_atof
+        // TODO: This should probably also be used in irr::core::string, but the float-to-string code
+        //              used there has to be rewritten first.
+        IRRLICHT_API extern irr::core::stringc LOCALE_DECIMAL_POINTS;
+// we write [17] here instead of [] to work around a swig bug
+const float fast_atof_table[17] = {
+        0.f,
+        0.1f,
+        0.01f,
+        0.001f,
+        0.0001f,
+        0.00001f,
+        0.000001f,
+        0.0000001f,
+        0.00000001f,
+        0.000000001f,
+        0.0000000001f,
+        0.00000000001f,
+        0.000000000001f,
+        0.0000000000001f,
+        0.00000000000001f,
+        0.000000000000001f,
+        0.0000000000000001f
+};
+//! Convert a simple string of base 10 digits into an unsigned 32 bit integer.
+/** \param[in] in: The string of digits to convert. No leading chars are
+    allowed, only digits 0 to 9. Parsing stops at the first non-digit.
+    \param[out] out: (optional) If provided, it will be set to point at the
+    first character not used in the calculation.
+    \return The unsigned integer value of the digits. If the string specifies
+    too many digits to encode in an u32 then INT_MAX will be returned.
+*/
+inline u32 strtoul10(const char* in, const char** out=0)
+{
+        if (!in)
+        {
+                if (out)
+                        *out = in;
+                return 0;
+        }
+        bool overflow=false;
+        u32 unsignedValue = 0;
+        while ( ( *in >= '0') && ( *in <= '9' ))
+        {
+                const u32 tmp = ( unsignedValue * 10 ) + ( *in - '0' );
+                if (tmp<unsignedValue)
+                {
+                        unsignedValue=(u32)0xffffffff;
+                        overflow=true;
+                }
+                if (!overflow)
+                        unsignedValue = tmp;
+                ++in;
+        }
+        if (out)
+                *out = in;
+        return unsignedValue;
+}
+//! Convert a simple string of base 10 digits into a signed 32 bit integer.
+/** \param[in] in: The string of digits to convert. Only a leading - or +
+    followed by digits 0 to 9 will be considered. Parsing stops at the first
+    non-digit.
+    \param[out] out: (optional) If provided, it will be set to point at the
+    first character not used in the calculation.
+    \return The signed integer value of the digits. If the string specifies
+    too many digits to encode in an s32 then +INT_MAX or -INT_MAX will be
+    returned.
+*/
+inline s32 strtol10(const char* in, const char** out=0)
+{
+        if (!in)
+        {
+                if (out)
+                        *out = in;
+                return 0;
+        }
+        const bool negative = ('-' == *in);
+        if (negative || ('+' == *in))
+                ++in;
+        const u32 unsignedValue = strtoul10(in,out);
+        if (unsignedValue > (u32)INT_MAX)
+        {
+                if (negative)
+                        return (s32)INT_MIN;
+                else
+                        return (s32)INT_MAX;
+        }
+        else
+        {
+                if (negative)
+                        return -((s32)unsignedValue);
+                else
+                        return (s32)unsignedValue;
+        }
+}
+//! Convert a hex-encoded character to an unsigned integer.
+/** \param[in] in The digit to convert. Only digits 0 to 9 and chars A-F,a-f
+    will be considered.
+    \return The unsigned integer value of the digit. 0xffffffff if the input is
+    not hex
+*/
+inline u32 ctoul16(char in)
+{
+        if (in >= '0' && in <= '9')
+                return in - '0';
+        else if (in >= 'a' && in <= 'f')
+                return 10u + in - 'a';
+        else if (in >= 'A' && in <= 'F')
+                return 10u + in - 'A';
+        else
+                return 0xffffffff;
+}
+//! Convert a simple string of base 16 digits into an unsigned 32 bit integer.
+/** \param[in] in: The string of digits to convert. No leading chars are
+    allowed, only digits 0 to 9 and chars A-F,a-f are allowed. Parsing stops
+    at the first illegal char.
+    \param[out] out: (optional) If provided, it will be set to point at the
+    first character not used in the calculation.
+    \return The unsigned integer value of the digits. If the string specifies
+    too many digits to encode in an u32 then INT_MAX will be returned.
+*/
+inline u32 strtoul16(const char* in, const char** out=0)
+{
+        if (!in)
+        {
+                if (out)
+                        *out = in;
+                return 0;
+        }
+        bool overflow=false;
+        u32 unsignedValue = 0;
+        while (true)
+        {
+                u32 tmp = 0;
+                if ((*in >= '0') && (*in <= '9'))
+                        tmp = (unsignedValue << 4u) + (*in - '0');
+                else if ((*in >= 'A') && (*in <= 'F'))
+                        tmp = (unsignedValue << 4u) + (*in - 'A') + 10;
+                else if ((*in >= 'a') && (*in <= 'f'))
+                        tmp = (unsignedValue << 4u) + (*in - 'a') + 10;
+                else
+                        break;
+                if (tmp<unsignedValue)
+                {
+                        unsignedValue=(u32)INT_MAX;
+                        overflow=true;
+                }
+                if (!overflow)
+                        unsignedValue = tmp;
+                ++in;
+        }
+        if (out)
+                *out = in;
+        return unsignedValue;
+}
+//! Convert a simple string of base 8 digits into an unsigned 32 bit integer.
+/** \param[in] in The string of digits to convert. No leading chars are
+    allowed, only digits 0 to 7 are allowed. Parsing stops at the first illegal
+    char.
+    \param[out] out (optional) If provided, it will be set to point at the
+    first character not used in the calculation.
+    \return The unsigned integer value of the digits. If the string specifies
+    too many digits to encode in an u32 then INT_MAX will be returned.
+*/
+inline u32 strtoul8(const char* in, const char** out=0)
+{
+        if (!in)
+        {
+                if (out)
+                        *out = in;
+                return 0;
+        }
+        bool overflow=false;
+        u32 unsignedValue = 0;
+        while (true)
+        {
+                u32 tmp = 0;
+                if ((*in >= '0') && (*in <= '7'))
+                        tmp = (unsignedValue << 3u) + (*in - '0');
+                else
+                        break;
+                if (tmp<unsignedValue)
+                {
+                        unsignedValue=(u32)INT_MAX;
+                        overflow=true;
+                }
+                if (!overflow)
+                        unsignedValue = tmp;
+                ++in;
+        }
+        if (out)
+                *out = in;
+        return unsignedValue;
+}
+//! Convert a C-style prefixed string (hex, oct, integer) into an unsigned 32 bit integer.
+/** \param[in] in The string of digits to convert. If string starts with 0x the
+    hex parser is used, if only leading 0 is used, oct parser is used. In all
+    other cases, the usual unsigned parser is used.
+    \param[out] out (optional) If provided, it will be set to point at the
+    first character not used in the calculation.
+    \return The unsigned integer value of the digits. If the string specifies
+    too many digits to encode in an u32 then INT_MAX will be returned.
+*/
+inline u32 strtoul_prefix(const char* in, const char** out=0)
+{
+        if (!in)
+        {
+                if (out)
+                        *out = in;
+                return 0;
+        }
+        if ('0'==in[0])
+                return ('x'==in[1] ? strtoul16(in+2,out) : strtoul8(in+1,out));
+        return strtoul10(in,out);
+}
+//! Converts a sequence of digits into a whole positive floating point value.
+/** Only digits 0 to 9 are parsed.  Parsing stops at any other character,
+    including sign characters or a decimal point.
+    \param in: the sequence of digits to convert.
+    \param out: (optional) will be set to point at the first non-converted
+    character.
+    \return The whole positive floating point representation of the digit
+    sequence.
+*/
+inline f32 strtof10(const char* in, const char** out = 0)
+{
+        if (!in)
+        {
+                if (out)
+                        *out = in;
+                return 0.f;
+        }
+        const u32 MAX_SAFE_U32_VALUE = UINT_MAX / 10 - 10;
+        u32 intValue = 0;
+        // Use integer arithmetic for as long as possible, for speed
+        // and precision.
+        while ( ( *in >= '0') && ( *in <= '9' ) )
+        {
+                // If it looks like we're going to overflow, bail out
+                // now and start using floating point.
+                if (intValue >= MAX_SAFE_U32_VALUE)
+                        break;
+                intValue = (intValue * 10) + (*in - '0');
+                ++in;
+        }
+        f32 floatValue = (f32)intValue;
+        // If there are any digits left to parse, then we need to use
+        // floating point arithmetic from here.
+        while ( ( *in >= '0') && ( *in <= '9' ) )
+        {
+                floatValue = (floatValue * 10.f) + (f32)(*in - '0');
+                ++in;
+                if (floatValue > FLT_MAX) // Just give up.
+                        break;
+        }
+        if (out)
+                *out = in;
+        return floatValue;
+}
+//! Provides a fast function for converting a string into a float.
+/** This is not guaranteed to be as accurate as atof(), but is
+    approximately 6 to 8 times as fast.
+    \param[in] in The string to convert.
+    \param[out] result The resultant float will be written here.
+    \return Pointer to the first character in the string that wasn't used
+    to create the float value.
+*/
+inline const char* fast_atof_move(const char* in, f32& result)
+{
+        // Please run the regression test when making any modifications to this function.
+        result = 0.f;
+        if (!in)
+                return 0;
+        const bool negative = ('-' == *in);
+        if (negative || ('+'==*in))
+                ++in;
+        f32 value = strtof10(in, &in);
+        if ( LOCALE_DECIMAL_POINTS.findFirst(*in) >= 0 )
+        {
+                const char* afterDecimal = ++in;
+                const f32 decimal = strtof10(in, &afterDecimal);
+                value += decimal * fast_atof_table[afterDecimal - in];
+                in = afterDecimal;
+        }
+        if ('e' == *in || 'E' == *in)
+        {
+                ++in;
+                // Assume that the exponent is a whole number.
+                // strtol10() will deal with both + and - signs,
+                // but calculate as f32 to prevent overflow at FLT_MAX
+                value *= powf(10.f, (f32)strtol10(in, &in));
+        }
+        result = negative?-value:value;
+        return in;
+}
+//! Convert a string to a floating point number
+/** \param floatAsString The string to convert.
+    \param out Optional pointer to the first character in the string that
+    wasn't used to create the float value.
+    \result Float value parsed from the input string
+*/
+inline float fast_atof(const char* floatAsString, const char** out=0)
+{
+        float ret;
+        if (out)
+                *out=fast_atof_move(floatAsString, ret);
+        else
+                fast_atof_move(floatAsString, ret);
+        return ret;
+}
+} // end namespace core
+} // end namespace irr
+#endif

diff --git a/src/others/irrlicht-1.8.1/include/fast_atof.h b/src/others/irrlicht-1.8.1/include/fast_atof.h new file mode 100644 index 0000000..7d4917a --- /dev/null +++ b/src/others/irrlicht-1.8.1/include/fast_atof.h
@@ -0,0 +1,364 @@
	1	// Copyright (C) 2002-2012 Nikolaus Gebhardt
	2	// This file is part of the "Irrlicht Engine" and the "irrXML" project.
	3	// For conditions of distribution and use, see copyright notice in irrlicht.h and irrXML.h
	4
	5	#ifndef __FAST_ATOF_H_INCLUDED__
	6	#define __FAST_ATOF_H_INCLUDED__
	7
	8	#include "irrMath.h"
	9	#include "irrString.h"
	10
	11	namespace irr
	12	{
	13	namespace core
	14	{
	15	//! Selection of characters which count as decimal point in fast_atof
	16	// TODO: This should probably also be used in irr::core::string, but the float-to-string code
	17	// used there has to be rewritten first.
	18	IRRLICHT_API extern irr::core::stringc LOCALE_DECIMAL_POINTS;
	19
	20	// we write [17] here instead of [] to work around a swig bug
	21	const float fast_atof_table[17] = {
	22	0.f,
	23	0.1f,
	24	0.01f,
	25	0.001f,
	26	0.0001f,
	27	0.00001f,
	28	0.000001f,
	29	0.0000001f,
	30	0.00000001f,
	31	0.000000001f,
	32	0.0000000001f,
	33	0.00000000001f,
	34	0.000000000001f,
	35	0.0000000000001f,
	36	0.00000000000001f,
	37	0.000000000000001f,
	38	0.0000000000000001f
	39	};
	40
	41	//! Convert a simple string of base 10 digits into an unsigned 32 bit integer.
	42	/** \param[in] in: The string of digits to convert. No leading chars are
	43	allowed, only digits 0 to 9. Parsing stops at the first non-digit.
	44	\param[out] out: (optional) If provided, it will be set to point at the
	45	first character not used in the calculation.
	46	\return The unsigned integer value of the digits. If the string specifies
	47	too many digits to encode in an u32 then INT_MAX will be returned.
	48	*/
	49	inline u32 strtoul10(const char* in, const char** out=0)
	50	{
	51	if (!in)
	52	{
	53	if (out)
	54	*out = in;
	55	return 0;
	56	}
	57
	58	bool overflow=false;
	59	u32 unsignedValue = 0;
	60	while ( ( in >= '0') && ( in <= '9' ))
	61	{
	62	const u32 tmp = ( unsignedValue * 10 ) + ( *in - '0' );
	63	if (tmp<unsignedValue)
	64	{
	65	unsignedValue=(u32)0xffffffff;
	66	overflow=true;
	67	}
	68	if (!overflow)
	69	unsignedValue = tmp;
	70	++in;
	71	}
	72
	73	if (out)
	74	*out = in;
	75
	76	return unsignedValue;
	77	}
	78
	79	//! Convert a simple string of base 10 digits into a signed 32 bit integer.
	80	/** \param[in] in: The string of digits to convert. Only a leading - or +
	81	followed by digits 0 to 9 will be considered. Parsing stops at the first
	82	non-digit.
	83	\param[out] out: (optional) If provided, it will be set to point at the
	84	first character not used in the calculation.
	85	\return The signed integer value of the digits. If the string specifies
	86	too many digits to encode in an s32 then +INT_MAX or -INT_MAX will be
	87	returned.
	88	*/
	89	inline s32 strtol10(const char* in, const char** out=0)
	90	{
	91	if (!in)
	92	{
	93	if (out)
	94	*out = in;
	95	return 0;
	96	}
	97
	98	const bool negative = ('-' == *in);
	99	if (negative \|\| ('+' == *in))
	100	++in;
	101
	102	const u32 unsignedValue = strtoul10(in,out);
	103	if (unsignedValue > (u32)INT_MAX)
	104	{
	105	if (negative)
	106	return (s32)INT_MIN;
	107	else
	108	return (s32)INT_MAX;
	109	}
	110	else
	111	{
	112	if (negative)
	113	return -((s32)unsignedValue);
	114	else
	115	return (s32)unsignedValue;
	116	}
	117	}
	118
	119	//! Convert a hex-encoded character to an unsigned integer.
	120	/** \param[in] in The digit to convert. Only digits 0 to 9 and chars A-F,a-f
	121	will be considered.
	122	\return The unsigned integer value of the digit. 0xffffffff if the input is
	123	not hex
	124	*/
	125	inline u32 ctoul16(char in)
	126	{
	127	if (in >= '0' && in <= '9')
	128	return in - '0';
	129	else if (in >= 'a' && in <= 'f')
	130	return 10u + in - 'a';
	131	else if (in >= 'A' && in <= 'F')
	132	return 10u + in - 'A';
	133	else
	134	return 0xffffffff;
	135	}
	136
	137	//! Convert a simple string of base 16 digits into an unsigned 32 bit integer.
	138	/** \param[in] in: The string of digits to convert. No leading chars are
	139	allowed, only digits 0 to 9 and chars A-F,a-f are allowed. Parsing stops
	140	at the first illegal char.
	141	\param[out] out: (optional) If provided, it will be set to point at the
	142	first character not used in the calculation.
	143	\return The unsigned integer value of the digits. If the string specifies
	144	too many digits to encode in an u32 then INT_MAX will be returned.
	145	*/
	146	inline u32 strtoul16(const char* in, const char** out=0)
	147	{
	148	if (!in)
	149	{
	150	if (out)
	151	*out = in;
	152	return 0;
	153	}
	154
	155	bool overflow=false;
	156	u32 unsignedValue = 0;
	157	while (true)
	158	{
	159	u32 tmp = 0;
	160	if ((in >= '0') && (in <= '9'))
	161	tmp = (unsignedValue << 4u) + (*in - '0');
	162	else if ((in >= 'A') && (in <= 'F'))
	163	tmp = (unsignedValue << 4u) + (*in - 'A') + 10;
	164	else if ((in >= 'a') && (in <= 'f'))
	165	tmp = (unsignedValue << 4u) + (*in - 'a') + 10;
	166	else
	167	break;
	168	if (tmp<unsignedValue)
	169	{
	170	unsignedValue=(u32)INT_MAX;
	171	overflow=true;
	172	}
	173	if (!overflow)
	174	unsignedValue = tmp;
	175	++in;
	176	}
	177
	178	if (out)
	179	*out = in;
	180
	181	return unsignedValue;
	182	}
	183
	184	//! Convert a simple string of base 8 digits into an unsigned 32 bit integer.
	185	/** \param[in] in The string of digits to convert. No leading chars are
	186	allowed, only digits 0 to 7 are allowed. Parsing stops at the first illegal
	187	char.
	188	\param[out] out (optional) If provided, it will be set to point at the
	189	first character not used in the calculation.
	190	\return The unsigned integer value of the digits. If the string specifies
	191	too many digits to encode in an u32 then INT_MAX will be returned.
	192	*/
	193	inline u32 strtoul8(const char* in, const char** out=0)
	194	{
	195	if (!in)
	196	{
	197	if (out)
	198	*out = in;
	199	return 0;
	200	}
	201
	202	bool overflow=false;
	203	u32 unsignedValue = 0;
	204	while (true)
	205	{
	206	u32 tmp = 0;
	207	if ((in >= '0') && (in <= '7'))
	208	tmp = (unsignedValue << 3u) + (*in - '0');
	209	else
	210	break;
	211	if (tmp<unsignedValue)
	212	{
	213	unsignedValue=(u32)INT_MAX;
	214	overflow=true;
	215	}
	216	if (!overflow)
	217	unsignedValue = tmp;
	218	++in;
	219	}
	220
	221	if (out)
	222	*out = in;
	223
	224	return unsignedValue;
	225	}
	226
	227	//! Convert a C-style prefixed string (hex, oct, integer) into an unsigned 32 bit integer.
	228	/** \param[in] in The string of digits to convert. If string starts with 0x the
	229	hex parser is used, if only leading 0 is used, oct parser is used. In all
	230	other cases, the usual unsigned parser is used.
	231	\param[out] out (optional) If provided, it will be set to point at the
	232	first character not used in the calculation.
	233	\return The unsigned integer value of the digits. If the string specifies
	234	too many digits to encode in an u32 then INT_MAX will be returned.
	235	*/
	236	inline u32 strtoul_prefix(const char* in, const char** out=0)
	237	{
	238	if (!in)
	239	{
	240	if (out)
	241	*out = in;
	242	return 0;
	243	}
	244	if ('0'==in[0])
	245	return ('x'==in[1] ? strtoul16(in+2,out) : strtoul8(in+1,out));
	246	return strtoul10(in,out);
	247	}
	248
	249	//! Converts a sequence of digits into a whole positive floating point value.
	250	/** Only digits 0 to 9 are parsed. Parsing stops at any other character,
	251	including sign characters or a decimal point.
	252	\param in: the sequence of digits to convert.
	253	\param out: (optional) will be set to point at the first non-converted
	254	character.
	255	\return The whole positive floating point representation of the digit
	256	sequence.
	257	*/
	258	inline f32 strtof10(const char* in, const char** out = 0)
	259	{
	260	if (!in)
	261	{
	262	if (out)
	263	*out = in;
	264	return 0.f;
	265	}
	266
	267	const u32 MAX_SAFE_U32_VALUE = UINT_MAX / 10 - 10;
	268	u32 intValue = 0;
	269
	270	// Use integer arithmetic for as long as possible, for speed
	271	// and precision.
	272	while ( ( in >= '0') && ( in <= '9' ) )
	273	{
	274	// If it looks like we're going to overflow, bail out
	275	// now and start using floating point.
	276	if (intValue >= MAX_SAFE_U32_VALUE)
	277	break;
	278
	279	intValue = (intValue * 10) + (*in - '0');
	280	++in;
	281	}
	282
	283	f32 floatValue = (f32)intValue;
	284
	285	// If there are any digits left to parse, then we need to use
	286	// floating point arithmetic from here.
	287	while ( ( in >= '0') && ( in <= '9' ) )
	288	{
	289	floatValue = (floatValue * 10.f) + (f32)(*in - '0');
	290	++in;
	291	if (floatValue > FLT_MAX) // Just give up.
	292	break;
	293	}
	294
	295	if (out)
	296	*out = in;
	297
	298	return floatValue;
	299	}
	300
	301	//! Provides a fast function for converting a string into a float.
	302	/** This is not guaranteed to be as accurate as atof(), but is
	303	approximately 6 to 8 times as fast.
	304	\param[in] in The string to convert.
	305	\param[out] result The resultant float will be written here.
	306	\return Pointer to the first character in the string that wasn't used
	307	to create the float value.
	308	*/
	309	inline const char* fast_atof_move(const char* in, f32& result)
	310	{
	311	// Please run the regression test when making any modifications to this function.
	312
	313	result = 0.f;
	314	if (!in)
	315	return 0;
	316
	317	const bool negative = ('-' == *in);
	318	if (negative \|\| ('+'==*in))
	319	++in;
	320
	321	f32 value = strtof10(in, &in);
	322
	323	if ( LOCALE_DECIMAL_POINTS.findFirst(*in) >= 0 )
	324	{
	325	const char* afterDecimal = ++in;
	326	const f32 decimal = strtof10(in, &afterDecimal);
	327	value += decimal * fast_atof_table[afterDecimal - in];
	328	in = afterDecimal;
	329	}
	330
	331	if ('e' == in \|\| 'E' == in)
	332	{
	333	++in;
	334	// Assume that the exponent is a whole number.
	335	// strtol10() will deal with both + and - signs,
	336	// but calculate as f32 to prevent overflow at FLT_MAX
	337	value *= powf(10.f, (f32)strtol10(in, &in));
	338	}
	339
	340	result = negative?-value:value;
	341	return in;
	342	}
	343
	344	//! Convert a string to a floating point number
	345	/** \param floatAsString The string to convert.
	346	\param out Optional pointer to the first character in the string that
	347	wasn't used to create the float value.
	348	\result Float value parsed from the input string
	349	*/
	350	inline float fast_atof(const char* floatAsString, const char** out=0)
	351	{
	352	float ret;
	353	if (out)
	354	*out=fast_atof_move(floatAsString, ret);
	355	else
	356	fast_atof_move(floatAsString, ret);
	357	return ret;
	358	}
	359
	360	} // end namespace core
	361	} // end namespace irr
	362
	363	#endif
	364