dav: comparison libidav/davqlparser.c

-:237844f263b4
+:579238097973
 // process tokens
 for (size_t i = 0 ; i < n ; i++) {
 sstr_t tokendata = *token_sstr(token);
 // TODO: make it so
-printf("Processing %.*s...\n", sfmtarg(tokendata));
 // go to next token (if this is not the last token)
 if (i < n-1) {
 token = token->next;
 }
 #define _step_ORDER_BY_     50 // ORDER BY clause
 #define _step_end_         500 // expect end
 struct fieldlist_parser_state {
 UcxList *expr_firsttoken;
+DavQLField *currentfield;
 size_t expr_len;
 /*
 * 0: begin of field list - may encounter "*" or "-" special fields
 * 1: collect expression token
 *    switch to step 2 on keyword "as"
-*    expect "," only if expr_len is 1 (add expr to list and continue)
+*    expect "," or "from" only if expr_len is 1 (add to list and continue)
-* 2: expect one token (identifier) and a "," - continue with step 1
+* 2: expect one token (identifier) for as clause
+* 3: expect a ",": continue with step 1
+*    or a "from": leave field list parser
+* 4: expect end of field list (i.e. a "from" keyword)
 */
 int step;
 };
+static void dav_free_field(DavQLField *field) {
+dav_free_expression(field->expr);
+free(field);
+}
 static int dav_parse_fieldlist(DavQLStatement *stmt, UcxList *token,
 struct fieldlist_parser_state *state) {
 sstr_t tokendata = *token_sstr(token);
+_Bool fromkeyword = !sstrcasecmp(tokendata, S("from"));
+_Bool comma = !sstrcmp(tokendata, S(","));
 switch (state->step) {
 case 0:
+if (!sstrcmp(tokendata, S("*")) || !sstrcmp(tokendata, S("-"))) {
+DavQLField *field = malloc(sizeof(DavQLField));
+field->name = tokendata;
+field->expr = calloc(1, sizeof(DavQLExpression));
+field->expr->type = DAVQL_IDENTIFIER;
+field->expr->srctext = tokendata;
+stmt->fields = ucx_list_append(stmt->fields, field);
+if (tokendata.ptr[0] == '-') {
+// no further fields may follow, if dash symbol has been found
+state->step = 4;
+} else {
+state->step = 3;
+}
+return _step_fieldlist_;
+}
 // did not encounter special field, fall through to step 1
+state->step = 1;
 case 1:
-break;
+if (fromkeyword || comma) {
-}
+// add possible identifier to list
+if (state->expr_firsttoken) {
-_Bool fromkeyword = !sstrcasecmp(tokendata, S("from"));
+// TODO: skip comma in function call)
-if (fromkeyword || !sstrcmp(tokendata, S(","))) {
+if (state->expr_len > 1) {
-if (state->expr_firsttoken) {
+stmt->errorcode = DAVQL_ERROR_UNEXPECTED_TOKEN;
-DavQLField *field = malloc(sizeof(DavQLField));
+stmt->errormessage = ucx_sprintf(_expected_token,
-field->expr = dav_parse_expression(
+"AS", sfmtarg(tokendata)).ptr;
+return 0;
+}
+DavQLExpression *expr = dav_parse_expression(
+stmt, state->expr_firsttoken, state->expr_len);
+if (expr->type != DAVQL_IDENTIFIER) {
+dav_free_expression(expr);
+stmt->errorcode = DAVQL_ERROR_UNEXPECTED_TOKEN;
+stmt->errormessage = ucx_sprintf(_expected_token,
+"AS", sfmtarg(tokendata)).ptr;
+return 0;
+} // TODO: do not allow identifier when wildcard is present
+DavQLField *field = malloc(sizeof(DavQLField));
+field->expr = expr;
+field->name = field->expr->srctext;
+stmt->fields = ucx_list_append(stmt->fields, field);
+state->expr_firsttoken = NULL;
+state->expr_len = 0;
+if (fromkeyword) {
+return _step_FROM_;
+}
+} else {
+dav_error_in_context(DAVQL_ERROR_UNEXPECTED_TOKEN,
+_unexpected_token, stmt, token);
+return 0;
+}
+} else if (!sstrcasecmp(tokendata, S("as"))) {
+// TODO: return error, if expr_first_token is NULL
+state->currentfield = malloc(sizeof(DavQLField));
+state->currentfield->expr = dav_parse_expression(
 stmt, state->expr_firsttoken, state->expr_len);
-field->name = field->expr->srctext;
-stmt->fields = ucx_list_append(stmt->fields, field);
 state->expr_firsttoken = NULL;
 state->expr_len = 0;
-if (fromkeyword) {
+state->step = 2;
-return _step_FROM_;
+} else {
-}
+// collect tokens for field expression
+if (state->expr_firsttoken) {
+state->expr_len++;
+} else {
+state->expr_firsttoken = token;
+state->expr_len = 1;
+}
+}
+return _step_fieldlist_;
+case 2: {
+DavQLExpression *expr = dav_parse_expression(stmt, token, 1);
+if (expr->type == DAVQL_IDENTIFIER) {
+state->currentfield->name = expr->srctext;
+stmt->fields = ucx_list_append(stmt->fields, state->currentfield);
+state->currentfield = NULL;
+} else {
+dav_free_field(state->currentfield);
+dav_error_in_context(DAVQL_ERROR_IDENTIFIER_EXPECTED,
+_identifier_expected, stmt, token);
+}
+dav_free_expression(expr);
+state->step = 3;
+return _step_fieldlist_;
+}
+case 3:
+if (fromkeyword) {
+return _step_FROM_;
+} else if (comma) {
+state->step = 1;
+return _step_fieldlist_;
 } else {
 dav_error_in_context(DAVQL_ERROR_UNEXPECTED_TOKEN,
 _unexpected_token, stmt, token);
-}
+return 0;
-} else {
+}
-// collect tokens for field expression
+case 4:
-if (state->expr_firsttoken) {
+if (fromkeyword) {
-state->expr_len++;
+return _step_FROM_;
 } else {
-state->expr_firsttoken = token;
+stmt->errorcode = DAVQL_ERROR_UNEXPECTED_TOKEN;
-state->expr_len = 1;
+stmt->errormessage = ucx_sprintf(_expected_token,
-}
+"FROM", sfmtarg(tokendata)).ptr;
-}
+return 0;
+}
-return _step_fieldlist_;
+}
-}
-static void dav_free_field(DavQLField *field) {
-dav_free_expression(field->expr);
-free(field);
 }
 static int dav_parse_from(DavQLStatement *stmt, UcxList *token) {
 sstr_t tokendata = *token_sstr(token);

Mercurial > hg > dav / file comparison

comparison: libidav/davqlparser.c

libidav/davqlparser.c