#include <ctype.h>
#include <string.h>
#include <stdlib.h>
#include <stdio.h>
#include "conf.h"


typedef struct _SField
{
    char *name;
    int type;
    union {
        char *str_value;
        int int_value;
        double double_value;
        HTable table_value;
    } value;
    struct _SField *next;
} SField;


typedef struct _STable
{
    SField *fields;
    char *stat_buf;
} STable;


typedef struct _STableIterator
{
    HTable table;
    SField *cur_field;
    int before_start;
    char *stat_buf;
} STableIterator;



HTable table_create()
{
    HTable table;

    table = (STable*)calloc(1, sizeof(STable));
    return table;
}


static void free_field(SField *field)
{
    if (! field)
        return;
    if (field->name)
        free(field->name);
    switch (field->type)
    {
        case TYPE_STRING: free(field->value.str_value); break;
        case TYPE_TABLE: table_free(field->value.table_value); break;
    }
    free(field);
}


static SField* find_field(HTable table, const char *name)
{
    SField *f;

    if ((! table) || (! name))
        return NULL;

    f = table->fields;
    while (f)
    {
        if (f->name && (! strcmp(f->name, name)))
            return f;
        f = f->next;
    }

    return NULL;
}


int table_remove_field(HTable table, char *field)
{
    SField *f, *pf;

    if ((! table) || (! field))
        return -1;

    f = find_field(table, field);
    if (f)
    {
        if (table->fields == f)
            table->fields = f->next;
        else
        {
            pf = table->fields;
            while (pf && (pf->next != f))
                pf = pf->next;
            if (pf)
                pf->next = f->next;
        }
        free_field(f);
    }

    return 0;
}


static SField* add_empty_field(HTable table, const char *field)
{
    SField *f, *nf;

    if ((! table) || (! field))
        return NULL;

    f = find_field(table, field);
    if (f)
        table_remove_field(table, f->name);

    nf = (SField*)calloc(1, sizeof(SField));
    if (! nf) return NULL;
    nf->name = strdup(field);

    f = table->fields;
    if (f)
    {
        while (f->next)
            f = f->next;
        f->next = nf;
    }
    else
        table->fields = nf;

    return nf;
}


int table_set_str(HTable table, const char *field, const char *value)
{
    SField *f;

    if ((! table) || (! field) || (! value))
        return -1;
    
    f = add_empty_field(table, field);
    if (! f) return -1;

    f->type = TYPE_STRING;
    f->value.str_value = strdup(value);
    return 0;
}


int table_set_int(HTable table, const char *field, int value)
{
    SField *f;

    if ((! table) || (! field))
        return -1;
    
    f = add_empty_field(table, field);
    if (! f) return -1;

    f->type = TYPE_INT;
    f->value.int_value = value;
    return 0;
}


int table_set_double(HTable table, const char *field, double value)
{
    SField *f;

    if ((! table) || (! field))
        return -1;
    
    f = add_empty_field(table, field);
    if (! f) return -1;

    f->type = TYPE_FLOAT;
    f->value.double_value = value;
    return 0;
}


int table_set_table(HTable table, const char *field, HTable value)
{
    SField *f;

    if ((! table) || (! field) || (! value))
        return -1;
    
    f = add_empty_field(table, field);
    if (! f) return -1;

    f->type = TYPE_TABLE;
    f->value.table_value = value;
    return 0;
}


static int skip_spaces(char *buf, long int *pos);


static int skip_multy_comment(char *buf, long int *pos)
{
    while (buf[*pos])
    {
        if (buf[*pos] == '*')
        {
            (*pos)++;
            if (buf[*pos] == '/')
            {
                (*pos)++;
                return skip_spaces(buf, pos);
            }
        }
        (*pos)++;
    }

    return -1;
}


static int skip_line_comment(char *buf, long int *pos)
{
    while (buf[*pos] && ((buf[*pos]) != '\n'))
        (*pos)++;
    return skip_spaces(buf, pos);
}


