Removed use of size_t in string functions.

include/bx/string.h

@@ -27,10 +27,10 @@ namespace bx
 		StringView& operator=(const StringView& _rhs);
 
 		///
-		StringView(const char* _ptr, uint32_t _len = UINT16_MAX);
+		StringView(const char* _ptr, int32_t _len = INT32_MAX);
 
 		///
-		void set(const char* _ptr, uint32_t _len = UINT16_MAX);
+		void set(const char* _ptr, int32_t _len = INT32_MAX);
 
 		///
 		void clear();
@@ -45,11 +45,11 @@ namespace bx
 		bool isEmpty() const;
 
 		///
-		uint32_t getLength() const;
+		int32_t getLength() const;
 
 	protected:
 		const char* m_ptr;
-		uint32_t    m_len;
+		int32_t     m_len;
 	};
 
 	/// ASCII string
@@ -67,7 +67,7 @@ namespace bx
 		StringT<AllocatorT>& operator=(const StringT<AllocatorT>& _rhs);
 
 		///
-		StringT(const char* _ptr, uint32_t _len = UINT32_MAX);
+		StringT(const char* _ptr, int32_t _len = INT32_MAX);
 
 		///
 		StringT(const StringView& _rhs);
@@ -76,10 +76,10 @@ namespace bx
 		~StringT();
 
 		///
-		void set(const char* _ptr, uint32_t _len = UINT32_MAX);
+		void set(const char* _ptr, int32_t _len = INT32_MAX);
 
 		///
-		void append(const char* _ptr, uint32_t _len = UINT32_MAX);
+		void append(const char* _ptr, int32_t _len = INT32_MAX);
 
 		///
 		void clear();
@@ -110,50 +110,50 @@ namespace bx
 	char toLower(char _ch);
 
 	///
-	void toLowerUnsafe(char* _inOutStr, size_t _len);
+	void toLowerUnsafe(char* _inOutStr, int32_t _len);
 
 	///
-	void toLower(char* _inOutStr, size_t _max = INT32_MAX);
+	void toLower(char* _inOutStr, int32_t _max = INT32_MAX);
 
 	///
 	char toUpper(char _ch);
 
 	///
-	void toUpperUnsafe(char* _inOutStr, size_t _len);
+	void toUpperUnsafe(char* _inOutStr, int32_t _len);
 
 	///
-	void toUpper(char* _inOutStr, size_t _max = INT32_MAX);
+	void toUpper(char* _inOutStr, int32_t _max = INT32_MAX);
 
 	///
 	bool toBool(const char* _str);
 
 	/// String compare.
-	int32_t strncmp(const char* _lhs, const char* _rhs, size_t _max = INT32_MAX);
+	int32_t strncmp(const char* _lhs, const char* _rhs, int32_t _max = INT32_MAX);
 
 	/// Case insensitive string compare.
-	int32_t strincmp(const char* _lhs, const char* _rhs, size_t _max = INT32_MAX);
+	int32_t strincmp(const char* _lhs, const char* _rhs, int32_t _max = INT32_MAX);
 
 	///
-	size_t strnlen(const char* _str, size_t _max = -1);
+	int32_t strnlen(const char* _str, int32_t _max = INT32_MAX);
 
 	/// Copy _num characters from string _src to _dst buffer of maximum _dstSize capacity
 	/// including zero terminator. Copy will be terminated with '\0'.
-	size_t strlncpy(char* _dst, size_t _dstSize, const char* _src, size_t _num = INT32_MAX);
+	int32_t strlncpy(char* _dst, int32_t _dstSize, const char* _src, int32_t _num = INT32_MAX);
 
 	///
-	size_t strlncat(char* _dst, size_t _dstSize, const char* _src, size_t _num = INT32_MAX);
+	int32_t strlncat(char* _dst, int32_t _dstSize, const char* _src, int32_t _num = INT32_MAX);
 
 	///
-	const char* strnchr(const char* _str, char _ch, size_t _max = INT32_MAX);
+	const char* strnchr(const char* _str, char _ch, int32_t _max = INT32_MAX);
 
 	///
-	const char* strnrchr(const char* _str, char _ch, size_t _max = INT32_MAX);
+	const char* strnrchr(const char* _str, char _ch, int32_t _max = INT32_MAX);
 
 	/// Find substring in string. Limit search to _size.
-	const char* strnstr(const char* _str, const char* _find, size_t _max = INT32_MAX);
+	const char* strnstr(const char* _str, const char* _find, int32_t _max = INT32_MAX);
 
 	/// Find substring in string. Case insensitive. Limit search to _max.
-	const char* stristr(const char* _str, const char* _find, size_t _max = INT32_MAX);
+	const char* stristr(const char* _str, const char* _find, int32_t _max = INT32_MAX);
 
 	/// Find new line. Returns pointer after new line terminator.
 	const char* strnl(const char* _str);
@@ -174,7 +174,7 @@ namespace bx
 	const char* strmb(const char* _str, char _open, char _close);
 
 	// Normalize string to sane line endings.
-	void eolLF(char* _out, size_t _size, const char* _str);
+	void eolLF(char* _out, int32_t _size, const char* _str);
 
 	// Finds identifier.
 	const char* findIdentifierMatch(const char* _str, const char* _word);
@@ -185,18 +185,18 @@ namespace bx
 	/// Cross platform implementation of vsnprintf that returns number of
 	/// characters which would have been written to the final string if
 	/// enough space had been available.
