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"

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;
    UcxBuffer *path = dav_path_string(st->path, ap, &error);
    
    if(st->type == DAVQL_GET) {
        dav_exec_get(sn, st, path->space, ap);
    } else {
        // TODO
    }
    
    return result;
}

UcxBuffer* dav_path_string(sstr_t pathfmt, va_list ap, davqlerror_t *error) {
    UcxBuffer *path = ucx_buffer_new(NULL, 128, UCX_BUFFER_AUTOEXTEND);
    
    int placeholder = 0;
    for(int i=0;i<pathfmt.length;i++) {
        char c = pathfmt.ptr[i];
        if(placeholder) {
            if(c == '%') {
                // no placeholder, %% transposes to %
                ucx_buffer_putc(path, c);
            } else {
                // detect placeholder type and insert arg
                int err = 0;
                switch(c) {
                    case 's': {
                        char *arg = va_arg(ap, char*);
                        ucx_buffer_puts(path, arg);
                        break;
                    }
                    case 'd': {
                        int arg = va_arg(ap, int);
                        ucx_bprintf(path, "%d", arg);
                        break;
                    }
                    case 'u': {
                        unsigned int arg = va_arg(ap, unsigned int);
                        ucx_bprintf(path, "%u", arg);
                        break;
                    }
                    case 't': {
                        // time arguments doesn't make any sense in a path
                        *error = DAVQL_UNSUPPORTED_FORMATCHAR;
                        err = 1;
                        break;
                    }
                    default: {
                        *error = DAVQL_UNKNOWN_FORMATCHAR;
                        err = 1;
                    }
                }
                if(err) {
                    ucx_buffer_free(path);
                    return NULL;
                }
            }
            placeholder = 0;
        } else {
            if(c == '%') {
                placeholder = 1;
            } else {
                ucx_buffer_putc(path, c);
            }
        }
    }
    ucx_buffer_putc(path, '\0');
    *error = DAVQL_OK;
    return path;
}

void dav_exec_get(DavSession *sn, DavQLStatement *st, char* path, va_list ap) {
    // execute a davql get statement
    
    // TODO: get property list
    
    
}

int dav_eval_lexpr(DavResource *res, DavQLExpression *lexpr) {
    
}