static int is_cspace(char *buf, long int *pos)
{
    if (isspace(buf[*pos]))
        return 1;
    if (buf[*pos] == '/')
    {
        if ((buf[(*pos) + 1] == '*') || (buf[(*pos) + 1] == '/'))
            return 1;
    }
    return 0;
}


static int skip_spaces(char *buf, long int *pos)
{
    while (buf[*pos] && isspace(buf[*pos]))
        (*pos)++;
    
    if (buf[*pos] == '/')
    {
        (*pos)++;
        if (buf[*pos] == '*')
        {
            (*pos)++;
            return skip_multy_comment(buf, pos);
        }
        else if (buf[*pos] == '/')
        {
            (*pos)++;
            return skip_line_comment(buf, pos);
        }
        else
            return -1;
    }
    return 0;
}


static int is_symbol(char sym)
{
    static char syms[] = { '=', '{', '}', ';', '\'', '"', ',', '/', '\\' };
    unsigned int i;

    for (i = 0; i < sizeof(syms) / sizeof(char); i++)
    {
        if (sym == syms[i])
            return 1;
    }

    return 0;
}


static char* read_string(char* buf, long int *pos)
{
    int allocated=50, len=1;
    char *b;

    b = (char*)malloc(allocated);
    if (! b) return NULL;
    b[0] = buf[*pos];
    (*pos)++;
    while (buf[*pos])
    {
        if (len + 3 > allocated)
        {
            char *s = (char*)realloc(b, allocated+=20);
            if (! s)
            {
                free(b);
                return NULL;
            }
            b = s;
        }
        if ((buf[*pos] == '\\') && (buf[*pos + 1] == b[0]))
        {
            b[len++] = '\\';
            b[len] = b[0];
        }
        else
        {
            b[len++] = buf[*pos];
            if (buf[*pos] == b[0])
            {
                b[len] = 0;
                (*pos)++;
                return b;
            }
        }
        (*pos)++;
    }
    free(b);
    return NULL;
}


static char* read_word(char* buf, long int *pos)
{
    int allocated=50, len=0;
    char *b;

    b = (char*)malloc(allocated);
    if (! b) return NULL;
    while (buf[*pos] && (! is_cspace(buf, pos)) && (! is_symbol(buf[*pos])))
    {
        if (len + 3 > allocated)
        {
            char *s = (char*)realloc(b, allocated+=20);
            if (! s)
            {
                free(b);
                return NULL;
            }
            b = s;
        }
        b[len++] = buf[*pos];
        (*pos)++;
    }
    if (! len)
    {
        free(b);
        return NULL;
    }
    b[len] = 0;
    return b;
}


static char* read_token(char *buf, long int *pos)
{
    if (skip_spaces(buf, pos) || (! buf[*pos]))
        return NULL;

    if ((buf[*pos] == '\'') || (buf[*pos] == '"'))
        return read_string(buf, pos);

    if (is_symbol(buf[*pos]))
    {
        char *b = (char*)malloc(2);
        if (! b) return NULL;
        b[0] = buf[*pos];
        b[1] = 0;
        (*pos)++;
        return b;
    }

    return read_word(buf, pos);
}


static long int get_file_size(FILE *f)
{
    long int len;
    
    if (fseek(f, 0L, SEEK_END))
        return -1;

    len = ftell(f);
    
    if (fseek(f, 0L, SEEK_SET))
        return -1;

    return len;
}


static char* read_file(const char *filename, long int *length)
{
    FILE *f;
    char *buf;
    long int len;

    f = fopen(filename, "rb");
    if (! f) return NULL;

    len = get_file_size(f);
    if (len <= 0)
    {
        fclose(f);
        return NULL;
    }

    buf = (char*)malloc(len + 1);
    if (! buf)
    {
        fclose(f);
        return NULL;
    }

    if (fread(buf, 1, len, f) != (unsigned)len)
    {
        free(buf);
        fclose(f);
        return NULL;
    }

    buf[len] = 0;

    fclose(f);
    *length = len + 1;
    return buf;
}


