1
0
Fork 0

Merge pull request #25 from a2800276/realloc_stringbuffer

Realloc stringbuffer
This commit is contained in:
Frank Celler 2012-03-10 07:33:42 -08:00
commit c5a2f038a8
2 changed files with 75 additions and 119 deletions

View File

@ -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';
}
////////////////////////////////////////////////////////////////////////////////

View File

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