SUBDIR=	jansson \

	sqlite

Copyright (c) 2009, 2010 Petri Lehtinen <petri@digip.org>

Permission is hereby granted, free of charge, to any person obtaining a copy

of this software and associated documentation files (the "Software"), to deal

in the Software without restriction, including without limitation the rights

to use, copy, modify, merge, publish, distribute, sublicense, and/or sell

copies of the Software, and to permit persons to whom the Software is

furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in

all copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR

IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,

FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE

AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER

LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,

OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN

THE SOFTWARE.

LIB=		jansson

INTERNALLIB=

SRCS=		dump.c \

		hashtable.c \

		load.c \

		strbuffer.c \

		utf.c \

		value.c

CFLAGS+=	-fPIC -I.

WARNS=		2

WFORMAT=	1

NO_MAN=		true

.include <bsd.lib.mk>

/* config.h.  Generated from config.h.in by configure.  */

/* config.h.in.  Generated from configure.ac by autoheader.  */

/* Define to 1 if you have the <dlfcn.h> header file. */

#define HAVE_DLFCN_H 1

/* Define to 1 if you have the <inttypes.h> header file. */

#define HAVE_INTTYPES_H 1

/* Define to 1 if you have the <memory.h> header file. */

#define HAVE_MEMORY_H 1

/* Define to 1 if you have the <stdint.h> header file. */

#define HAVE_STDINT_H 1

/* Define to 1 if you have the <stdlib.h> header file. */

#define HAVE_STDLIB_H 1

/* Define to 1 if you have the <strings.h> header file. */

#define HAVE_STRINGS_H 1

/* Define to 1 if you have the <string.h> header file. */

#define HAVE_STRING_H 1

/* Define to 1 if you have the <sys/stat.h> header file. */

#define HAVE_SYS_STAT_H 1

/* Define to 1 if you have the <sys/types.h> header file. */

#define HAVE_SYS_TYPES_H 1

/* Define to 1 if you have the <unistd.h> header file. */

#define HAVE_UNISTD_H 1

/* Define to the sub-directory in which libtool stores uninstalled libraries.

   */

#define LT_OBJDIR ".libs/"

/* Name of package */

#define PACKAGE "jansson"

/* Define to the address where bug reports for this package should be sent. */

#define PACKAGE_BUGREPORT "petri@digip.org"

/* Define to the full name of this package. */

#define PACKAGE_NAME "jansson"

/* Define to the full name and version of this package. */

#define PACKAGE_STRING "jansson 1.3"

/* Define to the one symbol short name of this package. */

#define PACKAGE_TARNAME "jansson"

/* Define to the home page for this package. */

#define PACKAGE_URL ""

/* Define to the version of this package. */

#define PACKAGE_VERSION "1.3"

/* Define to 1 if you have the ANSI C header files. */

#define STDC_HEADERS 1

/* Version number of package */

#define VERSION "1.3"

/* Define to `__inline__' or `__inline' if that's what the C compiler

   calls it, or to nothing if 'inline' is not supported under any name.  */

#ifndef __cplusplus

/* #undef inline */

#endif

/* Define to the type of a signed integer type of width exactly 32 bits if

   such a type exists and the standard includes do not define it. */

/* #undef int32_t */

/*

 * Copyright (c) 2009, 2010 Petri Lehtinen <petri@digip.org>

 *

 * Jansson is free software; you can redistribute it and/or modify

 * it under the terms of the MIT license. See LICENSE for details.

 */

#define _GNU_SOURCE

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

#include <assert.h>

#include <jansson.h>

#include "jansson_private.h"

#include "strbuffer.h"

#include "utf.h"

#define MAX_INTEGER_STR_LENGTH  100

#define MAX_REAL_STR_LENGTH     100

typedef int (*dump_func)(const char *buffer, int size, void *data);

struct string

{

    char *buffer;

    int length;

    int size;

};

static int dump_to_strbuffer(const char *buffer, int size, void *data)

{

    return strbuffer_append_bytes((strbuffer_t *)data, buffer, size);

}

static int dump_to_file(const char *buffer, int size, void *data)

{

    FILE *dest = (FILE *)data;

    if(fwrite(buffer, size, 1, dest) != 1)

        return -1;

    return 0;

}

/* 256 spaces (the maximum indentation size) */

static char whitespace[] = "                                                                                                                                                                                                                                                                ";

static int dump_indent(unsigned long flags, int depth, int space, dump_func dump, void *data)

{

    if(JSON_INDENT(flags) > 0)

    {

        int i, ws_count = JSON_INDENT(flags);

        if(dump("\n", 1, data))

            return -1;

        for(i = 0; i < depth; i++)

        {

            if(dump(whitespace, ws_count, data))

                return -1;

        }

    }

    else if(space && !(flags & JSON_COMPACT))

    {

        return dump(" ", 1, data);

    }

    return 0;

}

static int dump_string(const char *str, int ascii, dump_func dump, void *data)