static int get_next_index(HTable table)
{
    SField *f;
    int v, max_v=-1;
    char *endptr;
    
    for (f = table->fields; f; f = f->next)
    {
        v = strtol(f->name, &endptr, 10);
        if ((! f->name[0]) || (endptr[0])) 
            continue;
        if (v > max_v)
            max_v = v;
    }

    return max_v + 1;
}


static int is_ident(char *str)
{
    char *p;
    
    if (! str)
        return 0;
    if (strlen(str) < 1)
        return 0;
    if (! isalpha(str[0]))
        return 0;
    
    for (p = str; *p; p++)
        if (! (isalnum(*p) || (*p == '_') || (*p == '.')))
            return 0;
    
    return 1;
}


static int is_string_value(char *value)
{
    int len;

    if ((value[0] == '\'') || (value[0] == '"'))
    {
        if ((len = strlen(value)) >= 2)
        {
            if (value[len - 1] == value[0])
                return 1;
        }
    }
    
    return 0;
}


static int is_int_value(char *value)
{
    char *p;

    for (p = value; *p; p++)
    {
        if (! isdigit(*p))
        {
            if (p != value)
                return 0;
            else
                if (! ((*p == '+') || (*p == '-')))
                    return 0;
        }
    }
    return 1;
}


static int is_float_value(char *value)
{
    char *p;
    int pcount = 0;

    for (p = value; *p; p++)
    {
        if (! isdigit(*p))
        {
            if (p != value)
            {
                if (*p != '.')
                    return 0;
                else
                {
                    pcount++;
                    if (pcount > 1)
                        return 0;
                }
            }
            else
            {
                if (! ((*p == '+') || (*p == '-')))
                    return 0;
            }
        }
    }
    return 1;
}


static int get_value_type(char *value)
{
    if ((! value) || (! value[0]))
        return -1;

    if (is_string_value(value))
        return TYPE_STRING;
    if (! strcmp(value, "{"))
        return TYPE_TABLE;
    if (is_int_value(value))
        return TYPE_INT;
    if (is_float_value(value))
        return TYPE_FLOAT;

    return -1;
}


static char* unescape_string(char *str)
{
    char *buf, quote, *p;
    int allocated=50, len=0;

    buf = (char*)malloc(allocated);

    quote = str[0];
    p = str + 1;
    while ((*p) && (*p != quote))
    {
        if (len + 10 > allocated)
        {
            char *s = (char*)realloc(buf, allocated+=20);
            if (! s)
            {
                free(buf);
                return NULL;
            }
            buf = s;
        }
        if (*p == '\\')
        {
            p++;
            switch (*p)
            {
                case 'n': buf[len++] = '\n'; break;
                case 't': buf[len++] = '\t'; break;
                case 'r': buf[len++] = '\r'; break;
                default: buf[len++] = *p;
            }
        }
        else
            buf[len++] = *p;
        p++;
    }
    buf[len] = 0;

    if ((*p == quote) && (*(p + 1)))
    {
        free(buf);
        return NULL;
    }
    return buf;
}


static int parse_table(HTable table, char *buf, long int *pos, int top_level);


static int add_field(HTable table, char *name, char *value, char *buf, long int *pos)
{
    int value_type;
    char *s;
    HTable tbl;

    value_type = get_value_type(value);
    switch (value_type)
    {
        case TYPE_INT:
            table_set_int(table, name, atoi(value));
            break;
        case TYPE_STRING:
            s = unescape_string(value);
            if (! s)
                return -1;
            table_set_str(table, name, s);
            free(s);
            break;
        case TYPE_FLOAT:
            table_set_double(table, name, atof(value));
            break;
        case TYPE_TABLE:
            tbl = table_create();
            if (table_set_table(table, name, tbl))
            {
                table_free(tbl);
                return -1;
            }
            if (parse_table(tbl, buf, pos, 0))
                return -1;
            break;
        default:
            return -1;
    }
    return 0;
}


