dav: comparison libidav/davqlparser.c

-:1e3e374d9386
+:8828260d2fd8
 lp, prev.ptr,
 sfmtarg(tokenstr),
 ln, pn).ptr;
 }
-// TODO: this macro results in a memory leak - we return without freeing memory
 #define dqlsec_alloc_failed(ptr, stmt)                                  \
-if (!(ptr)) {                                       \
+if (!(ptr)) do {                                    \
 (stmt)->errorcode = DAVQL_ERROR_OUT_OF_MEMORY;  \
 return 0;                                       \
-}
+} while(0)
-#define dqlsec_malloc(stmt, ptr, type)  ptr = malloc(sizeof(type));     \
+#define dqlsec_malloc(stmt, ptr, type) \
-dqlsec_alloc_failed(ptr, stmt);
+dqlsec_alloc_failed(ptr = malloc(sizeof(type)), stmt)
-#define dqlsec_mallocz(stmt, ptr, type) ptr = calloc(1, sizeof(type));  \
+#define dqlsec_mallocz(stmt, ptr, type) \
-dqlsec_alloc_failed(ptr, stmt);
+dqlsec_alloc_failed(ptr = calloc(1, sizeof(type)), stmt)
-#define dqlsec_list_append(stmt, list, data)                    \
+#define dqlsec_list_append_or_free(stmt, list, data)            \
-{                                                           \
+do {                                                        \
 UcxList *_dqlsecbak_ = list;                            \
 list = ucx_list_append(list, data);                     \
 if (!list) {                                            \
+free(data);                                         \
+data = NULL;                                        \
 (stmt)->errorcode = DAVQL_ERROR_OUT_OF_MEMORY;      \
 list = _dqlsecbak_;                                 \
+return 0;                                           \
 }                                                       \
-}
+} while(0)
 // special symbols are single tokens - the % sign MUST NOT be a special symbol
 static const char *special_token_symbols = ",()+-*/&|^~=!<>";
 static _Bool iskeyword(DavQLToken *token) {
 return NULL;
 }
 }
 static UcxList* dav_parse_tokenize(sstr_t src) {
-#define alloc_token token = malloc(sizeof(DavQLToken));\
+#define alloc_token() do {token = malloc(sizeof(DavQLToken));\
-if(!token) {ucx_list_free(tokens); return NULL;}
+if(!token) {ucx_list_free(tokens); return NULL;}} while(0)
-#define add_token tokens = dav_parse_add_token(tokens, token); \
+#define add_token() do {tokens = dav_parse_add_token(tokens, token); \
-if(!tokens) {return NULL;}
+if(!tokens) {return NULL;}} while(0)
 UcxList *tokens = NULL;
 DavQLToken *token = NULL;
 char insequence = '\0';
 for (size_t i = 0 ; i < src.length ; i++) {
 token->value.length += 3;
 i += 2;
 } else {
 // add quoted token to list
 token->value.length++;
-add_token
+add_token();
 token = NULL;
 insequence = '\0';
 }
 } else if (insequence == '\0') {
 insequence = src.ptr[i];
 // always create new token for quoted strings
 if (token) {
-add_token
+add_token();
 }
-alloc_token
+alloc_token();
 token->value.ptr = src.ptr + i;
 token->value.length = 1;
 } else {
 // add other kind of quotes to token
 token->value.length++;
 } else if (insequence) {
 token->value.length++;
 } else if (isspace(src.ptr[i])) {
 // add token before spaces to list (if any)
 if (token) {
-add_token
+add_token();
 token = NULL;
 }
 } else if (strchr(special_token_symbols, src.ptr[i])) {
 // add token before special symbol to list (if any)
 if (token) {
-add_token
+add_token();
 token = NULL;
 }
 // add special symbol as single token to list
-alloc_token
+alloc_token();
 token->value.ptr = src.ptr + i;
 token->value.length = 1;
-add_token
+add_token();
 // set tokenizer ready to read more tokens
 token = NULL;
 } else {
 // if this is a new token, create memory for it
 if (!token) {
-alloc_token
+alloc_token();
 token->value.ptr = src.ptr + i;
 token->value.length = 0;
 }
 // extend token length when reading more bytes
 token->value.length++;
 }
 }
 if (token) {
-add_token
+add_token();
 }
