diff --git a/include/bx/string.h b/include/bx/string.h index ccdebda..44312e6 100644 --- a/include/bx/string.h +++ b/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& operator=(const StringT& _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 @@ -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 diff --git a/include/bx/string.inl b/include/bx/string.inl index d9569f3..10e27ec 100644 --- a/include/bx/string.inl +++ b/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 - inline StringT::StringT(const char* _ptr, uint32_t _len) + inline StringT::StringT(const char* _ptr, int32_t _len) { set(_ptr, _len); } @@ -155,19 +155,19 @@ namespace bx } template - inline void StringT::set(const char* _ptr, uint32_t _len) + inline void StringT::set(const char* _ptr, int32_t _len) { clear(); append(_ptr, _len); } template - inline void StringT::append(const char* _ptr, uint32_t _len) + inline void StringT::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(m_ptr) : NULL, len+1); m_len = len; strlncpy(ptr + old, len-old+1, _ptr, _len); diff --git a/src/crt.cpp b/src/crt.cpp index d363897..da7919e 100644 --- a/src/crt.cpp +++ b/src/crt.cpp @@ -3,9 +3,8 @@ * License: https://github.com/bkaradzic/bx#license-bsd-2-clause */ -#include -#include #include +#include #if !BX_CRT_NONE # include // memcpy, memmove, memset diff --git a/src/crtnone.cpp b/src/crtnone.cpp new file mode 100644 index 0000000..d2d9c54 --- /dev/null +++ b/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 +#include +#include + +#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 diff --git a/src/dtoa.cpp b/src/dtoa.cpp index 4dd0079..98640ed 100644 --- a/src/dtoa.cpp +++ b/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 - 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 - 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); } diff --git a/src/string.cpp b/src/string.cpp index 9e81450..55a1001 100644 --- a/src/string.cpp +++ b/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 + 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 0 == _max ? 0 : *_lhs - *_rhs; + return strCmp(_lhs, _rhs, _max); } - size_t strnlen(const char* _str, size_t _max) + int32_t strincmp(const char* _lhs, const char* _rhs, int32_t _max) + { + return strCmp(_lhs, _rhs, _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 + 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; + return strStr(_str, _max, _find, INT32_MAX); + } - 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 NULL; + const char* stristr(const char* _str, const char* _find, int32_t _max) + { + return strStr(_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); } diff --git a/tests/string_test.cpp b/tests/string_test.cpp index 6b4d5e9..35e1dac 100644 --- a/tests/string_test.cpp +++ b/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", "")