static int add_field_to_array(HTable table, char *token, char *buf, long int *pos)
{
    int idx = get_next_index(table);
    char b[100];
    sprintf(b, "%i", idx);
    return add_field(table, b, token, buf, pos);
}



/*
 * TODO: add field as in array highly unoptimized.  it scans for max index
 *       number on every element addition, converting idexes from strings
 *       to numbers where it possible.  optimizations method: process
 *       indexes in batch
 */

static int parse_table(HTable table, char *buf, long int *pos, int top_level)
{
    char *token=NULL;
    char *name;
    int res;

    while (1)
    {
        if (! token)
            token = read_token(buf, pos);
        if (! token)
        {
            if (top_level)
                return 0;
            else
                return -1;
        }

        if (! strcmp(token, "{"))
        {
            if (add_field_to_array(table, token, buf, pos))
            {
                free(token);
                return -1;
            }
            free(token);
            token = read_token(buf, pos);
            if (! token)
            {
                if (top_level)
                    return 0;
                else
                    return -1;
            }
            if ((! strcmp(token, ";")) || (! strcmp(token, ",")))
            {
                free(token);
                token = NULL;
            }
            continue;
        } 
        else if (! strcmp(token, "}"))
        {
            free(token);
            if (top_level)
                return -1;
            else
                return 0;
        }

        name = token;
        
        token = read_token(buf, pos);
        
        if (token && (! strcmp(token, "=")))
        {
            free(token);

            if (! is_ident(name))
            {
                free(name);
                return -1;
            }

            token = read_token(buf, pos);
            if (! token)
            {
                free(name);
                return -1;
            }

            res = add_field(table, name, token, buf, pos);
            free(name);
            free(token);
            if (res)
            {
                return -1;
            }

            token = read_token(buf, pos);
            if (! token)
            {
                if (top_level)
                    return 0;
                else
                    return -1;
            }
            if ((! strcmp(token, ";")) || (! strcmp(token, ",")))
            {
                free(token);
                token = NULL;
            }
            else
                if (strcmp(token, "}"))
                {
                    free(token);
                    return -1;
                }
        }
        else
        {
            if ((! token) && (! top_level))
            {
                free(name);
                return -1;
            }
            if (! (token && ((! strcmp(token, ";")) || (! strcmp(token, ",")) 
                        || (! strcmp(token, "}")))))
            {
                free(name);
                if (token) free(token);
                return -1;
            }

            res = add_field_to_array(table, name, buf, pos);
            free(name);
            if (res)
            {
                free(token);
                return -1;
            }

            if ((! token) || (! strcmp(token, "}")))
            {
                if (token) free(token);
                return 0;
            }

            if (token && ((! strcmp(token, ",")) || ((! strcmp(token, ";")))))
            {
                free(token);
                token = NULL;
            }
        }
    }
    
    return 0;
}


HTable table_read(const char *filename)
{
    long int len, pos;
    char *buf;
    HTable table;
    int res;

    buf = read_file(filename, &len);
    if (! buf) return NULL;

    pos = 0;
    table = table_create();
    res = parse_table(table, buf, &pos, 1);
    if (res)
    {
        table_free(table);
        table = NULL;
    }

    free(buf);
    return table;
}


void table_free(HTable table)
{
    SField *f, *nf;

    if (! table) return;

    f = table->fields;
    while (f)
    {
        nf = f->next;
        free_field(f);
        f = nf;
    }
    if (table->stat_buf)
        free(table->stat_buf);
    free(table);
}


HTableIterator table_get_iter(HTable table)
{
    HTableIterator it;

    it = (HTableIterator)calloc(sizeof(STableIterator), 1);
    if (! it) return NULL;

    it->table = table;
    it->before_start = 1;
    
    return it;
}


