mirror of https://gitee.com/bigwinds/arangodb
Merge branch 'master' of github.com:triAGENS/AvocadoDB into devel
This commit is contained in:
Frank Celler
commit
0fbbba73d1
|
|
@ -59,3 +59,5 @@ ARCH.*
|
|||
*.old
|
||||
avocsh
|
||||
libavocado.a
|
||||
*.swp
|
||||
tags
|
||||
|
|
|
|||
|
|
@ -41,7 +41,14 @@
|
|||
////////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
static void AppendChar (TRI_string_buffer_t * self, char chr) {
|
||||
*self->_bufferPtr++ = chr;
|
||||
*(self->_buffer + self->_off++) = chr;
|
||||
}
|
||||
|
||||
////////////////////////////////////////////////////////////////////////////////
|
||||
/// @brief how much space is presently left in buffer?
|
||||
////////////////////////////////////////////////////////////////////////////////
|
||||
static size_t Remaining (TRI_string_buffer_t * self) {
|
||||
return self->_len - self->_off;
|
||||
}
|
||||
|
||||
////////////////////////////////////////////////////////////////////////////////
|
||||
|
|
@ -49,25 +56,18 @@ static void AppendChar (TRI_string_buffer_t * self, char chr) {
|
|||
////////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
static void Reserve (TRI_string_buffer_t * self, size_t size) {
|
||||
if (self->_buffer == NULL) {
|
||||
self->_buffer = (char*) TRI_Allocate(size + 1);
|
||||
self->_bufferPtr = self->_buffer;
|
||||
self->_bufferEnd = self->_buffer + size;
|
||||
if (size < 1) {
|
||||
return;
|
||||
}
|
||||
else if ((size_t)(self->_bufferEnd - self->_bufferPtr) < size) {
|
||||
size_t newlen;
|
||||
char * b;
|
||||
|
||||
newlen = (size_t)(1.2 * ((self->_bufferEnd - self->_buffer) + size));
|
||||
b = TRI_Allocate(newlen + 1);
|
||||
|
||||
memcpy(b, self->_buffer, self->_bufferEnd - self->_buffer + 1);
|
||||
|
||||
TRI_Free(self->_buffer);
|
||||
|
||||
self->_bufferPtr = b + (self->_bufferPtr - self->_buffer);
|
||||
self->_bufferEnd = b + newlen;
|
||||
self->_buffer = b;
|
||||
if (size > Remaining(self)) {
|
||||
self->_len = (size_t)(1.2 * (self->_len + size));
|
||||
self->_buffer = TRI_Reallocate(self->_buffer, self->_len+1);
|
||||
memset(self->_buffer+self->_off, 0, Remaining(self)+1);
|
||||
#if I_CARE_ABOUT_MALLOC_FAILURES
|
||||
if (NULL == self->_buffer) {
|
||||
abort();
|
||||
}
|
||||
#endif
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -91,12 +91,8 @@ static void Reserve (TRI_string_buffer_t * self, size_t size) {
|
|||
////////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
void TRI_InitStringBuffer (TRI_string_buffer_t * self) {
|
||||
self->_buffer = NULL;
|
||||
self->_bufferPtr = NULL;
|
||||
self->_bufferEnd = NULL;
|
||||
|
||||
memset (self, 0, sizeof(TRI_string_buffer_t));
|
||||
Reserve(self, 1);
|
||||
*self->_bufferPtr = 0;
|
||||
}
|
||||
|
||||
////////////////////////////////////////////////////////////////////////////////
|
||||
|
|
@ -108,10 +104,8 @@ void TRI_InitStringBuffer (TRI_string_buffer_t * self) {
|
|||
void TRI_FreeStringBuffer (TRI_string_buffer_t * self) {
|
||||
if (self->_buffer != NULL) {
|
||||
TRI_Free(self->_buffer);
|
||||
|
||||
self->_buffer = NULL;
|
||||
self->_bufferPtr = NULL;
|
||||
self->_bufferEnd = NULL;
|
||||
|
||||
memset (self, 0, sizeof(TRI_string_buffer_t));
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -123,13 +117,11 @@ void TRI_FreeStringBuffer (TRI_string_buffer_t * self) {
|
|||
|
||||
void TRI_DestroyStringBuffer (TRI_string_buffer_t * self) {
|
||||
if (self->_buffer != NULL) {
|
||||
// somewhat paranoid?
|
||||
memset(self->_buffer, 0, self->_bufferEnd - self->_buffer);
|
||||
|
||||
TRI_Free(self->_buffer);
|
||||
|
||||
self->_buffer = NULL;
|
||||
self->_bufferPtr = NULL;
|
||||
self->_bufferEnd = NULL;
|
||||
memset (self, 0, sizeof(TRI_string_buffer_t));
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -151,17 +143,17 @@ void TRI_DestroyStringBuffer (TRI_string_buffer_t * self) {
|
|||
////////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
void TRI_SwapStringBuffer (TRI_string_buffer_t * self, TRI_string_buffer_t * other) {
|
||||
char * otherBuffer = other->_buffer;
|
||||
char * otherBufferPtr = other->_bufferPtr;
|
||||
char * otherBufferEnd = other->_bufferEnd;
|
||||
char * otherBuffer= other->_buffer;
|
||||
ptrdiff_t otherOff= other->_off;
|
||||
size_t otherLen = other->_len;
|
||||
|
||||
other->_buffer = self->_buffer;
|
||||
other->_bufferPtr = self->_bufferPtr;
|
||||
other->_bufferEnd = self->_bufferEnd;
|
||||
other->_off = self->_off;
|
||||
other->_len = self->_len;
|
||||
|
||||
self->_buffer = otherBuffer;
|
||||
self->_bufferPtr = otherBufferPtr;
|
||||
self->_bufferEnd = otherBufferEnd;
|
||||
self->_buffer = otherBuffer;
|
||||
self->_off = otherOff;
|
||||
self->_len = otherLen;
|
||||
}
|
||||
|
||||
////////////////////////////////////////////////////////////////////////////////
|
||||
|
|
@ -177,7 +169,7 @@ char const * TRI_BeginStringBuffer (TRI_string_buffer_t const * self) {
|
|||
////////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
char const * TRI_EndStringBuffer (TRI_string_buffer_t const * self) {
|
||||
return self->_bufferPtr;
|
||||
return self->_buffer + self->_off;
|
||||
}
|
||||
|
||||
////////////////////////////////////////////////////////////////////////////////
|
||||
|
|
@ -185,7 +177,7 @@ char const * TRI_EndStringBuffer (TRI_string_buffer_t const * self) {
|
|||
////////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
size_t TRI_LengthStringBuffer (TRI_string_buffer_t const * self) {
|
||||
return self->_bufferPtr - self->_buffer;
|
||||
return self->_off;
|
||||
}
|
||||
|
||||
////////////////////////////////////////////////////////////////////////////////
|
||||
|
|
@ -193,7 +185,7 @@ size_t TRI_LengthStringBuffer (TRI_string_buffer_t const * self) {
|
|||
////////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
bool TRI_EmptyStringBuffer (TRI_string_buffer_t const * self) {
|
||||
return self->_bufferPtr == self->_buffer;
|
||||
return self->_off == 0;
|
||||
}
|
||||
|
||||
////////////////////////////////////////////////////////////////////////////////
|
||||
|
|
@ -201,49 +193,46 @@ bool TRI_EmptyStringBuffer (TRI_string_buffer_t const * self) {
|
|||
////////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
void TRI_ClearStringBuffer (TRI_string_buffer_t * self) {
|
||||
self->_bufferPtr = self->_buffer;
|
||||
self->_off = 0;
|
||||
memset(self->_buffer, 0, self->_len+1);
|
||||
}
|
||||
|
||||
////////////////////////////////////////////////////////////////////////////////
|
||||
/// @brief copies the string buffer
|
||||
////////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
void TRI_CopyStringBuffer (TRI_string_buffer_t * self, TRI_string_buffer_t const * source) {
|
||||
TRI_ReplaceStringStringBuffer(self, source->_buffer, source->_bufferPtr - source->_buffer);
|
||||
TRI_ReplaceStringStringBuffer(self, source->_buffer, source->_off);
|
||||
}
|
||||
|
||||
////////////////////////////////////////////////////////////////////////////////
|
||||
/// @brief removes the first characters
|
||||
////////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
void TRI_EraseFrontStringBuffer (TRI_string_buffer_t * self, size_t len) {
|
||||
if ((size_t)(self->_bufferPtr - self->_buffer) <= len) {
|
||||
self->_bufferPtr = self->_buffer;
|
||||
if (self->_off <= len) {
|
||||
TRI_ClearStringBuffer(self);
|
||||
}
|
||||
else if (0 < len) {
|
||||
memmove(self->_buffer, self->_buffer + len, self->_bufferPtr - self->_buffer - len);
|
||||
self->_bufferPtr -= len;
|
||||
memmove(self->_buffer, self->_buffer+len, self->_off - len);
|
||||
self->_off -= len;
|
||||
memset (self->_buffer + self->_off, 0, self->_len);
|
||||
}
|
||||
}
|
||||
|
||||
////////////////////////////////////////////////////////////////////////////////
|
||||
/// @brief replaces characters
|
||||
////////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
void TRI_ReplaceStringStringBuffer (TRI_string_buffer_t * self, char const * str, size_t len) {
|
||||
self->_bufferPtr = self->_buffer;
|
||||
|
||||
self->_off = 0;
|
||||
TRI_AppendString2StringBuffer(self, str, len);
|
||||
}
|
||||
|
||||
////////////////////////////////////////////////////////////////////////////////
|
||||
/// @brief replaces characters
|
||||
////////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
void TRI_ReplaceStringBufferStringBuffer (TRI_string_buffer_t * self, TRI_string_buffer_t const * text) {
|
||||
self->_bufferPtr = self->_buffer;
|
||||
self->_off = 0;
|
||||
|
||||
TRI_AppendString2StringBuffer(self, text->_buffer, text->_bufferPtr - text->_buffer);
|
||||
TRI_AppendString2StringBuffer(self, text->_buffer, text->_off);
|
||||
}
|
||||
|
||||
////////////////////////////////////////////////////////////////////////////////
|
||||
|
|
@ -270,8 +259,10 @@ void TRI_ReplaceStringBufferStringBuffer (TRI_string_buffer_t * self, TRI_string
|
|||
void TRI_AppendCharStringBuffer (TRI_string_buffer_t * self, char chr) {
|
||||
Reserve(self, 2);
|
||||
|
||||
*self->_bufferPtr++ = chr;
|
||||
*self->_bufferPtr = '\0';
|
||||
*(self->_buffer + self->_off) = chr;
|
||||
++(self->_off);
|
||||
// bzero at init?
|
||||
*(self->_buffer + self->_off) = '\0';
|
||||
}
|
||||
|
||||
////////////////////////////////////////////////////////////////////////////////
|
||||
|
|
@ -281,42 +272,37 @@ void TRI_AppendCharStringBuffer (TRI_string_buffer_t * self, char chr) {
|
|||
void TRI_AppendStringStringBuffer (TRI_string_buffer_t * self, char const * str) {
|
||||
size_t len = strlen(str);
|
||||
|
||||
Reserve(self, len + 1);
|
||||
Reserve(self, len);
|
||||
|
||||
memcpy(self->_bufferPtr, str, len);
|
||||
self->_bufferPtr += len;
|
||||
*self->_bufferPtr = '\0';
|
||||
memcpy((self->_buffer + self->_off), str, len);
|
||||
self->_off += len;
|
||||
*(self->_buffer + self->_off) = '\0';
|
||||
}
|
||||
|
||||
////////////////////////////////////////////////////////////////////////////////
|
||||
/// @brief appends characters
|
||||
////////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
void TRI_AppendString2StringBuffer (TRI_string_buffer_t * self, char const * str, size_t len) {
|
||||
if (len == 0) {
|
||||
Reserve(self, 1);
|
||||
*self->_bufferPtr = '\0';
|
||||
return;
|
||||
}
|
||||
else {
|
||||
Reserve(self, len + 1);
|
||||
memcpy(self->_bufferPtr, str, len);
|
||||
self->_bufferPtr += len;
|
||||
*self->_bufferPtr = '\0';
|
||||
Reserve(self, len);
|
||||
memcpy(self->_buffer+self->_off, str, len);
|
||||
self->_off += len;
|
||||
}
|
||||
}
|
||||
|
||||
////////////////////////////////////////////////////////////////////////////////
|
||||
/// @brief appends a string buffer
|
||||
////////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
void TRI_AppendStringBufferStringBuffer (TRI_string_buffer_t * self, TRI_string_buffer_t const * text) {
|
||||
TRI_AppendString2StringBuffer(self, text->_buffer, text->_bufferPtr - text->_buffer);
|
||||
TRI_AppendString2StringBuffer(self, text->_buffer, text->_off);
|
||||
}
|
||||
|
||||
////////////////////////////////////////////////////////////////////////////////
|
||||
/// @brief appends a blob
|
||||
////////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
void TRI_AppendBlobStringBuffer (TRI_string_buffer_t * self, TRI_blob_t const * text) {
|
||||
TRI_AppendString2StringBuffer(self, text->data, text->length);
|
||||
}
|
||||
|
|
@ -324,7 +310,6 @@ void TRI_AppendBlobStringBuffer (TRI_string_buffer_t * self, TRI_blob_t const *
|
|||
////////////////////////////////////////////////////////////////////////////////
|
||||
/// @brief appends eol character
|
||||
////////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
void TRI_AppendEolStringBuffer (TRI_string_buffer_t * self) {
|
||||
TRI_AppendCharStringBuffer(self, '\n');
|
||||
}
|
||||
|
|
@ -349,56 +334,48 @@ void TRI_AppendEolStringBuffer (TRI_string_buffer_t * self) {
|
|||
////////////////////////////////////////////////////////////////////////////////
|
||||
/// @brief appends integer with two digits
|
||||
////////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
void TRI_AppendInteger2StringBuffer (TRI_string_buffer_t * self, uint32_t attr) {
|
||||
Reserve(self, 3);
|
||||
Reserve(self, 2);
|
||||
|
||||
AppendChar(self, (attr / 10U) % 10 + '0');
|
||||
AppendChar(self, attr % 10 + '0');
|
||||
|
||||
*self->_bufferPtr = '\0';
|
||||
}
|
||||
|
||||
////////////////////////////////////////////////////////////////////////////////
|
||||
/// @brief appends integer with three digits
|
||||
////////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
void TRI_AppendInteger3StringBuffer (TRI_string_buffer_t * self, uint32_t attr) {
|
||||
Reserve(self, 4);
|
||||
Reserve(self, 3);
|
||||
|
||||
AppendChar(self, (attr / 100U) % 10 + '0');
|
||||
AppendChar(self, (attr / 10U) % 10 + '0');
|
||||
AppendChar(self, attr % 10 + '0');
|
||||
|
||||
*self->_bufferPtr = '\0';
|
||||
}
|
||||
|
||||
////////////////////////////////////////////////////////////////////////////////
|
||||
/// @brief appends integer with four digits
|
||||
////////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
void TRI_AppendInteger4StringBuffer (TRI_string_buffer_t * self, uint32_t attr) {
|
||||
Reserve(self, 5);
|
||||
Reserve(self, 4);
|
||||
|
||||
AppendChar(self, (attr / 1000U) % 10 + '0');
|
||||
AppendChar(self, (attr / 100U) % 10 + '0');
|
||||
AppendChar(self, (attr / 10U) % 10 + '0');
|
||||
AppendChar(self, attr % 10 + '0');
|
||||
|
||||
*self->_bufferPtr = '\0';
|
||||
}
|
||||
|
||||
////////////////////////////////////////////////////////////////////////////////
|
||||
/// @brief appends integer with 8 bits
|
||||
////////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
void TRI_AppendInt8StringBuffer (TRI_string_buffer_t * self, int8_t attr) {
|
||||
if (attr == INT8_MIN) {
|
||||
TRI_AppendString2StringBuffer(self, "-128", 4);
|
||||
return;
|
||||
}
|
||||
|
||||
Reserve(self, 5);
|
||||
Reserve(self, 4);
|
||||
|
||||
if (attr < 0) {
|
||||
AppendChar(self, '-');
|
||||
|
|
@ -411,35 +388,31 @@ void TRI_AppendInt8StringBuffer (TRI_string_buffer_t * self, int8_t attr) {
|
|||
|
||||
AppendChar(self, attr % 10 + '0');
|
||||
|
||||
*self->_bufferPtr = '\0';
|
||||
}
|
||||
|
||||
////////////////////////////////////////////////////////////////////////////////
|
||||
/// @brief appends unsigned integer with 8 bits
|
||||
////////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
void TRI_AppendUInt8StringBuffer (TRI_string_buffer_t * self, uint8_t attr) {
|
||||
Reserve(self, 4);
|
||||
Reserve(self, 3);
|
||||
|
||||
if (100U <= attr) { AppendChar(self, (attr / 100U) % 10 + '0'); }
|
||||
if ( 10U <= attr) { AppendChar(self, (attr / 10U) % 10 + '0'); }
|
||||
|
||||
AppendChar(self, attr % 10 + '0');
|
||||
|
||||
*self->_bufferPtr = '\0';
|
||||
}
|
||||
|
||||
////////////////////////////////////////////////////////////////////////////////
|
||||
/// @brief appends integer with 16 bits
|
||||
////////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
void TRI_AppendInt16StringBuffer (TRI_string_buffer_t * self, int16_t attr) {
|
||||
if (attr == INT16_MIN) {
|
||||
TRI_AppendString2StringBuffer(self, "-32768", 6);
|
||||
return;
|
||||
}
|
||||
|
||||
Reserve(self, 7);
|
||||
Reserve(self, 6);
|
||||
|
||||
if (attr < 0) {
|
||||
AppendChar(self, '-');
|
||||
|
|
@ -453,15 +426,13 @@ void TRI_AppendInt16StringBuffer (TRI_string_buffer_t * self, int16_t attr) {
|
|||
|
||||
AppendChar(self, attr % 10 + '0');
|
||||
|
||||
*self->_bufferPtr = '\0';
|
||||
}
|
||||
|
||||
////////////////////////////////////////////////////////////////////////////////
|
||||
/// @brief appends unsigned integer with 32 bits
|
||||
////////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
void TRI_AppendUInt16StringBuffer (TRI_string_buffer_t * self, uint16_t attr) {
|
||||
Reserve(self, 6);
|
||||
Reserve(self, 5);
|
||||
|
||||
if (10000U <= attr) { AppendChar(self, (attr / 10000U) % 10 + '0'); }
|
||||
if ( 1000U <= attr) { AppendChar(self, (attr / 1000U) % 10 + '0'); }
|
||||
|
|
@ -469,21 +440,18 @@ void TRI_AppendUInt16StringBuffer (TRI_string_buffer_t * self, uint16_t attr) {
|
|||
if ( 10U <= attr) { AppendChar(self, (attr / 10U) % 10 + '0'); }
|
||||
|
||||
AppendChar(self, attr % 10 + '0');
|
||||
|
||||
*self->_bufferPtr = '\0';
|
||||
}
|
||||
|
||||
////////////////////////////////////////////////////////////////////////////////
|
||||
/// @brief appends integer with 32 bits
|
||||
////////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
void TRI_AppendInt32StringBuffer (TRI_string_buffer_t * self, int32_t attr) {
|
||||
if (attr == INT32_MIN) {
|
||||
TRI_AppendString2StringBuffer(self, "-2147483648", 11);
|
||||
return;
|
||||
}
|
||||
|
||||
Reserve(self, 12);
|
||||
Reserve(self, 11);
|
||||
|
||||
if (attr < 0) {
|
||||
AppendChar(self, '-');
|
||||
|
|
@ -502,15 +470,13 @@ void TRI_AppendInt32StringBuffer (TRI_string_buffer_t * self, int32_t attr) {
|
|||
|
||||
AppendChar(self, attr % 10 + '0');
|
||||
|
||||
*self->_bufferPtr = '\0';
|
||||
}
|
||||
|
||||
////////////////////////////////////////////////////////////////////////////////
|
||||
/// @brief appends unsigned integer with 32 bits
|
||||
////////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
void TRI_AppendUInt32StringBuffer (TRI_string_buffer_t * self, uint32_t attr) {
|
||||
Reserve(self, 11);
|
||||
Reserve(self, 10);
|
||||
|
||||
if (1000000000U <= attr) { AppendChar(self, (attr / 1000000000U) % 10 + '0'); }
|
||||
if ( 100000000U <= attr) { AppendChar(self, (attr / 100000000U) % 10 + '0'); }
|
||||
|
|
@ -524,13 +490,11 @@ void TRI_AppendUInt32StringBuffer (TRI_string_buffer_t * self, uint32_t attr) {
|
|||
|
||||
AppendChar(self, attr % 10 + '0');
|
||||
|
||||
*self->_bufferPtr = '\0';
|
||||
}
|
||||
|
||||
////////////////////////////////////////////////////////////////////////////////
|
||||
/// @brief appends integer with 64 bits
|
||||
////////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
void TRI_AppendInt64StringBuffer (TRI_string_buffer_t * self, int64_t attr) {
|
||||
if (attr == INT64_MIN) {
|
||||
TRI_AppendString2StringBuffer(self, "-9223372036854775808", 20);
|
||||
|
|
@ -571,13 +535,11 @@ void TRI_AppendInt64StringBuffer (TRI_string_buffer_t * self, int64_t attr) {
|
|||
|
||||
AppendChar(self, attr % 10 + '0');
|
||||
|
||||
*self->_bufferPtr = '\0';
|
||||
}
|
||||
|
||||
////////////////////////////////////////////////////////////////////////////////
|
||||
/// @brief appends unsigned integer with 64 bits
|
||||
////////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
void TRI_AppendUInt64StringBuffer (TRI_string_buffer_t * self, uint64_t attr) {
|
||||
if ((attr >> 32) == 0) {
|
||||
TRI_AppendUInt32StringBuffer(self, (uint32_t) attr);
|
||||
|
|
@ -609,13 +571,11 @@ void TRI_AppendUInt64StringBuffer (TRI_string_buffer_t * self, uint64_t attr) {
|
|||
|
||||
AppendChar(self, attr % 10 + '0');
|
||||
|
||||
*self->_bufferPtr = '\0';
|
||||
}
|
||||
|
||||
////////////////////////////////////////////////////////////////////////////////
|
||||
/// @brief appends size_t
|
||||
////////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
void TRI_AppendSizeStringBuffer (TRI_string_buffer_t * self, size_t attr) {
|
||||
#if TRI_SIZEOF_SIZE_T == 8
|
||||
TRI_AppendUInt64StringBuffer(self, (uint64_t) attr);
|
||||
|
|
@ -646,7 +606,7 @@ void TRI_AppendSizeStringBuffer (TRI_string_buffer_t * self, size_t attr) {
|
|||
////////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
void TRI_AppendUInt32OctalStringBuffer (TRI_string_buffer_t * self, uint32_t attr) {
|
||||
Reserve(self, 9);
|
||||
Reserve(self, 8);
|
||||
|
||||
if (010000000U <= attr) { AppendChar(self, (attr / 010000000U) % 010 + '0'); }
|
||||
if ( 01000000U <= attr) { AppendChar(self, (attr / 01000000U) % 010 + '0'); }
|
||||
|
|
@ -658,7 +618,6 @@ void TRI_AppendUInt32OctalStringBuffer (TRI_string_buffer_t * self, uint32_t att
|
|||
|
||||
AppendChar(self, attr % 010 + '0');
|
||||
|
||||
*self->_bufferPtr = '\0';
|
||||
}
|
||||
|
||||
////////////////////////////////////////////////////////////////////////////////
|
||||
|
|
@ -666,7 +625,7 @@ void TRI_AppendUInt32OctalStringBuffer (TRI_string_buffer_t * self, uint32_t att
|
|||
////////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
void TRI_AppendUInt64OctalStringBuffer (TRI_string_buffer_t * self, uint64_t attr) {
|
||||
Reserve(self, 17);
|
||||
Reserve(self, 16);
|
||||
|
||||
if (01000000000000000ULL <= attr) { AppendChar(self, (attr / 01000000000000000ULL) % 010 + '0'); }
|
||||
if ( 0100000000000000ULL <= attr) { AppendChar(self, (attr / 0100000000000000ULL) % 010 + '0'); }
|
||||
|
|
@ -686,7 +645,6 @@ void TRI_AppendUInt64OctalStringBuffer (TRI_string_buffer_t * self, uint64_t att
|
|||
|
||||
AppendChar(self, attr % 010 + '0');
|
||||
|
||||
*self->_bufferPtr = '\0';
|
||||
}
|
||||
|
||||
////////////////////////////////////////////////////////////////////////////////
|
||||
|
|
@ -722,10 +680,10 @@ void TRI_AppendSizeOctalStringBuffer (TRI_string_buffer_t * self, size_t attr) {
|
|||
/// @brief appends unsigned integer with 32 bits in hex
|
||||
////////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
static char const * const HEX = "0123456789ABCDEF";
|
||||
void TRI_AppendUInt32HexStringBuffer (TRI_string_buffer_t * self, uint32_t attr) {
|
||||
static char const * const HEX = "0123456789ABCDEF";
|
||||
|
||||
Reserve(self, 5);
|
||||
Reserve(self, 4);
|
||||
|
||||
if (0x1000U <= attr) { AppendChar(self, HEX[(attr / 0x1000U) % 0x10]); }
|
||||
if ( 0x100U <= attr) { AppendChar(self, HEX[(attr / 0x100U) % 0x10]); }
|
||||
|
|
@ -733,7 +691,6 @@ void TRI_AppendUInt32HexStringBuffer (TRI_string_buffer_t * self, uint32_t attr)
|
|||
|
||||
AppendChar(self, HEX[attr % 0x10]);
|
||||
|
||||
*self->_bufferPtr = '\0';
|
||||
}
|
||||
|
||||
////////////////////////////////////////////////////////////////////////////////
|
||||
|
|
@ -741,9 +698,8 @@ void TRI_AppendUInt32HexStringBuffer (TRI_string_buffer_t * self, uint32_t attr)
|
|||
////////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
void TRI_AppendUInt64HexStringBuffer (TRI_string_buffer_t * self, uint64_t attr) {
|
||||
static char const * const HEX = "0123456789ABCDEF";
|
||||
|
||||
Reserve(self, 9);
|
||||
Reserve(self, 8);
|
||||
|
||||
if (0x10000000U <= attr) { AppendChar(self, HEX[(attr / 0x10000000U) % 0x10]); }
|
||||
if ( 0x1000000U <= attr) { AppendChar(self, HEX[(attr / 0x1000000U) % 0x10]); }
|
||||
|
|
@ -755,7 +711,6 @@ void TRI_AppendUInt64HexStringBuffer (TRI_string_buffer_t * self, uint64_t attr)
|
|||
|
||||
AppendChar(self, HEX[attr % 0x10]);
|
||||
|
||||
*self->_bufferPtr = '\0';
|
||||
}
|
||||
|
||||
////////////////////////////////////////////////////////////////////////////////
|
||||
|
|
@ -993,7 +948,6 @@ void TRI_AppendTimeStringBuffer (TRI_string_buffer_t * self, int32_t attr) {
|
|||
AppendChar(self, ':');
|
||||
TRI_AppendInteger2StringBuffer(self, second);
|
||||
|
||||
*self->_bufferPtr = '\0';
|
||||
}
|
||||
|
||||
////////////////////////////////////////////////////////////////////////////////
|
||||
|
|
|
|||
|
|
@ -51,6 +51,8 @@ typedef struct TRI_string_buffer_s {
|
|||
char * _buffer;
|
||||
char * _bufferPtr;
|
||||
char * _bufferEnd;
|
||||
ptrdiff_t _off;
|
||||
size_t _len;
|
||||
}
|
||||
TRI_string_buffer_t;
|
||||
|
||||
|
|
|
|||
|
|
@ -0,0 +1,265 @@
|
|||
#include "../BasicsC/string-buffer.h"
|
||||
#include <assert.h>
|
||||
#include <string.h>
|
||||
#include <stdio.h>
|
||||
|
||||
/*
|
||||
* gcc -g -I . -L . -lavocado UnitTests/string-buffer-test.c && ./a.out
|
||||
* from base dir.
|
||||
*/
|
||||
|
||||
static int tst_tst_cnt;
|
||||
static int tst_err_cnt;
|
||||
|
||||
#define STR "The quick brown fox jumped over the laxy dog"
|
||||
#define STRSTR STR STR
|
||||
|
||||
#define TWNTYA "aaaaaaaaaaaaaaaaaaaa"
|
||||
|
||||
#define ABC "ABCDEFGHIJKLMNOP"
|
||||
#define REP "REPDEFGHIJKLMNOP"
|
||||
#define AEP "AEPDEFGHIJKLMNOP"
|
||||
|
||||
static cmp_int (int should, int is, char * name) {
|
||||
if (should != is) {
|
||||
printf("'%s' failed! should: %d is: %d\n", name, should, is);
|
||||
tst_err_cnt++;
|
||||
}
|
||||
tst_tst_cnt++;
|
||||
}
|
||||
|
||||
static cmp_ptr (const char * should, const char * is, char * name) {
|
||||
if (should != is) {
|
||||
printf("'%s' failed! should: %p is: %p\n", name, should, is);
|
||||
tst_err_cnt++;
|
||||
}
|
||||
tst_tst_cnt++;
|
||||
}
|
||||
static cmp_str (char * should, char * is, size_t len, char * name) {
|
||||
if (strncmp(should, is, len)) {
|
||||
printf("'%s' failed! should: \n>>%s<< is: \n>>%s<<\n", name, should, is);
|
||||
tst_err_cnt++;
|
||||
}
|
||||
tst_tst_cnt++;
|
||||
}
|
||||
|
||||
static cmp_bool (int value, char * name) {
|
||||
if (!value) {
|
||||
printf("'%s' failed! should be truish is: %d\n", name, value);
|
||||
tst_err_cnt++;
|
||||
}
|
||||
tst_tst_cnt++;
|
||||
}
|
||||
|
||||
static void tst_str_append() {
|
||||
int l1, l2;
|
||||
|
||||
TRI_string_buffer_t sb, sb2;
|
||||
TRI_InitStringBuffer(&sb);
|
||||
TRI_AppendStringStringBuffer(&sb, STR);
|
||||
TRI_AppendStringStringBuffer(&sb, STR);
|
||||
l1 = strnlen( STRSTR, 1024);
|
||||
l2 = strnlen( sb._buffer, 1024);
|
||||
|
||||
cmp_int((int)l1, (int)l2, "basic append (len)");
|
||||
cmp_str(STRSTR, sb._buffer, l1, "basic append (cmp)");
|
||||
|
||||
TRI_AppendString2StringBuffer(&sb, ABC, 3); // ABC ... Z
|
||||
|
||||
l2 = strnlen( sb._buffer, 1024);
|
||||
cmp_str(STRSTR"ABC", sb._buffer, l2, "basic append 2 (cmp)");
|
||||
|
||||
TRI_ClearStringBuffer(&sb);
|
||||
TRI_AppendStringStringBuffer(&sb, STR);
|
||||
TRI_InitStringBuffer(&sb2);
|
||||
TRI_AppendStringStringBuffer(&sb2, STR);
|
||||
TRI_AppendStringBufferStringBuffer(&sb, &sb2);
|
||||
|
||||
l2 = strnlen( sb._buffer, 1024);
|
||||
cmp_str(STRSTR, sb._buffer, l2, "basic append 3 (cmp)");
|
||||
cmp_str(STR, sb2._buffer, l2, "basic append 4 (cmp)");
|
||||
|
||||
TRI_FreeStringBuffer(&sb);
|
||||
|
||||
}
|
||||
|
||||
static void tst_char_append() {
|
||||
int l1, l2, i;
|
||||
|
||||
TRI_string_buffer_t sb;
|
||||
TRI_InitStringBuffer(&sb);
|
||||
|
||||
for (i=0l; i!=20; ++i) {
|
||||
TRI_AppendCharStringBuffer(&sb, 'a');
|
||||
}
|
||||
|
||||
l1 = strnlen( TWNTYA, 1024);
|
||||
l2 = strnlen( sb._buffer, 1024);
|
||||
|
||||
cmp_int((int)l1, (int)l2, "char append (len)");
|
||||
cmp_str(TWNTYA, sb._buffer, l1, "char append (cmp)");
|
||||
|
||||
TRI_FreeStringBuffer(&sb);
|
||||
}
|
||||
static void tst_swp() {
|
||||
int l1, l2, i;
|
||||
|
||||
TRI_string_buffer_t sb1, sb2;
|
||||
TRI_InitStringBuffer(&sb1);
|
||||
TRI_InitStringBuffer(&sb2);
|
||||
|
||||
for (i=0l; i!=20; ++i) {
|
||||
TRI_AppendCharStringBuffer(&sb1, 'a');
|
||||
}
|
||||
|
||||
TRI_AppendStringStringBuffer(&sb2, STR);
|
||||
|
||||
TRI_SwapStringBuffer(&sb1, &sb2);
|
||||
|
||||
l1 = strnlen( TWNTYA, 1024);
|
||||
l2 = strnlen( STR, 1024);
|
||||
|
||||
cmp_str(TWNTYA, sb2._buffer, l1, "swp test 1");
|
||||
cmp_str(STR, sb1._buffer, l2, "swp test 2");
|
||||
|
||||
TRI_FreeStringBuffer(&sb1);
|
||||
TRI_FreeStringBuffer(&sb2);
|
||||
}
|
||||
static void tst_begin_end_empty_clear() {
|
||||
int l1, i;
|
||||
const char * ptr;
|
||||
|
||||
TRI_string_buffer_t sb;
|
||||
TRI_InitStringBuffer(&sb);
|
||||
|
||||
TRI_AppendStringStringBuffer(&sb, STR);
|
||||
|
||||
ptr = TRI_BeginStringBuffer(&sb);
|
||||
cmp_ptr(sb._buffer, ptr, "begin test");
|
||||
|
||||
|
||||
l1 = strnlen(STR, 1024);
|
||||
ptr = TRI_EndStringBuffer(&sb);
|
||||
cmp_ptr(sb._buffer+l1, ptr, "end test");
|
||||
|
||||
cmp_bool((int)!TRI_EmptyStringBuffer(&sb), "empty 1");
|
||||
TRI_ClearStringBuffer(&sb);
|
||||
cmp_bool((int)TRI_EmptyStringBuffer(&sb), "empty 2");
|
||||
|
||||
TRI_FreeStringBuffer(&sb);
|
||||
}
|
||||
|
||||
static void tst_cpy() {
|
||||
int l1, l2, i;
|
||||
|
||||
TRI_string_buffer_t sb1, sb2;
|
||||
TRI_InitStringBuffer(&sb1);
|
||||
TRI_InitStringBuffer(&sb2);
|
||||
|
||||
for (i=0l; i!=20; ++i) {
|
||||
TRI_AppendCharStringBuffer(&sb1, 'a');
|
||||
}
|
||||
|
||||
TRI_AppendStringStringBuffer(&sb2, STR);
|
||||
|
||||
TRI_CopyStringBuffer(&sb1, &sb2);
|
||||
|
||||
l1 = strnlen( STR, 1024);
|
||||
|
||||
cmp_int(l1, strnlen(sb1._buffer, l1) , "copy (len)");
|
||||
cmp_str(STR, sb2._buffer, l1, "cpy test 1");
|
||||
cmp_str(STR, sb1._buffer, l1, "cpy test 2");
|
||||
|
||||
TRI_FreeStringBuffer(&sb1);
|
||||
TRI_FreeStringBuffer(&sb2);
|
||||
}
|
||||
|
||||
#define Z_2_T "0123456789A"
|
||||
#define F_2_T "56789A"
|
||||
#define Z_2_F "012345"
|
||||
static void tst_erase_frnt() {
|
||||
int l;
|
||||
|
||||
TRI_string_buffer_t sb;
|
||||
TRI_InitStringBuffer(&sb);
|
||||
TRI_AppendStringStringBuffer(&sb, Z_2_T);
|
||||
TRI_EraseFrontStringBuffer(&sb, 5);
|
||||
|
||||
l = strnlen(sb._buffer, 1024);
|
||||
cmp_str(F_2_T, sb._buffer, l, "erase front");
|
||||
|
||||
|
||||
TRI_EraseFrontStringBuffer(&sb, 15);
|
||||
|
||||
cmp_bool(TRI_EmptyStringBuffer(&sb), "erase front2");
|
||||
|
||||
TRI_FreeStringBuffer(&sb);
|
||||
}
|
||||
|
||||
static void tst_replace () {
|
||||
int l;
|
||||
|
||||
TRI_string_buffer_t sb;
|
||||
TRI_string_buffer_t sb2;
|
||||
|
||||
TRI_InitStringBuffer(&sb);
|
||||
TRI_AppendStringStringBuffer(&sb, ABC);
|
||||
TRI_ReplaceStringStringBuffer(&sb, "REP", 3);
|
||||
|
||||
l = strnlen(sb._buffer, 1024);
|
||||
cmp_str(REP, sb._buffer, l, "replace1");
|
||||
|
||||
TRI_ReplaceStringStringBuffer(&sb, ABC, 1);
|
||||
l = strnlen(sb._buffer, 1024);
|
||||
cmp_str(AEP, sb._buffer, l, "replace2");
|
||||
|
||||
TRI_ClearStringBuffer(&sb);
|
||||
TRI_AppendStringStringBuffer(&sb, ABC);
|
||||
|
||||
TRI_InitStringBuffer(&sb2);
|
||||
TRI_AppendStringStringBuffer(&sb2, "REP");
|
||||
|
||||
TRI_ReplaceStringBufferStringBuffer(&sb, &sb2);
|
||||
l = strnlen(sb._buffer, 1024);
|
||||
cmp_str(REP, sb._buffer, l, "replace stringbuffer 1");
|
||||
|
||||
// TRI_ClearStringBuffer(&sb2);
|
||||
// TRI_AppendStringStringBuffer(&sb2, ABC);
|
||||
//
|
||||
// TRI_ReplaceStringBufferStringBuffer(&sb, &sb2, 1);
|
||||
// l = strnlen(sb._buffer, 1024);
|
||||
// cmp_str(AEP, sb._buffer, l, "replace stringbuffer 2");
|
||||
|
||||
|
||||
}
|
||||
|
||||
#define ONETWOTHREE "123"
|
||||
void tst_smpl_utils () {
|
||||
// these are built on prev. tested building blocks...
|
||||
TRI_string_buffer_t sb;
|
||||
TRI_InitStringBuffer(&sb);
|
||||
TRI_AppendInteger3StringBuffer(&sb, 123);
|
||||
cmp_str(ONETWOTHREE, sb._buffer, 1024, "append int3");
|
||||
TRI_ClearStringBuffer(&sb);
|
||||
TRI_AppendInteger3StringBuffer(&sb, 1234);
|
||||
cmp_str("234", sb._buffer, 1024, "append int3");
|
||||
|
||||
}
|
||||
|
||||
void tst_report () {
|
||||
printf("%d test run. %d failed.\n", tst_tst_cnt, tst_err_cnt);
|
||||
}
|
||||
|
||||
int main () {
|
||||
tst_str_append();
|
||||
tst_char_append();
|
||||
tst_swp();
|
||||
tst_begin_end_empty_clear();
|
||||
tst_cpy();
|
||||
tst_erase_frnt();
|
||||
tst_replace();
|
||||
tst_smpl_utils();
|
||||
tst_report();
|
||||
return 0;
|
||||
}
|
||||
|
||||
Loading…
Reference in New Issue