dav: comparison libidav/davqlparser.c

-:a569148841ff
+:efbd59642577
 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 * POSSIBILITY OF SUCH DAMAGE.
 */
 #include "davqlparser.h"
-#include <ucx/utils.h>
+#include <cx/utils.h>
+#include <cx/linked_list.h>
+#include <cx/printf.h>
 #include <string.h>
 #include <stdio.h>
 #include <ctype.h>
 #define sfmtarg(s) ((int)(s).length), (s).ptr
 }
 static void dav_debug_ql_fnames_print(DavQLStatement *stmt) {
 if (stmt->fields) {
 printf("Field names: ");
-UCX_FOREACH(field, stmt->fields) {
+CxIterator i = cxListIterator(stmt->fields);
-DavQLField *f = field->data;
+cx_foreach(DavQLField *, f, i) {
-printf("%.*s, ", sfmtarg(f->name));
+printf("%.*s, ", (int)f->name.length, f->name.ptr);
 }
 printf("\b\b  \b\b\n");
 }
 }
 static void dav_debug_ql_stmt_print(DavQLStatement *stmt) {
 // Basic information
-size_t fieldcount = ucx_list_size(stmt->fields);
+size_t fieldcount = stmt->fields ? stmt->fields->size : 0;
 int specialfield = 0;
-if (stmt->fields) {
+if (stmt->fields && stmt->fields->size > 0) {
-DavQLField* firstfield = (DavQLField*)stmt->fields->data;
+DavQLField* firstfield = (DavQLField*)cxListAt(stmt->fields, 0);
 if (firstfield->expr->type == DAVQL_IDENTIFIER) {
 switch (firstfield->expr->srctext.ptr[0]) {
 case '*': specialfield = 1; break;
 case '-': specialfield = 2; break;
 }
 }
 if (specialfield) {
 fieldcount--;
 }
 printf("Statement: %.*s\nType: %s\nField count: %zu %s\n",
-sfmtarg(stmt->srctext),
+(int)stmt->srctext.length, stmt->srctext.ptr,
 _map_querytype(stmt->type),
 fieldcount,
 _map_specialfield(specialfield));
 dav_debug_ql_fnames_print(stmt);
 printf("Path: %.*s\nHas where clause: %s\n",
-sfmtarg(stmt->path),
+(int)stmt->path.length, stmt->path.ptr,
 stmt->where ? "yes" : "no");
 // WITH attributes
 if (stmt->depth == DAV_DEPTH_INFINITY) {
 printf("Depth: infinity\n");
 }
 // order by clause
 printf("Order by: ");
 if (stmt->orderby) {
-UCX_FOREACH(crit, stmt->orderby) {
+CxIterator i = cxListIterator(stmt->orderby);
-DavQLOrderCriterion *critdata = crit->data;
+cx_foreach(DavQLOrderCriterion*, critdata, i) {
-printf("%.*s %s%s", sfmtarg(critdata->column->srctext),
+printf("%.*s %s%s", (int)critdata->column->srctext.length, critdata->column->srctext.ptr,
 critdata->descending ? "desc" : "asc",
-crit->next ? ", " : "\n");
+i.index+1 < stmt->orderby->size ? ", " : "\n");
 }
 } else {
 printf("nothing\n");
 }
 }
 }
 static void dav_debug_ql_expr_print(DavQLExpression *expr) {
 if (dav_debug_ql_expr_selected(expr)) {
-sstr_t empty = ST("(empty)");
+cxstring empty = CX_STR("(empty)");
 printf(
 "Text: %.*s\nType: %s\nOperator: %s\n",
 sfmtarg(expr->srctext),
 _map_exprtype(expr->type),
 _map_operator(expr->op));
 if (stmt->errorcode) {
 return;
 }
 DavQLExpression *examineexpr = NULL;
-UcxList *examineelem = NULL;
+CxList *examineelem = NULL;
 int examineclause = 0;
 while(1) {
 int cmd = dav_debug_ql_command();
 switch (cmd) {
 case DQLD_CMD_PT: dav_debug_ql_tree_print(examineexpr, 1); break;
 case DQLD_CMD_PF: dav_debug_ql_fnames_print(stmt); break;
 case DQLD_CMD_F:
 examineclause = DQLD_CMD_F;
 examineelem = stmt->fields;
-if (stmt->fields) {
+if (stmt->fields && stmt->fields->size > 0) {
-DavQLField* field = ((DavQLField*)stmt->fields->data);
+DavQLField* field = cxListAt(stmt->fields, 0);
 examineexpr = field->expr;
 dav_debug_ql_field_print(field);
 } else {
 examineexpr = NULL;
 }
 dav_debug_ql_expr_print(examineexpr);
 break;
 case DQLD_CMD_O:
 examineclause = DQLD_CMD_O;
 examineelem = stmt->orderby;
-examineexpr = stmt->orderby ?
+examineexpr = stmt->orderby && stmt->orderby->size > 0 ?
-((DavQLOrderCriterion*)stmt->orderby->data)->column : NULL;
+((DavQLOrderCriterion*)cxListAt(stmt->orderby, 0))->column : NULL;
 dav_debug_ql_expr_print(examineexpr);
 break;
 case DQLD_CMD_N:
 case DQLD_CMD_P:
+printf("TODO: port code to ucx 3\n");
+/*
 if (examineelem) {
-UcxList *newelem = (cmd == DQLD_CMD_N ?
+CxList *newelem = (cmd == DQLD_CMD_N ?
 examineelem->next : examineelem->prev);
 if (newelem) {
 examineelem = newelem;
 if (examineclause == DQLD_CMD_O) {
 examineexpr = ((DavQLOrderCriterion*)
 printf("Reached end of list.\n");
 }
 } else {
 printf("Currently not examining an expression list.\n");
 }
+*/
 break;
 case DQLD_CMD_L:
 if (dav_debug_ql_expr_selected(examineexpr)) {
 if (examineexpr->left) {
 examineexpr = examineexpr->left;
 #define _error_invalid_logical_op "invalid logical operator "  _error_context
 #define _error_invalid_fmtspec "invalid format specifier " _error_context
 #define _error_invalid_string "string expected " _error_context
 #define _error_invalid_order_criterion "invalid order criterion " _error_context
-#define token_sstr(token) (((DavQLToken*)(token)->data)->value)
+#define token_sstr(token) ((token)->value)
 static void dav_error_in_context(int errorcode, const char *errormsg,
-DavQLStatement *stmt, UcxList *token) {
+DavQLStatement *stmt, DavQLToken *token) {
 // we try to achieve two things: get as many information as possible
 // and recover the concrete source string (and not the token strings)
-sstr_t emptystring = ST("");
+cxstring emptystring = CX_STR("");
-sstr_t prev = token->prev ? (token->prev->prev ?
+cxstring prev = token->prev ? (token->prev->prev ?
 token_sstr(token->prev->prev) : token_sstr(token->prev))
 : emptystring;
-sstr_t tokenstr = token_sstr(token);
+cxstring tokenstr = token_sstr(token);
-sstr_t next = token->next ? (token->next->next ?
+cxstring next = token->next ? (token->next->next ?
 token_sstr(token->next->next) : token_sstr(token->next))
 : emptystring;
 int lp = prev.length == 0 ? 0 : tokenstr.ptr-prev.ptr;
-char *pn = tokenstr.ptr + tokenstr.length;
+const char *pn = tokenstr.ptr + tokenstr.length;
 int ln = next.ptr+next.length - pn;
 stmt->errorcode = errorcode;
-stmt->errormessage = ucx_sprintf(errormsg,
+stmt->errormessage = cx_asprintf(errormsg,
 lp, prev.ptr,
 sfmtarg(tokenstr),
 ln, pn).ptr;
 }
 #define dqlsec_malloc(stmt, ptr, type) \
 dqlsec_alloc_failed(ptr = malloc(sizeof(type)), stmt)
 #define dqlsec_mallocz(stmt, ptr, type) \
 dqlsec_alloc_failed(ptr = calloc(1, sizeof(type)), stmt)
-#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) {
-sstr_t keywords[] ={ST("select"), ST("set"), ST("from"), ST("at"), ST("as"),
+cxstring keywords[] ={CX_STR("select"), CX_STR("set"), CX_STR("from"), CX_STR("at"), CX_STR("as"),
-ST("where"), ST("anywhere"), ST("like"), ST("unlike"), ST("and"),
+CX_STR("where"), CX_STR("anywhere"), CX_STR("like"), CX_STR("unlike"), CX_STR("and"),
-ST("or"), ST("not"), ST("xor"), ST("with"), ST("infinity"),
+CX_STR("or"), CX_STR("not"), CX_STR("xor"), CX_STR("with"), CX_STR("infinity"),
-ST("order"), ST("by"), ST("asc"), ST("desc")
+CX_STR("order"), CX_STR("by"), CX_STR("asc"), CX_STR("desc")
 };
-for (int i = 0 ; i < sizeof(keywords)/sizeof(sstr_t) ; i++) {
+for (int i = 0 ; i < sizeof(keywords)/sizeof(cxstring) ; i++) {
-if (!sstrcasecmp(token->value, keywords[i])) {
+if (!cx_strcasecmp(token->value, keywords[i])) {
 return 1;
 }
 }
 return 0;
 }
 static _Bool islongoperator(DavQLToken *token) {
-sstr_t operators[] = {ST("and"), ST("or"), ST("not"), ST("xor"),
+cxstring operators[] = {CX_STR("and"), CX_STR("or"), CX_STR("not"), CX_STR("xor"),
-ST("like"), ST("unlike")
+CX_STR("like"), CX_STR("unlike")
 };
-for (int i = 0 ; i < sizeof(operators)/sizeof(sstr_t) ; i++) {
+for (int i = 0 ; i < sizeof(operators)/sizeof(cxstring) ; i++) {
-if (!sstrcasecmp(token->value, operators[i])) {
+if (!cx_strcasecmp(token->value, operators[i])) {
 return 1;
 }
 }
 return 0;
 }
-static UcxList* dav_parse_add_token(UcxList *tokenlist, DavQLToken *token) {
+static int dav_stmt_add_field(DavQLStatement *stmt, DavQLField *field) {
+if(!stmt->fields) {
+stmt->fields = cxLinkedListCreateSimple(CX_STORE_POINTERS);
+if(!stmt->fields) {
+stmt->errorcode = DAVQL_ERROR_OUT_OF_MEMORY;
+return 1;
+}
+}
+if(cxListAdd(stmt->fields, field)) {
+stmt->errorcode = DAVQL_ERROR_OUT_OF_MEMORY;
+return 1;
+}
+return 0;
+}
+static void tokenlist_free(DavQLToken *tokenlist) {
+DavQLToken *token = tokenlist;
+while(token) {
+DavQLToken *next = token->next;
+free(token);
+token = next;
+}
+}
+static int dav_parse_add_token(DavQLToken **begin, DavQLToken **end, DavQLToken *token) {
 // determine token class (order of if-statements is very important!)
 char firstchar = token->value.ptr[0];
 if (isdigit(firstchar)) {
 } else {
 token->tokenclass = DAVQL_TOKEN_INVALID;
 }
 }
+cx_linked_list_add((void**)begin, (void**)end, offsetof(DavQLToken, prev), offsetof(DavQLToken, next), token);
-UcxList *ret = ucx_list_append(tokenlist, token);
+return 0;
-if (ret) {
+}
-return ret;
-} else {
-ucx_list_free(tokenlist);
-return NULL;
+static DavQLToken* dav_parse_tokenize(cxstring src) {
-}
+#define alloc_token() do {token = calloc(1, sizeof(DavQLToken));\
-}
+if(!token) {tokenlist_free(tokens_begin); return NULL;}} while(0)
+#define add_token() if(dav_parse_add_token(&tokens_begin, &tokens_end, token)) return NULL;
-static UcxList* dav_parse_tokenize(sstr_t src) {
-#define alloc_token() do {token = malloc(sizeof(DavQLToken));\
+DavQLToken *tokens_begin = NULL;
-if(!token) {ucx_list_free(tokens); return NULL;}} while(0)
+DavQLToken *tokens_end = NULL;
-#define add_token() do {tokens = dav_parse_add_token(tokens, token); \
-if(!tokens) {return NULL;}} while(0)
-UcxList *tokens = NULL;
 DavQLToken *token = NULL;
 char insequence = '\0';
 for (size_t i = 0 ; i < src.length ; i++) {
 // quoted strings / identifiers are a single token
 if (src.ptr[i] == '\'' || src.ptr[i] == '`') {
 if (src.ptr[i] == insequence) {
 add_token();
 }
 alloc_token();
 token->tokenclass = DAVQL_TOKEN_END;
-token->value = S("");
+token->value = CX_STR("");
-UcxList *ret = ucx_list_append(tokens, token);
-if (ret) {
+cx_linked_list_add((void**)&tokens_begin, (void**)&tokens_end, offsetof(DavQLToken, prev), offsetof(DavQLToken, next), token);
-return ret;
+return tokens_begin;
-} else {
-ucx_list_free(tokens);
-return NULL;
-}
 #undef alloc_token
 #undef add_token
 }
 static void dav_free_expression(DavQLExpression *expr) {
 static void dav_free_order_criterion(DavQLOrderCriterion *crit) {
 if (crit->column) { // do it null-safe though column is expected to be set
 dav_free_expression(crit->column);
 }
-free(crit);
 }
 #define token_is(token, expectedclass) (token && \
-(((DavQLToken*)(token)->data)->tokenclass == expectedclass))
+(token->tokenclass == expectedclass))
 #define tokenvalue_is(token, expectedvalue) (token && \
-!sstrcasecmp(((DavQLToken*)(token)->data)->value, S(expectedvalue)))
+!cx_strcasecmp(token->value, cx_str(expectedvalue)))
-typedef int(*exprparser_f)(DavQLStatement*,UcxList*,DavQLExpression*);
+typedef int(*exprparser_f)(DavQLStatement*,DavQLToken*,DavQLExpression*);
-static int dav_parse_binary_expr(DavQLStatement* stmt, UcxList* token,
+static int dav_parse_binary_expr(DavQLStatement* stmt, DavQLToken* token,
 DavQLExpression* expr, exprparser_f parseL, char* opc, int* opv,
 exprparser_f parseR) {
 if (!token) {
 return 0;
 consumed = parseL(stmt, token, &left);
 if (!consumed || stmt->errorcode) {
 return 0;
 }
 total_consumed += consumed;
-token = ucx_list_get(token, consumed);
+token = cx_linked_list_at(token, 0, offsetof(DavQLToken, next), consumed);
 char *op;
 if (token_is(token, DAVQL_TOKEN_OPERATOR) &&
 (op = strchr(opc, token_sstr(token).ptr[0]))) {
 expr->op = opv[op-opc];
 }
 return total_consumed;
 }
-static void dav_add_fmt_args(DavQLStatement *stmt, sstr_t str) {
+static void fmt_args_add(DavQLStatement *stmt, void *data) {
+if(!stmt->args) {
+stmt->args = cxLinkedListCreateSimple(CX_STORE_POINTERS);
+}
+cxListAdd(stmt->args, data);
+}
+static void dav_add_fmt_args(DavQLStatement *stmt, cxstring str) {
 int placeholder = 0;
 for (size_t i=0;i<str.length;i++) {
 char c = str.ptr[i];
 if (placeholder) {
 if (c != '%') {
-stmt->args = ucx_list_append(
+fmt_args_add(stmt, (void*)(intptr_t)c);
-stmt->args,
-(void*)(intptr_t)c);
 }
 placeholder = 0;
 } else if (c == '%') {
 placeholder = 1;
 }
 }
 }
-static int dav_parse_literal(DavQLStatement* stmt, UcxList* token,
+static int dav_parse_literal(DavQLStatement* stmt, DavQLToken* token,
 DavQLExpression* expr) {
 expr->srctext = token_sstr(token);
 if (token_is(token, DAVQL_TOKEN_NUMBER)) {
 expr->type = DAVQL_NUMBER;
 dav_error_in_context(DAVQL_ERROR_INVALID_FMTSPEC,
 _error_invalid_fmtspec, stmt, token);
 return 0;
 }
 // add fmtspec type to query arg list
-stmt->args = ucx_list_append(stmt->args, (void*)(intptr_t)expr->srctext.ptr[1]);
+fmt_args_add(stmt, (void*)(intptr_t)expr->srctext.ptr[1]);
 } else {
 return 0;
 }
 return 1;
 }
 // forward declaration
-static int dav_parse_expression(DavQLStatement* stmt, UcxList* token,
+static int dav_parse_expression(DavQLStatement* stmt, DavQLToken* token,
 DavQLExpression* expr);
-static int dav_parse_arglist(DavQLStatement* stmt, UcxList* token,
+static int dav_parse_arglist(DavQLStatement* stmt, DavQLToken* token,
 DavQLExpression* expr) {
 expr->srctext.ptr = token_sstr(token).ptr;
 expr->srctext.length = 0;
 expr->left = expr->right = NULL; // in case we fail, we want them to be sane
 int total_consumed = 0;
 // RULE:    Expression, {",", Expression};
 DavQLExpression *arglist = expr;
 DavQLExpression arg;
-char *lastchar = expr->srctext.ptr;
+const char *lastchar = expr->srctext.ptr;
 int consumed;
 do {
 memset(&arg, 0, sizeof(DavQLExpression));
 consumed = dav_parse_expression(stmt, token, &arg);
 if (consumed) {
 lastchar = arg.srctext.ptr + arg.srctext.length;
 total_consumed += consumed;
-token = ucx_list_get(token, consumed);
+token = cx_linked_list_at(token, 0, offsetof(DavQLToken, next), consumed);
 // look ahead for a comma
 if (token_is(token, DAVQL_TOKEN_COMMA)) {
 total_consumed++;
 token = token->next;
 /* we have more arguments, so put the current argument to the
 }
 return total_consumed;
 }
-static int dav_parse_funccall(DavQLStatement* stmt, UcxList* token,
+static int dav_parse_funccall(DavQLStatement* stmt, DavQLToken* token,
 DavQLExpression* expr) {
 // RULE:    Identifier, "(", ArgumentList, ")";
 if (token_is(token, DAVQL_TOKEN_IDENTIFIER) &&
 token_is(token->next, DAVQL_TOKEN_OPENP)) {
 if (stmt->errorcode) {
 // if an error occurred while parsing the arglist, return now
 return 2;
 }
 if (argtokens) {
-token = ucx_list_get(token, argtokens);
+token = cx_linked_list_at(token, 0, offsetof(DavQLToken, next), argtokens);
 dqlsec_malloc(stmt, expr->right, DavQLExpression);
 memcpy(expr->right, &arg, sizeof(DavQLExpression));
 } else {
 // arg list may be empty
 expr->right = NULL;
 } else {
 return 0;
 }
 }
-static int dav_parse_unary_expr(DavQLStatement* stmt, UcxList* token,
+static int dav_parse_unary_expr(DavQLStatement* stmt, DavQLToken* token,
 DavQLExpression* expr) {
-UcxList *firsttoken = token; // save for srctext recovery
+DavQLToken *firsttoken = token; // save for srctext recovery
 DavQLExpression* atom = expr;
 int total_consumed = 0;
 // optional unary operator
 if (!consumed) {
 dav_error_in_context(DAVQL_ERROR_INVALID_EXPR,
 _error_invalid_expr, stmt, token);
 return 0;
 }
-token = ucx_list_get(token, consumed);
+token = cx_linked_list_at(token, 0, offsetof(DavQLToken, next), consumed);
 total_consumed += consumed;
 if (token_is(token, DAVQL_TOKEN_CLOSEP)) {
 token = token->next; total_consumed++;
 } else {
 dav_error_in_context(DAVQL_ERROR_MISSING_PAR,
 }
 // recover source text
 expr->srctext.ptr = token_sstr(firsttoken).ptr;
 if (total_consumed > 0) {
-sstr_t lasttoken =
+cxstring lasttoken =
-token_sstr(ucx_list_get(firsttoken, total_consumed-1));
+token_sstr((DavQLToken*)cx_linked_list_at(token, 0, offsetof(DavQLToken, next), total_consumed-1));
 expr->srctext.length =
 lasttoken.ptr - expr->srctext.ptr + lasttoken.length;
 } else {
 // the expression should not be used anyway, but we want to be safe
 expr->srctext.length = 0;
 return total_consumed;
 }
-static int dav_parse_bitexpr(DavQLStatement* stmt, UcxList* token,
+static int dav_parse_bitexpr(DavQLStatement* stmt, DavQLToken* token,
 DavQLExpression* expr) {
 return dav_parse_binary_expr(stmt, token, expr,
 dav_parse_unary_expr,
 "&|^", (int[]){DAVQL_AND, DAVQL_OR, DAVQL_XOR},
 dav_parse_bitexpr);
 }
-static int dav_parse_multexpr(DavQLStatement* stmt, UcxList* token,
+static int dav_parse_multexpr(DavQLStatement* stmt, DavQLToken* token,
 DavQLExpression* expr) {
 return dav_parse_binary_expr(stmt, token, expr,
 dav_parse_bitexpr,
 "*/", (int[]){DAVQL_MUL, DAVQL_DIV},
 dav_parse_multexpr);
 }
-static int dav_parse_expression(DavQLStatement* stmt, UcxList* token,
+static int dav_parse_expression(DavQLStatement* stmt, DavQLToken* token,
 DavQLExpression* expr) {
 return dav_parse_binary_expr(stmt, token, expr,
 dav_parse_multexpr,
 "+-", (int[]){DAVQL_ADD, DAVQL_SUB},
 dav_parse_expression);
 }
-static int dav_parse_named_field(DavQLStatement *stmt, UcxList *token,
+static int dav_parse_named_field(DavQLStatement *stmt, DavQLToken *token,
 DavQLField *field) {
 int total_consumed = 0, consumed;
 // RULE:    Expression, " as ", Identifier;
 DavQLExpression *expr;
 dav_error_in_context(DAVQL_ERROR_INVALID_EXPR,
 _error_invalid_expr, stmt, token);
 return 0;
 }
-token = ucx_list_get(token, consumed);
+token = cx_linked_list_at(token, 0, offsetof(DavQLToken, next), consumed);
 total_consumed += consumed;
 if (token_is(token, DAVQL_TOKEN_KEYWORD) && tokenvalue_is(token, "as")) {
 token = token->next; total_consumed++;
 } else {
 _error_missing_identifier, stmt, token);
 return 0;
 }
 }
-static int dav_parse_fieldlist(DavQLStatement *stmt, UcxList *token) {
+static int dav_parse_fieldlist(DavQLStatement *stmt, DavQLToken *token) {
 // 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);
+if(dav_stmt_add_field(stmt, field)) {
+free(field);
+return 0;
+}
 dqlsec_mallocz(stmt, field->expr, DavQLExpression);
 field->expr->type = DAVQL_IDENTIFIER;
 field->expr->srctext = field->name = token_sstr(token);
 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);
+if(dav_stmt_add_field(stmt, field)) {
+free(field);
+return 0;
+}
 dqlsec_mallocz(stmt, field->expr, DavQLExpression);
 field->expr->type = DAVQL_IDENTIFIER;
 field->expr->srctext = field->name = token_sstr(token);
 int total_consumed = 0;
 int consumed = 1;
 do {
-token = ucx_list_get(token, consumed);
+token = cx_linked_list_at(token, 0, offsetof(DavQLToken, next), consumed);
 total_consumed += consumed;
 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;
 dqlsec_malloc(stmt, field, DavQLField);
 memcpy(field, &localfield, sizeof(DavQLField));
-dqlsec_list_append_or_free(stmt, stmt->fields, field);
+if(dav_stmt_add_field(stmt, field)) {
+free(field);
+return 0;
+}
 }
 } 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_or_free(stmt, stmt->fields, field);
+if(dav_stmt_add_field(stmt, field)) {
-token = ucx_list_get(token, consumed);
+free(field);
+return 0;
+}
+token = cx_linked_list_at(token, 0, offsetof(DavQLToken, next), 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;
 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_or_free(stmt, stmt->fields, field);
+if(dav_stmt_add_field(stmt, field)) {
+free(field);
+return 0;
+}
 consumed = 1;
 total_consumed++;
 token = token->next;
 return total_consumed;
 }
 }
 // forward declaration
-static int dav_parse_logical_expr(DavQLStatement *stmt, UcxList *token,
+static int dav_parse_logical_expr(DavQLStatement *stmt, DavQLToken *token,
 DavQLExpression *expr);
-static int dav_parse_bool_prim(DavQLStatement *stmt, UcxList *token,
+static int dav_parse_bool_prim(DavQLStatement *stmt, DavQLToken *token,
 DavQLExpression *expr) {
 expr->type = DAVQL_LOGICAL;
 expr->srctext = token_sstr(token);
 memset(&bexpr, 0, sizeof(DavQLExpression));
 total_consumed = dav_parse_expression(stmt, token, &bexpr);
 if (!total_consumed || stmt->errorcode) {
 return 0;
 }
-token = ucx_list_get(token, total_consumed);
+token = cx_linked_list_at(token, 0, offsetof(DavQLToken, next), total_consumed);
-UcxList* optok = token;
+DavQLToken* optok = token;
 // RULE:    Expression, (" like " | " unlike "), String
 if (token_is(optok, DAVQL_TOKEN_OPERATOR) && (tokenvalue_is(optok,
 "like") || tokenvalue_is(optok, "unlike"))) {
 total_consumed++;
 } else {
 return 0;
 }
 }
-static int dav_parse_bool_expr(DavQLStatement *stmt, UcxList *token,
+static int dav_parse_bool_expr(DavQLStatement *stmt, DavQLToken *token,
 DavQLExpression *expr) {
 // RULE:    "not ", LogicalExpression
 if (token_is(token, DAVQL_TOKEN_OPERATOR) && tokenvalue_is(token, "not")) {
 expr->type = DAVQL_LOGICAL;
 int consumed = dav_parse_bool_expr(stmt, token, expr->left);
 if (stmt->errorcode) {
 return 0;
 }
 if (consumed) {
-sstr_t lasttok = token_sstr(ucx_list_get(token, consumed-1));
+cxstring lasttok = token_sstr((DavQLToken*)cx_linked_list_at(token, 0, offsetof(DavQLToken, next), consumed-1));
 expr->srctext.length =
 lasttok.ptr - expr->srctext.ptr + lasttok.length;
 return consumed + 1;
 } else {
 dav_error_in_context(DAVQL_ERROR_MISSING_EXPR,
 }
 // RULE:    "(", LogicalExpression, ")"
 else if (token_is(token, DAVQL_TOKEN_OPENP)) {
 int consumed = dav_parse_logical_expr(stmt, token->next, expr);
 if (consumed) {
-token = ucx_list_get(token->next, consumed);
+token = cx_linked_list_at(token, 0, offsetof(DavQLToken, next), consumed);
 if (token_is(token, DAVQL_TOKEN_CLOSEP)) {
 token = token->next;
 return consumed + 2;
 } else {
 // RULE:    BooleanPrimary
 return dav_parse_bool_prim(stmt, token, expr);
 }
-static int dav_parse_logical_expr(DavQLStatement *stmt, UcxList *token,
+static int dav_parse_logical_expr(DavQLStatement *stmt, DavQLToken *token,
 DavQLExpression *expr) {
-UcxList *firsttoken = token;
+DavQLToken *firsttoken = token;
 int total_consumed = 0;
 // RULE:    BooleanLiteral, [LogicalOperator, LogicalExpression];
 DavQLExpression left, right;
 memset(&left, 0, sizeof(DavQLExpression));
 dav_error_in_context(DAVQL_ERROR_MISSING_EXPR,
 _error_missing_expr, stmt, token);
 return 0;
 }
 total_consumed += consumed;
-token = ucx_list_get(token, consumed);
+token = cx_linked_list_at(token, 0, offsetof(DavQLToken, next), consumed);
 if (token_is(token, DAVQL_TOKEN_OPERATOR)) {
 expr->type = DAVQL_LOGICAL;
 davqloperator_t op = DAVQL_NOOP;
 dav_error_in_context(DAVQL_ERROR_MISSING_EXPR,
 _error_missing_expr, stmt, token);
 return 0;
 }
 total_consumed += consumed;
-token = ucx_list_get(token, consumed);
+token = cx_linked_list_at(token, 0, offsetof(DavQLToken, next), consumed);
 dqlsec_malloc(stmt, expr->left, DavQLExpression);
 memcpy(expr->left, &left, sizeof(DavQLExpression));
 dqlsec_malloc(stmt, expr->right, DavQLExpression);
 memcpy(expr->right, &right, sizeof(DavQLExpression));
 }
 // set type and recover source text
 if (total_consumed > 0) {
 expr->srctext.ptr = token_sstr(firsttoken).ptr;
-sstr_t lasttok = token_sstr(ucx_list_get(firsttoken, total_consumed-1));
+cxstring lasttok = token_sstr((DavQLToken*)cx_linked_list_at(firsttoken, 0, offsetof(DavQLToken, next), total_consumed-1));
 expr->srctext.length = lasttok.ptr-expr->srctext.ptr+lasttok.length;
 }
 return total_consumed;
 }
-static int dav_parse_where_clause(DavQLStatement *stmt, UcxList *token) {
+static int dav_parse_where_clause(DavQLStatement *stmt, DavQLToken *token) {
 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) {
+static int dav_parse_with_clause(DavQLStatement *stmt, DavQLToken *token) {
 int total_consumed = 0;
 // RULE:    "depth", "=", (Number | "infinity")
 if (tokenvalue_is(token, "depth")) {
 if (consumed) {
 if (depthexpr->type == DAVQL_NUMBER) {
 if (depthexpr->srctext.ptr[0] == '%') {
 stmt->depth = DAV_DEPTH_PLACEHOLDER;
 } else {
-sstr_t depthstr = depthexpr->srctext;
+cxstring depthstr = depthexpr->srctext;
 char *conv = malloc(depthstr.length+1);
 if (!conv) {
 dav_free_expression(depthexpr);
 stmt->errorcode = DAVQL_ERROR_OUT_OF_MEMORY;
 return 0;
 }
 return total_consumed;
 }
-static int dav_parse_order_crit(DavQLStatement *stmt, UcxList *token,
+static int dav_parse_order_crit(DavQLStatement *stmt, DavQLToken *token,
 DavQLOrderCriterion *crit) {
 // RULE:    (Identifier | Number), [" asc"|" desc"];
 DavQLExpression expr;
 memset(&expr, 0, sizeof(DavQLExpression));
 }
 dqlsec_malloc(stmt, crit->column, DavQLExpression);
 memcpy(crit->column, &expr, sizeof(DavQLExpression));
-token = ucx_list_get(token, consumed);
+token = cx_linked_list_at(token, 0, offsetof(DavQLToken, next), consumed);
 if (token_is(token, DAVQL_TOKEN_KEYWORD) && (
 tokenvalue_is(token, "asc") || tokenvalue_is(token, "desc"))) {
 crit->descending = tokenvalue_is(token, "desc");
 crit->descending = 0;
 return consumed;
 }
 }
-static int dav_parse_orderby_clause(DavQLStatement *stmt, UcxList *token) {
+static int dav_parse_orderby_clause(DavQLStatement *stmt, DavQLToken *token) {
 int total_consumed = 0, consumed;
 DavQLOrderCriterion crit;
+if(!stmt->orderby) {
+stmt->orderby = cxLinkedListCreateSimple(sizeof(DavQLOrderCriterion));
+if(!stmt->orderby) {
+return 0;
+}
+}
 // RULE:    OrderByCriterion, {",", OrderByCriterion};
 do {
 consumed = dav_parse_order_crit(stmt, token, &crit);
 if (stmt->errorcode) {
 if (!consumed) {
 dav_error_in_context(DAVQL_ERROR_MISSING_EXPR, _error_missing_expr,
 stmt, token);
 return 0;
 }
-token = ucx_list_get(token, consumed);
+token = cx_linked_list_at(token, 0, offsetof(DavQLToken, next), consumed);
 total_consumed += consumed;
-DavQLOrderCriterion *criterion;
+if(cxListAdd(stmt->orderby, &crit)) {
-dqlsec_malloc(stmt, criterion, DavQLOrderCriterion);
+stmt->errorcode = DAVQL_ERROR_OUT_OF_MEMORY;
-memcpy(criterion, &crit, sizeof(DavQLOrderCriterion));
+return 0;
-dqlsec_list_append_or_free(stmt, stmt->orderby, criterion);
+}
 if (token_is(token, DAVQL_TOKEN_COMMA)) {
 total_consumed++;
 token = token->next;
 } else {
 return total_consumed;
 }
-static int dav_parse_assignments(DavQLStatement *stmt, UcxList *token) {
+static int dav_parse_assignments(DavQLStatement *stmt, DavQLToken *token) {
 // RULE:    Assignment, {",", Assignment}
 int total_consumed = 0, consumed;
 do {
 // RULE:    Identifier, "=", Expression
 consumed = dav_parse_expression(stmt, token, field->expr);
 if (stmt->errorcode) {
 dav_free_field(field);
 return total_consumed;
 }
-token = ucx_list_get(token, consumed);
+token = cx_linked_list_at(token, 0, offsetof(DavQLToken, next), consumed);
 total_consumed += consumed;
 // Add assignment to list and check if there's another one
-dqlsec_list_append_or_free(stmt, stmt->fields, field);
+if(dav_stmt_add_field(stmt, field)) {
+free(field);
+return 0;
+}
 consumed = token_is(token, DAVQL_TOKEN_COMMA) ? 1 : 0;
 if (consumed) {
 token = token->next;
 total_consumed++;
 }
 } while (consumed);
 return total_consumed;
 }
-static int dav_parse_path(DavQLStatement *stmt, UcxList *tokens) {
+static int dav_parse_path(DavQLStatement *stmt, DavQLToken *tokens) {
 if (token_is(tokens, DAVQL_TOKEN_STRING)) {
 stmt->path = token_sstr(tokens);
 tokens = tokens->next;
 return 1;
 } else if (token_is(tokens, DAVQL_TOKEN_OPERATOR)
 stmt->path = token_sstr(tokens);
 tokens = tokens->next;
 int consumed = 1;
 while (!token_is(tokens, DAVQL_TOKEN_KEYWORD) &&
 !token_is(tokens, DAVQL_TOKEN_END)) {
-sstr_t toksstr = token_sstr(tokens);
+cxstring toksstr = token_sstr(tokens);
 stmt->path.length = toksstr.ptr-stmt->path.ptr+toksstr.length;
 tokens = tokens->next;
 consumed++;
 }
 return consumed;
 } else if (token_is(tokens, DAVQL_TOKEN_FMTSPEC) &&
 tokenvalue_is(tokens, "%s")) {
 stmt->path = token_sstr(tokens);
 tokens = tokens->next;
-stmt->args = ucx_list_append(stmt->args, (void*)(intptr_t)'s');
+fmt_args_add(stmt, (void*)(intptr_t)'s');
 return 1;
 } else {
 dav_error_in_context(DAVQL_ERROR_MISSING_TOKEN,
 _error_missing_path, stmt, tokens);
 return 0;
 /**
 * Parser of a select statement.
 * @param stmt the statement object that shall contain the syntax tree
 * @param tokens the token list
 */
-static void dav_parse_select_statement(DavQLStatement *stmt, UcxList *tokens) {
+static void dav_parse_select_statement(DavQLStatement *stmt, DavQLToken *tokens) {
 stmt->type = DAVQL_SELECT;
 // Consume field list
-tokens = ucx_list_get(tokens, dav_parse_fieldlist(stmt, tokens));
+tokens = cx_linked_list_at(tokens, 0, offsetof(DavQLToken, next), dav_parse_fieldlist(stmt, tokens));
 if (stmt->errorcode) {
 return;
 }
 // Consume FROM keyword
 _error_missing_from, stmt, tokens);
 return;
 }
 // Consume path
-tokens = ucx_list_get(tokens, dav_parse_path(stmt, tokens));
+tokens = cx_linked_list_at(tokens, 0, offsetof(DavQLToken, next), dav_parse_path(stmt, tokens));
 if (stmt->errorcode) {
 return;
 }
 //dav_add_fmt_args(stmt, stmt->path); // add possible path args
 // Consume with clause (if any)
 if (token_is(tokens, DAVQL_TOKEN_KEYWORD)
 && tokenvalue_is(tokens, "with")) {
 tokens = tokens->next;
-tokens = ucx_list_get(tokens,
+tokens = cx_linked_list_at(tokens, 0, offsetof(DavQLToken, next),
 dav_parse_with_clause(stmt, tokens));
 }
 if (stmt->errorcode) {
 return;
 }
 // Consume where clause (if any)
 if (token_is(tokens, DAVQL_TOKEN_KEYWORD)
 && tokenvalue_is(tokens, "where")) {
 tokens = tokens->next;
-tokens = ucx_list_get(tokens,
+tokens = cx_linked_list_at(tokens, 0, offsetof(DavQLToken, next),
 dav_parse_where_clause(stmt, tokens));
 } else if (token_is(tokens, DAVQL_TOKEN_KEYWORD)
 && tokenvalue_is(tokens, "anywhere")) {
 // useless, but the user may want to explicitly express his intent
 tokens = tokens->next;
 && tokenvalue_is(tokens, "order")) {
 tokens = tokens->next;
 if (token_is(tokens, DAVQL_TOKEN_KEYWORD)
 && tokenvalue_is(tokens, "by")) {
 tokens = tokens->next;
-tokens = ucx_list_get(tokens,
+tokens = cx_linked_list_at(tokens, 0, offsetof(DavQLToken, next),
 dav_parse_orderby_clause(stmt, tokens));
 } else {
 dav_error_in_context(DAVQL_ERROR_MISSING_TOKEN,
 _error_missing_by, stmt, tokens);
 return;
 _error_unexpected_token, stmt, tokens);
 }
 }
 }
-static void dav_parse_set_statement(DavQLStatement *stmt, UcxList *tokens) {
+static void dav_parse_set_statement(DavQLStatement *stmt, DavQLToken *tokens) {
 stmt->type = DAVQL_SET;
 // Consume assignments
-tokens = ucx_list_get(tokens, dav_parse_assignments(stmt, tokens));
+tokens = cx_linked_list_at(tokens, 0, offsetof(DavQLToken, next), dav_parse_assignments(stmt, tokens));
 if (stmt->errorcode) {
 return;
 }
 // Consume AT keyword
 _error_missing_at, stmt, tokens);
 return;
 }
 // Consume path
-tokens = ucx_list_get(tokens, dav_parse_path(stmt, tokens));
+tokens = cx_linked_list_at(tokens, 0, offsetof(DavQLToken, next), dav_parse_path(stmt, tokens));
 if (stmt->errorcode) {
 return;
 }
 // Consume with clause (if any)
 if (token_is(tokens, DAVQL_TOKEN_KEYWORD)
 && tokenvalue_is(tokens, "with")) {
 tokens = tokens->next;
-tokens = ucx_list_get(tokens,
+tokens = cx_linked_list_at(tokens, 0, offsetof(DavQLToken, next),
 dav_parse_with_clause(stmt, tokens));
 }
 if (stmt->errorcode) {
 return;
 }
 // Consume mandatory where clause (or anywhere keyword)
 if (token_is(tokens, DAVQL_TOKEN_KEYWORD)
 && tokenvalue_is(tokens, "where")) {
 tokens = tokens->next;
-tokens = ucx_list_get(tokens,
+tokens = cx_linked_list_at(tokens, 0, offsetof(DavQLToken, next),
 dav_parse_where_clause(stmt, tokens));
 } else if (token_is(tokens, DAVQL_TOKEN_KEYWORD)
 && tokenvalue_is(tokens, "anywhere")) {
 // no-op, but we want the user to be explicit about this
 tokens = tokens->next;
 _error_missing_where, stmt, tokens);
 return;
 }
 }
-DavQLStatement* dav_parse_statement(sstr_t srctext) {
+DavQLStatement* dav_parse_statement(cxstring srctext) {
 DavQLStatement *stmt = calloc(1, sizeof(DavQLStatement));
 // if we can't even get enough memory for the statement object or an error
 // message, we can simply die without returning anything
 if (!stmt) {
 // default values
 stmt->type = -1;
 stmt->depth = 1;
 // save trimmed source text
-stmt->srctext = sstrtrim(srctext);
+stmt->srctext = cx_strtrim(srctext);
 if (stmt->srctext.length) {
 // tokenization
-UcxList* tokens = dav_parse_tokenize(stmt->srctext);
+DavQLToken* tokens = dav_parse_tokenize(stmt->srctext);
 if (tokens) {
 // use first token to determine query type
 if (tokenvalue_is(tokens, "select")) {
 stmt->errorcode = DAVQL_ERROR_INVALID;
 stmt->errormessage = strdup(_error_invalid);
 }
 // free token data
-UCX_FOREACH(token, tokens) {
+tokenlist_free(tokens);
-free(token->data);
-}
-ucx_list_free(tokens);
 } else {
 stmt->errorcode = DAVQL_ERROR_OUT_OF_MEMORY;
 }
 } else {
 stmt->type = DAVQL_ERROR;
 return stmt;
 }
 void dav_free_statement(DavQLStatement *stmt) {
-UCX_FOREACH(expr, stmt->fields) {
+if(stmt->fields) {
-dav_free_field(expr->data);
+stmt->fields->simple_destructor = (cx_destructor_func)dav_free_field;
-}
+cxListDestroy(stmt->fields);
-ucx_list_free(stmt->fields);
+}
 if (stmt->where) {
 dav_free_expression(stmt->where);
 }
 if (stmt->errormessage) {
 free(stmt->errormessage);
 }
-UCX_FOREACH(crit, stmt->orderby) {
-dav_free_order_criterion(crit->data);
+if(stmt->orderby) {
-}
+stmt->orderby->simple_destructor = (cx_destructor_func)dav_free_order_criterion;
-ucx_list_free(stmt->orderby);
+cxListDestroy(stmt->orderby);
-ucx_list_free(stmt->args);
+}
+if(stmt->args) {
+cxListDestroy(stmt->args);
+}
 free(stmt);
 }

Mercurial > hg > dav / file comparison

comparison: libidav/davqlparser.c

libidav/davqlparser.c