void table_free_iter(HTableIterator iterator)
{
    if (! iterator) return;
    if (iterator->stat_buf) free(iterator->stat_buf);
    free(iterator);
}


int table_iter_next(HTableIterator iterator)
{
    if (! iterator)
        return 0;

    if (iterator->before_start)
    {
        iterator->before_start = 0;
        iterator->cur_field = iterator->table->fields;
    }
    else
    {
        if (iterator->cur_field)
            iterator->cur_field = iterator->cur_field->next;
    }
    
    if (! iterator->cur_field)
        return 0;
    
    return 1;
}


char* table_iter_get_name(HTableIterator iterator)
{
    if ((! iterator) || (! iterator->cur_field))
        return NULL;

    return iterator->cur_field->name;
}


int table_iter_get_type(HTableIterator iterator)
{
    if ((! iterator) || (! iterator->cur_field))
        return -1;

    return iterator->cur_field->type;
}


static char* encode_string(char *str)
{
    char *buf, *s;
    int allocated, len;

    if (! str)
        return strdup("''");

    allocated = 20;
    buf = (char*)malloc(allocated);
    if (! buf) return NULL;
    buf[0] = '\'';
    len = 1;
    for (s = str; *s; s++)
    {
        if (len + 2 < allocated - 2)
        {
            char *m = (char*)realloc(buf, allocated += 20);
            if (! m)
            {
                free(buf);
                return NULL;
            }
            buf = m;
        }
        switch (*s)
        {
            case '\n':  buf[len++] = '\\';  buf[len++] = 'n';  break;
            case '\r':  buf[len++] = '\\';  buf[len++] = 'r';  break;
            case '\'':  buf[len++] = '\\';  buf[len++] = '\'';  break;
            case '\\':  buf[len++] = '\\';  buf[len++] = '\\';  break;
            default:
                buf[len++] = *s;
        }
    }
    buf[len++] = '\'';
    buf[len] = 0;
    return buf;
}


static char* print_field(SField *field, int butify, int spaces)
{
    char buf[100];
    
    if (! field) return NULL;
    
    switch (field->type)
    {
        case TYPE_STRING:
            return encode_string(field->value.str_value);
        case TYPE_INT:
            sprintf(buf, "%i", field->value.int_value);
            return strdup(buf);
        case TYPE_FLOAT:
            sprintf(buf, "%g", field->value.double_value);
            if (! strchr(buf, '.'))
                strcat(buf, ".0");
            return strdup(buf);
        case TYPE_TABLE:
            return table_to_str(field->value.table_value, 1, butify, spaces);
    }

    return NULL;
}


static int isSimpleArray(HTable table)
{
    SField *f;
    char buf[50];
    int i;
    
    for (f = table->fields, i = 0; f; f = f->next, i++)
    {
        sprintf(buf, "%i", i);
        if (! (f && f->name && (! strcmp(f->name, buf))))
            return 0;
    }
    return 1;
}


#define APPEND_BUF(buf, s) { int l = strlen(s); \
        if (len + l > allocated - 5) { \
            char *nb; \
            allocated += l + 50; \
            nb = (char*)realloc(buf, allocated); \
            if (! nb) { \
                free(buf); \
                return NULL; \
            } \
            buf = nb; \
        } \
        strcat(buf, s); \
        len += l; \
    }

#define APPEND_SPACES(buf, n) \
        for (int i = 0; i < n; i++) { APPEND_BUF(buf, " "); }