-	int32_t vsnprintf(char* _out, size_t _max, const char* _format, va_list _argList);
+	int32_t vsnprintf(char* _out, int32_t _max, const char* _format, va_list _argList);
 
 	/// Cross platform implementation of vsnwprintf that returns number of
 	/// characters which would have been written to the final string if
 	/// enough space had been available.
-	int32_t vsnwprintf(wchar_t* _out, size_t _max, const wchar_t* _format, va_list _argList);
+	int32_t vsnwprintf(wchar_t* _out, int32_t _max, const wchar_t* _format, va_list _argList);
 
 	///
-	int32_t snprintf(char* _out, size_t _max, const char* _format, ...);
+	int32_t snprintf(char* _out, int32_t _max, const char* _format, ...);
 
 	///
-	int32_t swnprintf(wchar_t* _out, size_t _max, const wchar_t* _format, ...);
+	int32_t swnprintf(wchar_t* _out, int32_t _max, const wchar_t* _format, ...);
 
 	///
 	template <typename Ty>
@@ -214,34 +214,34 @@ namespace bx
 	const char* baseName(const char* _filePath);
 
 	/// Convert size in bytes to human readable string.
-	void prettify(char* _out, size_t _count, uint64_t _size);
+	void prettify(char* _out, int32_t _count, uint64_t _size);
 
 	/// Copy src to string dst of size siz.  At most siz-1 characters
 	/// will be copied.  Always NUL terminates (unless siz == 0).
 	/// Returns strlen(src); if retval >= siz, truncation occurred.
-	size_t strlcpy(char* _dst, const char* _src, size_t _max);
+	int32_t strlcpy(char* _dst, const char* _src, int32_t _max);
 
 	/// Appends src to string dst of size siz (unlike strncat, siz is the
 	/// full size of dst, not space left).  At most siz-1 characters
 	/// will be copied.  Always NUL terminates (unless siz <= strlen(dst)).
 	/// Returns strlen(src) + MIN(siz, strlen(initial dst)).
 	/// If retval >= siz, truncation occurred.
-	size_t strlcat(char* _dst, const char* _src, size_t _max);
+	int32_t strlcat(char* _dst, const char* _src, int32_t _max);
 
 	///
-	int32_t toString(char* _out, size_t _max, double _value);
+	int32_t toString(char* _out, int32_t _max, double _value);
 
 	///
-	int32_t toString(char* _out, size_t _max, int32_t _value, uint32_t _base = 10);
+	int32_t toString(char* _out, int32_t _max, int32_t _value, uint32_t _base = 10);
 
 	///
-	int32_t toString(char* _out, size_t _max, int64_t _value, uint32_t _base = 10);
+	int32_t toString(char* _out, int32_t _max, int64_t _value, uint32_t _base = 10);
 
 	///
-	int32_t toString(char* _out, size_t _max, uint32_t _value, uint32_t _base = 10);
+	int32_t toString(char* _out, int32_t _max, uint32_t _value, uint32_t _base = 10);
 
 	///
-	int32_t toString(char* _out, size_t _max, uint64_t _value, uint32_t _base = 10);
+	int32_t toString(char* _out, int32_t _max, uint64_t _value, uint32_t _base = 10);
 
 } // namespace bx
 

include/bx/string.inl