-alloc_token
+alloc_token();
 token->tokenclass = DAVQL_TOKEN_END;
 token->value = S("");
 UcxList *ret = ucx_list_append(tokens, token);
 if (ret) {
 return ret;
 // RULE:    "-"
 if (token_is(token, DAVQL_TOKEN_OPERATOR) && tokenvalue_is(token, "-")) {
 DavQLField *field;
 dqlsec_malloc(stmt, field, DavQLField);
+dqlsec_list_append_or_free(stmt, stmt->fields, field);
 dqlsec_mallocz(stmt, field->expr, DavQLExpression);
 field->expr->type = DAVQL_IDENTIFIER;
 field->expr->srctext = field->name = token_sstr(token);
-dqlsec_list_append(stmt, stmt->fields, field);
 return 1;
 }
 // RULE:    "*", {",", NamedExpression}
 if (token_is(token, DAVQL_TOKEN_OPERATOR) && tokenvalue_is(token, "*")) {
 DavQLField *field;
 dqlsec_malloc(stmt, field, DavQLField);
+dqlsec_list_append_or_free(stmt, stmt->fields, field);
 dqlsec_mallocz(stmt, field->expr, DavQLExpression);
 field->expr->type = DAVQL_IDENTIFIER;
 field->expr->srctext = field->name = token_sstr(token);
-dqlsec_list_append(stmt, stmt->fields, field);
 int total_consumed = 0;
 int consumed = 1;
 do {
 consumed = dav_parse_named_field(stmt, token, &localfield);
 if (!stmt->errorcode && consumed) {
 DavQLField *field;
 dqlsec_malloc(stmt, field, DavQLField);
 memcpy(field, &localfield, sizeof(DavQLField));
-dqlsec_list_append(stmt, stmt->fields, field);
+dqlsec_list_append_or_free(stmt, stmt->fields, field);
 }
 } else {
 consumed = 0;
 }
 } while (consumed > 0);
 consumed = dav_parse_named_field(stmt, token, &localfield);
 if (consumed) {
 DavQLField *field;
 dqlsec_malloc(stmt, field, DavQLField);
 memcpy(field, &localfield, sizeof(DavQLField));
-dqlsec_list_append(stmt, stmt->fields, field);
+dqlsec_list_append_or_free(stmt, stmt->fields, field);
 token = ucx_list_get(token, consumed);
 total_consumed += consumed;
 } else if (token_is(token, DAVQL_TOKEN_IDENTIFIER)
 // look ahead, if the field is JUST the identifier
 && (token_is(token->next, DAVQL_TOKEN_COMMA) ||
 DavQLField *field;
 dqlsec_malloc(stmt, field, DavQLField);
 dqlsec_mallocz(stmt, field->expr, DavQLExpression);
 field->expr->type = DAVQL_IDENTIFIER;
 field->expr->srctext = field->name = token_sstr(token);
-dqlsec_list_append(stmt, stmt->fields, field);
+dqlsec_list_append_or_free(stmt, stmt->fields, field);
 consumed = 1;
 total_consumed++;
 token = token->next;
 total_consumed += consumed;
 DavQLOrderCriterion *criterion;
 dqlsec_malloc(stmt, criterion, DavQLOrderCriterion);
 memcpy(criterion, &crit, sizeof(DavQLOrderCriterion));
-dqlsec_list_append(stmt, stmt->orderby, criterion);
+dqlsec_list_append_or_free(stmt, stmt->orderby, criterion);
 if (token_is(token, DAVQL_TOKEN_COMMA)) {
 total_consumed++;
 token = token->next;
 } else {

Mercurial > hg > dav / file comparison

comparison: libidav/davqlparser.c

libidav/davqlparser.c