char* table_to_str(HTable table, int print_braces, int butify, int spaces)
{
    char *b, *fs;
    int len=0, allocated;
    SField *f;

    if (! table) return NULL;

    allocated = 100;
    b = (char*)malloc(allocated);
    if (! b) return NULL;

    if (print_braces) {
        if (butify)
            strcpy(b, "{\n");
        else
            strcpy(b, "{ ");
    } else
        strcpy(b, "");
    len = strlen(b);
    int printNames = ! isSimpleArray(table);
    for (f = table->fields; f; f = f->next) {
        if (butify) {
            APPEND_SPACES(b, spaces);
        } else
            if (f != table->fields) {
                APPEND_BUF(b, " ");
            }
        if (printNames) {
            APPEND_BUF(b, f->name);
            APPEND_BUF(b, " = ");
        }
        fs = print_field(f, butify, spaces + 4);
        APPEND_BUF(b, fs);
        free(fs);
        if (butify) {
            APPEND_BUF(b, ";\n");
        } else {
            APPEND_BUF(b, ";");
        }
    }
    if (print_braces) {
        if (! butify) {
            APPEND_BUF(b, " }");
        } else {
            APPEND_SPACES(b, spaces);
            APPEND_BUF(b, "}");
        }
    }
    return b;
}


static char* get_field_str(SField *field, int *err)
{
    char buf[100];
    
    if (err) *err = 0;

    if (! field) 
    {
        if (err) *err = 1;
        return NULL;
    }

    switch (field->type)
    {
        case TYPE_STRING:
            return strdup(field->value.str_value);
        case TYPE_INT:
            sprintf(buf, "%i", field->value.int_value);
            return strdup(buf);
        case TYPE_FLOAT:
            sprintf(buf, "%f", field->value.double_value);
            return strdup(buf);
        case TYPE_TABLE:
            return table_to_str(field->value.table_value, 1, 0, 0);;
    }
    
    if (err) *err = 1;
    return NULL;
}


char* table_iter_get_str(HTableIterator iterator, int *err)
{
    if ((! iterator) || (! iterator->cur_field))
    {
        if (err) *err = 1;
        return NULL;
    }

    return get_field_str(iterator->cur_field, err);
}


char* table_iter_get_strs(HTableIterator iterator, int *err)
{
    if ((! iterator) || (! iterator->cur_field))
    {
        if (err) *err = 1;
        return NULL;
    }

    if (iterator->stat_buf)
        free(iterator->stat_buf);
    iterator->stat_buf = get_field_str(iterator->cur_field, err);
    return iterator->stat_buf;
}


static int get_field_int(SField *field, int *err)
{
    char *endptr;
    int n;

    if (err) *err = 0;

    if (! field) 
    {
        if (err) *err = 1;
        return 0;
    }

    switch (field->type)
    {
        case TYPE_STRING:
            n = strtol(field->value.str_value, &endptr, 10);
            if ((! field->value.str_value[0]) || (endptr[0])) 
            {
                if (err) *err = 1;
                return 0;
            }
            return n;
        case TYPE_INT:
            return field->value.int_value;
        case TYPE_FLOAT:
            return (int)field->value.double_value;
    }
    
    if (err) *err = 1;
    return 0;
}


int table_iter_get_int(HTableIterator iterator, int *err)
{
    if ((! iterator) || (! iterator->cur_field))
    {
        if (err) *err = 1;
        return 0;
    }

    return get_field_int(iterator->cur_field, err);
}


static double get_field_double(SField *field, int *err)
{
    char *endptr;
    double n;

    if (err) *err = 0;

    if (! field) 
    {
        if (err) *err = 1;
        return 0.0;
    }

    switch (field->type)
    {
        case TYPE_STRING:
            n = strtod(field->value.str_value, &endptr);
            if ((! field->value.str_value[0]) || (endptr[0])) 
            {
                if (err) *err = 1;
                return 0.0;
            }
            return n;
        case TYPE_INT:
            return field->value.int_value;
        case TYPE_FLOAT:
            return field->value.double_value;
    }
    
    if (err) *err = 1;
    return 0.0;
}


double table_iter_get_double(HTableIterator iterator, int *err)
{
    if ((! iterator) || (! iterator->cur_field))
    {
        if (err) *err = 1;
        return 0.0;
    }

    return get_field_double(iterator->cur_field, err);
}