@@ -42,9 +42,9 @@ namespace bx
 	inline Ty replaceAll(const Ty& _str, const char* _from, const char* _to)
 	{
 		Ty str = _str;
-		size_t startPos = 0;
-		const size_t fromLen = strnlen(_from);
-		const size_t toLen   = strnlen(_to);
+		int32_t startPos = 0;
+		const int32_t fromLen = strnlen(_from);
+		const int32_t toLen   = strnlen(_to);
 		while ( (startPos = str.find(_from, startPos) ) != Ty::npos)
 		{
 			str.replace(startPos, fromLen, _to);
@@ -70,18 +70,18 @@ namespace bx
 		return *this;
 	}
 
-	inline StringView::StringView(const char* _ptr, uint32_t _len)
+	inline StringView::StringView(const char* _ptr, int32_t _len)
 	{
 		set(_ptr, _len);
 	}
 
-	inline void StringView::set(const char* _ptr, uint32_t _len)
+	inline void StringView::set(const char* _ptr, int32_t _len)
 	{
 		clear();
 
 		if (NULL != _ptr)
 		{
-			uint32_t len = uint32_t(strnlen(_ptr, _len) );
+			int32_t len = strnlen(_ptr, _len);
 			if (0 != len)
 			{
 				m_len = len;
@@ -111,7 +111,7 @@ namespace bx
 		return 0 == m_len;
 	}
 
-	inline uint32_t StringView::getLength() const
+	inline int32_t StringView::getLength() const
 	{
 		return m_len;
 	}
@@ -137,7 +137,7 @@ namespace bx
 	}
 
 	template<bx::AllocatorI** AllocatorT>
-	inline StringT<AllocatorT>::StringT(const char* _ptr, uint32_t _len)
+	inline StringT<AllocatorT>::StringT(const char* _ptr, int32_t _len)
 	{
 		set(_ptr, _len);
 	}
@@ -155,19 +155,19 @@ namespace bx
 	}
 
 	template<bx::AllocatorI** AllocatorT>
-	inline void StringT<AllocatorT>::set(const char* _ptr, uint32_t _len)
+	inline void StringT<AllocatorT>::set(const char* _ptr, int32_t _len)
 	{
 		clear();
 		append(_ptr, _len);
 	}
 
 	template<bx::AllocatorI** AllocatorT>
-	inline void StringT<AllocatorT>::append(const char* _ptr, uint32_t _len)
+	inline void StringT<AllocatorT>::append(const char* _ptr, int32_t _len)
 	{
 		if (0 != _len)
 		{
-			uint32_t old = m_len;
-			uint32_t len = m_len + uint32_t(strnlen(_ptr, _len) );
+			int32_t old = m_len;
+			int32_t len = m_len + strnlen(_ptr, _len);
 			char* ptr = (char*)BX_REALLOC(*AllocatorT, 0 != m_len ? const_cast<char*>(m_ptr) : NULL, len+1);
 			m_len = len;
 			strlncpy(ptr + old, len-old+1, _ptr, _len);

src/crt.cpp

@@ -3,9 +3,8 @@
  * License: https://github.com/bkaradzic/bx#license-bsd-2-clause
  */
 
-#include <bx/bx.h>
-#include <bx/readerwriter.h>
 #include <bx/debug.h>
+#include <bx/readerwriter.h>
 
 #if !BX_CRT_NONE
 #	include <string.h> // memcpy, memmove, memset

src/crtnone.cpp

@@ -0,0 +1,560 @@
+/*
+ * Copyright 2010-2017 Branimir Karadzic. All rights reserved.
+ * License: https://github.com/bkaradzic/bx#license-bsd-2-clause
+ */
+
+#include <bx/debug.h>
+#include <bx/sort.h>
+#include <bx/readerwriter.h>
+
+#if BX_CRT_NONE
+
+extern "C" size_t strlen(const char* _str)
+{
+	return bx::strnlen(_str);
+}
+
+extern "C" size_t strnlen(const char* _str, size_t _max)
+{
+	return bx::strnlen(_str, _max);
+}
+
+extern "C" void* strcpy(char* _dst, const char* _src)
+{
+	bx::strlncpy(_dst, INT32_MAX, _src, INT32_MAX);
+	return _dst;
+}
+
+extern "C" void* strncpy(char* _dst, const char* _src, size_t _num)
+{
+	bx::strlncpy(_dst, INT32_MAX, _src, _num);
+	return _dst;
+}
+
+extern "C" char* strcat(char* _dst, const char* _src)
+{
+	bx::strlncat(_dst, INT32_MAX, _src, INT32_MAX);
+	return _dst;
+}
+
+extern "C" const char* strchr(const char* _str, int _ch)
+{
+	return bx::strnchr(_str, _ch);
+}
+
+extern "C" int32_t strcmp(const char* _lhs, const char* _rhs)
+{
+	return bx::strncmp(_lhs, _rhs);
+}
+
+extern "C" int32_t strncmp(const char* _lhs, const char* _rhs, size_t _max)
+{
+	return bx::strncmp(_lhs, _rhs, _max);
+}
+
+extern "C" const char* strstr(const char* _str, const char* _find)
+{
+	return bx::strnstr(_str, _find);
+}
+
+extern "C" void qsort(void* _base, size_t _num, size_t _size, ComparisonFn _fn)
+{
+	BX_CHECK(_num <= UINT32_MAX && _size <= UINT32_MAX, "");
+	return bx::quickSort(_base, _num, _size, _fn);
+}
+
+extern "C" int isprint(int _ch)
+{
+	return bx::isPrint(_ch);
+}
+
+extern "C" int toupper (int _ch)
+{
+	return bx::toUpper(_ch);
+}
+
+extern "C" size_t mbstowcs(wchar_t* _dst, const char* _src, size_t _max)
+{
+	BX_UNUSED(_dst, _src, _max);
+	return 0;
+}
+
+extern "C" char* strdup(const char* _src)
+{
+	BX_UNUSED(_src);
+	return NULL;
+}
+
+extern "C" long int strtol(const char* _str, char** _end, int _base)
+{
+	BX_UNUSED(_str, _end, _base);
+	return -1;
+}
+
+extern "C" int abs(int _value)
+{
+	return _value >= 0 ? _value : -_value;
+}
+
+extern "C" float fabsf(float _value)
+{
+	return _value >= 0.0f ? _value : -_value;
+}
+
+extern "C" double fabs(double _value)
+{
+	return _value >= 0.0 ? _value : -_value;
+}
+
+extern "C" double ldexp(double _x, int _exp)
+{
+	BX_UNUSED(_x, _exp);
+	return 0.0;
+}
+
+extern "C" float expf(float _x)
+{
+	BX_UNUSED(_x);
+	return 0.0f;
+}
+
+extern "C" float logf(float _x)
+{
+	BX_UNUSED(_x);
+	return 0.0f;
+}
+
+extern "C" float log10f(float _x)
+{
+	BX_UNUSED(_x);
+	return 0.0f;
+}
+
+extern "C" float powf(float _x)
+{
+	BX_UNUSED(_x);
+	return 0.0f;
+}
+
+extern "C" double pow(double _x)
+{
+	BX_UNUSED(_x);
+	return 0.0;
+}
+
+extern "C" float sinf(float _x)
+{
+	BX_UNUSED(_x);
+	return 0.0f;
+}
+
+extern "C" float cosf(float _x)
+{
+	BX_UNUSED(_x);
+	return 0.0f;
+}
+
+extern "C" float tanf(float _x)
+{
+	BX_UNUSED(_x);
+	return 0.0f;
+}
+
+extern "C" float atan2f(float _y, float _x)
+{
+	BX_UNUSED(_y, _x);
+	return 0.0f;
+}
+
+extern "C" float sqrtf(float _x)
+{
+	BX_UNUSED(_x);
+	return 0.0f;
+}
+
+extern "C" double sqrt(double _x)
+{
+	BX_UNUSED(_x);
+	return 0.0;
+}
+
+extern "C" float ceilf(float _x)
+{
+	BX_UNUSED(_x);
+	return 0.0f;
+}
+
+extern "C" double ceil(double _x)
+{
+	BX_UNUSED(_x);
+	return 0.0;
+}
+
+extern "C" float floorf(float _x)
+{
+	BX_UNUSED(_x);
+	return 0.0f;
+}
+
+extern "C" double floor(double _x)
+{
+	BX_UNUSED(_x);
+	return 0.0;
+}
+
+extern "C" float acosf(float _x)
+{
+	BX_UNUSED(_x);
+	return 0.0f;
+}
+
+extern "C" float fmodf(float _numer, float _denom)
+{
+	BX_UNUSED(_numer, _denom);
+	return 0.0f;
+}
+
+extern "C" int atoi(const char* _str)
+{
+	BX_UNUSED(_str);
+	return 0;
+}
+
+extern "C" double atof(const char* _str)
+{
+	BX_UNUSED(_str);
+	return 0.0;
+}
+
+extern "C" struct DIR* opendir(const char* dirname)
+{
+	BX_UNUSED(dirname);
+	return NULL;
+}
+
+extern "C" struct dirent* readdir(struct DIR* dirp)
+{
+	BX_UNUSED(dirp);
+	return NULL;
+}
+
+extern "C" int closedir (struct DIR* dirp)
+{
+	BX_UNUSED(dirp);
+	return 0;
+}
+
+extern "C" int vsnprintf(char* _out, size_t _max, const char* _format, va_list _argList)
+{
+	return bx::vsnprintf(_out, _max, _format, _argList);
+}
+
+extern "C" int sprintf(char* _out, const char* _format, ...)
+{
+	va_list argList;
+	va_start(argList, _format);
+	int32_t len = bx::vsnprintf(_out, INT32_MAX, _format, argList);
+	va_end(argList);
+	return len;
+}
+
+extern "C" int snprintf(char* _out, size_t _max, const char* _format, ...)
+{
+	va_list argList;
+	va_start(argList, _format);
+	int32_t len = bx::vsnprintf(_out, _max, _format, argList);
+	va_end(argList);
+	return len;
+}
+
+extern "C" int printf(const char* _format, ...)
+{
+	BX_UNUSED(_format);
+	return -1;
+}
+
+extern "C" int fprintf(FILE* _stream, const char* _format, ...)
+{
+	BX_UNUSED(_stream, _format);
+	return -1;
+}
+
+extern "C" int vfprintf(FILE* _stream, const char* _format, va_list _argList)
+{
+	BX_UNUSED(_stream, _format, _argList);
+	return -1;
+}
+
+extern "C" int sscanf(const char* _str, const char* _format, ...)
+{
+	BX_UNUSED(_str, _format);
+	return -1;
+}
+
+extern "C" int fscanf(FILE* _stream, const char* _format, ...)
+{
+	BX_UNUSED(_stream, _format);
+	return -1;
+}
+
+FILE * stdout;
+
+extern "C" FILE* fopen(const char* _filename, const char* _mode)
+{
+	BX_UNUSED(_filename, _mode);
+	return NULL;
+}
+
+extern "C" int fclose(FILE* _stream)
+{
+	BX_UNUSED(_stream);
+	return -1;
+}
+
+extern "C" size_t fread(void* _ptr, size_t _size, size_t _count, FILE* _stream)
+{
+	BX_UNUSED(_ptr, _size, _count, _stream);
+	return -1;
+}
+
+extern "C" size_t fwrite(const void* _ptr, size_t _size, size_t _count, FILE* _stream)
+{
+	BX_UNUSED(_ptr, _size, _count, _stream);
+	return -1;
+}
+
+extern "C" int fseek(FILE* _stream, long int _offset, int _origin)
+{
+	BX_UNUSED(_stream, _offset, _origin);
+	return -1;
+}
+
+extern "C" int fseeko64(FILE* _stream, off64_t _offset, int _whence)
+{
+	BX_UNUSED(_stream, _offset, _whence);
+	return -1;
+}
+
+extern "C" long int ftell(FILE* _stream)
+{
+	BX_UNUSED(_stream);
+	return -1;
+}
+
+extern "C" off64_t ftello64(FILE* _stream)
+{
+	BX_UNUSED(_stream);
+	return -1;
+}
+
+extern "C" int feof(FILE* _stream)
+{
+	BX_UNUSED(_stream);
+	return -1;
+}
+
+extern "C" int ferror(FILE* _stream)
+{
+	BX_UNUSED(_stream);
+	return -1;
+}
+
+extern "C" FILE* popen(const char* _command, const char* _type)
+{
+	BX_UNUSED(_command, _type);
+	return NULL;
+}void*   __dso_handle = (void*) &__dso_handle;
+
+extern "C" int pclose(FILE* _stream)
+{
+	BX_UNUSED(_stream);
+	return -1;
+}
+
+extern "C" int execvp(const char* _file, char* const _argv[])
+{
+	BX_UNUSED(_file, _argv);
+	return -1;
+}
+
+extern "C" long syscall(long _num, ...)
+{
+	BX_UNUSED(_num);
+	return -1;
+}
+
+extern "C" long sysconf(int name)
+{
+	BX_UNUSED(name);
+	return -1;
+}
+
+extern "C" pid_t fork()
+{
+	return -1;
+}
+
+extern "C" int sched_yield()
+{
+	return -1;
+}
+
+extern "C" int prctl(int _option, unsigned long _arg2, unsigned long _arg3, unsigned long _arg4, unsigned long _arg5)
+{
+	BX_UNUSED(_option, _arg2, _arg3, _arg4, _arg5);
+	return -1;
+}
+
+extern "C" int chdir(const char* _path)
+{
+	BX_UNUSED(_path);
+	return -1;
+}
+
+extern "C" char* getcwd(char* _buf, size_t _size)
+{
+	BX_UNUSED(_buf, _size);
+	return NULL;
+}
+
+extern "C" char* getenv(const char* _name)
+{
+	BX_UNUSED(_name);
+	return NULL;
+}
+
+extern "C" int setenv(const char* _name, const char* _value, int _overwrite)
+{
+	BX_UNUSED(_name, _value, _overwrite);
+	return -1;
+}
+
+extern "C" int unsetenv(const char* _name)
+{
+	BX_UNUSED(_name);
+	return -1;
+}
+
+extern "C" time_t time(time_t* _arg)
+{
+	BX_UNUSED(_arg);
+	return -1;
+}
+
+extern "C" int gettimeofday(struct timeval* _tv, struct timezone* _tz)
+{
+	BX_UNUSED(_tv, _tz);
+	return -1;
+}
+
+extern "C" void* realloc(void* _ptr, size_t _size)
+{
+	BX_UNUSED(_ptr, _size);
+	return NULL;
+}
+
+extern "C" void* malloc(size_t _size)
+{
+	return ::realloc(NULL, _size);
+}
+
+extern "C" void free(void* _ptr)
+{
+	BX_UNUSED(_ptr);
+}
+
+extern "C" void abort()
+{
+	while (true) {};
+}
+
+extern "C" void __assert_fail(const char* _assertion, const char* _file, uint32_t _line, const char* _function)
+{
+	BX_UNUSED(_assertion, _file, _line, _function);
+	abort();
+}
+
+void* __dso_handle = (void*)&__dso_handle;
+
+void operator delete(void*)
+{
+}
+
+extern "C" void __cxa_pure_virtual()
+{
+}
+
+extern "C" int __cxa_atexit(void (*_dtorFn)(void*), void* _arg, void* _dsoHandle)
+{
+	BX_UNUSED(_dtorFn, _arg, _dsoHandle);
+	return 0;
+}
+
+extern "C" void __gxx_personality_v0()
+{
+}
+
+extern "C" void _Unwind_Resume(void*)
+{
+}
+
+extern "C" int __gcc_personality_v0(int _version, ...)
+{
+	BX_UNUSED(_version);
+	return 0;
+}
+
+namespace __cxxabiv1
+{
+	class __class_type_info
+	{
+	public:
+		virtual ~__class_type_info();
+
+		const char* m_name;
+	};
+
+	__class_type_info::~__class_type_info()
+	{
+	}
+
+	class __si_class_type_info : public __class_type_info
+	{
+	public:
+		virtual ~__si_class_type_info();
+	};
+
+	__si_class_type_info::~__si_class_type_info()
+	{
+	}
+
+	class __vmi_class_type_info : public __class_type_info
+	{
+	public:
+		virtual ~__vmi_class_type_info();
+	};
+
+	__vmi_class_type_info::~__vmi_class_type_info()
+	{
+	}
+
+	__extension__ typedef int __guard __attribute__( (mode(__DI__) ) );
+
+	extern "C" int __cxa_guard_acquire (__guard* _g)
+	{
+		return !*(char*)(_g);
+	}
+
+	extern "C" void __cxa_guard_release (__guard* _g)
+	{
+		*(char*)_g = 1;
+	}
+
+	extern "C" void __cxa_guard_abort (__guard* _g)
+	{
+		BX_UNUSED(_g);
+	}
+
+} // namespace __cxxabiv1
+
+#endif // BX_CRT_NONE

src/dtoa.cpp

@@ -424,7 +424,7 @@ namespace bx
 		return length + 2 + exp;
 	}
 
-	int32_t toString(char* _dst, size_t _max, double _value)
+	int32_t toString(char* _dst, int32_t _max, double _value)
 	{
 		int32_t sign = 0 != (doubleToBits(_value) & (UINT64_C(1)<<63) ) ? 1 : 0;
 		if (1 == sign)
@@ -458,16 +458,16 @@ namespace bx
 		return len + sign;
 	}
 
-	static void reverse(char* _dst, size_t _len)
+	static void reverse(char* _dst, int32_t _len)
 	{
-		for (size_t ii = 0, jj = _len - 1; ii < jj; ++ii, --jj)
+		for (int32_t ii = 0, jj = _len - 1; ii < jj; ++ii, --jj)
 		{
 			xchg(_dst[ii], _dst[jj]);
 		}
 	}
 
 	template<typename Ty>
-	int32_t toStringSigned(char* _dst, size_t _max, Ty _value, uint32_t _base)
+	int32_t toStringSigned(char* _dst, int32_t _max, Ty _value, uint32_t _base)
 	{
 		if (_base == 10
 		&&  _value < 0)
@@ -498,21 +498,21 @@ namespace bx
 					);
 	}
 
-	int32_t toString(char* _dst, size_t _max, int32_t _value, uint32_t _base)
+	int32_t toString(char* _dst, int32_t _max, int32_t _value, uint32_t _base)
 	{
 		return toStringSigned(_dst, _max, _value, _base);
 	}
 
-	int32_t toString(char* _dst, size_t _max, int64_t _value, uint32_t _base)
+	int32_t toString(char* _dst, int32_t _max, int64_t _value, uint32_t _base)
 	{
 		return toStringSigned(_dst, _max, _value, _base);
 	}
 
 	template<typename Ty>
-	int32_t toStringUnsigned(char* _dst, size_t _max, Ty _value, uint32_t _base)
+	int32_t toStringUnsigned(char* _dst, int32_t _max, Ty _value, uint32_t _base)
 	{
 		char data[32];
-		size_t len = 0;
+		int32_t len = 0;
 
 		if (_base > 16
 		||  _base < 2)
@@ -547,12 +547,12 @@ namespace bx
 		return int32_t(len);
 	}
 
-	int32_t toString(char* _dst, size_t _max, uint32_t _value, uint32_t _base)
+	int32_t toString(char* _dst, int32_t _max, uint32_t _value, uint32_t _base)
 	{
 		return toStringUnsigned(_dst, _max, _value, _base);
 	}
 
-	int32_t toString(char* _dst, size_t _max, uint64_t _value, uint32_t _base)
+	int32_t toString(char* _dst, int32_t _max, uint64_t _value, uint32_t _base)
 	{
 		return toStringUnsigned(_dst, _max, _value, _base);
 	}

src/string.cpp

@@ -60,17 +60,17 @@ namespace bx
 		return _ch + (isUpper(_ch) ? 0x20 : 0);
 	}
 
