util.c

/*-
 * See the file LICENSE for redistribution information.
 *
 * Copyright (c) 2005
 *      Sleepycat Software.  All rights reserved.
 *
 * $Id: util.c,v 1.17 2005/10/14 12:50:37 bostic Exp $
 */

#include "csv.h"
#include "csv_local.h"
#include "csv_extern.h"

/*
 * entry_print --
 *      Display the primary database's data item.
 */
int
entry_print(void *data, size_t len, u_int32_t field_count)
{
        u_int32_t a, *offset;
        u_int i;
        char *raw;

        memcpy(&a, data, sizeof(u_int32_t));
        printf("\tversion: %lu\n", (u_long)a);

        offset = (u_int32_t *)data + 1;
        if (field_count == 0) {
                memcpy(&a, offset++, sizeof(u_int32_t));
                printf("\tcolumn map: %lu fields: {%.*s}\n", (u_long)a,
                    (int)(len - 2 * sizeof(u_int32_t)),
                    (u_int8_t *)data + 2 * sizeof(u_int32_t));
        } else {
                raw = (char *)(offset + (field_count + 1));
                for (i = 0; i < field_count; ++i) {
                        memcpy(&a, &offset[i], sizeof(u_int32_t));
                        len = OFFSET_LEN(offset, i);
                        printf("\toffset %4lu: len %4lu: {%.*s}\n",
                            (u_long)offset[i],
                            (u_long)len, (int)len, raw + a);
                }
        }

        return (0);
}

/*
 * strtod_err --
 *      strtod(3) with error checking.
 */
int
strtod_err(char *input, double *valp)
{
        double val;
        char *end;

        /*
         * strtoul requires setting errno to detect errors.
         */
        errno = 0;
        val = strtod(input, &end);
        if (errno == ERANGE) {
                dbenv->err(dbenv, ERANGE, "%s", input);
                return (1);
        }
        if (input[0] == '\0' ||
            (end[0] != '\0' && end[0] != '\n' && !isspace(end[0]))) {
                dbenv->errx(dbenv,
                    "%s: invalid floating point argument", input);
                return (1);
        }

        *valp = val;
        return (0);
}

/*
 * strtoul_err --
 *      strtoul(3) with error checking.
 */
int
strtoul_err(char *input, u_long *valp)
{
        u_long val;
        char *end;

        /*
         * strtoul requires setting errno to detect errors.
         */
        errno = 0;
        val = strtoul(input, &end, 10);
        if (errno == ERANGE) {
                dbenv->err(dbenv, ERANGE, "%s", input);
                return (1);
        }
        if (input[0] == '\0' ||
            (end[0] != '\0' && end[0] != '\n' && !isspace(end[0]))) {
                dbenv->errx(dbenv, "%s: invalid unsigned long argument", input);
                return (1);
        }

        *valp = val;
        return (0);
}

int
secondary_callback(DB *db_arg, const DBT *key, const DBT *data, DBT *result)
{
        DbField *f;
        DbRecord record;
        void *faddr, *addr;

        /* Populate the field. */
        if (DbRecord_init(key, data, &record) != 0)
                return (-1);

        f = db_arg->app_private;
        faddr = (u_int8_t *)&record + f->offset;

        /*
         * If necessary, copy the field into separate memory.
         * Set up the result DBT.
         */
        switch (f->type) {
        case STRING:
                result->data = *(char **)faddr;
                result->size = strlen(*(char **)faddr) + 1;
                break;
        case DOUBLE:
                if ((addr = malloc(sizeof(double))) == NULL)
                        return (-1);
                result->data = addr;
                result->size = sizeof(double);
                result->flags = DB_DBT_APPMALLOC;
                memcpy(addr, faddr, sizeof(double));
                break;
        case ULONG:
                if ((addr = malloc(sizeof(u_long))) == NULL)
                        return (-1);
                result->data = addr;
                result->size = sizeof(u_long);
                result->flags = DB_DBT_APPMALLOC;
                memcpy(addr, faddr, sizeof(u_long));
                break;
        default:
        case NOTSET:
                abort();
                /* NOTREACHED */
        }

        return (0);
}