{

    const char *pos, *end;

    int32_t codepoint;

    if(dump("\"", 1, data))

        return -1;

    end = pos = str;

    while(1)

    {

        const char *text;

        char seq[13];

        int length;

        while(*end)

        {

            end = utf8_iterate(pos, &codepoint);

            if(!end)

                return -1;

            /* mandatory escape or control char */

            if(codepoint == '\\' || codepoint == '"' || codepoint < 0x20)

                break;

            /* non-ASCII */

            if(ascii && codepoint > 0x7F)

                break;

            pos = end;

        }

        if(pos != str) {

            if(dump(str, pos - str, data))

                return -1;

        }

        if(end == pos)

            break;

        /* handle \, ", and control codes */

        length = 2;

        switch(codepoint)

        {

            case '\\': text = "\\\\"; break;

            case '\"': text = "\\\""; break;

            case '\b': text = "\\b"; break;

            case '\f': text = "\\f"; break;

            case '\n': text = "\\n"; break;

            case '\r': text = "\\r"; break;

            case '\t': text = "\\t"; break;

            default:

            {

                /* codepoint is in BMP */

                if(codepoint < 0x10000)

                {

                    sprintf(seq, "\\u%04x", codepoint);

                    length = 6;

                }

                /* not in BMP -> construct a UTF-16 surrogate pair */

                else

                {

                    int32_t first, last;

                    codepoint -= 0x10000;

                    first = 0xD800 | ((codepoint & 0xffc00) >> 10);

                    last = 0xDC00 | (codepoint & 0x003ff);

                    sprintf(seq, "\\u%04x\\u%04x", first, last);

                    length = 12;

                }

                text = seq;

                break;

            }

        }

        if(dump(text, length, data))

            return -1;

        str = pos = end;

    }

    return dump("\"", 1, data);

}

static int object_key_compare_keys(const void *key1, const void *key2)

{

    return strcmp((*(const object_key_t **)key1)->key,

                  (*(const object_key_t **)key2)->key);

}

static int object_key_compare_serials(const void *key1, const void *key2)

{

    return (*(const object_key_t **)key1)->serial -

           (*(const object_key_t **)key2)->serial;

}

static int do_dump(const json_t *json, unsigned long flags, int depth,

                   dump_func dump, void *data)

{

    int ascii = flags & JSON_ENSURE_ASCII ? 1 : 0;

    switch(json_typeof(json)) {

        case JSON_NULL:

            return dump("null", 4, data);

        case JSON_TRUE:

            return dump("true", 4, data);

        case JSON_FALSE:

            return dump("false", 5, data);

        case JSON_INTEGER:

        {

            char buffer[MAX_INTEGER_STR_LENGTH];

            int size;

            size = snprintf(buffer, MAX_INTEGER_STR_LENGTH, "%d", json_integer_value(json));

            if(size >= MAX_INTEGER_STR_LENGTH)

                return -1;

            return dump(buffer, size, data);

        }

        case JSON_REAL:

        {

            char buffer[MAX_REAL_STR_LENGTH];

            int size;

            size = snprintf(buffer, MAX_REAL_STR_LENGTH, "%.17g",

                            json_real_value(json));

            if(size >= MAX_REAL_STR_LENGTH)

                return -1;

            /* Make sure there's a dot or 'e' in the output. Otherwise

               a real is converted to an integer when decoding */

            if(strchr(buffer, '.') == NULL &&

               strchr(buffer, 'e') == NULL)

            {

                if(size + 2 >= MAX_REAL_STR_LENGTH) {

                    /* No space to append ".0" */

                    return -1;

                }

                buffer[size] = '.';

                buffer[size + 1] = '0';

                size += 2;

            }

            return dump(buffer, size, data);

        }

        case JSON_STRING:

            return dump_string(json_string_value(json), ascii, dump, data);

        case JSON_ARRAY:

        {

            int i;

            int n;

            json_array_t *array;

            /* detect circular references */

            array = json_to_array(json);

            if(array->visited)

                goto array_error;

            array->visited = 1;

            n = json_array_size(json);

            if(dump("[", 1, data))

                goto array_error;

            if(n == 0) {

                array->visited = 0;

                return dump("]", 1, data);

            }

            if(dump_indent(flags, depth + 1, 0, dump, data))

                goto array_error;

            for(i = 0; i < n; ++i) {

                if(do_dump(json_array_get(json, i), flags, depth + 1,

                           dump, data))

                    goto array_error;

                if(i < n - 1)

                {

                    if(dump(",", 1, data) ||

                       dump_indent(flags, depth + 1, 1, dump, data))

                        goto array_error;

                }

                else

                {

                    if(dump_indent(flags, depth, 0, dump, data))

                        goto array_error;

                }

            }

            array->visited = 0;

            return dump("]", 1, data);

        array_error:

            array->visited = 0;

            return -1;

        }

        case JSON_OBJECT:

        {

            json_object_t *object;

            void *iter;

            const char *separator;

            int separator_length;

            if(flags & JSON_COMPACT) {

                separator = ":";

                separator_length = 1;

            }

            else {

                separator = ": ";

                separator_length = 2;

            }

            /* detect circular references */

            object = json_to_object(json);

            if(object->visited)

                goto object_error;

            object->visited = 1;

            iter = json_object_iter((json_t *)json);

            if(dump("{", 1, data))

                goto object_error;

            if(!iter) {

                object->visited = 0;

                return dump("}", 1, data);

            }

            if(dump_indent(flags, depth + 1, 0, dump, data))

                goto object_error;

            if(flags & JSON_SORT_KEYS || flags & JSON_PRESERVE_ORDER)

            {

                const object_key_t **keys;

                unsigned int size;

                unsigned int i;

                int (*cmp_func)(const void *, const void *);

                size = json_object_size(json);

                keys = malloc(size * sizeof(object_key_t *));

                if(!keys)

                    goto object_error;

                i = 0;

                while(iter)

                {

                    keys[i] = jsonp_object_iter_fullkey(iter);

                    iter = json_object_iter_next((json_t *)json, iter);

                    i++;

                }

                assert(i == size);

                if(flags & JSON_SORT_KEYS)

                    cmp_func = object_key_compare_keys;

                else

                    cmp_func = object_key_compare_serials;

                qsort(keys, size, sizeof(object_key_t *), cmp_func);

                for(i = 0; i < size; i++)

                {

                    const char *key;

                    json_t *value;

                    key = keys[i]->key;

                    value = json_object_get(json, key);

                    assert(value);

                    dump_string(key, ascii, dump, data);

                    if(dump(separator, separator_length, data) ||

                       do_dump(value, flags, depth + 1, dump, data))

                    {

                        free(keys);

                        goto object_error;

                    }

                    if(i < size - 1)

                    {

                        if(dump(",", 1, data) ||

                           dump_indent(flags, depth + 1, 1, dump, data))

                        {

                            free(keys);

                            goto object_error;

                        }

                    }

                    else

                    {

                        if(dump_indent(flags, depth, 0, dump, data))

                        {

                            free(keys);

                            goto object_error;

                        }

                    }

                }

                free(keys);

            }

            else

            {

                /* Don't sort keys */

                while(iter)

                {

                    void *next = json_object_iter_next((json_t *)json, iter);

                    dump_string(json_object_iter_key(iter), ascii, dump, data);

                    if(dump(separator, separator_length, data) ||

                       do_dump(json_object_iter_value(iter), flags, depth + 1,

                               dump, data))

                        goto object_error;

                    if(next)

                    {

                        if(dump(",", 1, data) ||

                           dump_indent(flags, depth + 1, 1, dump, data))

                            goto object_error;

                    }

                    else

                    {

                        if(dump_indent(flags, depth, 0, dump, data))

                            goto object_error;

                    }

                    iter = next;

                }

            }

            object->visited = 0;

            return dump("}", 1, data);

        object_error:

            object->visited = 0;

            return -1;

        }

        default:

            /* not reached */

            return -1;

    }

}

