dav: comparison libidav/davqlparser.c

-:0ab1cf261a44
+:ecba8bdf9741
 * 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 <string.h>
 #include <stdio.h>
 #include <ctype.h>
 #define sfmtarg(s) ((int)(s).length), (s).ptr
 case DAVQL_UNARY: return "UNARY";
 case DAVQL_BINARY: return "BINARY";
 case DAVQL_LOGICAL: return "LOGICAL";
 case DAVQL_FUNCCALL: return "FUNCCALL";
 default: return "unknown";
+}
+}
+static const char* _map_specialfield(int info) {
+switch(info) {
+case 0: return "";
+case 1: return "with wildcard";
+case 2: return "(resource data only)";
+default: return "with mysterious identifier";
 }
 }
 static const char* _map_operator(davqloperator_t op) {
 // don't use string array, because enum values may change
 static void dav_debug_ql_stmt_print(DavQLStatement *stmt) {
 sstr_t empty = ST("(empty)");
 // Basic information
-printf("Statement: %.*s\nType: %s\nField count: %zu",
+size_t fieldcount = ucx_list_size(stmt->fields);
+int specialfield = 0;
+UCX_FOREACH(elm, stmt->fields) {
+DavQLExpression* expr = (DavQLExpression*)elm->data;
+if (expr->type == DAVQL_IDENTIFIER && expr->srctext.length == 1) {
+if (expr->srctext.ptr[0] == '*') {
+specialfield = 1;
+} else if (expr->srctext.ptr[0] == '-') {
+specialfield = 2;
+}
+}
+}
+if (specialfield) {
+fieldcount--;
+}
+printf("Statement: %.*s\nType: %s\nField count: %zu %s\nPath: %.*s\n"
+"Has where clause: %s\n",
 sfmtarg(stmt->srctext),
 _map_querytype(stmt->type),
-ucx_list_size(stmt->fields));
+fieldcount,
+_map_specialfield(specialfield),
-// 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[0] == '*') {
-wildcard = 1;
-}
-}
-printf(" %s wildcard\nPath: %.*s\nHas where clause: %s\n",
-wildcard?"with":"without",
 sfmtarg(stmt->path ? stmt->path->srctext : empty),
 stmt->where ? "yes" : "no");
 if (stmt->type == DAVQL_SET) {
 printf("Value list size matches: %s",
 ucx_list_size(stmt->fields) == ucx_list_size(stmt->setvalues)
 // WITH attributes
 if (stmt->depth < 0) {
 printf("Depth: infinity\n");
 } else {
 printf("Depth: %d\n", stmt->depth);
+}
+if (stmt->errorcode) {
+printf("\nError code: %d\nError: %s\n",
+stmt->errorcode, stmt->errormessage);
 }
 }
 static int dav_debug_ql_expr_selected(DavQLExpression *expr) {
 if (!expr) {
 }
 printf("Starting DavQL debugger (type 'h' for help)...\n\n");
 dav_debug_ql_stmt_print(stmt);
+if (stmt->errorcode) {
+return;
+}
 DavQLExpression *examineexpr = NULL;
 while(1) {
 int cmd = dav_debug_ql_command();
 switch (cmd) {
 }
 // ------------------------------------------------------------------------
 //                         P A R S E R
 // ------------------------------------------------------------------------
+#define _unexpected_end_msg "unexpected end of statement"
+#define _invalid_msg "invalid statement"
+#define _unexpected_token "unexpected token (%.*s [->]%.*s %.*s)"
 static UcxList* dav_parse_tokenize(sstr_t src) {
 UcxList *tokens = NULL;
 // Delimiters: whitespace and dead whitespace around commas
 }
 return expr;
 }
+static void dav_parse_unexpected_token(DavQLStatement *stmt, UcxList *token) {
+sstr_t emptystring = ST("");
+stmt->errorcode = DAVQL_ERROR_UNEXPECTED_TOKEN;
+sstr_t errormsg = ucx_sprintf(_unexpected_token,
+sfmtarg(token->prev?*token_sstr(token->prev):emptystring),
+sfmtarg(*token_sstr(token)),
+sfmtarg(token->next?*token_sstr(token->next):emptystring));
+stmt->errormessage = errormsg.ptr;
+}
 static void dav_parse_get_statement(DavQLStatement *stmt, UcxList *tokens) {
 stmt->type = DAVQL_GET;
 /*
 *   10: field list
 *  520: expecting WHERE or WITH clause
 *   30: WHERE clause
 *  530: expecting WITH clause
 *   40: WITH clause
 *  500: ready to quit
+*  999: error
 *
 */
 int step = 10;
 // Variables for token sublists for expressions
 // optional clauses
 case 520:
 if (!sstrcasecmp(tokendata, S("where"))) {
 step = 30;
 }
-/* no break */
+/* no break and no else*/
 case 530:
 if (!sstrcasecmp(tokendata, S("with"))) {
 step = 40;
+} else {
+dav_parse_unexpected_token(stmt, token);
+step = 999;
 }
 break;
 // field list
 case 10: {
 _Bool fromkeyword = !sstrcasecmp(tokendata, S("from"));
 break;
 }
 }
 if (step < 500) {
-stmt->type = DAVQL_ERROR;
+stmt->errorcode = DAVQL_ERROR_UNEXPECTED_END;
-// TODO: save parse error message
+stmt->errormessage = strdup(_unexpected_end_msg);
 }
 }
 static void dav_parse_set_statement(DavQLStatement *stmt, UcxList *tokens) {
 stmt->type = DAVQL_SET;
 dav_parse_get_statement(stmt, tokens);
 } else if (!sstrcasecmp(token, S("set"))) {
 dav_parse_set_statement(stmt, tokens);
 } else {
 stmt->type = DAVQL_ERROR;
+stmt->errorcode = DAVQL_ERROR_INVALID;
+stmt->errormessage = strdup(_invalid_msg);
 }
 // 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(_invalid_msg);
 }
 return stmt;
 }
 dav_free_expression(stmt->path);
 }
 if (stmt->where) {
 dav_free_expression(stmt->where);
 }
+if (stmt->errormessage) {
+free(stmt->errormessage);
+}
 free(stmt);
 }

Mercurial > hg > dav / file comparison

comparison: libidav/davqlparser.c

libidav/davqlparser.c