dav: comparison libidav/davqlparser.c

-:32e7b3e6b482
+:8c9b84f37af5
 #define dqlsec_malloc(stmt, ptr, type)  ptr = malloc(sizeof(type));     \
 dqlsec_alloc_failed(ptr, stmt);
 #define dqlsec_mallocz(stmt, ptr, type) ptr = calloc(1, sizeof(type));  \
 dqlsec_alloc_failed(ptr, stmt);
+#define dqlsec_list_append(stmt, list, data)                    \
+{                                                           \
+UcxList *_dqlsecbak_ = list;                            \
+list = ucx_list_append(list, data);                     \
+if (!list) {                                            \
+(stmt)->errorcode = DAVQL_ERROR_OUT_OF_MEMORY;      \
+list = _dqlsecbak_;                                 \
+}                                                       \
+}
 // special symbols are single tokens - the % sign MUST NOT be a special symbol
 static const char *special_token_symbols = ",()+-*/&|^~=!<>";
 static _Bool iskeyword(DavQLToken *token) {
 token->tokenclass = DAVQL_TOKEN_INVALID;
 }
 }
-return ucx_list_append(tokenlist, token);
+UcxList *ret = ucx_list_append(tokenlist, token);
+if (ret) {
+return ret;
+} else {
+ucx_list_free(tokenlist);
+return NULL;
+}
 }
 static UcxList* dav_parse_tokenize(sstr_t src) {
 #define alloc_token token = malloc(sizeof(DavQLToken));\
 if(!token) {ucx_list_free(tokens); return NULL;}
+#define add_token tokens = dav_parse_add_token(tokens, token); \
+if(!tokens) {return NULL;}
 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++;
-tokens = dav_parse_add_token(tokens, token);
+add_token
 token = NULL;
 insequence = '\0';
 }
 } else if (insequence == '\0') {
 insequence = src.ptr[i];
 // always create new token for quoted strings
 if (token) {
-tokens = dav_parse_add_token(tokens, token);
+add_token
 }
 alloc_token
 token->value.ptr = src.ptr + i;
 token->value.length = 1;
 } else {
 } else if (insequence) {
 token->value.length++;
 } else if (isspace(src.ptr[i])) {
 // add token before spaces to list (if any)
 if (token) {
-tokens = dav_parse_add_token(tokens, 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) {
-tokens = dav_parse_add_token(tokens, token);
+add_token
 token = NULL;
 }
 // add special symbol as single token to list
 alloc_token
 token->value.ptr = src.ptr + i;
 token->value.length = 1;
-tokens = dav_parse_add_token(tokens, 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) {
 token->value.length++;
 }
 }
 if (token) {
-tokens = dav_parse_add_token(tokens, token);
+add_token
 }
 alloc_token
 token->tokenclass = DAVQL_TOKEN_END;
 token->value = S("");
-return ucx_list_append(tokens, token);
+UcxList *ret = ucx_list_append(tokens, token);
+if (ret) {
+return ret;
+} else {
+ucx_list_free(tokens);
+return NULL;
+}
 #undef alloc_token
+#undef add_token
 }
 static void dav_free_expression(DavQLExpression *expr) {
 if (expr) {
 if (expr->left) {
 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);
-stmt->fields = ucx_list_append(stmt->fields, field);
+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_mallocz(stmt, field->expr, DavQLExpression);
 field->expr->type = DAVQL_IDENTIFIER;
 field->expr->srctext = field->name = token_sstr(token);
-stmt->fields = ucx_list_append(stmt->fields, field);
+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));
-stmt->fields = ucx_list_append(stmt->fields, field);
+dqlsec_list_append(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));
-stmt->fields = ucx_list_append(stmt->fields, field);
+dqlsec_list_append(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);
-stmt->fields = ucx_list_append(stmt->fields, field);
+dqlsec_list_append(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));
-stmt->orderby = ucx_list_append(stmt->orderby, criterion);
+dqlsec_list_append(stmt, stmt->orderby, criterion);
 if (token_is(token, DAVQL_TOKEN_COMMA)) {
 total_consumed++;
 token = token->next;
 } else {
 stmt->depth = 1;
 // save trimmed source text
 stmt->srctext = sstrtrim(srctext);
-// tokenization
+if (stmt->srctext.length) {
-UcxList* tokens = dav_parse_tokenize(stmt->srctext);
+// tokenization
+UcxList* tokens = dav_parse_tokenize(stmt->srctext);
-if (tokens) {
-// use first token to determine query type
+if (tokens) {
+// use first token to determine query type
-if (tokenvalue_is(tokens, "select")) {
-dav_parse_select_statement(stmt, tokens->next);
+if (tokenvalue_is(tokens, "select")) {
-} else if (tokenvalue_is(tokens, "set")) {
+dav_parse_select_statement(stmt, tokens->next);
-dav_parse_set_statement(stmt, tokens->next);
+} else if (tokenvalue_is(tokens, "set")) {
+dav_parse_set_statement(stmt, tokens->next);
+} else {
+stmt->type = DAVQL_ERROR;
+stmt->errorcode = DAVQL_ERROR_INVALID;
+stmt->errormessage = strdup(_error_invalid);
+}
+// free token data
+UCX_FOREACH(token, tokens) {
+free(token->data);
+}
+ucx_list_free(tokens);
 } else {
-stmt->type = DAVQL_ERROR;
+stmt->errorcode = DAVQL_ERROR_OUT_OF_MEMORY;
-stmt->errorcode = DAVQL_ERROR_INVALID;
+}
-stmt->errormessage = strdup(_error_invalid);
-}
-// free token data
-UCX_FOREACH(token, tokens) {
-free(token->data);
-}
-ucx_list_free(tokens);
 } else {
 stmt->type = DAVQL_ERROR;
 stmt->errorcode = DAVQL_ERROR_INVALID;
 stmt->errormessage = strdup(_error_invalid);
 }

Mercurial > hg > dav / file comparison

comparison: libidav/davqlparser.c

libidav/davqlparser.c