char *json_dumps(const json_t *json, unsigned long flags)

{

    strbuffer_t strbuff;

    char *result;

    if(!json_is_array(json) && !json_is_object(json))

        return NULL;

    if(strbuffer_init(&strbuff))

        return NULL;

    if(do_dump(json, flags, 0, dump_to_strbuffer, (void *)&strbuff)) {

        strbuffer_close(&strbuff);

        return NULL;

    }

    result = strdup(strbuffer_value(&strbuff));

    strbuffer_close(&strbuff);

    return result;

}

int json_dumpf(const json_t *json, FILE *output, unsigned long flags)

{

    if(!json_is_array(json) && !json_is_object(json))

        return -1;

    return do_dump(json, flags, 0, dump_to_file, (void *)output);

}

int json_dump_file(const json_t *json, const char *path, unsigned long flags)

{

    int result;

    FILE *output = fopen(path, "w");

    if(!output)

        return -1;

    result = json_dumpf(json, output, flags);

    fclose(output);

    return result;

}

/*

 * Copyright (c) 2009, 2010 Petri Lehtinen <petri@digip.org>

 *

 * This library is free software; you can redistribute it and/or modify

 * it under the terms of the MIT license. See LICENSE for details.

 */

#include <config.h>

#include <stdlib.h>

#include "hashtable.h"

typedef struct hashtable_list list_t;

typedef struct hashtable_pair pair_t;

typedef struct hashtable_bucket bucket_t;

#define container_of(ptr_, type_, member_)                      \

    ((type_ *)((char *)ptr_ - (size_t)&((type_ *)0)->member_))

#define list_to_pair(list_)  container_of(list_, pair_t, list)

static inline void list_init(list_t *list)

{

    list->next = list;

    list->prev = list;

}

static inline void list_insert(list_t *list, list_t *node)

{

    node->next = list;

    node->prev = list->prev;

    list->prev->next = node;

    list->prev = node;

}

static inline void list_remove(list_t *list)

{

    list->prev->next = list->next;

    list->next->prev = list->prev;

}

static inline int bucket_is_empty(hashtable_t *hashtable, bucket_t *bucket)

{

    return bucket->first == &hashtable->list && bucket->first == bucket->last;

}

static void insert_to_bucket(hashtable_t *hashtable, bucket_t *bucket,

                             list_t *list)

{

    if(bucket_is_empty(hashtable, bucket))

    {

        list_insert(&hashtable->list, list);

        bucket->first = bucket->last = list;

    }

    else

    {

        list_insert(bucket->first, list);

        bucket->first = list;

    }

}

