mirror of https://gitee.com/bigwinds/arangodb
Merge pull request #25 from a2800276/realloc_stringbuffer
Realloc stringbuffer
This commit is contained in:
commit
c5a2f038a8
|
@ -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;
|
||||
|
||||
|
|
Loading…
Reference in New Issue