/*
 * compare_double --
 *      Compare two keys.
 */
int
compare_double(DB *db_arg, const DBT *a_arg, const DBT *b_arg)
{
        double a, b;

        db_arg = db_arg;                        /* Quiet compiler. */

        memcpy(&a, a_arg->data, sizeof(double));
        memcpy(&b, b_arg->data, sizeof(double));
        return (a > b ? 1 : ((a < b) ? -1 : 0));
}

/*
 * compare_ulong --
 *      Compare two keys.
 */
int
compare_ulong(DB *db_arg, const DBT *a_arg, const DBT *b_arg)
{
        u_long a, b;

        db_arg = db_arg;                        /* Quiet compiler. */

        memcpy(&a, a_arg->data, sizeof(u_long));
        memcpy(&b, b_arg->data, sizeof(u_long));
        return (a > b ? 1 : ((a < b) ? -1 : 0));
}

/*
 * field_cmp_double --
 *      Compare two double.
 */
int
field_cmp_double(void *a, void *b, OPERATOR op)
{
        switch (op) {
        case GT:
                return (*(double *)a > *(double *)b);
        case GTEQ:
                return (*(double *)a >= *(double *)b);
        case LT:
                return (*(double *)a < *(double *)b);
        case LTEQ:
                return (*(double *)a <= *(double *)b);
        case NEQ:
                return (*(double *)a != *(double *)b);
        case EQ:
                return (*(double *)a == *(double *)b);
        case WC:
        case NWC:
                break;
        }

        abort();
        /* NOTREACHED */
}

/*
 * field_cmp_re --
 *      Compare against regular expression.
 */
int
field_cmp_re(void *a, void *b, OPERATOR op)
{
        op = op;                                /* Quiet compiler. */

        switch (op) {
#ifdef HAVE_WILDCARD_SUPPORT
        case WC:
                return (regexec(b, *(char **)a, 0, NULL, 0) == 0);
        case NWC:
                return (regexec(b, *(char **)a, 0, NULL, 0) != 0);
#else
        case WC:
        case NWC:
                a = a;
                b = b;                          /* Quiet compiler. */
                /* FALLTHROUGH */
#endif
        case GT:
        case GTEQ:
        case LT:
        case LTEQ:
        case NEQ:
        case EQ:
                break;
        }

        abort();
        /* NOTREACHED */
}

/*
 * field_cmp_string --
 *      Compare two strings.
 */
int
field_cmp_string(void *a, void *b, OPERATOR op)
{
        int v;

        v = strcasecmp(*(char **)a, b);
        switch (op) {
        case GT:
                return (v > 0 ? 1 : 0);
        case GTEQ:
                return (v >= 0 ? 1 : 0);
        case LT:
                return (v < 0 ? 1 : 0);
        case LTEQ:
                return (v <= 0 ? 1 : 0);
        case NEQ:
                return (v ? 1 : 0);
        case EQ:
                return (v ? 0 : 1);
        case WC:
        case NWC:
                break;
        }

        abort();
        /* NOTREACHED */
}

/*
 * field_cmp_ulong --
 *      Compare two ulongs.
 */
int
field_cmp_ulong(void *a, void *b, OPERATOR op)
{
        switch (op) {
        case GT:
                return (*(u_long *)a > *(u_long *)b);
        case GTEQ:
                return (*(u_long *)a >= *(u_long *)b);
        case LT:
                return (*(u_long *)a < *(u_long *)b);
        case LTEQ:
                return (*(u_long *)a <= *(u_long *)b);
        case NEQ:
                return (*(u_long *)a != *(u_long *)b);
        case EQ:
                return (*(u_long *)a == *(u_long *)b);
        case WC:
        case NWC:
                break;
        }

        abort();
        /* NOTREACHED */
}

---