Defcon/hook_lib/asmjit/core/string.cpp
MatrixMMOfficial 9631e4ca40 Initial commit
2023-11-26 08:54:06 -05:00

560 lines
13 KiB
C++

// This file is part of AsmJit project <https://asmjit.com>
//
// See asmjit.h or LICENSE.md for license and copyright information
// SPDX-License-Identifier: Zlib
#include "../core/api-build_p.h"
#include "../core/string.h"
#include "../core/support.h"
ASMJIT_BEGIN_NAMESPACE
// String - Globals
// ================
static const char String_baseN[] = "0123456789ABCDEF";
constexpr size_t kMinAllocSize = 64;
constexpr size_t kMaxAllocSize = SIZE_MAX - Globals::kGrowThreshold;
// String - Clear & Reset
// ======================
Error String::reset() noexcept {
if (_type == kTypeLarge)
::free(_large.data);
_resetInternal();
return kErrorOk;
}
Error String::clear() noexcept {
if (isLargeOrExternal()) {
_large.size = 0;
_large.data[0] = '\0';
}
else {
_raw.uptr[0] = 0;
}
return kErrorOk;
}
// String - Prepare
// ================
char* String::prepare(ModifyOp op, size_t size) noexcept {
char* curData;
size_t curSize;
size_t curCapacity;
if (isLargeOrExternal()) {
curData = this->_large.data;
curSize = this->_large.size;
curCapacity = this->_large.capacity;
}
else {
curData = this->_small.data;
curSize = this->_small.type;
curCapacity = kSSOCapacity;
}
if (op == ModifyOp::kAssign) {
if (size > curCapacity) {
// Prevent arithmetic overflow.
if (ASMJIT_UNLIKELY(size >= kMaxAllocSize))
return nullptr;
size_t newCapacity = Support::alignUp<size_t>(size + 1, kMinAllocSize);
char* newData = static_cast<char*>(::malloc(newCapacity));
if (ASMJIT_UNLIKELY(!newData))
return nullptr;
if (_type == kTypeLarge)
::free(curData);
_large.type = kTypeLarge;
_large.size = size;
_large.capacity = newCapacity - 1;
_large.data = newData;
newData[size] = '\0';
return newData;
}
else {
_setSize(size);
curData[size] = '\0';
return curData;
}
}
else {
// Prevent arithmetic overflow.
if (ASMJIT_UNLIKELY(size >= kMaxAllocSize - curSize))
return nullptr;
size_t newSize = size + curSize;
size_t newSizePlusOne = newSize + 1;
if (newSizePlusOne > curCapacity) {
size_t newCapacity = Support::max<size_t>(curCapacity + 1, kMinAllocSize);
if (newCapacity < newSizePlusOne && newCapacity < Globals::kGrowThreshold)
newCapacity = Support::alignUpPowerOf2(newCapacity);
if (newCapacity < newSizePlusOne)
newCapacity = Support::alignUp(newSizePlusOne, Globals::kGrowThreshold);
if (ASMJIT_UNLIKELY(newCapacity < newSizePlusOne))
return nullptr;
char* newData = static_cast<char*>(::malloc(newCapacity));
if (ASMJIT_UNLIKELY(!newData))
return nullptr;
memcpy(newData, curData, curSize);
if (_type == kTypeLarge)
::free(curData);
_large.type = kTypeLarge;
_large.size = newSize;
_large.capacity = newCapacity - 1;
_large.data = newData;
newData[newSize] = '\0';
return newData + curSize;
}
else {
_setSize(newSize);
curData[newSize] = '\0';
return curData + curSize;
}
}
}
// String - Assign
// ===============
Error String::assign(const char* data, size_t size) noexcept {
char* dst = nullptr;
// Null terminated string without `size` specified.
if (size == SIZE_MAX)
size = data ? strlen(data) : size_t(0);
if (isLargeOrExternal()) {
if (size <= _large.capacity) {
dst = _large.data;
_large.size = size;
}
else {
size_t capacityPlusOne = Support::alignUp(size + 1, 32);
if (ASMJIT_UNLIKELY(capacityPlusOne < size))
return DebugUtils::errored(kErrorOutOfMemory);
dst = static_cast<char*>(::malloc(capacityPlusOne));
if (ASMJIT_UNLIKELY(!dst))
return DebugUtils::errored(kErrorOutOfMemory);
if (_type == kTypeLarge)
::free(_large.data);
_large.type = kTypeLarge;
_large.data = dst;
_large.size = size;
_large.capacity = capacityPlusOne - 1;
}
}
else {
if (size <= kSSOCapacity) {
ASMJIT_ASSERT(size < 0xFFu);
dst = _small.data;
_small.type = uint8_t(size);
}
else {
dst = static_cast<char*>(::malloc(size + 1));
if (ASMJIT_UNLIKELY(!dst))
return DebugUtils::errored(kErrorOutOfMemory);
_large.type = kTypeLarge;
_large.data = dst;
_large.size = size;
_large.capacity = size;
}
}
// Optionally copy data from `data` and null-terminate.
if (data && size) {
// NOTE: It's better to use `memmove()`. If, for any reason, somebody uses
// this function to substring the same string it would work as expected.
::memmove(dst, data, size);
}
dst[size] = '\0';
return kErrorOk;
}
// String - Operations
// ===================
Error String::_opString(ModifyOp op, const char* str, size_t size) noexcept {
if (size == SIZE_MAX)
size = str ? strlen(str) : size_t(0);
if (!size)
return kErrorOk;
char* p = prepare(op, size);
if (!p)
return DebugUtils::errored(kErrorOutOfMemory);
memcpy(p, str, size);
return kErrorOk;
}
Error String::_opChar(ModifyOp op, char c) noexcept {
char* p = prepare(op, 1);
if (!p)
return DebugUtils::errored(kErrorOutOfMemory);
*p = c;
return kErrorOk;
}
Error String::_opChars(ModifyOp op, char c, size_t n) noexcept {
if (!n)
return kErrorOk;
char* p = prepare(op, n);
if (!p)
return DebugUtils::errored(kErrorOutOfMemory);
memset(p, c, n);
return kErrorOk;
}
Error String::padEnd(size_t n, char c) noexcept {
size_t size = this->size();
return n > size ? appendChars(c, n - size) : kErrorOk;
}
Error String::_opNumber(ModifyOp op, uint64_t i, uint32_t base, size_t width, StringFormatFlags flags) noexcept {
if (base == 0)
base = 10;
char buf[128];
char* p = buf + ASMJIT_ARRAY_SIZE(buf);
uint64_t orig = i;
char sign = '\0';
// Format Sign
// -----------
if (Support::test(flags, StringFormatFlags::kSigned) && int64_t(i) < 0) {
i = uint64_t(-int64_t(i));
sign = '-';
}
else if (Support::test(flags, StringFormatFlags::kShowSign)) {
sign = '+';
}
else if (Support::test(flags, StringFormatFlags::kShowSpace)) {
sign = ' ';
}
// Format Number
// -------------
switch (base) {
case 2:
case 8:
case 16: {
uint32_t shift = Support::ctz(base);
uint32_t mask = base - 1;
do {
uint64_t d = i >> shift;
size_t r = size_t(i & mask);
*--p = String_baseN[r];
i = d;
} while (i);
break;
}
case 10: {
do {
uint64_t d = i / 10;
uint64_t r = i % 10;
*--p = char(uint32_t('0') + uint32_t(r));
i = d;
} while (i);
break;
}
default:
return DebugUtils::errored(kErrorInvalidArgument);
}
size_t numberSize = (size_t)(buf + ASMJIT_ARRAY_SIZE(buf) - p);
// Alternate Form
// --------------
if (Support::test(flags, StringFormatFlags::kAlternate)) {
if (base == 8) {
if (orig != 0)
*--p = '0';
}
if (base == 16) {
*--p = 'x';
*--p = '0';
}
}
// String Width
// ------------
if (sign != 0)
*--p = sign;
if (width > 256)
width = 256;
if (width <= numberSize)
width = 0;
else
width -= numberSize;
// Finalize
// --------
size_t prefixSize = (size_t)(buf + ASMJIT_ARRAY_SIZE(buf) - p) - numberSize;
char* data = prepare(op, prefixSize + width + numberSize);
if (!data)
return DebugUtils::errored(kErrorOutOfMemory);
memcpy(data, p, prefixSize);
data += prefixSize;
memset(data, '0', width);
data += width;
memcpy(data, p + prefixSize, numberSize);
return kErrorOk;
}
Error String::_opHex(ModifyOp op, const void* data, size_t size, char separator) noexcept {
char* dst;
const uint8_t* src = static_cast<const uint8_t*>(data);
if (!size)
return kErrorOk;
if (separator) {
if (ASMJIT_UNLIKELY(size >= SIZE_MAX / 3))
return DebugUtils::errored(kErrorOutOfMemory);
dst = prepare(op, size * 3 - 1);
if (ASMJIT_UNLIKELY(!dst))
return DebugUtils::errored(kErrorOutOfMemory);
size_t i = 0;
for (;;) {
dst[0] = String_baseN[(src[0] >> 4) & 0xF];
dst[1] = String_baseN[(src[0] ) & 0xF];
if (++i == size)
break;
// This makes sure that the separator is only put between two hexadecimal bytes.
dst[2] = separator;
dst += 3;
src++;
}
}
else {
if (ASMJIT_UNLIKELY(size >= SIZE_MAX / 2))
return DebugUtils::errored(kErrorOutOfMemory);
dst = prepare(op, size * 2);
if (ASMJIT_UNLIKELY(!dst))
return DebugUtils::errored(kErrorOutOfMemory);
for (size_t i = 0; i < size; i++, dst += 2, src++) {
dst[0] = String_baseN[(src[0] >> 4) & 0xF];
dst[1] = String_baseN[(src[0] ) & 0xF];
}
}
return kErrorOk;
}
Error String::_opFormat(ModifyOp op, const char* fmt, ...) noexcept {
Error err;
va_list ap;
va_start(ap, fmt);
err = _opVFormat(op, fmt, ap);
va_end(ap);
return err;
}
Error String::_opVFormat(ModifyOp op, const char* fmt, va_list ap) noexcept {
size_t startAt = (op == ModifyOp::kAssign) ? size_t(0) : size();
size_t remainingCapacity = capacity() - startAt;
char buf[1024];
int fmtResult;
size_t outputSize;
va_list apCopy;
va_copy(apCopy, ap);
if (remainingCapacity >= 128) {
fmtResult = vsnprintf(data() + startAt, remainingCapacity, fmt, ap);
outputSize = size_t(fmtResult);
if (ASMJIT_LIKELY(outputSize <= remainingCapacity)) {
_setSize(startAt + outputSize);
return kErrorOk;
}
}
else {
fmtResult = vsnprintf(buf, ASMJIT_ARRAY_SIZE(buf), fmt, ap);
outputSize = size_t(fmtResult);
if (ASMJIT_LIKELY(outputSize < ASMJIT_ARRAY_SIZE(buf)))
return _opString(op, buf, outputSize);
}
if (ASMJIT_UNLIKELY(fmtResult < 0))
return DebugUtils::errored(kErrorInvalidState);
char* p = prepare(op, outputSize);
if (ASMJIT_UNLIKELY(!p))
return DebugUtils::errored(kErrorOutOfMemory);
fmtResult = vsnprintf(p, outputSize + 1, fmt, apCopy);
ASMJIT_ASSERT(size_t(fmtResult) == outputSize);
return kErrorOk;
}
Error String::truncate(size_t newSize) noexcept {
if (isLargeOrExternal()) {
if (newSize < _large.size) {
_large.data[newSize] = '\0';
_large.size = newSize;
}
}
else {
if (newSize < _type) {
_small.data[newSize] = '\0';
_small.type = uint8_t(newSize);
}
}
return kErrorOk;
}
bool String::eq(const char* other, size_t size) const noexcept {
const char* aData = data();
const char* bData = other;
size_t aSize = this->size();
size_t bSize = size;
if (bSize == SIZE_MAX) {
size_t i;
for (i = 0; i < aSize; i++)
if (aData[i] != bData[i] || bData[i] == 0)
return false;
return bData[i] == 0;
}
else {
if (aSize != bSize)
return false;
return ::memcmp(aData, bData, aSize) == 0;
}
}
// String - Tests
// ==============
#if defined(ASMJIT_TEST)
UNIT(core_string) {
String s;
EXPECT(s.isLargeOrExternal() == false);
EXPECT(s.isExternal() == false);
EXPECT(s.assign('a') == kErrorOk);
EXPECT(s.size() == 1);
EXPECT(s.capacity() == String::kSSOCapacity);
EXPECT(s.data()[0] == 'a');
EXPECT(s.data()[1] == '\0');
EXPECT(s.eq("a") == true);
EXPECT(s.eq("a", 1) == true);
EXPECT(s.assignChars('b', 4) == kErrorOk);
EXPECT(s.size() == 4);
EXPECT(s.capacity() == String::kSSOCapacity);
EXPECT(s.data()[0] == 'b');
EXPECT(s.data()[1] == 'b');
EXPECT(s.data()[2] == 'b');
EXPECT(s.data()[3] == 'b');
EXPECT(s.data()[4] == '\0');
EXPECT(s.eq("bbbb") == true);
EXPECT(s.eq("bbbb", 4) == true);
EXPECT(s.assign("abc") == kErrorOk);
EXPECT(s.size() == 3);
EXPECT(s.capacity() == String::kSSOCapacity);
EXPECT(s.data()[0] == 'a');
EXPECT(s.data()[1] == 'b');
EXPECT(s.data()[2] == 'c');
EXPECT(s.data()[3] == '\0');
EXPECT(s.eq("abc") == true);
EXPECT(s.eq("abc", 3) == true);
const char* large = "Large string that will not fit into SSO buffer";
EXPECT(s.assign(large) == kErrorOk);
EXPECT(s.isLargeOrExternal() == true);
EXPECT(s.size() == strlen(large));
EXPECT(s.capacity() > String::kSSOCapacity);
EXPECT(s.eq(large) == true);
EXPECT(s.eq(large, strlen(large)) == true);
const char* additional = " (additional content)";
EXPECT(s.isLargeOrExternal() == true);
EXPECT(s.append(additional) == kErrorOk);
EXPECT(s.size() == strlen(large) + strlen(additional));
EXPECT(s.clear() == kErrorOk);
EXPECT(s.size() == 0);
EXPECT(s.empty() == true);
EXPECT(s.data()[0] == '\0');
EXPECT(s.isLargeOrExternal() == true); // Clear should never release the memory.
EXPECT(s.appendUInt(1234) == kErrorOk);
EXPECT(s.eq("1234") == true);
EXPECT(s.assignUInt(0xFFFF, 16, 0, StringFormatFlags::kAlternate) == kErrorOk);
EXPECT(s.eq("0xFFFF"));
StringTmp<64> sTmp;
EXPECT(sTmp.isLargeOrExternal());
EXPECT(sTmp.isExternal());
EXPECT(sTmp.appendChars(' ', 1000) == kErrorOk);
EXPECT(!sTmp.isExternal());
}
#endif
ASMJIT_END_NAMESPACE