Hawkin
/
arangodb
mirror of https://gitee.com/bigwinds/arangodb
1
0
Fork 0
Code Issues Projects Releases Wiki Activity

more memory zones

This commit is contained in:
Frank Celler 2012-04-25 23:35:30 +02:00
parent 85db82258b
commit ac74aa7ec9
11 changed files with 333 additions and 209 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
Basics/ProgramOptions.cpp
View File

@ -299,7 +299,7 @@ ProgramOptions::~ProgramOptions () {
}
for (map<string, TRI_vector_string_t*>::iterator i = _valuesVector.begin(); i != _valuesVector.end(); ++i) {
TRI_FreeVectorString(i->second);
TRI_FreeVectorString(TRI_CORE_MEM_ZONE, i->second);
}
for (map<string, bool*>::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);

6
BasicsC/json.h
View File

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

6
BasicsC/memory.h
View File

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

12
BasicsC/strings.h
View File

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

110
BasicsC/vector.c
View File

@ -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) {

16
BasicsC/vector.h
View File

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

143
JsonParser/json-parser.c
View File

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

139
JsonParser/json-parser.l
View File

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

2
Logger/Logger.cpp
View File

@ -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 == '%') {

98
ProgramOptions/program-options.c
View File

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

6
Rest/HttpResponse.cpp
View File

@ -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() {