Mirrors/bx
1
0
Fork 0
mirror of https://github.com/bkaradzic/bx.git synced 2026-02-17 20:52:37 +01:00
Code Issues Packages Projects Releases Wiki Activity

Removed use of size_t in string functions.

Browse Source
This commit is contained in:
Branimir Karadžić
2017-02-14 22:29:09 -08:00
parent 54e1d6643f
commit 8c30c6463a
7 changed files with 688 additions and 153 deletions
Download Patch File Download Diff File Expand all files Collapse all files

66
include/bx/string.h
View File

@@ -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

24
include/bx/string.inl
View File

@@ -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);

3
src/crt.cpp
View File

@@ -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

560
src/crtnone.cpp Normal file
View File

@@ -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

20
src/dtoa.cpp
View File

@@ -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);
}

154
src/string.cpp
View File

@@ -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 0 == _max ? 0 : *_lhs - *_rhs;
return strCmp<toNoop>(_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<toLower>(_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<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;
return strStr<toNoop>(_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<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);
}

14
tests/string_test.cpp
View File

@@ -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", "")