static unsigned int primes[] = {

    5, 13, 23, 53, 97, 193, 389, 769, 1543, 3079, 6151, 12289, 24593,

    49157, 98317, 196613, 393241, 786433, 1572869, 3145739, 6291469,

    12582917, 25165843, 50331653, 100663319, 201326611, 402653189,

    805306457, 1610612741

};

static const unsigned int num_primes = sizeof(primes) / sizeof(unsigned int);

static inline unsigned int num_buckets(hashtable_t *hashtable)

{

    return primes[hashtable->num_buckets];

}

static pair_t *hashtable_find_pair(hashtable_t *hashtable, bucket_t *bucket,

                                   const void *key, unsigned int hash)

{

    list_t *list;

    pair_t *pair;

    if(bucket_is_empty(hashtable, bucket))

        return NULL;

    list = bucket->first;

    while(1)

    {

        pair = list_to_pair(list);

        if(pair->hash == hash && hashtable->cmp_keys(pair->key, key))

            return pair;

        if(list == bucket->last)

            break;

        list = list->next;

    }

    return NULL;

}

/* returns 0 on success, -1 if key was not found */

static int hashtable_do_del(hashtable_t *hashtable,

                            const void *key, unsigned int hash)

{

    pair_t *pair;

    bucket_t *bucket;

    unsigned int index;

    index = hash % num_buckets(hashtable);

    bucket = &hashtable->buckets[index];

    pair = hashtable_find_pair(hashtable, bucket, key, hash);

    if(!pair)

        return -1;

    if(&pair->list == bucket->first && &pair->list == bucket->last)

        bucket->first = bucket->last = &hashtable->list;

    else if(&pair->list == bucket->first)

        bucket->first = pair->list.next;

    else if(&pair->list == bucket->last)

        bucket->last = pair->list.prev;

    list_remove(&pair->list);

    if(hashtable->free_key)

        hashtable->free_key(pair->key);

    if(hashtable->free_value)

        hashtable->free_value(pair->value);

    free(pair);

    hashtable->size--;

    return 0;

}

static void hashtable_do_clear(hashtable_t *hashtable)

{

    list_t *list, *next;

    pair_t *pair;

    for(list = hashtable->list.next; list != &hashtable->list; list = next)

    {

        next = list->next;

        pair = list_to_pair(list);

        if(hashtable->free_key)

            hashtable->free_key(pair->key);

        if(hashtable->free_value)

            hashtable->free_value(pair->value);

        free(pair);

    }

}

static int hashtable_do_rehash(hashtable_t *hashtable)

{

    list_t *list, *next;

    pair_t *pair;

    unsigned int i, index, new_size;

    free(hashtable->buckets);

    hashtable->num_buckets++;

    new_size = num_buckets(hashtable);

    hashtable->buckets = malloc(new_size * sizeof(bucket_t));

    if(!hashtable->buckets)

        return -1;

    for(i = 0; i < num_buckets(hashtable); i++)

    {

        hashtable->buckets[i].first = hashtable->buckets[i].last =

            &hashtable->list;

    }

    list = hashtable->list.next;

    list_init(&hashtable->list);

    for(; list != &hashtable->list; list = next) {

        next = list->next;

        pair = list_to_pair(list);

        index = pair->hash % new_size;

        insert_to_bucket(hashtable, &hashtable->buckets[index], &pair->list);

    }

    return 0;

}

hashtable_t *hashtable_create(key_hash_fn hash_key, key_cmp_fn cmp_keys,

                              free_fn free_key, free_fn free_value)

{

    hashtable_t *hashtable = malloc(sizeof(hashtable_t));

    if(!hashtable)

        return NULL;

    if(hashtable_init(hashtable, hash_key, cmp_keys, free_key, free_value))

    {

        free(hashtable);

        return NULL;

    }

    return hashtable;

}

void hashtable_destroy(hashtable_t *hashtable)

{

    hashtable_close(hashtable);

    free(hashtable);

}

int hashtable_init(hashtable_t *hashtable,

                   key_hash_fn hash_key, key_cmp_fn cmp_keys,

                   free_fn free_key, free_fn free_value)

{

    unsigned int i;

    hashtable->size = 0;

    hashtable->num_buckets = 0;  /* index to primes[] */

    hashtable->buckets = malloc(num_buckets(hashtable) * sizeof(bucket_t));

    if(!hashtable->buckets)

        return -1;

    list_init(&hashtable->list);

    hashtable->hash_key = hash_key;

    hashtable->cmp_keys = cmp_keys;

    hashtable->free_key = free_key;

    hashtable->free_value = free_value;

    for(i = 0; i < num_buckets(hashtable); i++)

    {

        hashtable->buckets[i].first = hashtable->buckets[i].last =

            &hashtable->list;

    }

    return 0;

}

void hashtable_close(hashtable_t *hashtable)

{

    hashtable_do_clear(hashtable);

    free(hashtable->buckets);

}

int hashtable_set(hashtable_t *hashtable, void *key, void *value)