-	void toLowerUnsafe(char* _inOutStr, size_t _len)
+	void toLowerUnsafe(char* _inOutStr, int32_t _len)
 	{
-		for (size_t ii = 0; ii < _len; ++ii)
+		for (int32_t ii = 0; ii < _len; ++ii)
 		{
 			*_inOutStr = toLower(*_inOutStr);
 		}
 	}
 
-	void toLower(char* _inOutStr, size_t _max)
+	void toLower(char* _inOutStr, int32_t _max)
 	{
-		const size_t len = strnlen(_inOutStr, _max);
+		const int32_t len = strnlen(_inOutStr, _max);
 		toLowerUnsafe(_inOutStr, len);
 	}
 
@@ -79,17 +79,17 @@ namespace bx
 		return _ch - (isLower(_ch) ? 0x20 : 0);
 	}
 
-	void toUpperUnsafe(char* _inOutStr, size_t _len)
+	void toUpperUnsafe(char* _inOutStr, int32_t _len)
 	{
-		for (size_t ii = 0; ii < _len; ++ii)
+		for (int32_t ii = 0; ii < _len; ++ii)
 		{
 			*_inOutStr = toUpper(*_inOutStr);
 		}
 	}
 
-	void toUpper(char* _inOutStr, size_t _max)
+	void toUpper(char* _inOutStr, int32_t _max)
 	{
-		const size_t len = strnlen(_inOutStr, _max);
+		const int32_t len = strnlen(_inOutStr, _max);
 		toUpperUnsafe(_inOutStr, len);
 	}
 