HTable table_iter_get_table(HTableIterator iterator, int *err)
{
    if ((! iterator) || (! iterator->cur_field))
    {
        if (err) *err = 1;
        return NULL;
    }

    if (iterator->cur_field->type != TYPE_TABLE)
    {
        if (err) *err = 1;
        return NULL;
    }
    
    if (err) *err = 0;
    return iterator->cur_field->value.table_value;
}


int table_is_field_exists(HTable table, char *name)
{
    SField *f;

    f = find_field(table, name);
    if (f)
        return 1;
    else
        return 0;
}


int table_get_field_type(HTable table, char *field)
{
    SField *f;

    f = find_field(table, field);
    if (! f)
        return -1;
        
    return f->type;
}


char* table_get_str(HTable table, char *field, char *dflt, int *err)
{
    SField *f;
    char *s;
    int e;
    
    f = find_field(table, field);
    if (! f)
    {
        if (err) *err = 1;
        if (dflt)
            return strdup(dflt);
        else
            return NULL;
    }

    s = get_field_str(f, &e);
    if (err) *err = e;
    if (e)
    {
        if (dflt)
            return strdup(dflt);
        else
            return NULL;
    }
    else
    {
        if (s)
            return strdup(s);
        else
            return NULL;
    }
}


char* table_get_strs(HTable table, char *field, char *dflt, int *err)
{
    SField *f;
    char *s;
    int e;

    if (! table)
    {
        if (err) *err = 1;
        return dflt;
    }

    if (table->stat_buf)
    {
        free(table->stat_buf);
        table->stat_buf = NULL;
    }
    
    f = find_field(table, field);
    if (! f)
    {
        if (err) *err = 1;
        return dflt;
    }

    s = get_field_str(f, &e);
    table->stat_buf = s;
    if (err) *err = e;
    if (e)
        s = dflt;
        
    return s;
}


int table_get_int(HTable table, char *field, int dflt, int *err)
{
    SField *f;
    int v, e;
    
    f = find_field(table, field);
    if (! f)
    {
        if (err) *err = 1;
        return dflt;
    }

    v = get_field_int(f, &e);
    if (err) *err = e;
    if (e)
        v = dflt;
        
    return v;
}


double table_get_double(HTable table, char *field, double dflt, int *err)
{
    SField *f;
    double v;
    int e;
    
    f = find_field(table, field);
    if (! f)
    {
        if (err) *err = 1;
        return dflt;
    }

    v = get_field_double(f, &e);
    if (err) *err = e;
    if (e)
        v = dflt;
        
    return v;
}


HTable table_get_table(HTable table, char *field, HTable dflt, int *err)
{
    SField *f;
    HTable v;
    
    f = find_field(table, field);
    if ((! f) || (f->type != TYPE_TABLE))
    {
        if (err) *err = 1;
        return dflt;
    }

    v = f->value.table_value;
    if (err) *err = 0;
        
    return v;
}


int table_append_str(HTable table, const char *val)
{
    int idx;
    char b[100];

    if ((! table) || (! val))
        return -1;

    idx = get_next_index(table);
    sprintf(b, "%i", idx);
    table_set_str(table, b, val);
    return 0;
}


int table_append_int(HTable table, int val)
{
    int idx;
    char b[100];

    if ((! table) || (! val))
        return -1;

    idx = get_next_index(table);
    sprintf(b, "%i", idx);
    table_set_int(table, b, val);
    return 0;
}


int table_append_double(HTable table, double val)
{
    int idx;
    char b[100];

    if ((! table) || (! val))
        return -1;

    idx = get_next_index(table);
    sprintf(b, "%i", idx);
    table_set_double(table, b, val);
    return 0;
}


int table_append_table(HTable table, HTable val)
{
    int idx;
    char b[100];

    if ((! table) || (! val))
        return -1;

    idx = get_next_index(table);
    sprintf(b, "%i", idx);
    table_set_table(table, b, val);
    return 0;
}