{

    pair_t *pair;

    bucket_t *bucket;

    unsigned int hash, index;

    /* rehash if the load ratio exceeds 1 */

    if(hashtable->size >= num_buckets(hashtable))

        if(hashtable_do_rehash(hashtable))

            return -1;

    hash = hashtable->hash_key(key);

    index = hash % num_buckets(hashtable);

    bucket = &hashtable->buckets[index];

    pair = hashtable_find_pair(hashtable, bucket, key, hash);

    if(pair)

    {

        if(hashtable->free_key)

            hashtable->free_key(key);

        if(hashtable->free_value)

            hashtable->free_value(pair->value);

        pair->value = value;

    }

    else

    {

        pair = malloc(sizeof(pair_t));

        if(!pair)

            return -1;

        pair->key = key;

        pair->value = value;

        pair->hash = hash;

        list_init(&pair->list);

        insert_to_bucket(hashtable, bucket, &pair->list);

        hashtable->size++;

    }

    return 0;

}

void *hashtable_get(hashtable_t *hashtable, const void *key)

{

    pair_t *pair;

    unsigned int hash;

    bucket_t *bucket;

    hash = hashtable->hash_key(key);

    bucket = &hashtable->buckets[hash % num_buckets(hashtable)];

    pair = hashtable_find_pair(hashtable, bucket, key, hash);

    if(!pair)

        return NULL;

    return pair->value;

}

int hashtable_del(hashtable_t *hashtable, const void *key)

{

    unsigned int hash = hashtable->hash_key(key);

    return hashtable_do_del(hashtable, key, hash);

}

void hashtable_clear(hashtable_t *hashtable)

{

    unsigned int i;

    hashtable_do_clear(hashtable);

    for(i = 0; i < num_buckets(hashtable); i++)

    {

        hashtable->buckets[i].first = hashtable->buckets[i].last =

            &hashtable->list;

    }

    list_init(&hashtable->list);

    hashtable->size = 0;

}

void *hashtable_iter(hashtable_t *hashtable)

{

    return hashtable_iter_next(hashtable, &hashtable->list);

}

void *hashtable_iter_at(hashtable_t *hashtable, const void *key)

{

    pair_t *pair;

    unsigned int hash;

    bucket_t *bucket;

    hash = hashtable->hash_key(key);

    bucket = &hashtable->buckets[hash % num_buckets(hashtable)];

    pair = hashtable_find_pair(hashtable, bucket, key, hash);

    if(!pair)

        return NULL;

    return &pair->list;

}

void *hashtable_iter_next(hashtable_t *hashtable, void *iter)

{

    list_t *list = (list_t *)iter;

    if(list->next == &hashtable->list)

        return NULL;

    return list->next;

}

void *hashtable_iter_key(void *iter)

{

    pair_t *pair = list_to_pair((list_t *)iter);

    return pair->key;

}

void *hashtable_iter_value(void *iter)

{

    pair_t *pair = list_to_pair((list_t *)iter);

    return pair->value;

}

void hashtable_iter_set(hashtable_t *hashtable, void *iter, void *value)

{

    pair_t *pair = list_to_pair((list_t *)iter);

    if(hashtable->free_value)

        hashtable->free_value(pair->value);

    pair->value = value;

}

/*

 * Copyright (c) 2009, 2010 Petri Lehtinen <petri@digip.org>

 *

 * This library is free software; you can redistribute it and/or modify

 * it under the terms of the MIT license. See LICENSE for details.

 */

#ifndef HASHTABLE_H

#define HASHTABLE_H

typedef unsigned int (*key_hash_fn)(const void *key);

typedef int (*key_cmp_fn)(const void *key1, const void *key2);

typedef void (*free_fn)(void *key);

struct hashtable_list {

    struct hashtable_list *prev;

    struct hashtable_list *next;

};

struct hashtable_pair {

    void *key;

    void *value;

    unsigned int hash;

    struct hashtable_list list;

};

struct hashtable_bucket {

    struct hashtable_list *first;

    struct hashtable_list *last;

};

typedef struct hashtable {

    unsigned int size;

    struct hashtable_bucket *buckets;

    unsigned int num_buckets;  /* index to primes[] */

    struct hashtable_list list;

    key_hash_fn hash_key;

    key_cmp_fn cmp_keys;  /* returns non-zero for equal keys */

    free_fn free_key;

    free_fn free_value;

} hashtable_t;

/**

 * hashtable_create - Create a hashtable object

 *

 * @hash_key: The key hashing function

 * @cmp_keys: The key compare function. Returns non-zero for equal and

 *     zero for unequal unequal keys

 * @free_key: If non-NULL, called for a key that is no longer referenced.

 * @free_value: If non-NULL, called for a value that is no longer referenced.

 *

 * Returns a new hashtable object that should be freed with

 * hashtable_destroy when it's no longer used, or NULL on failure (out

 * of memory).

 */

hashtable_t *hashtable_create(key_hash_fn hash_key, key_cmp_fn cmp_keys,

                              free_fn free_key, free_fn free_value);

/**

 * hashtable_destroy - Destroy a hashtable object

 *

 * @hashtable: The hashtable

 *

 * Destroys a hashtable created with hashtable_create().

 */

void hashtable_destroy(hashtable_t *hashtable);

