From ac74aa7ec964f18089e32769f85d231e17190858 Mon Sep 17 00:00:00 2001 From: Frank Celler Date: Wed, 25 Apr 2012 23:35:30 +0200 Subject: [PATCH] more memory zones --- Basics/ProgramOptions.cpp | 4 +- BasicsC/json.h | 6 +- BasicsC/memory.h | 6 ++ BasicsC/strings.h | 12 +++ BasicsC/vector.c | 110 +++++++++++++++--------- BasicsC/vector.h | 16 ++-- JsonParser/json-parser.c | 143 ++++++++++++++++++++----------- JsonParser/json-parser.l | 139 +++++++++++++++++++----------- Logger/Logger.cpp | 2 +- ProgramOptions/program-options.c | 98 ++++++++++----------- Rest/HttpResponse.cpp | 6 +- 11 files changed, 333 insertions(+), 209 deletions(-) diff --git a/Basics/ProgramOptions.cpp b/Basics/ProgramOptions.cpp index 23a8b005d4..3cbbcad7f5 100644 --- a/Basics/ProgramOptions.cpp +++ b/Basics/ProgramOptions.cpp @@ -299,7 +299,7 @@ ProgramOptions::~ProgramOptions () { } for (map::iterator i = _valuesVector.begin(); i != _valuesVector.end(); ++i) { - TRI_FreeVectorString(i->second); + TRI_FreeVectorString(TRI_CORE_MEM_ZONE, i->second); } for (map::iterator i = _valuesBool.begin(); i != _valuesBool.end(); ++i) { @@ -538,7 +538,7 @@ void ProgramOptions::setupSubDescription (ProgramOptionsDescription const& descr if (wtr == 0) { wtr = _valuesVector[option] = (TRI_vector_string_t*) TRI_Allocate(TRI_CORE_MEM_ZONE, sizeof(TRI_vector_string_t)); - TRI_InitVectorString(TRI_CORE_MEM_ZONE, wtr); + TRI_InitVectorString(wtr, TRI_CORE_MEM_ZONE); } TRI_AddVectorStringPODescription(desc, option.c_str(), shortOption, help.c_str(), wtr); diff --git a/BasicsC/json.h b/BasicsC/json.h index 3859237ab4..492837b047 100644 --- a/BasicsC/json.h +++ b/BasicsC/json.h @@ -280,19 +280,19 @@ TRI_json_t* TRI_CopyJson (TRI_memory_zone_t*, TRI_json_t*); /// @brief parses a json string //////////////////////////////////////////////////////////////////////////////// -TRI_json_t* TRI_JsonString (char const* text); +TRI_json_t* TRI_JsonString (TRI_memory_zone_t*, char const* text); //////////////////////////////////////////////////////////////////////////////// /// @brief parses a json string and returns error message //////////////////////////////////////////////////////////////////////////////// -TRI_json_t* TRI_Json2String (char const* text, char** error); +TRI_json_t* TRI_Json2String (TRI_memory_zone_t*, char const* text, char** error); //////////////////////////////////////////////////////////////////////////////// /// @brief parses a json file and returns error message //////////////////////////////////////////////////////////////////////////////// -TRI_json_t* TRI_JsonFile (char const* path, char** error); +TRI_json_t* TRI_JsonFile (TRI_memory_zone_t*, char const* path, char** error); //////////////////////////////////////////////////////////////////////////////// /// @} diff --git a/BasicsC/memory.h b/BasicsC/memory.h index 74469bbded..c253d11b92 100644 --- a/BasicsC/memory.h +++ b/BasicsC/memory.h @@ -70,6 +70,12 @@ typedef void TRI_memory_zone_t; TRI_memory_zone_t* TRI_CORE_MEM_ZONE; +//////////////////////////////////////////////////////////////////////////////// +/// @brief unknown memory zone +//////////////////////////////////////////////////////////////////////////////// + +TRI_memory_zone_t* TRI_UNKNOWN_MEM_ZONE; + //////////////////////////////////////////////////////////////////////////////// /// @} //////////////////////////////////////////////////////////////////////////////// diff --git a/BasicsC/strings.h b/BasicsC/strings.h index 3c49327ad2..3f635706f6 100644 --- a/BasicsC/strings.h +++ b/BasicsC/strings.h @@ -93,6 +93,12 @@ bool TRI_IsPrefixString (char const* full, char const* prefix); char* TRI_DuplicateString (char const*); +//////////////////////////////////////////////////////////////////////////////// +/// @brief duplicates a string +//////////////////////////////////////////////////////////////////////////////// + +char* TRI_DuplicateStringZ (TRI_memory_zone_t*, char const*); + //////////////////////////////////////////////////////////////////////////////// /// @brief duplicates a string of given length //////////////////////////////////////////////////////////////////////////////// @@ -224,6 +230,12 @@ char* TRI_EscapeUtf8String (char const* in, size_t inLength, bool escapeSlash, s char* TRI_UnescapeUtf8String (char const* in, size_t inLength, size_t* outLength); +//////////////////////////////////////////////////////////////////////////////// +/// @brief unescapes unicode escape sequences +//////////////////////////////////////////////////////////////////////////////// + +char* TRI_UnescapeUtf8StringZ (TRI_memory_zone_t*, char const* in, size_t inLength, size_t* outLength); + //////////////////////////////////////////////////////////////////////////////// /// @} //////////////////////////////////////////////////////////////////////////////// diff --git a/BasicsC/vector.c b/BasicsC/vector.c index 2c3681de77..2b4fc8d10f 100644 --- a/BasicsC/vector.c +++ b/BasicsC/vector.c @@ -435,7 +435,7 @@ int TRI_ResizeVectorPointer (TRI_vector_pointer_t* vector, size_t n) { if (vector->_buffer != NULL) { memcpy(newBuffer, vector->_buffer, vector->_length * sizeof(void*)); - TRI_Free(vector->_buffer); + TRI_Free(vector->_memoryZone, vector->_buffer); } vector->_buffer = newBuffer; @@ -450,34 +450,36 @@ int TRI_ResizeVectorPointer (TRI_vector_pointer_t* vector, size_t n) { /// @brief adds an element at the end //////////////////////////////////////////////////////////////////////////////// -void TRI_PushBackVectorPointer (TRI_vector_pointer_t* vector, void* element) { +int TRI_PushBackVectorPointer (TRI_vector_pointer_t* vector, void* element) { if (vector->_length == vector->_capacity) { void* newBuffer; size_t newSize = (size_t) (1 + GROW_FACTOR * vector->_capacity); - newBuffer = TRI_Allocate(newSize * sizeof(void*)); - if (!newBuffer) { - // TODO FIXME: handle memory allocation failure */ + newBuffer = TRI_Allocate(vector->_memoryZone, newSize * sizeof(void*)); + + if (newBuffer == NULL) { + return TRI_ERROR_OUT_OF_MEMORY; } vector->_capacity = newSize; if (vector->_buffer != NULL) { memcpy(newBuffer, vector->_buffer, vector->_length * sizeof(void*)); - TRI_Free(vector->_buffer); + TRI_Free(vector->_memoryZone, vector->_buffer); } vector->_buffer = newBuffer; } vector->_buffer[vector->_length++] = element; + return TRI_ERROR_NO_ERROR; } //////////////////////////////////////////////////////////////////////////////// /// @brief inserts an element at position n, shifting the following elements //////////////////////////////////////////////////////////////////////////////// -void TRI_InsertVectorPointer (TRI_vector_pointer_t* vector, void* element, size_t n) { +int TRI_InsertVectorPointer (TRI_vector_pointer_t* vector, void* element, size_t n) { if (vector->_length >= vector->_capacity) { void* newBuffer; size_t newSize = (size_t) (1 + GROW_FACTOR * vector->_capacity); @@ -486,16 +488,17 @@ void TRI_InsertVectorPointer (TRI_vector_pointer_t* vector, void* element, size_ newSize = n + 1; } - newBuffer = TRI_Allocate(newSize * sizeof(void*)); - if (!newBuffer) { - // TODO FIXME: handle memory allocation failure */ + newBuffer = TRI_Allocate(vector->_memoryZone, newSize * sizeof(void*)); + + if (newBuffer == NULL) { + return TRI_ERROR_OUT_OF_MEMORY; } vector->_capacity = newSize; if (vector->_buffer != NULL) { memcpy(newBuffer, vector->_buffer, vector->_length * sizeof(void*)); - TRI_Free(vector->_buffer); + TRI_Free(vector->_memoryZone, vector->_buffer); } vector->_buffer = newBuffer; @@ -515,6 +518,8 @@ void TRI_InsertVectorPointer (TRI_vector_pointer_t* vector, void* element, size_ else { ++vector->_length; } + + return TRI_ERROR_NO_ERROR; } //////////////////////////////////////////////////////////////////////////////// @@ -574,7 +579,8 @@ void* TRI_AtVectorPointer (TRI_vector_pointer_t const* vector, size_t pos) { /// @brief initialises a vector //////////////////////////////////////////////////////////////////////////////// -void TRI_InitVectorString (TRI_vector_string_t* vector) { +void TRI_InitVectorString (TRI_vector_string_t* vector, TRI_memory_zone_t* zone) { + vector->_memoryZone = zone; vector->_buffer = NULL; vector->_length = 0; vector->_capacity = 0; @@ -590,11 +596,11 @@ void TRI_DestroyVectorString (TRI_vector_string_t* vector) { if (vector->_buffer != NULL) { for (i = 0; i < vector->_capacity; ++i) { if (vector->_buffer[i] != 0) { - TRI_Free(vector->_buffer[i]); + TRI_Free(vector->_memoryZone, vector->_buffer[i]); } } - TRI_Free(vector->_buffer); + TRI_Free(vector->_memoryZone, vector->_buffer); } } @@ -602,9 +608,9 @@ void TRI_DestroyVectorString (TRI_vector_string_t* vector) { /// @brief destroys a vector and frees the string //////////////////////////////////////////////////////////////////////////////// -void TRI_FreeVectorString (TRI_vector_string_t* vector) { +void TRI_FreeVectorString (TRI_memory_zone_t* zone, TRI_vector_string_t* vector) { TRI_DestroyVectorString(vector); - TRI_Free(vector); + TRI_Free(zone, vector); } //////////////////////////////////////////////////////////////////////////////// @@ -624,14 +630,16 @@ void TRI_FreeVectorString (TRI_vector_string_t* vector) { /// @brief copies a vector and all its strings //////////////////////////////////////////////////////////////////////////////// -TRI_vector_string_t* TRI_CopyVectorString (TRI_vector_string_t* vector) { +TRI_vector_string_t* TRI_CopyVectorString (TRI_memory_zone_t* zone, + TRI_vector_string_t* vector) { TRI_vector_string_t* copy; char** ptr; char** end; char** qtr; - copy = TRI_Allocate(sizeof(TRI_vector_t)); - if (!copy) { + copy = TRI_Allocate(zone, sizeof(TRI_vector_t)); + + if (copy == NULL) { return NULL; } @@ -641,9 +649,10 @@ TRI_vector_string_t* TRI_CopyVectorString (TRI_vector_string_t* vector) { copy->_capacity = 0; } else { - copy->_buffer = TRI_Allocate(vector->_length * sizeof(char*)); - if (!copy->_buffer) { - TRI_Free(copy); + copy->_buffer = TRI_Allocate(zone, vector->_length * sizeof(char*)); + + if (copy->_buffer == NULL) { + TRI_Free(zone, copy); return NULL; } @@ -655,8 +664,19 @@ TRI_vector_string_t* TRI_CopyVectorString (TRI_vector_string_t* vector) { qtr = copy->_buffer; for (; ptr < end; ++ptr, ++qtr) { - *qtr = TRI_DuplicateString(*ptr); - // TODO FIXME: handle memory allocation failure + *qtr = TRI_DuplicateStringZ(zone, *ptr); + + if (*qtr == NULL) { + char** xtr = copy->_buffer; + + for (; xtr < qtr; ++xtr) { + TRI_Free(zone, *xtr); + } + + TRI_Free(zone, copy->_buffer); + TRI_Free(zone, copy); + return NULL; + } } } @@ -683,64 +703,69 @@ void TRI_ClearVectorString (TRI_vector_string_t* vector) { /// @brief resizes the vector //////////////////////////////////////////////////////////////////////////////// -void TRI_ResizeVectorString (TRI_vector_string_t* vector, size_t n) { +int TRI_ResizeVectorString (TRI_vector_string_t* vector, size_t n) { if (vector->_length == n) { - return; + return TRI_ERROR_NO_ERROR; } if (vector->_capacity < n) { void* newBuffer; size_t newSize = n; - newBuffer = TRI_Allocate(newSize * sizeof(char*)); - if (!newBuffer) { - // TODO FIXME: handle memory allocation failure + newBuffer = TRI_Allocate(vector->_memoryZone, newSize * sizeof(char*)); + + if (newBuffer == NULL) { + return TRI_ERROR_OUT_OF_MEMORY; } vector->_capacity = n; if (vector->_buffer != NULL) { memcpy(newBuffer, vector->_buffer, vector->_length * sizeof(char*)); - TRI_Free(vector->_buffer); + TRI_Free(vector->_memoryZone, vector->_buffer); } vector->_buffer = newBuffer; } vector->_length = n; + return TRI_ERROR_NO_ERROR; } //////////////////////////////////////////////////////////////////////////////// /// @brief adds an element at the end //////////////////////////////////////////////////////////////////////////////// -void TRI_PushBackVectorString (TRI_vector_string_t* vector, char* element) { +int TRI_PushBackVectorString (TRI_vector_string_t* vector, char* element) { if (vector->_length == vector->_capacity) { char** newBuffer; size_t newSize = (size_t) (1 + GROW_FACTOR * vector->_capacity); - newBuffer = (char**) TRI_Allocate(newSize * sizeof(char*)); - if (!newBuffer) { - // TODO FIXME: handle memory allocation failure + newBuffer = (char**) TRI_Allocate(vector->_memoryZone, newSize * sizeof(char*)); + + if (newBuffer == NULL) { + return TRI_ERROR_OUT_OF_MEMORY; } + vector->_capacity = newSize; if (vector->_buffer != NULL) { memcpy(newBuffer, vector->_buffer, vector->_length * sizeof(char*)); - TRI_Free(vector->_buffer); + TRI_Free(vector->_memoryZone, vector->_buffer); } vector->_buffer = newBuffer; } vector->_buffer[vector->_length++] = element; + return TRI_ERROR_NO_ERROR; } //////////////////////////////////////////////////////////////////////////////// /// @brief inserts an element at position n //////////////////////////////////////////////////////////////////////////////// -void TRI_InsertVectorString (TRI_vector_string_t* vector, char* element, size_t n) { +int TRI_InsertVectorString (TRI_vector_string_t* vector, char* element, size_t n) { if (n >= vector->_capacity) { char** newBuffer; size_t newSize = (size_t) (1 + GROW_FACTOR * vector->_capacity); @@ -749,16 +774,17 @@ void TRI_InsertVectorString (TRI_vector_string_t* vector, char* element, size_t newSize = n + 1; } - newBuffer = (char**) TRI_Allocate(newSize * sizeof(char*)); - if (!newBuffer) { - // TODO FIXME: handle memory allocation failure + newBuffer = (char**) TRI_Allocate(vector->_memoryZone, newSize * sizeof(char*)); + + if (newBuffer == NULL) { + return TRI_ERROR_OUT_OF_MEMORY; } vector->_capacity = newSize; if (vector->_buffer != NULL) { memcpy(newBuffer, vector->_buffer, vector->_length * sizeof(char*)); - TRI_Free(vector->_buffer); + TRI_Free(vector->_memoryZone, vector->_buffer); } vector->_buffer = newBuffer; @@ -769,8 +795,10 @@ void TRI_InsertVectorString (TRI_vector_string_t* vector, char* element, size_t vector->_buffer + n, sizeof(char**) * (vector->_length - n)); } + vector->_length++; vector->_buffer[n] = element; + return TRI_ERROR_NO_ERROR; } //////////////////////////////////////////////////////////////////////////////// @@ -780,7 +808,7 @@ void TRI_InsertVectorString (TRI_vector_string_t* vector, char* element, size_t void TRI_RemoveVectorString (TRI_vector_string_t* vector, size_t n) { if (n < vector->_length) { if (vector->_buffer[n] != NULL) { - TRI_Free(vector->_buffer[n]); + TRI_Free(vector->_memoryZone, vector->_buffer[n]); } if (n + 1 < vector->_length) { diff --git a/BasicsC/vector.h b/BasicsC/vector.h index 675498744a..7bd3aa6072 100644 --- a/BasicsC/vector.h +++ b/BasicsC/vector.h @@ -271,13 +271,13 @@ int TRI_ResizeVectorPointer (TRI_vector_pointer_t*, size_t); /// @brief adds an element at the end //////////////////////////////////////////////////////////////////////////////// -void TRI_PushBackVectorPointer (TRI_vector_pointer_t*, void*); +int TRI_PushBackVectorPointer (TRI_vector_pointer_t*, void*); //////////////////////////////////////////////////////////////////////////////// /// @brief adds an element at position n //////////////////////////////////////////////////////////////////////////////// -void TRI_InsertVectorPointer (TRI_vector_pointer_t*, void*, size_t); +int TRI_InsertVectorPointer (TRI_vector_pointer_t*, void*, size_t); //////////////////////////////////////////////////////////////////////////////// /// @brief removes an element, returns this element @@ -340,7 +340,7 @@ TRI_vector_string_t; /// @brief initialises a vector //////////////////////////////////////////////////////////////////////////////// -void TRI_InitVectorString (TRI_memory_zone_t*, TRI_vector_string_t*); +void TRI_InitVectorString (TRI_vector_string_t*, TRI_memory_zone_t*); //////////////////////////////////////////////////////////////////////////////// /// @brief destroys a vector and all strings, but does not free the pointer @@ -352,7 +352,7 @@ void TRI_DestroyVectorString (TRI_vector_string_t*); /// @brief destroys a vector and frees the string //////////////////////////////////////////////////////////////////////////////// -void TRI_FreeVectorString (TRI_vector_string_t*); +void TRI_FreeVectorString (TRI_memory_zone_t*, TRI_vector_string_t*); //////////////////////////////////////////////////////////////////////////////// /// @} @@ -371,7 +371,7 @@ void TRI_FreeVectorString (TRI_vector_string_t*); /// @brief copies a vector and all its strings //////////////////////////////////////////////////////////////////////////////// -TRI_vector_string_t* TRI_CopyVectorString (TRI_vector_string_t*); +TRI_vector_string_t* TRI_CopyVectorString (TRI_memory_zone_t*, TRI_vector_string_t*); //////////////////////////////////////////////////////////////////////////////// /// @brief returns true if the vector is empty @@ -389,7 +389,7 @@ void TRI_ClearVectorString (TRI_vector_string_t*); /// @brief resizes the vector //////////////////////////////////////////////////////////////////////////////// -void TRI_ResizeVectorString (TRI_vector_string_t*, size_t n); +int TRI_ResizeVectorString (TRI_vector_string_t*, size_t n); //////////////////////////////////////////////////////////////////////////////// /// @brief adds an element at the end @@ -397,7 +397,7 @@ void TRI_ResizeVectorString (TRI_vector_string_t*, size_t n); /// Note that the vector claims owenship of element. //////////////////////////////////////////////////////////////////////////////// -void TRI_PushBackVectorString (TRI_vector_string_t*, char* element); +int TRI_PushBackVectorString (TRI_vector_string_t*, char* element); //////////////////////////////////////////////////////////////////////////////// /// @brief adds an element at position n @@ -405,7 +405,7 @@ void TRI_PushBackVectorString (TRI_vector_string_t*, char* element); /// Note that the vector claims owenship of element. //////////////////////////////////////////////////////////////////////////////// -void TRI_InsertVectorString (TRI_vector_string_t*, char* element, size_t n); +int TRI_InsertVectorString (TRI_vector_string_t*, char* element, size_t n); //////////////////////////////////////////////////////////////////////////////// /// @brief removes an element, frees this element diff --git a/JsonParser/json-parser.c b/JsonParser/json-parser.c index 0b01cfbb70..6898e01e53 100644 --- a/JsonParser/json-parser.c +++ b/JsonParser/json-parser.c @@ -590,8 +590,8 @@ static yyconst flex_int16_t yy_chk[130] = static yyconst flex_int16_t yy_rule_linenum[14] = { 0, - 85, 89, 93, 101, 109, 117, 121, 125, 129, 133, - 137, 146, 149 + 86, 90, 94, 102, 110, 118, 122, 126, 130, 134, + 138, 147, 150 } ; /* The intent behind this definition is that it'll catch @@ -617,7 +617,8 @@ static yyconst flex_int16_t yy_rule_linenum[14] = #define UNQUOTED_STRING 12 struct jsonData { - char const* message; + char const* _message; + TRI_memory_zone_t* _memoryZone; }; #define YY_FATAL_ERROR(a) \ @@ -2391,9 +2392,10 @@ static TRI_json_t* ParseList (yyscan_t scanner) { bool comma; int c; - list = TRI_CreateListJson(); + list = TRI_CreateListJson(yyextra._memoryZone); if (list == NULL) { + yyextra._message = "out-of-memory"; return NULL; } @@ -2409,8 +2411,8 @@ static TRI_json_t* ParseList (yyscan_t scanner) { if (comma) { if (c != COMMA) { - TRI_FreeJson(list); - yyextra.message = "expecting comma"; + TRI_FreeJson(yyextra._memoryZone, list); + yyextra._message = "expecting comma"; return NULL; } @@ -2423,17 +2425,17 @@ static TRI_json_t* ParseList (yyscan_t scanner) { sub = ParseObject(scanner, c); if (sub == NULL) { - TRI_FreeJson(list); + TRI_FreeJson(yyextra._memoryZone, list); return NULL; } - TRI_PushBack3ListJson(list, sub); + TRI_PushBack3ListJson(yyextra._memoryZone, list, sub); c = tri_jsp_lex(scanner); } - TRI_FreeJson(list); - yyextra.message = "expecting a list element, got end-of-file"; + TRI_FreeJson(yyextra._memoryZone, list); + yyextra._message = "expecting a list element, got end-of-file"; return NULL; } @@ -2455,7 +2457,11 @@ static TRI_json_t* ParseArray (yyscan_t scanner) { size_t outLength; comma = false; - array = TRI_CreateArrayJson(); + array = TRI_CreateArrayJson(yyextra._memoryZone); + + if (array == NULL) { + yyextra._message = "out-of-memory"; + } c = tri_jsp_lex(scanner); @@ -2466,8 +2472,8 @@ static TRI_json_t* ParseArray (yyscan_t scanner) { if (comma) { if (c != COMMA) { - TRI_FreeJson(array); - yyextra.message = "expecting comma"; + TRI_FreeJson(yyextra._memoryZone, array); + yyextra._message = "expecting comma"; return NULL; } @@ -2479,22 +2485,22 @@ static TRI_json_t* ParseArray (yyscan_t scanner) { // attribute name if (c != STRING_CONSTANT) { - TRI_FreeJson(array); - yyextra.message = "expecting attribute name"; + TRI_FreeJson(yyextra._memoryZone, array); + yyextra._message = "expecting attribute name"; return NULL; } ptr = yytext; len = yyleng; - name = TRI_UnescapeUtf8String(ptr + 1, len - 2, &outLength); + name = TRI_UnescapeUtf8StringZ(yyextra._memoryZone, ptr + 1, len - 2, &outLength); // followed by a colon c = tri_jsp_lex(scanner); if (c != COLON) { - TRI_FreeString(name); - TRI_FreeJson(array); - yyextra.message = "expecting colon"; + TRI_FreeString(yyextra._memoryZone, name); + TRI_FreeJson(yyextra._memoryZone, array); + yyextra._message = "expecting colon"; return NULL; } @@ -2503,19 +2509,19 @@ static TRI_json_t* ParseArray (yyscan_t scanner) { sub = ParseObject(scanner, c); if (sub == NULL) { - TRI_FreeString(name); - TRI_FreeJson(array); + TRI_FreeString(yyextra._memoryZone, name); + TRI_FreeJson(yyextra._memoryZone, array); return NULL; } - TRI_Insert3ArrayJson(array, name, sub); - TRI_FreeString(name); + TRI_Insert3ArrayJson(yyextra._memoryZone, array, name, sub); + TRI_FreeString(yyextra._memoryZone, name); c = tri_jsp_lex(scanner); } - TRI_FreeJson(array); - yyextra.message = "expecting a object attribute name or element, got end-of-file"; + TRI_FreeJson(yyextra._memoryZone, array); + yyextra._message = "expecting a object attribute name or element, got end-of-file"; return NULL; } @@ -2526,20 +2532,39 @@ static TRI_json_t* ParseArray (yyscan_t scanner) { static TRI_json_t* ParseObject (yyscan_t scanner, int c) { struct yyguts_t * yyg = (struct yyguts_t*) scanner; + TRI_json_t* result; switch (c) { case END_OF_FILE: - yyextra.message = "expecting atom, got end-of-file"; + yyextra._message = "expecting atom, got end-of-file"; return NULL; case FALSE_CONSTANT: - return TRI_CreateBooleanJson(false); + result = TRI_CreateBooleanJson(yyextra._memoryZone, false); + + if (result == NULL) { + yyextra._message = "out-of-memory"; + } + + return result; case TRUE_CONSTANT: - return TRI_CreateBooleanJson(true); + result = TRI_CreateBooleanJson(yyextra._memoryZone, true); + + if (result == NULL) { + yyextra._message = "out-of-memory"; + } + + return result; case NULL_CONSTANT: - return TRI_CreateNullJson(); + result = TRI_CreateNullJson(yyextra._memoryZone); + + if (result == NULL) { + yyextra._message = "out-of-memory"; + } + + return result; case NUMBER_CONSTANT: { char buffer[512]; @@ -2547,7 +2572,7 @@ static TRI_json_t* ParseObject (yyscan_t scanner, int c) { double d; if ((size_t) yyleng >= sizeof(buffer)) { - yyextra.message = "number too big"; + yyextra._message = "number too big"; return NULL; } @@ -2557,60 +2582,71 @@ static TRI_json_t* ParseObject (yyscan_t scanner, int c) { d = strtod(buffer, &ep); if (d == HUGE_VAL && errno == ERANGE) { - yyextra.message = "number too big"; + yyextra._message = "number too big"; return NULL; } if (d == 0 && errno == ERANGE) { - yyextra.message = "number too small"; + yyextra._message = "number too small"; return NULL; } if (ep != buffer + yyleng) { - yyextra.message = "cannot parse number"; + yyextra._message = "cannot parse number"; return NULL; } - return TRI_CreateNumberJson(d); + result = TRI_CreateNumberJson(yyextra._memoryZone, d); + + if (result == NULL) { + yyextra._message = "out-of-memory"; + } + + return result; } case STRING_CONSTANT: { char* ptr; size_t outLength; - ptr = TRI_UnescapeUtf8String(yytext + 1, yyleng - 2, &outLength); + ptr = TRI_UnescapeUtf8StringZ(yyextra._memoryZone, yytext + 1, yyleng - 2, &outLength); + result = TRI_CreateString2Json(yyextra._memoryZone, ptr, outLength); - return TRI_CreateString2Json(ptr, outLength); + if (result == NULL) { + yyextra._message = "out-of-memory"; + } + + return result; } case OPEN_BRACE: return ParseArray(scanner); case CLOSE_BRACE: - yyextra.message = "expected object, got '}'"; + yyextra._message = "expected object, got '}'"; return NULL; case OPEN_BRACKET: return ParseList(scanner); case CLOSE_BRACKET: - yyextra.message = "expected object, got ']'"; + yyextra._message = "expected object, got ']'"; return NULL; case COMMA: - yyextra.message = "expected object, got ','"; + yyextra._message = "expected object, got ','"; return NULL; case COLON: - yyextra.message = "expected object, got ':'"; + yyextra._message = "expected object, got ':'"; return NULL; case UNQUOTED_STRING: - yyextra.message = "expected object, got unquoted string"; + yyextra._message = "expected object, got unquoted string"; return NULL; } - yyextra.message = "unknown atom"; + yyextra._message = "unknown atom"; return NULL; } @@ -2631,7 +2667,7 @@ static TRI_json_t* ParseObject (yyscan_t scanner, int c) { /// @brief parses a json string //////////////////////////////////////////////////////////////////////////////// -TRI_json_t* TRI_Json2String (char const* text, char** error) { +TRI_json_t* TRI_Json2String (TRI_memory_zone_t* zone, char const* text, char** error) { TRI_json_t* object; YY_BUFFER_STATE buf; int c; @@ -2643,13 +2679,15 @@ TRI_json_t* TRI_Json2String (char const* text, char** error) { tri_jsp_lex_init(&scanner); yyg = (struct yyguts_t*) scanner; + yyextra._memoryZone = zone; + buf = tri_jsp__scan_string((char yyconst*) text,scanner); c = tri_jsp_lex(scanner); object = ParseObject(scanner, c); if (object == NULL) { - LOG_DEBUG("failed to parse json object: '%s'", yyextra.message); + LOG_DEBUG("failed to parse json object: '%s'", yyextra._message); } else { c = tri_jsp_lex(scanner); @@ -2661,8 +2699,8 @@ TRI_json_t* TRI_Json2String (char const* text, char** error) { } if (error != NULL) { - if (yyextra.message != 0) { - *error = TRI_DuplicateString(yyextra.message); + if (yyextra._message != 0) { + *error = TRI_DuplicateString(yyextra._message); } else { *error = NULL; @@ -2679,15 +2717,15 @@ TRI_json_t* TRI_Json2String (char const* text, char** error) { /// @brief parses a json string //////////////////////////////////////////////////////////////////////////////// -TRI_json_t* TRI_JsonString (char const* text) { - return TRI_Json2String(text, 0); +TRI_json_t* TRI_JsonString (TRI_memory_zone_t* zone, char const* text) { + return TRI_Json2String(zone, text, 0); } //////////////////////////////////////////////////////////////////////////////// /// @brief parses a json file //////////////////////////////////////////////////////////////////////////////// -TRI_json_t* TRI_JsonFile (char const* path, char** error) { +TRI_json_t* TRI_JsonFile (TRI_memory_zone_t* zone, char const* path, char** error) { FILE* in; TRI_json_t* object; int c; @@ -2705,13 +2743,14 @@ TRI_json_t* TRI_JsonFile (char const* path, char** error) { tri_jsp_lex_init(&scanner); yyg = (struct yyguts_t*) scanner; + yyextra._memoryZone = zone; yyin = in; c = tri_jsp_lex(scanner); object = ParseObject(scanner, c); if (object == NULL) { - LOG_DEBUG("failed to parse json object: '%s'", yyextra.message); + LOG_DEBUG("failed to parse json object: '%s'", yyextra._message); } else { c = tri_jsp_lex(scanner); @@ -2723,8 +2762,8 @@ TRI_json_t* TRI_JsonFile (char const* path, char** error) { } if (error != NULL) { - if (yyextra.message != NULL) { - *error = TRI_DuplicateString(yyextra.message); + if (yyextra._message != NULL) { + *error = TRI_DuplicateString(yyextra._message); } else { *error = NULL; diff --git a/JsonParser/json-parser.l b/JsonParser/json-parser.l index 5da8ed0d7a..a79aa79d7c 100644 --- a/JsonParser/json-parser.l +++ b/JsonParser/json-parser.l @@ -69,7 +69,8 @@ PLUS [+] #define UNQUOTED_STRING 12 struct jsonData { - char const* message; + char const* _message; + TRI_memory_zone_t* _memoryZone; }; #define YY_FATAL_ERROR(a) \ @@ -179,9 +180,10 @@ static TRI_json_t* ParseList (yyscan_t scanner) { bool comma; int c; - list = TRI_CreateListJson(); + list = TRI_CreateListJson(yyextra._memoryZone); if (list == NULL) { + yyextra._message = "out-of-memory"; return NULL; } @@ -197,8 +199,8 @@ static TRI_json_t* ParseList (yyscan_t scanner) { if (comma) { if (c != COMMA) { - TRI_FreeJson(list); - yyextra.message = "expecting comma"; + TRI_FreeJson(yyextra._memoryZone, list); + yyextra._message = "expecting comma"; return NULL; } @@ -211,17 +213,17 @@ static TRI_json_t* ParseList (yyscan_t scanner) { sub = ParseObject(scanner, c); if (sub == NULL) { - TRI_FreeJson(list); + TRI_FreeJson(yyextra._memoryZone, list); return NULL; } - TRI_PushBack3ListJson(list, sub); + TRI_PushBack3ListJson(yyextra._memoryZone, list, sub); c = yylex(scanner); } - TRI_FreeJson(list); - yyextra.message = "expecting a list element, got end-of-file"; + TRI_FreeJson(yyextra._memoryZone, list); + yyextra._message = "expecting a list element, got end-of-file"; return NULL; } @@ -243,7 +245,11 @@ static TRI_json_t* ParseArray (yyscan_t scanner) { size_t outLength; comma = false; - array = TRI_CreateArrayJson(); + array = TRI_CreateArrayJson(yyextra._memoryZone); + + if (array == NULL) { + yyextra._message = "out-of-memory"; + } c = yylex(scanner); @@ -254,8 +260,8 @@ static TRI_json_t* ParseArray (yyscan_t scanner) { if (comma) { if (c != COMMA) { - TRI_FreeJson(array); - yyextra.message = "expecting comma"; + TRI_FreeJson(yyextra._memoryZone, array); + yyextra._message = "expecting comma"; return NULL; } @@ -267,22 +273,22 @@ static TRI_json_t* ParseArray (yyscan_t scanner) { // attribute name if (c != STRING_CONSTANT) { - TRI_FreeJson(array); - yyextra.message = "expecting attribute name"; + TRI_FreeJson(yyextra._memoryZone, array); + yyextra._message = "expecting attribute name"; return NULL; } ptr = yytext; len = yyleng; - name = TRI_UnescapeUtf8String(ptr + 1, len - 2, &outLength); + name = TRI_UnescapeUtf8StringZ(yyextra._memoryZone, ptr + 1, len - 2, &outLength); // followed by a colon c = yylex(scanner); if (c != COLON) { - TRI_FreeString(name); - TRI_FreeJson(array); - yyextra.message = "expecting colon"; + TRI_FreeString(yyextra._memoryZone, name); + TRI_FreeJson(yyextra._memoryZone, array); + yyextra._message = "expecting colon"; return NULL; } @@ -291,19 +297,19 @@ static TRI_json_t* ParseArray (yyscan_t scanner) { sub = ParseObject(scanner, c); if (sub == NULL) { - TRI_FreeString(name); - TRI_FreeJson(array); + TRI_FreeString(yyextra._memoryZone, name); + TRI_FreeJson(yyextra._memoryZone, array); return NULL; } - TRI_Insert3ArrayJson(array, name, sub); - TRI_FreeString(name); + TRI_Insert3ArrayJson(yyextra._memoryZone, array, name, sub); + TRI_FreeString(yyextra._memoryZone, name); c = yylex(scanner); } - TRI_FreeJson(array); - yyextra.message = "expecting a object attribute name or element, got end-of-file"; + TRI_FreeJson(yyextra._memoryZone, array); + yyextra._message = "expecting a object attribute name or element, got end-of-file"; return NULL; } @@ -314,20 +320,39 @@ static TRI_json_t* ParseArray (yyscan_t scanner) { static TRI_json_t* ParseObject (yyscan_t scanner, int c) { struct yyguts_t * yyg = (struct yyguts_t*) scanner; + TRI_json_t* result; switch (c) { case END_OF_FILE: - yyextra.message = "expecting atom, got end-of-file"; + yyextra._message = "expecting atom, got end-of-file"; return NULL; case FALSE_CONSTANT: - return TRI_CreateBooleanJson(false); + result = TRI_CreateBooleanJson(yyextra._memoryZone, false); + + if (result == NULL) { + yyextra._message = "out-of-memory"; + } + + return result; case TRUE_CONSTANT: - return TRI_CreateBooleanJson(true); + result = TRI_CreateBooleanJson(yyextra._memoryZone, true); + + if (result == NULL) { + yyextra._message = "out-of-memory"; + } + + return result; case NULL_CONSTANT: - return TRI_CreateNullJson(); + result = TRI_CreateNullJson(yyextra._memoryZone); + + if (result == NULL) { + yyextra._message = "out-of-memory"; + } + + return result; case NUMBER_CONSTANT: { char buffer[512]; @@ -335,7 +360,7 @@ static TRI_json_t* ParseObject (yyscan_t scanner, int c) { double d; if ((size_t) yyleng >= sizeof(buffer)) { - yyextra.message = "number too big"; + yyextra._message = "number too big"; return NULL; } @@ -345,60 +370,71 @@ static TRI_json_t* ParseObject (yyscan_t scanner, int c) { d = strtod(buffer, &ep); if (d == HUGE_VAL && errno == ERANGE) { - yyextra.message = "number too big"; + yyextra._message = "number too big"; return NULL; } if (d == 0 && errno == ERANGE) { - yyextra.message = "number too small"; + yyextra._message = "number too small"; return NULL; } if (ep != buffer + yyleng) { - yyextra.message = "cannot parse number"; + yyextra._message = "cannot parse number"; return NULL; } - return TRI_CreateNumberJson(d); + result = TRI_CreateNumberJson(yyextra._memoryZone, d); + + if (result == NULL) { + yyextra._message = "out-of-memory"; + } + + return result; } case STRING_CONSTANT: { char* ptr; size_t outLength; - ptr = TRI_UnescapeUtf8String(yytext + 1, yyleng - 2, &outLength); + ptr = TRI_UnescapeUtf8StringZ(yyextra._memoryZone, yytext + 1, yyleng - 2, &outLength); + result = TRI_CreateString2Json(yyextra._memoryZone, ptr, outLength); - return TRI_CreateString2Json(ptr, outLength); + if (result == NULL) { + yyextra._message = "out-of-memory"; + } + + return result; } case OPEN_BRACE: return ParseArray(scanner); case CLOSE_BRACE: - yyextra.message = "expected object, got '}'"; + yyextra._message = "expected object, got '}'"; return NULL; case OPEN_BRACKET: return ParseList(scanner); case CLOSE_BRACKET: - yyextra.message = "expected object, got ']'"; + yyextra._message = "expected object, got ']'"; return NULL; case COMMA: - yyextra.message = "expected object, got ','"; + yyextra._message = "expected object, got ','"; return NULL; case COLON: - yyextra.message = "expected object, got ':'"; + yyextra._message = "expected object, got ':'"; return NULL; case UNQUOTED_STRING: - yyextra.message = "expected object, got unquoted string"; + yyextra._message = "expected object, got unquoted string"; return NULL; } - yyextra.message = "unknown atom"; + yyextra._message = "unknown atom"; return NULL; } @@ -419,7 +455,7 @@ static TRI_json_t* ParseObject (yyscan_t scanner, int c) { /// @brief parses a json string //////////////////////////////////////////////////////////////////////////////// -TRI_json_t* TRI_Json2String (char const* text, char** error) { +TRI_json_t* TRI_Json2String (TRI_memory_zone_t* zone, char const* text, char** error) { TRI_json_t* object; YY_BUFFER_STATE buf; int c; @@ -431,13 +467,15 @@ TRI_json_t* TRI_Json2String (char const* text, char** error) { yylex_init(&scanner); yyg = (struct yyguts_t*) scanner; + yyextra._memoryZone = zone; + buf = yy_scan_string((char yyconst*) text, scanner); c = yylex(scanner); object = ParseObject(scanner, c); if (object == NULL) { - LOG_DEBUG("failed to parse json object: '%s'", yyextra.message); + LOG_DEBUG("failed to parse json object: '%s'", yyextra._message); } else { c = yylex(scanner); @@ -449,8 +487,8 @@ TRI_json_t* TRI_Json2String (char const* text, char** error) { } if (error != NULL) { - if (yyextra.message != 0) { - *error = TRI_DuplicateString(yyextra.message); + if (yyextra._message != 0) { + *error = TRI_DuplicateString(yyextra._message); } else { *error = NULL; @@ -467,15 +505,15 @@ TRI_json_t* TRI_Json2String (char const* text, char** error) { /// @brief parses a json string //////////////////////////////////////////////////////////////////////////////// -TRI_json_t* TRI_JsonString (char const* text) { - return TRI_Json2String(text, 0); +TRI_json_t* TRI_JsonString (TRI_memory_zone_t* zone, char const* text) { + return TRI_Json2String(zone, text, 0); } //////////////////////////////////////////////////////////////////////////////// /// @brief parses a json file //////////////////////////////////////////////////////////////////////////////// -TRI_json_t* TRI_JsonFile (char const* path, char** error) { +TRI_json_t* TRI_JsonFile (TRI_memory_zone_t* zone, char const* path, char** error) { FILE* in; TRI_json_t* object; int c; @@ -493,13 +531,14 @@ TRI_json_t* TRI_JsonFile (char const* path, char** error) { yylex_init(&scanner); yyg = (struct yyguts_t*) scanner; + yyextra._memoryZone = zone; yyin = in; c = yylex(scanner); object = ParseObject(scanner, c); if (object == NULL) { - LOG_DEBUG("failed to parse json object: '%s'", yyextra.message); + LOG_DEBUG("failed to parse json object: '%s'", yyextra._message); } else { c = yylex(scanner); @@ -511,8 +550,8 @@ TRI_json_t* TRI_JsonFile (char const* path, char** error) { } if (error != NULL) { - if (yyextra.message != NULL) { - *error = TRI_DuplicateString(yyextra.message); + if (yyextra._message != NULL) { + *error = TRI_DuplicateString(yyextra._message); } else { *error = NULL; diff --git a/Logger/Logger.cpp b/Logger/Logger.cpp index 2d40099125..4418dc5bc6 100644 --- a/Logger/Logger.cpp +++ b/Logger/Logger.cpp @@ -152,7 +152,7 @@ static void OutputMachine (string const& text, LoggerData::Info const& info) { char const* end = format + LoggerFormat.size(); time_t tt = time(0); - StringBuffer line; + StringBuffer line(TRI_CORE_MEM_ZONE); for (; format < end; ++format) { if (*format == '%') { diff --git a/ProgramOptions/program-options.c b/ProgramOptions/program-options.c index e11e3a6eb5..49e95e95d0 100644 --- a/ProgramOptions/program-options.c +++ b/ProgramOptions/program-options.c @@ -174,13 +174,13 @@ struct option * InitOptionStructure (struct option * option, //////////////////////////////////////////////////////////////////////////////// static void FreeOption (TRI_PO_desc_t* desc, void const * input, void * output) { - TRI_FreeString(desc->_name); + TRI_FreeString(TRI_CORE_MEM_ZONE, desc->_name); if (desc->_desc != NULL) { - TRI_FreeString(desc->_desc); + TRI_FreeString(TRI_CORE_MEM_ZONE, desc->_desc); } - TRI_Free(desc); + TRI_Free(TRI_CORE_MEM_ZONE, desc); } //////////////////////////////////////////////////////////////////////////////// @@ -440,7 +440,7 @@ static void ParseStringArg (char const * userarg, void * value) { desc = (TRI_PO_string_t*) value; if (*desc->_value != NULL) { - TRI_Free(*desc->_value); + TRI_Free(TRI_CORE_MEM_ZONE, *desc->_value); } *desc->_value = TRI_DuplicateString(userarg); @@ -736,7 +736,7 @@ static bool HandleOption (TRI_program_options_t * options, item = TRI_AtVector(&options->_items, i); if (TRI_EqualString(full, item->_desc->_name)) { - TRI_FreeString(full); + TRI_FreeString(TRI_CORE_MEM_ZONE, full); item->parse(value, item->_desc); item->_used = true; @@ -745,7 +745,7 @@ static bool HandleOption (TRI_program_options_t * options, } } - TRI_FreeString(full); + TRI_FreeString(TRI_CORE_MEM_ZONE, full); return false; } @@ -930,13 +930,13 @@ static void UsageVectorStringNode (TRI_PO_vector_string_t * desc, void const * i TRI_PO_section_t* TRI_CreatePODescription (char const *description) { TRI_PO_section_t * desc; - desc = TRI_Allocate(sizeof(TRI_PO_section_t)); + desc = TRI_Allocate(TRI_CORE_MEM_ZONE, sizeof(TRI_PO_section_t)); desc->base._type = TRI_PO_SECTION; desc->base._name = TRI_DuplicateString("Program Options"); desc->base._desc = (description != NULL) ? TRI_DuplicateString(description) : NULL; - TRI_InitVectorPointer(&desc->_children); + TRI_InitVectorPointer(&desc->_children, TRI_CORE_MEM_ZONE); return desc; } @@ -973,10 +973,10 @@ TRI_program_options_t * TRI_CreateProgramOptions (TRI_PO_section_t * desc) { po_visit_functions_t optionBuilders; struct option nullOpt; - po = TRI_Allocate(sizeof(TRI_program_options_t)); + po = TRI_Allocate(TRI_CORE_MEM_ZONE, sizeof(TRI_program_options_t)); - TRI_InitVector(&po->_longopts, sizeof(struct option)); - TRI_InitVector(&po->_items, sizeof(TRI_PO_item_t)); + TRI_InitVector(&po->_longopts, TRI_CORE_MEM_ZONE, sizeof(struct option)); + TRI_InitVector(&po->_items, TRI_CORE_MEM_ZONE, sizeof(TRI_PO_item_t)); optionBuilders.visitDoubleNode = CreateDoubleOption; optionBuilders.visitFlagNode = CreateFlagOption; @@ -998,7 +998,7 @@ TRI_program_options_t * TRI_CreateProgramOptions (TRI_PO_section_t * desc) { TRI_PushBackVector(&po->_longopts, &nullOpt); // setup argument vector - TRI_InitVectorString(&po->_arguments); + TRI_InitVectorString(&po->_arguments, TRI_CORE_MEM_ZONE); return po; } @@ -1019,7 +1019,7 @@ void TRI_DestroyProgramOptions (TRI_program_options_t * options) { void TRI_FreeProgramOptions (TRI_program_options_t * options) { TRI_DestroyProgramOptions(options); - TRI_Free(options); + TRI_Free(TRI_CORE_MEM_ZONE, options); } //////////////////////////////////////////////////////////////////////////////// @@ -1049,7 +1049,7 @@ void TRI_AddDoublePODescription (TRI_PO_section_t * desc, assert(name != NULL); assert(variable != NULL); - res = TRI_Allocate(sizeof(po_double_t)); + res = TRI_Allocate(TRI_CORE_MEM_ZONE, sizeof(po_double_t)); res->base._type = TRI_PO_DOUBLE; res->base._name = TRI_DuplicateString(name); @@ -1074,7 +1074,7 @@ void TRI_AddFlagPODescription (TRI_PO_section_t * desc, assert(name != NULL); - res = TRI_Allocate(sizeof(po_flag_t)); + res = TRI_Allocate(TRI_CORE_MEM_ZONE, sizeof(po_flag_t)); res->base._type = TRI_PO_FLAG; res->base._name = TRI_DuplicateString(name); @@ -1101,7 +1101,7 @@ void TRI_AddInt16PODescription (TRI_PO_section_t * desc, assert(variable != NULL); assert(name != NULL); - res = TRI_Allocate(sizeof(po_int16_t)); + res = TRI_Allocate(TRI_CORE_MEM_ZONE, sizeof(po_int16_t)); res->base._type = TRI_PO_INT16; res->base._name = TRI_DuplicateString(name); @@ -1128,7 +1128,7 @@ void TRI_AddInt32PODescription (TRI_PO_section_t * desc, assert(variable != NULL); assert(name != NULL); - res = TRI_Allocate(sizeof(po_int32_t)); + res = TRI_Allocate(TRI_CORE_MEM_ZONE, sizeof(po_int32_t)); res->base._type = TRI_PO_INT32; res->base._name = TRI_DuplicateString(name); @@ -1155,7 +1155,7 @@ void TRI_AddInt64PODescription (TRI_PO_section_t * desc, assert(variable != NULL); assert(name != NULL); - res = TRI_Allocate(sizeof(po_int64_t)); + res = TRI_Allocate(TRI_CORE_MEM_ZONE, sizeof(po_int64_t)); res->base._type = TRI_PO_INT64; res->base._name = TRI_DuplicateString(name); @@ -1181,7 +1181,7 @@ void TRI_AddStringPODescription (TRI_PO_section_t * desc, assert(variable != NULL); assert(name != NULL); - res = TRI_Allocate(sizeof(TRI_PO_string_t)); + res = TRI_Allocate(TRI_CORE_MEM_ZONE, sizeof(TRI_PO_string_t)); res->base._type = TRI_PO_STRING; res->base._name = TRI_DuplicateString(name); @@ -1208,7 +1208,7 @@ void TRI_AddUInt16PODescription (TRI_PO_section_t * desc, assert(variable != NULL); assert(name != NULL); - res = TRI_Allocate(sizeof(po_uint16_t)); + res = TRI_Allocate(TRI_CORE_MEM_ZONE, sizeof(po_uint16_t)); res->base._type = TRI_PO_UINT16; res->base._name = TRI_DuplicateString(name); @@ -1235,7 +1235,7 @@ void TRI_AddUInt32PODescription (TRI_PO_section_t * desc, assert(variable != NULL); assert(name != NULL); - res = TRI_Allocate(sizeof(po_uint32_t)); + res = TRI_Allocate(TRI_CORE_MEM_ZONE, sizeof(po_uint32_t)); res->base._type = TRI_PO_UINT32; res->base._name = TRI_DuplicateString(name); @@ -1262,7 +1262,7 @@ void TRI_AddUInt64PODescription (TRI_PO_section_t * desc, assert(variable != NULL); assert(name != NULL); - res = TRI_Allocate(sizeof(po_uint64_t)); + res = TRI_Allocate(TRI_CORE_MEM_ZONE, sizeof(po_uint64_t)); res->base._type = TRI_PO_UINT64; res->base._name = TRI_DuplicateString(name); @@ -1289,7 +1289,7 @@ void TRI_AddVectorStringPODescription (TRI_PO_section_t * desc, assert(variable != NULL); assert(name != NULL); - res = TRI_Allocate(sizeof(TRI_PO_vector_string_t)); + res = TRI_Allocate(TRI_CORE_MEM_ZONE, sizeof(TRI_PO_vector_string_t)); res->base._type = TRI_PO_VECTOR_STRING; res->base._name = TRI_DuplicateString(name); @@ -1333,7 +1333,7 @@ char * TRI_UsagePODescription (TRI_PO_section_t * desc) { visitors.visitUInt64Node = UsageUInt64Node; visitors.visitVectorStringNode = UsageVectorStringNode; - TRI_InitStringBuffer(&buffer); + TRI_InitStringBuffer(&buffer, TRI_CORE_MEM_ZONE); VisitProgramOptions(&desc->base, &visitors, NULL, &buffer); // the caller has to free this buffer @@ -1360,7 +1360,7 @@ bool TRI_ParseArgumentsProgramOptions (TRI_program_options_t * options, TRI_set_errno(TRI_ERROR_NO_ERROR); - TRI_InitStringBuffer(&buffer); + TRI_InitStringBuffer(&buffer, TRI_CORE_MEM_ZONE); for (i = 0; i < options->_items._length; ++i) { item = TRI_AtVector(&options->_items, i); @@ -1511,7 +1511,7 @@ bool TRI_ParseFileProgramOptions (TRI_program_options_t * options, res = regexec(&re1, buffer, 0, 0, 0); if (res == 0) { - TRI_FreeString(buffer); + TRI_FreeString(TRI_CORE_MEM_ZONE, buffer); buffer = NULL; continue; } @@ -1520,10 +1520,10 @@ bool TRI_ParseFileProgramOptions (TRI_program_options_t * options, res = regexec(&re2, buffer, sizeof(matches) / sizeof(matches[0]), matches, 0); if (res == 0) { - TRI_FreeString(section); + TRI_FreeString(TRI_CORE_MEM_ZONE, section); section = TRI_DuplicateString2(buffer + matches[1].rm_so, matches[1].rm_eo - matches[1].rm_so); - TRI_FreeString(buffer); + TRI_FreeString(TRI_CORE_MEM_ZONE, buffer); buffer = NULL; continue; @@ -1536,12 +1536,12 @@ bool TRI_ParseFileProgramOptions (TRI_program_options_t * options, option = TRI_DuplicateString2(buffer + matches[1].rm_so, matches[1].rm_eo - matches[1].rm_so); value = TRI_DuplicateString2(buffer + matches[2].rm_so, matches[2].rm_eo - matches[2].rm_so); - TRI_FreeString(buffer); + TRI_FreeString(TRI_CORE_MEM_ZONE, buffer); buffer = NULL; ok = HandleOption(options, section, option, value); - TRI_FreeString(value); + TRI_FreeString(TRI_CORE_MEM_ZONE, value); if (! ok) { TRI_set_errno(TRI_ERROR_ILLEGAL_OPTION); @@ -1553,11 +1553,11 @@ bool TRI_ParseFileProgramOptions (TRI_program_options_t * options, fprintf(stderr, "%s: unrecognized option '%s'\n", programName, option); } - TRI_FreeString(option); + TRI_FreeString(TRI_CORE_MEM_ZONE, option); break; } - TRI_FreeString(option); + TRI_FreeString(TRI_CORE_MEM_ZONE, option); continue; } @@ -1567,7 +1567,7 @@ bool TRI_ParseFileProgramOptions (TRI_program_options_t * options, if (res == 0) { option = TRI_DuplicateString2(buffer + matches[1].rm_so, matches[1].rm_eo - matches[1].rm_so); - TRI_FreeString(buffer); + TRI_FreeString(TRI_CORE_MEM_ZONE, buffer); buffer = NULL; ok = HandleOption(options, section, option, ""); @@ -1582,11 +1582,11 @@ bool TRI_ParseFileProgramOptions (TRI_program_options_t * options, fprintf(stderr, "%s: unrecognized option '%s'\n", programName, option); } - TRI_FreeString(option); + TRI_FreeString(TRI_CORE_MEM_ZONE, option); break; } - TRI_FreeString(option); + TRI_FreeString(TRI_CORE_MEM_ZONE, option); continue; } @@ -1598,24 +1598,24 @@ bool TRI_ParseFileProgramOptions (TRI_program_options_t * options, option = TRI_DuplicateString2(buffer + matches[2].rm_so, matches[2].rm_eo - matches[2].rm_so); value = TRI_DuplicateString2(buffer + matches[3].rm_so, matches[3].rm_eo - matches[3].rm_so); - TRI_FreeString(buffer); + TRI_FreeString(TRI_CORE_MEM_ZONE, buffer); buffer = NULL; ok = HandleOption(options, tmpSection, option, value); - TRI_FreeString(value); + TRI_FreeString(TRI_CORE_MEM_ZONE, value); if (! ok) { TRI_set_errno(TRI_ERROR_ILLEGAL_OPTION); fprintf(stderr, "%s: unrecognized option '%s.%s'\n", programName, tmpSection, option); - TRI_FreeString(tmpSection); - TRI_FreeString(option); + TRI_FreeString(TRI_CORE_MEM_ZONE, tmpSection); + TRI_FreeString(TRI_CORE_MEM_ZONE, option); break; } - TRI_FreeString(tmpSection); - TRI_FreeString(option); + TRI_FreeString(TRI_CORE_MEM_ZONE, tmpSection); + TRI_FreeString(TRI_CORE_MEM_ZONE, option); continue; } @@ -1626,7 +1626,7 @@ bool TRI_ParseFileProgramOptions (TRI_program_options_t * options, tmpSection = TRI_DuplicateString2(buffer + matches[1].rm_so, matches[1].rm_eo - matches[1].rm_so); option = TRI_DuplicateString2(buffer + matches[2].rm_so, matches[2].rm_eo - matches[1].rm_so); - TRI_FreeString(buffer); + TRI_FreeString(TRI_CORE_MEM_ZONE, buffer); buffer = NULL; ok = HandleOption(options, tmpSection, option, ""); @@ -1635,29 +1635,29 @@ bool TRI_ParseFileProgramOptions (TRI_program_options_t * options, TRI_set_errno(TRI_ERROR_ILLEGAL_OPTION); fprintf(stderr, "%s: unrecognized option '%s.%s'\n", programName, tmpSection, option); - TRI_FreeString(tmpSection); - TRI_FreeString(option); + TRI_FreeString(TRI_CORE_MEM_ZONE, tmpSection); + TRI_FreeString(TRI_CORE_MEM_ZONE, option); break; } - TRI_FreeString(tmpSection); - TRI_FreeString(option); + TRI_FreeString(TRI_CORE_MEM_ZONE, tmpSection); + TRI_FreeString(TRI_CORE_MEM_ZONE, option); continue; } TRI_set_errno(TRI_ERROR_ILLEGAL_OPTION); fprintf(stderr, "%s: unrecognized entry '%s'\n", programName, buffer); - TRI_FreeString(buffer); + TRI_FreeString(TRI_CORE_MEM_ZONE, buffer); buffer = NULL; break; } if (buffer != NULL) { - TRI_FreeString(buffer); + TRI_FreeString(TRI_CORE_MEM_ZONE, buffer); } - TRI_FreeString(section); + TRI_FreeString(TRI_CORE_MEM_ZONE, section); regfree(&re1); regfree(&re2); diff --git a/Rest/HttpResponse.cpp b/Rest/HttpResponse.cpp index 8103fde830..905f1ffb86 100644 --- a/Rest/HttpResponse.cpp +++ b/Rest/HttpResponse.cpp @@ -121,7 +121,7 @@ namespace triagens { HttpResponse::HttpResponse () : _code(NOT_IMPLEMENTED), _headers(5), - _body(), + _body(TRI_UNKNOWN_MEM_ZONE), _isHeadResponse(false), _bodySize(0), _freeables() { @@ -132,7 +132,7 @@ namespace triagens { HttpResponse::HttpResponse (string const& header) : _code(NOT_IMPLEMENTED), _headers(5), - _body(), + _body(TRI_UNKNOWN_MEM_ZONE), _isHeadResponse(false), _bodySize(0), _freeables() { @@ -144,7 +144,7 @@ namespace triagens { HttpResponse::HttpResponse (HttpResponseCode code) : _code(code), _headers(5), - _body(), + _body(TRI_UNKNOWN_MEM_ZONE), _isHeadResponse(false), _bodySize(0), _freeables() {