ks_bparse.c

Go to the documentation of this file.

/*
 * libkarmaclient - A C Library to the Karmasphere Reputation Server
 * Copyright (C) 2006 Karmasphere <http://www.karmasphere.com/>
 *  - Shevek <shevek@karmasphere.com>
 *  - Dave Stewart <dave.stewart@karmasphere.com>
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307  USA
 */

#include "ks_config.h"
#include "ks_bparse.h"
#include "ks_assoc.h"
#include "ks_array.h"
#include "ks_string.h"
#include "ks_number.h"

#ifdef HAVE_STDLIB_H
#include <stdlib.h>
#endif

#ifdef HAVE_CTYPE_H
#include <ctype.h>
#endif

#ifdef HAVE_STDIO_H
#include <stdio.h>
#endif

static long
ks_strtol(const char **datap, const char *endp, char stop)
{
        const char      *cp = *datap;
        long             value = 0;
        char             invert = 0;

        if (cp < endp && *cp == '-') {
                cp++;
                invert = 1;
        }

        while (cp < endp) {
                char    c = *cp++;
                if (c == stop)
                        break;
                if (!isdigit(c)) {
                        /* XXX Report error. */
                        ks_error("Invalid character %c in number %8.8s",
                                                        c, *datap);
                        break;
                }
                /* XXX Can this be done in a portable way? */
                value = (value * 10) + (c - '0');
        }
        *datap = cp;

        if (invert)
                value = 0 - value;

        return value;
}

/* XXX This is a slightly generous parser.
 *
 * The following invalid cases are accepted:
 * "ie" is an integer value 0.
 *
 * The following cases will cause a crash:
 * "dieiee" is a dictionary with a nonstring key
 */
static ks_base_t *
ks_bparse_recursive(const char **datap, const char *endp)
{
        ks_array_t      *a;
        ks_assoc_t      *s;
        ks_string_t     *r;
        ks_base_t       *b;
        const char      *k;
        const char      *cp = *datap;
        long             l;

        if (cp == endp)
                return NULL;
        switch (*cp++) {
                case '0': case '1': case '2': case '3': case '4':
                case '5': case '6': case '7': case '8': case '9':
                        cp--;   /* Digit not consumed. */
                        l = ks_strtol(&cp, endp, ':');
                        if (cp + l > endp) {
                                ks_error("String length %ld longer than "
                                                "data length %d", l, endp - cp);
                                return NULL;
                        }
                        r = ks_string_new(cp, l);
                        *datap = cp + l;
                        return (ks_base_t *)r;
                case 'i':
                        l = ks_strtol(&cp, endp, 'e');
                        *datap = cp;
                        return (ks_base_t *)ks_number_new(l);
                case 'l':
                        a = ks_array_new();
                        *datap = cp;
                        while (**datap != 'e') {
                                b = ks_bparse_recursive(datap, endp);
                                if (b == NULL) {
                                        ks_array_free(a);
                                        return NULL;
                                }
                                ks_array_add(a, b);
                        }
                        (*datap)++;
                        return (ks_base_t *)a;
                case 'd':
                        s = ks_assoc_new();
                        *datap = cp;
                        while (**datap != 'e') {
                                if (!isdigit(**datap)) {
                                        /* XXX Not a string. Report error. */
                                        ks_error("Key %8.8s not a string", *datap);
                                        ks_assoc_free(s);
                                        return NULL;
                                }
                                /* Get the key and length. */
                                l = ks_strtol(datap, endp, ':');
                                k = *datap;
                                *datap += l;

                                b = ks_bparse_recursive(datap, endp);
                                if (b == NULL) {
                                        ks_assoc_free(s);
                                        return NULL;
                                }

                                ks_assoc_put(s, k, l, b);
                        }
                        (*datap)++;
                        return (ks_base_t *)s;
                case 'e':
                        /* This can only be an error.
                         * Note that this differs structurally from the Java
                         * version. In this version, ANY NULL return is an
                         * error, and means clean up and return NULL. */
                        /*
                        *datap = cp;
                        return NULL;
                        */
                default:
                        /* XXX Report error. */
                        ks_error("Value %8.8s not valid", *datap);
                        break;
        }

        return NULL;
}

ks_base_t *
ks_bparse(const char *data, int len)
{
        const char      *endp = data + len;
        return ks_bparse_recursive(&data, endp);
}

---