/**

 * hashtable_init - Initialize a hashtable object

 *

 * @hashtable: The (statically allocated) hashtable object

 * @hash_key: The key hashing function

 * @cmp_keys: The key compare function. Returns non-zero for equal and

 *     zero for unequal unequal keys

 * @free_key: If non-NULL, called for a key that is no longer referenced.

 * @free_value: If non-NULL, called for a value that is no longer referenced.

 *

 * Initializes a statically allocated hashtable object. The object

 * should be cleared with hashtable_close when it's no longer used.

 *

 * Returns 0 on success, -1 on error (out of memory).

 */

int hashtable_init(hashtable_t *hashtable,

                   key_hash_fn hash_key, key_cmp_fn cmp_keys,

                   free_fn free_key, free_fn free_value);

/**

 * hashtable_close - Release all resources used by a hashtable object

 *

 * @hashtable: The hashtable

 *

 * Destroys a statically allocated hashtable object.

 */

void hashtable_close(hashtable_t *hashtable);

/**

 * hashtable_set - Add/modify value in hashtable

 *

 * @hashtable: The hashtable object

 * @key: The key

 * @value: The value

 *

 * If a value with the given key already exists, its value is replaced

 * with the new value.

 *

 * Key and value are "stealed" in the sense that hashtable frees them

 * automatically when they are no longer used. The freeing is

 * accomplished by calling free_key and free_value functions that were

 * supplied to hashtable_new. In case one or both of the free

 * functions is NULL, the corresponding item is not "stealed".

 *

 * Returns 0 on success, -1 on failure (out of memory).

 */

int hashtable_set(hashtable_t *hashtable, void *key, void *value);

/**

 * hashtable_get - Get a value associated with a key

 *

 * @hashtable: The hashtable object

 * @key: The key

 *

 * Returns value if it is found, or NULL otherwise.

 */

void *hashtable_get(hashtable_t *hashtable, const void *key);

/**

 * hashtable_del - Remove a value from the hashtable

 *

 * @hashtable: The hashtable object

 * @key: The key

 *

 * Returns 0 on success, or -1 if the key was not found.

 */

int hashtable_del(hashtable_t *hashtable, const void *key);

/**

 * hashtable_clear - Clear hashtable

 *

 * @hashtable: The hashtable object

 *

 * Removes all items from the hashtable.

 */

void hashtable_clear(hashtable_t *hashtable);

/**

 * hashtable_iter - Iterate over hashtable

 *

 * @hashtable: The hashtable object

 *

 * Returns an opaque iterator to the first element in the hashtable.

 * The iterator should be passed to hashtable_iter_* functions.

 * The hashtable items are not iterated over in any particular order.

 *

 * There's no need to free the iterator in any way. The iterator is

 * valid as long as the item that is referenced by the iterator is not

 * deleted. Other values may be added or deleted. In particular,

 * hashtable_iter_next() may be called on an iterator, and after that

 * the key/value pair pointed by the old iterator may be deleted.

 */

void *hashtable_iter(hashtable_t *hashtable);

/**

 * hashtable_iter_at - Return an iterator at a specific key

 *

 * @hashtable: The hashtable object

 * @key: The key that the iterator should point to

 *

 * Like hashtable_iter() but returns an iterator pointing to a

 * specific key.

 */

void *hashtable_iter_at(hashtable_t *hashtable, const void *key);

/**

 * hashtable_iter_next - Advance an iterator

 *

 * @hashtable: The hashtable object

 * @iter: The iterator

 *

 * Returns a new iterator pointing to the next element in the

 * hashtable or NULL if the whole hastable has been iterated over.

 */

void *hashtable_iter_next(hashtable_t *hashtable, void *iter);

/**

 * hashtable_iter_key - Retrieve the key pointed by an iterator

 *

 * @iter: The iterator

 */

void *hashtable_iter_key(void *iter);

/**

 * hashtable_iter_value - Retrieve the value pointed by an iterator

 *

 * @iter: The iterator

 */

void *hashtable_iter_value(void *iter);

/**

 * hashtable_iter_set - Set the value pointed by an iterator

 *

 * @iter: The iterator

 * @value: The value to set

 */

void hashtable_iter_set(hashtable_t *hashtable, void *iter, void *value);

#endif

/*

 * Copyright (c) 2009, 2010 Petri Lehtinen <petri@digip.org>

 *

 * Jansson is free software; you can redistribute it and/or modify

 * it under the terms of the MIT license. See LICENSE for details.

 */

#ifndef JANSSON_H

#define JANSSON_H

#include <stdio.h>

#ifndef __cplusplus

#define JSON_INLINE inline

#else

#define JSON_INLINE inline

