Sat, 30 May 2015 13:49:17 +0200
expression compiler generates byte code
/* * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER. * * Copyright 2015 Olaf Wintermann. All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions are met: * * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE * POSSIBILITY OF SUCH DAMAGE. */ #include <stdio.h> #include <stdlib.h> #include <string.h> #include <ucx/utils.h> #include "davqlexec.h" #include "utils.h" DavQLResult* dav_statement_exec(DavSession *sn, DavQLStatement *st, ...) { va_list ap; va_start(ap, st); DavQLResult *result = dav_statement_execv(sn, st, ap); va_end(ap); return result; } DavQLResult* dav_statement_execv(DavSession *sn, DavQLStatement *st, va_list ap) { DavQLResult *result = dav_session_malloc(sn, sizeof(DavQLResult)); result->result = NULL; result->status = 1; // make sure the statement was successfully parsed if(st->type == DAVQL_ERROR) { return result; } // get path string davqlerror_t error; sstr_t path = dav_format_string(sn->mp->allocator, st->path, ap, &error); if(st->type == DAVQL_GET) { dav_exec_get(sn, st, path.ptr, ap); } else { // TODO } return result; } sstr_t dav_format_string(UcxAllocator *a, sstr_t fstr, va_list ap, davqlerror_t *error) { UcxBuffer *buf = ucx_buffer_new(NULL, 128, UCX_BUFFER_AUTOEXTEND); int placeholder = 0; for(int i=0;i<fstr.length;i++) { char c = fstr.ptr[i]; if(placeholder) { if(c == '%') { // no placeholder, %% transposes to % ucx_buffer_putc(buf, c); } else { // detect placeholder type and insert arg int err = 0; switch(c) { case 's': { char *arg = va_arg(ap, char*); ucx_buffer_puts(buf, arg); break; } case 'd': { int arg = va_arg(ap, int); ucx_bprintf(buf, "%d", arg); break; } case 'u': { unsigned int arg = va_arg(ap, unsigned int); ucx_bprintf(buf, "%u", arg); break; } case 't': { // time arguments not supported for strings err = 1; break; } default: { *error = DAVQL_UNKNOWN_FORMATCHAR; err = 1; } } if(err) { ucx_buffer_free(buf); sstr_t n; n.ptr = NULL; n.length = 0; return n; } } placeholder = 0; } else { if(c == '%') { placeholder = 1; } else { ucx_buffer_putc(buf, c); } } } *error = DAVQL_OK; return sstrdup_a(a, sstrn(buf->space, buf->size)); } void dav_exec_get(DavSession *sn, DavQLStatement *st, char* path, va_list ap) { // execute a davql get statement UcxMempool *mp = ucx_mempool_new(128); // TODO: get property list UcxBuffer *bcode = dav_compile_expr(mp->allocator, st->where, ap); print_bytecode(bcode); } static int count_func_args(DavQLExpression *expr) { int count = 0; DavQLExpression *arg = expr->right; while(arg) { count++; if(arg->op == DAVQL_ARGLIST) { arg = arg->right; } else { break; } } return count; } static int add_cmd(UcxAllocator *a, UcxBuffer *bcode, DavQLExpression *expr, va_list ap) { if(!expr) { return 0; } int numcmd = 1; DavQLCmd cmd; memset(&cmd, sizeof(DavQLCmd), 0); davqlerror_t error; sstr_t src = expr->srctext; switch(expr->type) { case DAVQL_NUMBER: { cmd.type = DAVQL_CMD_INT; if(src.ptr[0] == '%') { cmd.data.integer = va_arg(ap, int); } else if(util_strtoint(src.ptr, &cmd.data.integer)) { ucx_buffer_write(&cmd, sizeof(cmd), 1, bcode); } else { // error return -1; } break; } case DAVQL_STRING: { cmd.type = DAVQL_CMD_STRING; cmd.data.string = dav_format_string(a, src, ap, &error); ucx_buffer_write(&cmd, sizeof(cmd), 1, bcode); break; } case DAVQL_TIMESTAMP: { if(src.ptr[0] == '%') { cmd.data.timestamp = va_arg(ap, time_t); ucx_buffer_write(&cmd, sizeof(cmd), 1, bcode); } else { // error return -1; } break; } case DAVQL_IDENTIFIER: { sstr_t propertyname = sstrchr(src, ':'); cmd.type = DAVQL_CMD_RES_IDENTIFIER; if(propertyname.length > 0) { cmd.type = DAVQL_CMD_PROP_IDENTIFIER; // TODO } else if(!sstrcmp(src, S("name"))) { cmd.data.resprop = DAVQL_RES_NAME; } else if(!sstrcmp(src, S("path"))) { cmd.data.resprop = DAVQL_RES_PATH; } else if(!sstrcmp(src, S("href"))) { cmd.data.resprop = DAVQL_RES_HREF; } else if(!sstrcmp(src, S("contentlength"))) { cmd.data.resprop = DAVQL_RES_CONTENTLENGTH; } else if(!sstrcmp(src, S("contenttype"))) { cmd.data.resprop = DAVQL_RES_CONTENTTYPE; } else if(!sstrcmp(src, S("creationdate"))) { cmd.data.resprop = DAVQL_RES_CREATIONDATE; } else if(!sstrcmp(src, S("lastmodified"))) { cmd.data.resprop = DAVQL_RES_LASTMODIFIED; } else if(!sstrcmp(src, S("iscollection"))) { cmd.data.resprop = DAVQL_RES_ISCOLLECTION; } ucx_buffer_write(&cmd, sizeof(cmd), 1, bcode); break; } case DAVQL_UNARY: { numcmd += add_cmd(a, bcode, expr->left, ap); switch(expr->op) { case DAVQL_ADD: { cmd.type = DAVQL_CMD_OP_UNARY_ADD; break; } case DAVQL_SUB: { cmd.type = DAVQL_CMD_OP_UNARY_SUB; break; } case DAVQL_NEG: { cmd.type = DAVQL_CMD_OP_UNARY_NEG; break; } } ucx_buffer_write(&cmd, sizeof(cmd), 1, bcode); break; } case DAVQL_BINARY: { numcmd += add_cmd(a, bcode, expr->left, ap); numcmd += add_cmd(a, bcode, expr->right, ap); switch(expr->op) { case DAVQL_ADD: { cmd.type = DAVQL_CMD_OP_BINARY_ADD; break; } case DAVQL_SUB: { cmd.type = DAVQL_CMD_OP_BINARY_SUB; break; } case DAVQL_MUL: { cmd.type = DAVQL_CMD_OP_BINARY_MUL; break; } case DAVQL_DIV: { cmd.type = DAVQL_CMD_OP_BINARY_DIV; break; } case DAVQL_AND: { cmd.type = DAVQL_CMD_OP_BINARY_AND; break; } case DAVQL_OR: { cmd.type = DAVQL_CMD_OP_BINARY_OR; break; } case DAVQL_XOR: { cmd.type = DAVQL_CMD_OP_BINARY_XOR; break; } } ucx_buffer_write(&cmd, sizeof(cmd), 1, bcode); break; } case DAVQL_LOGICAL: { if(expr->left && expr->right && expr->op != DAVQL_LOR) { numcmd += add_cmd(a, bcode, expr->left, ap); numcmd += add_cmd(a, bcode, expr->right, ap); } switch(expr->op) { case DAVQL_NOT: { numcmd += add_cmd(a, bcode, expr->left, ap); cmd.type = DAVQL_CMD_OP_LOGICAL_NOT; ucx_buffer_write(&cmd, sizeof(cmd), 1, bcode); break; } case DAVQL_LAND: { cmd.type = DAVQL_CMD_OP_LOGICAL_NOT; ucx_buffer_write(&cmd, sizeof(cmd), 1, bcode); break; } case DAVQL_LOR: { int nleft = add_cmd(a, bcode, expr->left, ap); cmd.type = DAVQL_CMD_OP_LOGICAL_OR_L; DavQLCmd *or_l = (DavQLCmd*)(bcode->space + bcode->pos); ucx_buffer_write(&cmd, sizeof(cmd), 1, bcode); int nright = add_cmd(a, bcode, expr->right, ap); or_l->data.integer = nright + 1; cmd.type = DAVQL_CMD_OP_LOGICAL_OR; cmd.data.integer = 0; ucx_buffer_write(&cmd, sizeof(cmd), 1, bcode); numcmd += nleft + nright; break; } case DAVQL_LXOR: { cmd.type = DAVQL_CMD_OP_LOGICAL_XOR; ucx_buffer_write(&cmd, sizeof(cmd), 1, bcode); break; } case DAVQL_EQ: { cmd.type = DAVQL_CMD_OP_EQ; ucx_buffer_write(&cmd, sizeof(cmd), 1, bcode); break; } case DAVQL_NEQ: { cmd.type = DAVQL_CMD_OP_NEQ; ucx_buffer_write(&cmd, sizeof(cmd), 1, bcode); break; } case DAVQL_LT: { cmd.type = DAVQL_CMD_OP_LT; ucx_buffer_write(&cmd, sizeof(cmd), 1, bcode); break; } case DAVQL_GT: { cmd.type = DAVQL_CMD_OP_GT; ucx_buffer_write(&cmd, sizeof(cmd), 1, bcode); break; } case DAVQL_LE: { cmd.type = DAVQL_CMD_OP_LE; ucx_buffer_write(&cmd, sizeof(cmd), 1, bcode); break; } case DAVQL_GE: { cmd.type = DAVQL_CMD_OP_GE; ucx_buffer_write(&cmd, sizeof(cmd), 1, bcode); break; } case DAVQL_LIKE: { cmd.type = DAVQL_CMD_OP_LIKE; ucx_buffer_write(&cmd, sizeof(cmd), 1, bcode); break; } case DAVQL_UNLIKE: { cmd.type = DAVQL_CMD_OP_UNLIKE; ucx_buffer_write(&cmd, sizeof(cmd), 1, bcode); break; } } break; } case DAVQL_FUNCCALL: { switch(expr->op) { case DAVQL_CALL: { int nright = add_cmd(a, bcode, expr->right, ap); // TODO: count args DavQLExpression *funcid = expr->left; if(!funcid && funcid->type != DAVQL_IDENTIFIER) { // fail return -1; } // numargs cmd.type = DAVQL_CMD_INT; cmd.data.integer = count_func_args(expr); ucx_buffer_write(&cmd, sizeof(cmd), 1, bcode); // TODO: resolve function name cmd.type = DAVQL_CMD_CALL; cmd.data.func = NULL; ucx_buffer_write(&cmd, sizeof(cmd), 1, bcode); numcmd = 2; numcmd += nright; break; } case DAVQL_ARGLIST: { numcmd = 0; numcmd += add_cmd(a, bcode, expr->left, ap); numcmd += add_cmd(a, bcode, expr->right, ap); break; } } break; } } return numcmd; } UcxBuffer* dav_compile_expr(UcxAllocator *a, DavQLExpression *lexpr, va_list ap) { UcxBuffer *bcode = ucx_buffer_new(NULL, 512, UCX_BUFFER_AUTOEXTEND); if(!bcode) { return NULL; } if(add_cmd(a, bcode, lexpr, ap) <= 0) { ucx_buffer_free(bcode); return NULL; } return bcode; } void print_bytecode(UcxBuffer *bcode) { bcode->pos = 0; DavQLCmd cmd; while(ucx_buffer_read(&cmd, sizeof(DavQLCmd), 1, bcode) == 1) { switch(cmd.type) { case DAVQL_CMD_INT: { printf("int %ll\n", cmd.data.integer); break; } case DAVQL_CMD_STRING: { printf("string \"%.*s\"\n", cmd.data.string.length, cmd.data.string.ptr); break; } case DAVQL_CMD_TIMESTAMP: { printf("timestamp %d\n", cmd.data.timestamp); break; } case DAVQL_CMD_RES_IDENTIFIER: { char *rid[8] = {"name", "path", "href", "contentlength", "contenttype", "creationdate", "lastmodified", "iscollection"}; printf("resprop %s\n", rid[cmd.data.resprop]); break; } case DAVQL_CMD_PROP_IDENTIFIER: { printf("property %s:%s\n", cmd.data.property.ns, cmd.data.property.name); break; } case DAVQL_CMD_OP_UNARY_ADD: { printf("uadd\n"); break; } case DAVQL_CMD_OP_UNARY_SUB: { printf("usub\n"); break; } case DAVQL_CMD_OP_UNARY_NEG: { printf("uneg\n"); break; } case DAVQL_CMD_OP_BINARY_ADD: { printf("add\n"); break; } case DAVQL_CMD_OP_BINARY_SUB: { printf("sub\n"); break; } case DAVQL_CMD_OP_BINARY_MUL: { printf("mul\n"); break; } case DAVQL_CMD_OP_BINARY_DIV: { printf("div\n"); break; } case DAVQL_CMD_OP_BINARY_AND: { printf("and\n"); break; } case DAVQL_CMD_OP_BINARY_OR: { printf("or\n"); break; } case DAVQL_CMD_OP_BINARY_XOR: { printf("xor\n"); break; } case DAVQL_CMD_OP_LOGICAL_NOT: { printf("not\n"); break; } case DAVQL_CMD_OP_LOGICAL_AND: { printf("land\n"); break; } case DAVQL_CMD_OP_LOGICAL_OR_L: { printf("or_l %d\n", cmd.data.integer); break; } case DAVQL_CMD_OP_LOGICAL_OR: { printf("or\n"); break; } case DAVQL_CMD_OP_LOGICAL_XOR: { printf("lxor\n"); break; } case DAVQL_CMD_OP_EQ: { printf("eq\n"); break; } case DAVQL_CMD_OP_NEQ: { printf("neq\n"); break; } case DAVQL_CMD_OP_LT: { printf("lt\n"); break; } case DAVQL_CMD_OP_GT: { printf("gt\n"); break; } case DAVQL_CMD_OP_LE: { printf("le\n"); break; } case DAVQL_CMD_OP_GE: { printf("ge\n"); break; } case DAVQL_CMD_OP_LIKE: { printf("like\n"); break; } case DAVQL_CMD_OP_UNLIKE: { printf("unlike\n"); break; } case DAVQL_CMD_CALL: { printf("call %x\n", cmd.data.func); break; } } } printf("\n"); }