libidav/davqlexec.c

/*
 * 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");
}