@@ -99,10 +99,18 @@ namespace bx
 		return ch == 't' ||  ch == '1';
 	}
 
-	int32_t strncmp(const char* _lhs, const char* _rhs, size_t _max)
+	typedef char (*CharFn)(char _ch);
+
+	inline char toNoop(char _ch)
+	{
+		return _ch;
+	}
+
+	template<CharFn fn>
+	int32_t strCmp(const char* _lhs, const char* _rhs, int32_t _max)
 	{
 		for (
-			; 0 < _max && *_lhs == *_rhs
+			; 0 < _max && fn(*_lhs) == fn(*_rhs)
 			; ++_lhs, ++_rhs, --_max
 			)
 		{
@@ -113,27 +121,20 @@ namespace bx
 			}
 		}
 
-		return 0 == _max ? 0 : *_lhs - *_rhs;
+		return 0 == _max ? 0 : fn(*_lhs) - fn(*_rhs);
 	}
 
-	int32_t strincmp(const char* _lhs, const char* _rhs, size_t _max)
+	int32_t strncmp(const char* _lhs, const char* _rhs, int32_t _max)
 	{
-		for (
-			; 0 < _max && toLower(*_lhs) == toLower(*_rhs)
-			; ++_lhs, ++_rhs, --_max
-			)
-		{
-			if (*_lhs == '\0'
-			||  *_rhs == '\0')
-			{
-				break;
-			}
-		}
+		return strCmp<toNoop>(_lhs, _rhs, _max);
+	}
 
