dav: comparison libidav/davqlparser.c

-:eea36bf5ffe2
+:9a016d5fa9e7
 lp, prev.ptr,
 sfmtarg(tokenstr),
 ln, pn).ptr;
 }
+#define dqlsec_alloc_failed(ptr, stmt)                                  \
+if (!(ptr)) {                                       \
+(stmt)->errorcode = DAVQL_ERROR_OUT_OF_MEMORY;  \
+return 0;                                       \
+}
+#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);
 // special symbols are single tokens - the % sign MUST NOT be a special symbol
 static const char *special_token_symbols = ",()+-*/&|^~=!<>";
 static _Bool iskeyword(DavQLToken *token) {
 sstr_t keywords[] = {ST("get"), ST("set"), ST("from"), ST("at"), ST("as"),
 return ucx_list_append(tokenlist, token);
 }
 static UcxList* dav_parse_tokenize(sstr_t src) {
+#define alloc_token token = malloc(sizeof(DavQLToken));\
+if(!token) {ucx_list_free(tokens); return NULL;}
 UcxList *tokens = NULL;
 DavQLToken *token = NULL;
 char insequence = '\0';
 for (size_t i = 0 ; i < src.length ; i++) {
 insequence = src.ptr[i];
 // always create new token for quoted strings
 if (token) {
 tokens = dav_parse_add_token(tokens, token);
 }
-token = malloc(sizeof(DavQLToken));
+alloc_token
 token->value.ptr = src.ptr + i;
 token->value.length = 1;
 } else {
 // add other kind of quotes to token
 token->value.length++;
 if (token) {
 tokens = dav_parse_add_token(tokens, token);
 token = NULL;
 }
 // add special symbol as single token to list
-token = malloc(sizeof(DavQLToken));
+alloc_token
 token->value.ptr = src.ptr + i;
 token->value.length = 1;
 tokens = dav_parse_add_token(tokens, token);
 // set tokenizer ready to read more tokens
 token = NULL;
 } else {
 // if this is a new token, create memory for it
 if (!token) {
-token = malloc(sizeof(DavQLToken));
+alloc_token
 token->value.ptr = src.ptr + i;
 token->value.length = 0;
 }
 // extend token length when reading more bytes
 token->value.length++;
 if (token) {
 tokens = dav_parse_add_token(tokens, token);
 }
-DavQLToken *endtoken = malloc(sizeof(DavQLToken));
+alloc_token
-endtoken->tokenclass = DAVQL_TOKEN_END;
+token->tokenclass = DAVQL_TOKEN_END;
-endtoken->value = S("");
+token->value = S("");
-return ucx_list_append(tokens, endtoken);
+return ucx_list_append(tokens, token);
+#undef alloc_token
 }
 static void dav_free_expression(DavQLExpression *expr) {
 if (expr) {
 if (expr->left) {
 }
 if (expr->op == DAVQL_NOOP) {
 memcpy(expr, &left, sizeof(DavQLExpression));
 } else {
-expr->left = malloc(sizeof(DavQLExpression));
+dqlsec_malloc(stmt, expr->left, DavQLExpression);
 memcpy(expr->left, &left, sizeof(DavQLExpression));
-expr->right = malloc(sizeof(DavQLExpression));
+dqlsec_malloc(stmt, expr->right, DavQLExpression);
 memcpy(expr->right, &right, sizeof(DavQLExpression));
 expr->srctext.ptr = expr->left->srctext.ptr;
 expr->srctext.length =
 expr->right->srctext.ptr -
 total_consumed++;
 token = token->next;
 /* we have more arguments, so put the current argument to the
 * left subtree and create a new node to the right
 */
-arglist->left = malloc(sizeof(DavQLExpression));
+dqlsec_malloc(stmt, arglist->left, DavQLExpression);
 memcpy(arglist->left, &arg, sizeof(DavQLExpression));
 arglist->srctext.ptr = arg.srctext.ptr;
 arglist->op = DAVQL_ARGLIST;
 arglist->type = DAVQL_FUNCCALL;
-arglist->right = calloc(1, sizeof(DavQLExpression));
+dqlsec_mallocz(stmt, arglist->right, DavQLExpression);
 arglist = arglist->right;
 } else {
 // this was the last argument, so write it to the current node
 memcpy(arglist, &arg, sizeof(DavQLExpression));
 consumed = 0;
 token_is(token->next, DAVQL_TOKEN_OPENP)) {
 expr->type = DAVQL_FUNCCALL;
 expr->op = DAVQL_CALL;
-expr->left = calloc(1, sizeof(DavQLExpression));
+dqlsec_mallocz(stmt, expr->left, DavQLExpression);
 expr->left->type = DAVQL_IDENTIFIER;
 expr->left->srctext = token_sstr(token);
 expr->right = NULL;
 token = token->next->next;
 // if an error occurred while parsing the arglist, return now
 return 2;
 }
 if (argtokens) {
 token = ucx_list_get(token, argtokens);
-expr->right = malloc(sizeof(DavQLExpression));
+dqlsec_malloc(stmt, expr->right, DavQLExpression);
 memcpy(expr->right, &arg, sizeof(DavQLExpression));
 } else {
 // arg list may be empty
 expr->right = NULL;
 }
 switch (*op) {
 case '+': expr->op = DAVQL_ADD; break;
 case '-': expr->op = DAVQL_SUB; break;
 case '~': expr->op = DAVQL_NEG; break;
 }
-expr->left = calloc(1, sizeof(DavQLExpression));
+dqlsec_mallocz(stmt, expr->left, DavQLExpression);
 atom = expr->left;
 total_consumed++;
 token = token->next;
 } else {
 dav_error_in_context(DAVQL_ERROR_INVALID_UNARY_OP,
 static int dav_parse_named_field(DavQLStatement *stmt, UcxList *token,
 DavQLField *field) {
 int total_consumed = 0, consumed;
 // RULE:    Expression, " as ", Identifier;
-DavQLExpression *expr = calloc(1, sizeof(DavQLExpression));
+DavQLExpression *expr;
+dqlsec_mallocz(stmt, expr, DavQLExpression);
 consumed = dav_parse_expression(stmt, token, expr);
 if (stmt->errorcode) {
 dav_free_expression(expr);
 return 0;
 }
 static int dav_parse_fieldlist(DavQLStatement *stmt, UcxList *token) {
 // RULE:    "-"
 if (token_is(token, DAVQL_TOKEN_OPERATOR) && tokenvalue_is(token, "-")) {
-DavQLField *field = malloc(sizeof(DavQLField));
+DavQLField *field;
-field->expr = calloc(1, sizeof(DavQLExpression));
+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);
 return 1;
 }
 // RULE:    "*", {",", NamedExpression}
 if (token_is(token, DAVQL_TOKEN_OPERATOR) && tokenvalue_is(token, "*")) {
-DavQLField *field = malloc(sizeof(DavQLField));
+DavQLField *field;
-field->expr = calloc(1, sizeof(DavQLExpression));
+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);
 int total_consumed = 0;
 if (token_is(token, DAVQL_TOKEN_COMMA)) {
 total_consumed++; token = token->next;
 DavQLField localfield;
 consumed = dav_parse_named_field(stmt, token, &localfield);
 if (!stmt->errorcode && consumed) {
-DavQLField *field = malloc(sizeof(DavQLField));
+DavQLField *field;
+dqlsec_malloc(stmt, field, DavQLField);
 memcpy(field, &localfield, sizeof(DavQLField));
 stmt->fields = ucx_list_append(stmt->fields, field);
 }
 } else {
 consumed = 0;
 do {
 // RULE:    NamedField | Identifier
 DavQLField localfield;
 consumed = dav_parse_named_field(stmt, token, &localfield);
 if (consumed) {
-DavQLField *field = malloc(sizeof(DavQLField));
+DavQLField *field;
+dqlsec_malloc(stmt, field, DavQLField);
 memcpy(field, &localfield, sizeof(DavQLField));
 stmt->fields = ucx_list_append(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) ||
 tokenvalue_is(token->next, "from"))) {
-DavQLField *field = malloc(sizeof(DavQLField));
+DavQLField *field;
-field->expr = calloc(1, sizeof(DavQLExpression));
+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);
 consumed = 1;
 total_consumed++;
 token = token->next;
 if (token_is(token, DAVQL_TOKEN_STRING)) {
 expr->op = tokenvalue_is(optok, "like") ?
 DAVQL_LIKE : DAVQL_UNLIKE;
-expr->left = malloc(sizeof(DavQLExpression));
+dqlsec_malloc(stmt, expr->left, DavQLExpression);
 memcpy(expr->left, &bexpr, sizeof(DavQLExpression));
-expr->right = calloc(1, sizeof(DavQLExpression));
+dqlsec_mallocz(stmt, expr->right, DavQLExpression);
 expr->right->type = DAVQL_STRING;
 expr->right->srctext = token_sstr(token);
 return total_consumed + 1;
 } else {
 stmt, token);
 return 0;
 }
 total_consumed += consumed;
-expr->left = malloc(sizeof(DavQLExpression));
+dqlsec_malloc(stmt, expr->left, DavQLExpression);
 memcpy(expr->left, &bexpr, sizeof(DavQLExpression));
-expr->right = malloc(sizeof(DavQLExpression));
+dqlsec_malloc(stmt, expr->right, DavQLExpression);
 memcpy(expr->right, &rexpr, sizeof(DavQLExpression));
 return total_consumed;
 }
 // RULE:    FunctionCall | Identifier;
 // RULE:    "not ", LogicalExpression
 if (token_is(token, DAVQL_TOKEN_OPERATOR) && tokenvalue_is(token, "not")) {
 expr->type = DAVQL_LOGICAL;
 expr->op = DAVQL_NOT;
-expr->left = calloc(1, sizeof(DavQLExpression));
+dqlsec_mallocz(stmt, expr->left, DavQLExpression);
 expr->srctext = token_sstr(token);
 token = token->next;
 int consumed = dav_parse_bool_expr(stmt, token, expr->left);
 if (stmt->errorcode) {
 return 0;
 }
 total_consumed += consumed;
 token = ucx_list_get(token, consumed);
-expr->left = malloc(sizeof(DavQLExpression));
+dqlsec_malloc(stmt, expr->left, DavQLExpression);
 memcpy(expr->left, &left, sizeof(DavQLExpression));
-expr->right = malloc(sizeof(DavQLExpression));
+dqlsec_malloc(stmt, expr->right, DavQLExpression);
 memcpy(expr->right, &right, sizeof(DavQLExpression));
 }
 } else {
 memcpy(expr, &left, sizeof(DavQLExpression));
 }
 return total_consumed;
 }
 static int dav_parse_where_clause(DavQLStatement *stmt, UcxList *token) {
-stmt->where = calloc(1, sizeof(DavQLExpression));
+dqlsec_mallocz(stmt, stmt->where, DavQLExpression);
 return dav_parse_logical_expr(stmt, token, stmt->where);
 }
 static int dav_parse_with_clause(DavQLStatement *stmt, UcxList *token) {
 token = token->next; total_consumed++;
 if (tokenvalue_is(token, "infinity")) {
 stmt->depth = DAV_DEPTH_INFINITY;
 token = token->next; total_consumed++;
 } else {
-DavQLExpression *depthexpr = calloc(1, sizeof(DavQLExpression));
+DavQLExpression *depthexpr;
+dqlsec_mallocz(stmt, depthexpr, DavQLExpression);
 int consumed = dav_parse_expression(stmt, token, depthexpr);
 if (consumed) {
 if (depthexpr->type == DAVQL_NUMBER) {
 if (depthexpr->srctext.ptr[0] == '%') {
 stmt->depth = DAV_DEPTH_PLACEHOLDER;
 } else {
 sstr_t depthstr = depthexpr->srctext;
 char *conv = malloc(depthstr.length+1);
+if (!conv) {
+dav_free_expression(depthexpr);
+stmt->errorcode = DAVQL_ERROR_OUT_OF_MEMORY;
+return 0;
+}
 char *chk;
 memcpy(conv, depthstr.ptr, depthstr.length);
 conv[depthstr.length] = '\0';
 stmt->depth = strtol(conv, &chk, 10);
 if (*chk || stmt->depth < -1) {
 dav_error_in_context(DAVQL_ERROR_INVALID_ORDER_CRITERION,
 _error_invalid_order_criterion, stmt, token);
 return 0;
 }
-crit->column = malloc(sizeof(DavQLExpression));
+dqlsec_malloc(stmt, crit->column, DavQLExpression);
 memcpy(crit->column, &expr, sizeof(DavQLExpression));
 token = ucx_list_get(token, consumed);
 if (token_is(token, DAVQL_TOKEN_KEYWORD) && (
 tokenvalue_is(token, "asc") || tokenvalue_is(token, "desc"))) {
 return 0;
 }
 token = ucx_list_get(token, consumed);
 total_consumed += consumed;
-DavQLOrderCriterion *criterion = malloc(sizeof(DavQLOrderCriterion));
+DavQLOrderCriterion *criterion;
+dqlsec_malloc(stmt, criterion, DavQLOrderCriterion);
 memcpy(criterion, &crit, sizeof(DavQLOrderCriterion));
 stmt->orderby = ucx_list_append(stmt->orderby, criterion);
 if (token_is(token, DAVQL_TOKEN_COMMA)) {
 total_consumed++;
 stmt->type = DAVQL_ERROR;
 stmt->errorcode = DAVQL_ERROR_INVALID;
 stmt->errormessage = strdup(_error_invalid);
 }
-if (stmt->errorcode = DAVQL_ERROR_OUT_OF_MEMORY) {
+if (stmt->errorcode == DAVQL_ERROR_OUT_OF_MEMORY) {
 stmt->type = DAVQL_ERROR;
 stmt->errormessage = oommsg;
 } else {
 free(oommsg);
 }

Mercurial > hg > dav / file comparison

comparison: libidav/davqlparser.c

libidav/davqlparser.c