extern "C" {

#endif

/* types */

typedef enum {

    JSON_OBJECT,

    JSON_ARRAY,

    JSON_STRING,

    JSON_INTEGER,

    JSON_REAL,

    JSON_TRUE,

    JSON_FALSE,

    JSON_NULL

} json_type;

typedef struct {

    json_type type;

    unsigned long refcount;

} json_t;

#define json_typeof(json)      ((json)->type)

#define json_is_object(json)   (json && json_typeof(json) == JSON_OBJECT)

#define json_is_array(json)    (json && json_typeof(json) == JSON_ARRAY)

#define json_is_string(json)   (json && json_typeof(json) == JSON_STRING)

#define json_is_integer(json)  (json && json_typeof(json) == JSON_INTEGER)

#define json_is_real(json)     (json && json_typeof(json) == JSON_REAL)

#define json_is_number(json)   (json_is_integer(json) || json_is_real(json))

#define json_is_true(json)     (json && json_typeof(json) == JSON_TRUE)

#define json_is_false(json)    (json && json_typeof(json) == JSON_FALSE)

#define json_is_boolean(json)  (json_is_true(json) || json_is_false(json))

#define json_is_null(json)     (json && json_typeof(json) == JSON_NULL)

/* construction, destruction, reference counting */

json_t *json_object(void);

json_t *json_array(void);

json_t *json_string(const char *value);

json_t *json_string_nocheck(const char *value);

json_t *json_integer(int value);

json_t *json_real(double value);

json_t *json_true(void);

json_t *json_false(void);

json_t *json_null(void);

static JSON_INLINE

json_t *json_incref(json_t *json)

{

    if(json && json->refcount != (unsigned int)-1)

        ++json->refcount;

    return json;

}

/* do not call json_delete directly */

void json_delete(json_t *json);

static JSON_INLINE

void json_decref(json_t *json)

{

    if(json && json->refcount != (unsigned int)-1 && --json->refcount == 0)

        json_delete(json);

}

/* getters, setters, manipulation */

unsigned int json_object_size(const json_t *object);

json_t *json_object_get(const json_t *object, const char *key);

int json_object_set_new(json_t *object, const char *key, json_t *value);

int json_object_set_new_nocheck(json_t *object, const char *key, json_t *value);

int json_object_del(json_t *object, const char *key);

int json_object_clear(json_t *object);

int json_object_update(json_t *object, json_t *other);

void *json_object_iter(json_t *object);

void *json_object_iter_at(json_t *object, const char *key);

void *json_object_iter_next(json_t *object, void *iter);

const char *json_object_iter_key(void *iter);

json_t *json_object_iter_value(void *iter);

int json_object_iter_set_new(json_t *object, void *iter, json_t *value);

static JSON_INLINE

int json_object_set(json_t *object, const char *key, json_t *value)

{

    return json_object_set_new(object, key, json_incref(value));

}

static JSON_INLINE

int json_object_set_nocheck(json_t *object, const char *key, json_t *value)

{

    return json_object_set_new_nocheck(object, key, json_incref(value));

}

static inline

int json_object_iter_set(json_t *object, void *iter, json_t *value)

{

    return json_object_iter_set_new(object, iter, json_incref(value));

}

unsigned int json_array_size(const json_t *array);

json_t *json_array_get(const json_t *array, unsigned int index);

int json_array_set_new(json_t *array, unsigned int index, json_t *value);

int json_array_append_new(json_t *array, json_t *value);

int json_array_insert_new(json_t *array, unsigned int index, json_t *value);

int json_array_remove(json_t *array, unsigned int index);

int json_array_clear(json_t *array);

int json_array_extend(json_t *array, json_t *other);

static JSON_INLINE

int json_array_set(json_t *array, unsigned int index, json_t *value)

{

    return json_array_set_new(array, index, json_incref(value));

}

static JSON_INLINE

int json_array_append(json_t *array, json_t *value)

{

    return json_array_append_new(array, json_incref(value));

}

static JSON_INLINE

int json_array_insert(json_t *array, unsigned int index, json_t *value)

{

    return json_array_insert_new(array, index, json_incref(value));

}

const char *json_string_value(const json_t *string);

int json_integer_value(const json_t *integer);

double json_real_value(const json_t *real);

double json_number_value(const json_t *json);

int json_string_set(json_t *string, const char *value);

int json_string_set_nocheck(json_t *string, const char *value);

int json_integer_set(json_t *integer, int value);

int json_real_set(json_t *real, double value);

/* equality */

int json_equal(json_t *value1, json_t *value2);

/* copying */

json_t *json_copy(json_t *value);

json_t *json_deep_copy(json_t *value);

/* loading, printing */

#define JSON_ERROR_TEXT_LENGTH  160

typedef struct {

    char text[JSON_ERROR_TEXT_LENGTH];

    int line;

} json_error_t;

json_t *json_loads(const char *input, json_error_t *error);

json_t *json_loadf(FILE *input, json_error_t *error);

json_t *json_load_file(const char *path, json_error_t *error);

#define JSON_INDENT(n)      (n & 0xFF)

#define JSON_COMPACT        0x100

#define JSON_ENSURE_ASCII   0x200

#define JSON_SORT_KEYS      0x400

#define JSON_PRESERVE_ORDER 0x800

char *json_dumps(const json_t *json, unsigned long flags);

int json_dumpf(const json_t *json, FILE *output, unsigned long flags);

int json_dump_file(const json_t *json, const char *path, unsigned long flags);

#ifdef __cplusplus

}

#endif

#endif

/*

 * Copyright (c) 2009, 2010 Petri Lehtinen <petri@digip.org>

 *

 * Jansson is free software; you can redistribute it and/or modify

 * it under the terms of the MIT license. See LICENSE for details.

 */