-		return 0 == _max ? 0 : *_lhs - *_rhs;
+	int32_t strincmp(const char* _lhs, const char* _rhs, int32_t _max)
+	{
+		return strCmp<toLower>(_lhs, _rhs, _max);
 	}
 
-	size_t strnlen(const char* _str, size_t _max)
+	int32_t strnlen(const char* _str, int32_t _max)
 	{
 		if (NULL == _str)
 		{
@@ -145,35 +146,35 @@ namespace bx
 		return ptr - _str;
 	}
 
-	size_t strlncpy(char* _dst, size_t _dstSize, const char* _src, size_t _num)
+	int32_t strlncpy(char* _dst, int32_t _dstSize, const char* _src, int32_t _num)
 	{
 		BX_CHECK(NULL != _dst, "_dst can't be NULL!");
 		BX_CHECK(NULL != _src, "_src can't be NULL!");
 		BX_CHECK(0 < _dstSize, "_dstSize can't be 0!");
 
-		const size_t len = strnlen(_src, _num);
-		const size_t max = _dstSize-1;
-		const size_t num = (len < max ? len : max);
+		const int32_t len = strnlen(_src, _num);
+		const int32_t max = _dstSize-1;
+		const int32_t num = (len < max ? len : max);
 		memCopy(_dst, _src, num);
 		_dst[num] = '\0';
 
 		return num;
 	}
 
-	size_t strlncat(char* _dst, size_t _dstSize, const char* _src, size_t _num)
+	int32_t strlncat(char* _dst, int32_t _dstSize, const char* _src, int32_t _num)
 	{
 		BX_CHECK(NULL != _dst, "_dst can't be NULL!");
 		BX_CHECK(NULL != _src, "_src can't be NULL!");
 		BX_CHECK(0 < _dstSize, "_dstSize can't be 0!");
 
-		const size_t max = _dstSize;
-		const size_t len = strnlen(_dst, max);
+		const int32_t max = _dstSize;
+		const int32_t len = strnlen(_dst, max);
 		return strlncpy(&_dst[len], max-len, _src, _num);
 	}
 
-	const char* strnchr(const char* _str, char _ch, size_t _max)
+	const char* strnchr(const char* _str, char _ch, int32_t _max)
 	{
-		for (size_t ii = 0, len = strnlen(_str, _max); ii < len; ++ii)
+		for (int32_t ii = 0, len = strnlen(_str, _max); ii < len; ++ii)
 		{
 			if (_str[ii] == _ch)
 			{
@@ -184,9 +185,9 @@ namespace bx
 		return NULL;
 	}
 
-	const char* strnrchr(const char* _str, char _ch, size_t _max)
+	const char* strnrchr(const char* _str, char _ch, int32_t _max)
 	{
-		for (size_t ii = strnlen(_str, _max); 0 < ii; --ii)
+		for (int32_t ii = strnlen(_str, _max); 0 < ii; --ii)
 		{
 			if (_str[ii] == _ch)
 			{
@@ -197,17 +198,18 @@ namespace bx
 		return NULL;
 	}
 
-	const char* strnstr(const char* _str, const char* _find, size_t _max)
+	template<CharFn fn>
+	static const char* strStr(const char* _str, int32_t _strMax, const char* _find, int32_t _findMax)
 	{
 		const char* ptr = _str;
 
-		size_t       stringLen = strnlen(_str, _max);
-		const size_t findLen   = strnlen(_find);
+		int32_t       stringLen = strnlen(_str,  _strMax);
+		const int32_t findLen   = strnlen(_find, _findMax);
 
 		for (; stringLen >= findLen; ++ptr, --stringLen)
 		{
 			// Find start of the string.
-			while (*ptr != *_find)
+			while (fn(*ptr) != fn(*_find) )
 			{
 				++ptr;
 				--stringLen;
@@ -224,7 +226,7 @@ namespace bx
 			const char* search = _find;
 
 			// Start comparing.
-			while (*string++ == *search++)
+			while (fn(*string++) == fn(*search++) )
 			{
 				// If end of the 'search' string is reached, all characters match.
 				if ('\0' == *search)
@@ -237,44 +239,14 @@ namespace bx
 		return NULL;
 	}
 
-	const char* stristr(const char* _str, const char* _find, size_t _max)
+	const char* strnstr(const char* _str, const char* _find, int32_t _max)
 	{
-		const char* ptr = _str;
-
-		size_t       stringLen = strnlen(_str, _max);
-		const size_t findLen   = strnlen(_find);
-
-		for (; stringLen >= findLen; ++ptr, --stringLen)
-		{
-			// Find start of the string.
-			while (toLower(*ptr) != toLower(*_find) )
-			{
-				++ptr;
-				--stringLen;
-
-				// Search pattern lenght can't be longer than the string.
-				if (findLen > stringLen)
-				{
-					return NULL;
-				}
-			}
-
-			// Set pointers.
-			const char* string = ptr;
-			const char* search = _find;
-
-			// Start comparing.
-			while (toLower(*string++) == toLower(*search++) )
-			{
-				// If end of the 'search' string is reached, all characters match.
-				if ('\0' == *search)
-				{
-					return ptr;
-				}
-			}
-		}
+		return strStr<toNoop>(_str, _max, _find, INT32_MAX);
+	}
 
-		return NULL;
+	const char* stristr(const char* _str, const char* _find, int32_t _max)
+	{
+		return strStr<toLower>(_str, _max, _find, INT32_MAX);
 	}
 
 	const char* strnl(const char* _str)
@@ -357,7 +329,7 @@ namespace bx
 		return NULL;
 	}
 
-	void eolLF(char* _out, size_t _size, const char* _str)
+	void eolLF(char* _out, int32_t _size, const char* _str)
 	{
 		if (0 < _size)
 		{
@@ -376,7 +348,7 @@ namespace bx
 
 	const char* findIdentifierMatch(const char* _str, const char* _word)
 	{
-		size_t len = strnlen(_word);
+		int32_t len = strnlen(_word);
 		const char* ptr = strnstr(_str, _word);
 		for (; NULL != ptr; ptr = strnstr(ptr + len, _word) )
 		{
@@ -417,7 +389,7 @@ namespace bx
 
 	int32_t write(WriterI* _writer, const char* _format, va_list _argList, Error* _err);
 
-	int32_t vsnprintfRef(char* _out, size_t _max, const char* _format, va_list _argList)
+	int32_t vsnprintfRef(char* _out, int32_t _max, const char* _format, va_list _argList)
 	{
 		if (1 < _max)
 		{
@@ -446,9 +418,9 @@ namespace bx
 		return size - 1 /* size without '\0' terminator */;
 	}
 
-	int32_t vsnprintf(char* _out, size_t _max, const char* _format, va_list _argList)
+	int32_t vsnprintf(char* _out, int32_t _max, const char* _format, va_list _argList)
 	{
-#if BX_CRT_NONE
+#if 1 // BX_CRT_NONE
 		return vsnprintfRef(_out, _max, _format, _argList);
 #elif BX_CRT_MSVC
 		int32_t len = -1;
@@ -456,7 +428,7 @@ namespace bx
 		{
 			va_list argListCopy;
 			va_copy(argListCopy, _argList);
-			len = ::vsnprintf_s(_out, _max, size_t(-1), _format, argListCopy);
+			len = ::vsnprintf_s(_out, _max, int32_t(-1), _format, argListCopy);
 			va_end(argListCopy);
 		}
 		return -1 == len ? ::_vscprintf(_format, _argList) : len;
@@ -465,7 +437,7 @@ namespace bx
 #endif // BX_COMPILER_MSVC
 	}
 
-	int32_t snprintf(char* _out, size_t _max, const char* _format, ...)
+	int32_t snprintf(char* _out, int32_t _max, const char* _format, ...)
 	{
 		va_list argList;
 		va_start(argList, _format);
@@ -474,7 +446,7 @@ namespace bx
 		return len;
 	}
 
-	int32_t vsnwprintf(wchar_t* _out, size_t _max, const wchar_t* _format, va_list _argList)
+	int32_t vsnwprintf(wchar_t* _out, int32_t _max, const wchar_t* _format, va_list _argList)
 	{
 #if BX_CRT_NONE
 		BX_UNUSED(_out, _max, _format, _argList);
@@ -485,7 +457,7 @@ namespace bx
 		{
 			va_list argListCopy;
 			va_copy(argListCopy, _argList);
-			len = ::_vsnwprintf_s(_out, _max, size_t(-1), _format, argListCopy);
+			len = ::_vsnwprintf_s(_out, _max, int32_t(-1), _format, argListCopy);
 			va_end(argListCopy);
 		}
 		return -1 == len ? ::_vscwprintf(_format, _argList) : len;
@@ -496,7 +468,7 @@ namespace bx
 #endif // BX_COMPILER_MSVC
 	}
 
-	int32_t swnprintf(wchar_t* _out, size_t _max, const wchar_t* _format, ...)
+	int32_t swnprintf(wchar_t* _out, int32_t _max, const wchar_t* _format, ...)
 	{
 		va_list argList;
 		va_start(argList, _format);
@@ -520,7 +492,7 @@ namespace bx
 		return _filePath;
 	}
 
-	void prettify(char* _out, size_t _count, uint64_t _size)
+	void prettify(char* _out, int32_t _count, uint64_t _size)
 	{
 		uint8_t idx = 0;
 		double size = double(_size);
@@ -535,12 +507,12 @@ namespace bx
 		snprintf(_out, _count, "%0.2f %c%c", size, "BkMGTPEZY"[idx], idx > 0 ? 'B' : '\0');
 	}
 
-	size_t strlcpy(char* _dst, const char* _src, size_t _max)
+	int32_t strlcpy(char* _dst, const char* _src, int32_t _max)
 	{
 		return strlncpy(_dst, _max, _src);
 	}
 
-	size_t strlcat(char* _dst, const char* _src, size_t _max)
+	int32_t strlcat(char* _dst, const char* _src, int32_t _max)
 	{
 		return strlncat(_dst, _max, _src);
 	}

tests/string_test.cpp

@@ -29,7 +29,7 @@ TEST_CASE("strnlen", "")
 
 	REQUIRE(0 == bx::strnlen(test, 0) );
 	REQUIRE(2 == bx::strnlen(test, 2) );
-	REQUIRE(4 == bx::strnlen(test, UINT32_MAX) );
+	REQUIRE(4 == bx::strnlen(test, INT32_MAX) );
 }
 
 TEST_CASE("strlncpy", "")
@@ -135,10 +135,14 @@ static bool testToString(Ty _value, const char* _expected)
 	char tmp[1024];
 	int32_t num = bx::toString(tmp, BX_COUNTOF(tmp), _value);
 	int32_t len = (int32_t)bx::strnlen(_expected);
-	return true
-		&& 0 == bx::strncmp(tmp, _expected)
-		&& num == len
-		;
+	if (0 == bx::strncmp(tmp, _expected)
+	&&  num == len)
+	{
+		return true;
+	}
+
+	printf("result '%s' (%d), expected '%s' (%d)\n", tmp, num, _expected, len);
+	return false;
 }
 
 TEST_CASE("toString int32_t/uint32_t", "")