dav: comparison libidav/davqlparser.c

-:0567444f2d76
+:7d20ce5d235b
 }
 static const char* _map_operator(davqloperator_t op) {
 // don't use string array, because enum values may change
 switch(op) {
-case ADD: return "+"; case SUB: return "-"; case MUL: return "*";
+case DAVQL_NOOP: return "no operator";
-case DIV: return "/"; case AND: return "&"; case OR: return "|";
+case DAVQL_ADD: return "+"; case DAVQL_SUB: return "-";
-case XOR: return "^"; case NEG: return "~"; case NOT: return "NOT";
+case DAVQL_MUL: return "*"; case DAVQL_DIV: return "/";
-case LAND: return "AND"; case LOR: return "OR"; case LXOR: return "XOR";
+case DAVQL_AND: return "&"; case DAVQL_OR: return "|";
-case EQ: return "="; case NEQ: return "!="; case LT: return "<";
+case DAVQL_XOR: return "^"; case DAVQL_NEG: return "~";
-case GT: return ">"; case LE: return "<="; case GE: return ">=";
+case DAVQL_NOT: return "NOT"; case DAVQL_LAND: return "AND";
-case LIKE: return "LIKE"; case UNLIKE: return "UNLIKE";
+case DAVQL_LOR: return "OR"; case DAVQL_LXOR: return "XOR";
+case DAVQL_EQ: return "="; case DAVQL_NEQ: return "!=";
+case DAVQL_LT: return "<"; case DAVQL_GT: return ">";
+case DAVQL_LE: return "<="; case DAVQL_GE: return ">=";
+case DAVQL_LIKE: return "LIKE"; case DAVQL_UNLIKE: return "UNLIKE";
 default: return "unknown";
 }
 }
 static void dav_debug_ql_stmt_print(DavQLStatement *stmt) {
 // Has wildcard
 _Bool wildcard = 0;
 UCX_FOREACH(elm, stmt->fields) {
 DavQLExpression* expr = (DavQLExpression*)elm->data;
 if (expr->type == DAVQL_IDENTIFIER &&
-expr->srctext.length == 1 && *(expr->srctext.ptr) == '*') {
+expr->srctext.length == 1 && expr->srctext.ptr[0] == '*') {
 wildcard = 1;
 }
 }
 printf(" %s wildcard\nPath: %.*s\nHas where clause: %s\n",
 wildcard?"with":"without",
 if (token) {
 tokens = ucx_list_append(tokens, token);
 }
+// now find quotes and backsticks and merge enclosed tokens
+// TODO: make it so or disable tokenization in such cases in above code
 return tokens;
 }
-static DavQLExpression* dav_parse_expression(sstr_t src) {
+#define token_sstr(listelem) ((sstr_t*)(listelem)->data)
+static DavQLExpression* dav_parse_expression(UcxList* starttoken, size_t n) {
+if (n == 0) {
+return NULL;
+}
 DavQLExpression *expr = calloc(1, sizeof(DavQLExpression));
-expr->srctext = src;
+// set pointer for source text
+expr->srctext.ptr = token_sstr(starttoken)->ptr;
+// special case - only one token
+if (n == 1) {
+expr->srctext.length = token_sstr(starttoken)->length;
+char firstchar = expr->srctext.ptr[0];
+if (firstchar == '\'' || isdigit(firstchar)) {
+expr->type = DAVQL_LITERAL;
+} else {
+expr->type = DAVQL_IDENTIFIER;
+}
+} else {
+UcxList* token = starttoken;
+// check, if first token is (
+// if so, verify that last token is ) and throw both away
+if (!sstrcmp(*token_sstr(token), S("("))) {
+if (!sstrcmp(*token_sstr(ucx_list_get(token, n-1)), S(")"))) {
+token = token->next;
+n -= 2;
+} else {
+// TODO: throw syntax error
+}
+}
+// process tokens
+for (size_t i = 0 ; i < n ; i++) {
+// TODO: make it so
+// go to next token (if this is not the last token)
+if (i < n-1) {
+token = token->next;
+}
+}
+// compute length of source text (including delimiters)
+expr->srctext.length = token_sstr(token)->ptr +
+token_sstr(token)->length - expr->srctext.ptr;
+}
 return expr;
 }
 static void dav_parse_get_statement(DavQLStatement *stmt, UcxList *tokens) {
 *  500: ready to quit
 *
 */
 int step = 10;
+// Variables for token sublists for expressions
+UcxList *exprstart = NULL;
+size_t exprlen = 0;
+// Process tokens
 UCX_FOREACH(token, tokens) {
-sstr_t tokendata = *(sstr_t*)token->data;
+sstr_t tokendata = *token_sstr(token);
 switch (step) {
 // optional clauses
 case 520:
 if (!sstrcasecmp(tokendata, S("where"))) {
 if (!sstrcasecmp(tokendata, S("with"))) {
 step = 40;
 }
 break;
 // field list
-case 10:
+case 10: {
-if (!sstrcasecmp(tokendata, S("from"))) {
+_Bool fromkeyword = !sstrcasecmp(tokendata, S("from"));
-step = 20;
+if (fromkeyword || !sstrcmp(tokendata, S(","))) {
+if (exprstart) {
+stmt->fields = ucx_list_append(stmt->fields,
+dav_parse_expression(exprstart, exprlen));
+exprstart = NULL;
+exprlen = 0;
+} else {
+// TODO: throw syntax error
+}
+if (fromkeyword) {
+step = 20;
+}
 } else {
-stmt->fields = ucx_list_append(stmt->fields,
+// collect tokens for field expression
-dav_parse_expression(tokendata));
+if (exprstart) {
-}
+exprlen++;
-break;
+} else {
+exprstart = token;
+exprlen = 1;
+}
+}
+break;
+}
 // from clause
 case 20:
-stmt->path = dav_parse_expression(tokendata);
+stmt->path = dav_parse_expression(token, 1);
 step = 520;
 break;
 // where clause
 case 30:
 step = 530;
 // with clause
 case 40:
 step = 500;
 break;
 }
-free(token->data);
 }
 if (step < 500) {
 stmt->type = DAVQL_ERROR;
 // TODO: save parse error message
 static void dav_parse_set_statement(DavQLStatement *stmt, UcxList *tokens) {
 stmt->type = DAVQL_SET;
 UCX_FOREACH(token, tokens) {
-sstr_t tokendata = *(sstr_t*)token->data;
+sstr_t tokendata = *token_sstr(token);
-// just free the tokens, until the function is implemented
-free(token->data);
 }
 }
 DavQLStatement* dav_parse_statement(sstr_t srctext) {
 DavQLStatement *stmt = calloc(1, sizeof(DavQLStatement));
 stmt->srctext = sstrtrim(srctext);
 // tokenization
 UcxList* tokens = dav_parse_tokenize(stmt->srctext);
-// use first token to determine query type
 if (tokens) {
-sstr_t token = *(sstr_t*)tokens->data;
+// use first token to determine query type
+sstr_t token = *token_sstr(tokens);
 free(tokens->data);
 tokens = ucx_list_remove(tokens, tokens);
 if (!sstrcasecmp(token, S("get"))) {
 dav_parse_get_statement(stmt, tokens);
 } else if (!sstrcasecmp(token, S("set"))) {
 dav_parse_set_statement(stmt, tokens);
 } else {
 stmt->type = DAVQL_ERROR;
 }
+// free token data
+UCX_FOREACH(token, tokens) {
+free(token->data);
+}
 ucx_list_free(tokens);
 } else {
 stmt->type = DAVQL_ERROR;
 }

Mercurial > hg > dav / file comparison

comparison: libidav/davqlparser.c

libidav/davqlparser.c