#ifndef JANSSON_PRIVATE_H

#define JANSSON_PRIVATE_H

#include "jansson.h"

#include "hashtable.h"

#define container_of(ptr_, type_, member_)  \

    ((type_ *)((char *)ptr_ - (size_t)&((type_ *)0)->member_))

typedef struct {

    json_t json;

    hashtable_t hashtable;

    unsigned long serial;

    int visited;

} json_object_t;

typedef struct {

    json_t json;

    unsigned int size;

    unsigned int entries;

    json_t **table;

    int visited;

} json_array_t;

typedef struct {

    json_t json;

    char *value;

} json_string_t;

typedef struct {

    json_t json;

    double value;

} json_real_t;

typedef struct {

    json_t json;

    int value;

} json_integer_t;

#define json_to_object(json_)  container_of(json_, json_object_t, json)

#define json_to_array(json_)   container_of(json_, json_array_t, json)

#define json_to_string(json_)  container_of(json_, json_string_t, json)

#define json_to_real(json_)   container_of(json_, json_real_t, json)

#define json_to_integer(json_) container_of(json_, json_integer_t, json)

typedef struct {

    unsigned long serial;

    char key[];

} object_key_t;

const object_key_t *jsonp_object_iter_fullkey(void *iter);

#endif

/*

 * Copyright (c) 2009, 2010 Petri Lehtinen <petri@digip.org>

 *

 * Jansson is free software; you can redistribute it and/or modify

 * it under the terms of the MIT license. See LICENSE for details.

 */

#define _GNU_SOURCE

#include <ctype.h>

#include <errno.h>

#include <limits.h>

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

#include <stdarg.h>

#include <assert.h>

#include <jansson.h>

#include "jansson_private.h"

#include "strbuffer.h"

#include "utf.h"

#define TOKEN_INVALID         -1

#define TOKEN_EOF              0

#define TOKEN_STRING         256

#define TOKEN_INTEGER        257

#define TOKEN_REAL           258

#define TOKEN_TRUE           259

#define TOKEN_FALSE          260

#define TOKEN_NULL           261

/* read one byte from stream, return EOF on end of file */

typedef int (*get_func)(void *data);

/* return non-zero if end of file has been reached */

typedef int (*eof_func)(void *data);

typedef struct {

    get_func get;

    eof_func eof;

    void *data;

    int stream_pos;

    char buffer[5];

    int buffer_pos;

} stream_t;

typedef struct {

    stream_t stream;

    strbuffer_t saved_text;

    int token;

    int line, column;

    union {

        char *string;

        int integer;

        double real;

    } value;

} lex_t;

/*** error reporting ***/

static void error_init(json_error_t *error)

{

    if(error)

    {

        error->text[0] = '\0';

        error->line = -1;

    }

}

static void error_set(json_error_t *error, const lex_t *lex,

                      const char *msg, ...)

{

    va_list ap;

    char text[JSON_ERROR_TEXT_LENGTH];

    if(!error || error->text[0] != '\0') {

        /* error already set */

        return;

    }

    va_start(ap, msg);

    vsnprintf(text, JSON_ERROR_TEXT_LENGTH, msg, ap);

    va_end(ap);

    if(lex)

    {

        const char *saved_text = strbuffer_value(&lex->saved_text);

        error->line = lex->line;

        if(saved_text && saved_text[0])

        {

            if(lex->saved_text.length <= 20) {

                snprintf(error->text, JSON_ERROR_TEXT_LENGTH,

                         "%s near '%s'", text, saved_text);

            }

            else

                snprintf(error->text, JSON_ERROR_TEXT_LENGTH, "%s", text);

        }

        else

        {

            snprintf(error->text, JSON_ERROR_TEXT_LENGTH,

                     "%s near end of file", text);

        }

    }

    else

    {

        error->line = -1;

        snprintf(error->text, JSON_ERROR_TEXT_LENGTH, "%s", text);

    }

}

/*** lexical analyzer ***/

static void

stream_init(stream_t *stream, get_func get, eof_func eof, void *data)

{

    stream->get = get;

    stream->eof = eof;

    stream->data = data;

    stream->stream_pos = 0;

    stream->buffer[0] = '\0';

    stream->buffer_pos = 0;

}

static char stream_get(stream_t *stream, json_error_t *error)

{

    char c;

    if(!stream->buffer[stream->buffer_pos])

    {

        stream->buffer[0] = stream->get(stream->data);

        stream->buffer_pos = 0;

        c = stream->buffer[0];

        if((unsigned char)c >= 0x80 && c != (char)EOF)

        {

            /* multi-byte UTF-8 sequence */

            int i, count;

            count = utf8_check_first(c);

            if(!count)

                goto out;

            assert(count >= 2);

            for(i = 1; i < count; i++)

                stream->buffer[i] = stream->get(stream->data);

            if(!utf8_check_full(stream->buffer, count, NULL))

                goto out;

            stream->stream_pos += count;

            stream->buffer[count] = '\0';

        }

        else {

            stream->buffer[1] = '\0';

            stream->stream_pos++;

        }

    }

    return stream->buffer[stream->buffer_pos++];

out: