--- /dev/null
+#ifndef JANSSON_H
+#define JANSSON_H
+
+#include <stdio.h>
+#include <stdint.h>
+
+/* types */
+
+typedef enum {
+ JSON_OBJECT,
+ JSON_ARRAY,
+ JSON_STRING,
+ JSON_NUMBER,
+ 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_number(json) (json && json_typeof(json) == JSON_NUMBER)
+#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_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_number(double value);
+json_t *json_true(void);
+json_t *json_false(void);
+json_t *json_null(void);
+
+json_t *json_clone(json_t *json);
+
+static inline json_t *json_incref(json_t *json)
+{
+ if(json)
+ ++json->refcount;
+ return json;
+}
+
+/* do not call json_delete directly */
+void json_delete(json_t *json);
+
+static inline void json_decref(json_t *json)
+{
+ if(json && --json->refcount == 0)
+ json_delete(json);
+}
+
+
+/* getters, setters, manipulation */
+
+json_t *json_object_get(const json_t *object, const char *key);
+int json_object_set(json_t *object, const char *key, json_t *value);
+int json_object_del(json_t *object, const char *key);
+
+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(json_t *array, unsigned int index, json_t *value);
+int json_array_append(json_t *array, json_t *value);
+
+const char *json_string_value(const json_t *json);
+double json_number_value(const json_t *json);
+
+
+/* loading, printing */
+
+const char *json_get_error(void);
+
+json_t *json_load(const char *path);
+json_t *json_loads(const char *input);
+json_t *json_loadf(FILE *input);
+
+#define JSON_INDENT(n) (n & 0xFF)
+#define JSON_SORT_KEYS 0x100
+
+int json_dump(const json_t *json, const char *path, uint32_t flags);
+char *json_dumps(const json_t *json, uint32_t flags);
+int json_dumpf(const json_t *json, FILE *output, uint32_t flags);
+
+#endif
--- /dev/null
+CFLAGS = -I../include -std=c99 -Wall -Wextra -Werror -g -O0
+
+OBJS = dump.o load.o value.o hashtable.o
+
+LIB = libjansson.a
+
+all: $(LIB)
+
+$(LIB): $(OBJS)
+ ar crsv $@ $^
+
+clean:
+ rm -f -- $(OBJS)
+ rm -f -- $(LIB)
--- /dev/null
+#include <jansson.h>
+
+char *json_dumps(const json_t *json, uint32_t flags)
+{
+ (void)flags;
+
+ switch(json_typeof(json)) {
+ case JSON_NULL:
+ printf("null");
+ break;
+
+ case JSON_TRUE:
+ printf("true");
+ break;
+
+ case JSON_FALSE:
+ printf("false");
+ break;
+
+ case JSON_NUMBER:
+ printf("%f", json_number_value(json));
+ break;
+
+ case JSON_STRING:
+ printf("%s", json_string_value(json));
+ break;
+
+ case JSON_ARRAY: {
+ int i, n = json_array_size(json);
+ printf("[");
+ for(i = 0; i < n; ++i) {
+ json_dumps(json_array_get(json, i), 0);
+ if(i < n - 1)
+ printf(", ");
+ }
+ printf("]");
+ break;
+ }
+
+ default:
+ printf("<object>");
+ break;
+ }
+ return NULL;
+}
+
--- /dev/null
+/*
+ * Copyright (c) 2009 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 <stdlib.h>
+#include "hashtable.h"
+
+#define container_of(ptr_, type_, member_) \
+ ((type_ *)((char *)ptr_ - (size_t)&((type_ *)0)->member_))
+
+typedef struct list_t {
+ struct list_t *prev;
+ struct list_t *next;
+} list_t;
+
+typedef struct {
+ void *key;
+ void *value;
+ unsigned int hash;
+ list_t list;
+} pair_t;
+
+#define list_to_pair(list_) container_of(list_, pair_t, list)
+
+typedef struct {
+ list_t *first;
+ list_t *last;
+} bucket_t;
+
+struct hashtable {
+ unsigned int size;
+ bucket_t *buckets;
+ unsigned int num_buckets; /* index to primes[] */
+ list_t 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;
+};
+
+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 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_new(key_hash_fn hash_key, key_cmp_fn cmp_keys,
+ free_fn free_key, free_fn free_value)
+{
+ unsigned int i;
+ hashtable_t *hashtable = malloc(sizeof(hashtable_t));
+ if(!hashtable)
+ return NULL;
+
+ hashtable->size = 0;
+ hashtable->num_buckets = 0; /* index to primes[] */
+ hashtable->buckets = malloc(num_buckets(hashtable) * sizeof(bucket_t));
+ if(!hashtable->buckets)
+ {
+ free(hashtable);
+ return NULL;
+ }
+ 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 hashtable;
+}
+
+void hashtable_free(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);
+ }
+
+ free(hashtable->buckets);
+ free(hashtable);
+}
+
+int hashtable_set(hashtable_t *hashtable, void *key, void *value)
+{
+ pair_t *pair;
+ bucket_t *bucket;
+ unsigned int hash, index;
+
+ hash = hashtable->hash_key(key);
+
+ /* if the key already exists, delete it */
+ hashtable_do_del(hashtable, key, hash);
+
+ /* rehash if the load ratio exceeds 1 */
+ if(hashtable->size >= num_buckets(hashtable))
+ if(hashtable_do_rehash(hashtable))
+ return -1;
+
+ pair = malloc(sizeof(pair_t));
+ if(!pair)
+ return -1;
+
+ pair->key = key;
+ pair->value = value;
+ pair->hash = hash;
+
+ index = hash % num_buckets(hashtable);
+ bucket = &hashtable->buckets[index];
+
+ 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_iter(hashtable_t *hashtable)
+{
+ return hashtable_iter_next(hashtable, &hashtable->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;
+}
--- /dev/null
+/*
+ * Copyright (c) 2009 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 struct hashtable hashtable_t;
+
+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);
+
+/**
+ * hashtable_new - 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_free when it's no longer used.
+ */
+hashtable_t *hashtable_new(key_hash_fn hash_key, key_cmp_fn cmp_keys,
+ free_fn free_key, free_fn free_value);
+
+/**
+ * hashtable_free - Destroy a hashtable object
+ *
+ * @hashtable: The hashtable
+ */
+void hashtable_free(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_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_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);
+
+#endif
--- /dev/null
+#define _GNU_SOURCE
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <ctype.h>
+#include <assert.h>
+
+#include <jansson.h>
+
+
+#define JSON_TOKEN_INVALID -1
+#define JSON_TOKEN_EOF 0
+#define JSON_TOKEN_STRING 256
+#define JSON_TOKEN_NUMBER 257
+#define JSON_TOKEN_TRUE 258
+#define JSON_TOKEN_FALSE 259
+#define JSON_TOKEN_NULL 260
+
+typedef struct {
+ const char *input;
+ const char *start;
+ int token;
+ int line, column;
+ union {
+ char *string;
+ double number;
+ } value;
+} json_lex;
+
+
+/*** error reporting ***/
+
+static __thread char *json_error_msg = NULL;
+
+static void json_set_error(const json_lex *lex, const char *msg)
+{
+ free(json_error_msg);
+ if(*lex->start)
+ asprintf(&json_error_msg, "%s near '%.*s' on line %d", msg,
+ (int)(lex->input - lex->start), lex->start, lex->line);
+ else
+ asprintf(&json_error_msg, "%s near end of file", msg);
+}
+
+const char *json_get_error(void)
+{
+ if(!json_error_msg)
+ json_error_msg = strdup("success");
+ return json_error_msg;
+}
+
+
+/*** lexical analyzer ***/
+
+static void json_scan_string(json_lex *lex)
+{
+ /* skip the " */
+ const char *p = lex->input + 1;
+ char *t;
+
+ lex->token = JSON_TOKEN_INVALID;
+
+ while(*p != '"') {
+ if(*p == '\0') {
+ /* unterminated string literal */
+ goto out;
+ }
+
+ if(0 <= *p && *p <= 31) {
+ /* control character */
+ goto out;
+ }
+ else if(*p == '\\') {
+ p++;
+ if(*p == 'u') {
+ p++;
+ for(int i = 0; i < 4; i++, p++) {
+ if(!isxdigit(*p))
+ goto out;
+ }
+ }
+ if(*p == '"' || *p == '\\' || *p == '/' || *p == 'b' ||
+ *p == 'f' || *p == 'n' || *p == 'r' || *p == 't')
+ p++;
+ else
+ goto out;
+ }
+ else
+ p++;
+ }
+
+ /* the actual value is at most of the same length as the source
+ string */
+ lex->value.string = malloc(p - lex->start);
+ if(!lex->value.string) {
+ /* this is not very nice, since TOKEN_INVALID is returned */
+ goto out;
+ }
+
+ /* the target */
+ t = lex->value.string;
+
+ p = lex->input + 1;
+ while(*p != '"') {
+ if(*p == '\\') {
+ p++;
+ if(*p == 'u') {
+ /* TODO: \uXXXX not supported yet */
+ free(lex->value.string);
+ lex->value.string = NULL;
+ goto out;
+ } else {
+ switch(*p) {
+ case '"': case '\\': case '/':
+ *t = *p; break;
+ case 'b': *t = '\b'; break;
+ case 'f': *t = '\f'; break;
+ case 'n': *t = '\n'; break;
+ case 'r': *t = '\r'; break;
+ case 't': *t = '\t'; break;
+ default: assert(0);
+ }
+ }
+ }
+ else
+ *t = *p;
+
+ t++;
+ p++;
+ }
+ /* skip the " */
+ p++;
+
+ *t = '\0';
+ lex->token = JSON_TOKEN_STRING;
+
+out:
+ lex->input = p;
+}
+
+static void json_scan_number(json_lex *lex)
+{
+ const char *p = lex->input;
+ char *end;
+
+ lex->token = JSON_TOKEN_INVALID;
+
+ if(*p == '-')
+ p++;
+
+ if(*p == '0')
+ p++;
+ else /* *p != '0' */ {
+ p++;
+ while(isdigit(*p))
+ p++;
+ }
+
+ if(*p == '.') {
+ p++;
+ if(!isdigit(*(p++)))
+ goto out;
+
+ while(isdigit(*p))
+ p++;
+ }
+
+ if(*p == 'E' || *p == 'e') {
+ p++;
+ if(*p == '+' || *p == '-')
+ p++;
+
+ if(!isdigit(*(p++)))
+ goto out;
+
+ while(isdigit(*p))
+ p++;
+ }
+
+ lex->token = JSON_TOKEN_NUMBER;
+
+ lex->value.number = strtod(lex->start, &end);
+ assert(end == p);
+
+out:
+ lex->input = p;
+}
+
+static int json_lex_scan(json_lex *lex)
+{
+ char c;
+
+ if(lex->token == JSON_TOKEN_STRING) {
+ free(lex->value.string);
+ lex->value.string = NULL;
+ }
+
+ while(isspace(*lex->input)) {
+ if(*lex->input == '\n')
+ lex->line++;
+
+ lex->input++;
+ }
+
+ lex->start = lex->input;
+ c = *lex->input;
+
+ if(c == '\0')
+ lex->token = JSON_TOKEN_EOF;
+
+ else if(c == '{' || c == '}' || c == '[' || c == ']' ||
+ c == ':' || c == ',') {
+ lex->token = c;
+ lex->input++;
+ }
+
+ else if(c == '"')
+ json_scan_string(lex);
+
+ else if(isdigit(c) || c == '-')
+ json_scan_number(lex);
+
+ else if(isalpha(c)) {
+ /* eat up the whole identifier for clearer error messages */
+ int len;
+
+ while(isalpha(*lex->input))
+ lex->input++;
+ len = lex->input - lex->start;
+
+ if(strncmp(lex->start, "true", len) == 0)
+ lex->token = JSON_TOKEN_TRUE;
+ else if(strncmp(lex->start, "false", len) == 0)
+ lex->token = JSON_TOKEN_FALSE;
+ else if(strncmp(lex->start, "null", len) == 0)
+ lex->token = JSON_TOKEN_NULL;
+ else
+ lex->token = JSON_TOKEN_INVALID;
+ }
+
+ else {
+ lex->token = JSON_TOKEN_INVALID;
+ lex->input++;
+ }
+
+ return lex->token;
+}
+
+static int json_lex_init(json_lex *lex, const char *input)
+{
+ lex->input = input;
+ lex->token = JSON_TOKEN_INVALID;
+ lex->line = 1;
+
+ json_lex_scan(lex);
+ return 0;
+}
+
+static void json_lex_close(json_lex *lex)
+{
+ if(lex->token == JSON_TOKEN_STRING)
+ free(lex->value.string);
+}
+
+
+/*** parser ***/
+
+static json_t *json_parse(json_lex *lex);
+
+static json_t *json_parse_object(json_lex *lex)
+{
+ json_t *object = json_object();
+ if(!object)
+ return NULL;
+
+ json_lex_scan(lex);
+ while(1) {
+ char *key;
+ json_t *value;
+
+ if(lex->token != JSON_TOKEN_STRING) {
+ json_set_error(lex, "string expected");
+ goto error;
+ }
+
+ key = strdup(lex->value.string);
+ if(!key)
+ return NULL;
+
+ json_lex_scan(lex);
+ if(lex->token != ':') {
+ json_set_error(lex, "':' expected");
+ goto error;
+ }
+
+ json_lex_scan(lex);
+
+ value = json_parse(lex);
+ if(!value)
+ goto error;
+
+ if(json_object_set(object, key, value)) {
+ json_decref(value);
+ goto error;
+ }
+
+ json_decref(value);
+ free(key);
+
+ if(lex->token != ',')
+ break;
+
+ json_lex_scan(lex);
+ }
+
+ if(lex->token != '}') {
+ json_set_error(lex, "'}' expected");
+ goto error;
+ }
+
+ return object;
+
+error:
+ json_decref(object);
+ return NULL;
+}
+
+static json_t *json_parse_array(json_lex *lex)
+{
+ json_t *array = json_array();
+ if(!array)
+ return NULL;
+
+ json_lex_scan(lex);
+ if(lex->token != ']') {
+ while(1) {
+ json_t *elem = json_parse(lex);
+ if(!elem)
+ goto error;
+
+ if(json_array_append(array, elem)) {
+ json_decref(elem);
+ goto error;
+ }
+ json_decref(elem);
+
+ if(lex->token != ',')
+ break;
+
+ json_lex_scan(lex);
+ }
+ }
+
+ if(lex->token != ']') {
+ json_set_error(lex, "']' expected");
+ goto error;
+ }
+
+ return array;
+
+error:
+ json_decref(array);
+ return NULL;
+}
+
+static json_t *json_parse(json_lex *lex)
+{
+ json_t *json;
+
+ switch(lex->token) {
+ case JSON_TOKEN_STRING: {
+ json = json_string(lex->value.string);
+ break;
+ }
+
+ case JSON_TOKEN_NUMBER: {
+ json = json_number(lex->value.number);
+ break;
+ }
+
+ case JSON_TOKEN_TRUE:
+ json = json_true();
+ break;
+
+ case JSON_TOKEN_FALSE:
+ json = json_false();
+ break;
+
+ case JSON_TOKEN_NULL:
+ json = json_null();
+ break;
+
+ case '{':
+ json = json_parse_object(lex);
+ break;
+
+ case '[':
+ json = json_parse_array(lex);
+ break;
+
+ case JSON_TOKEN_INVALID:
+ json_set_error(lex, "invalid token");
+ return NULL;
+
+ default:
+ json_set_error(lex, "unexpected token");
+ return NULL;
+ }
+
+ if(!json)
+ return NULL;
+
+ json_lex_scan(lex);
+ return json;
+}
+
+json_t *json_loads(const char *string)
+{
+ json_lex lex;
+ json_t *result = NULL;
+
+ if(json_lex_init(&lex, string))
+ return NULL;
+
+ if(lex.token != '[' && lex.token != '{') {
+ json_set_error(&lex, "'[' or '{' expected");
+ goto out;
+ }
+
+ result = json_parse(&lex);
+ if(!result)
+ goto out;
+
+ if(lex.token != JSON_TOKEN_EOF) {
+ json_set_error(&lex, "end of file expected");
+ json_decref(result);
+ result = NULL;
+ }
+
+out:
+ json_lex_close(&lex);
+ return result;
+}
--- /dev/null
+#define _GNU_SOURCE
+#include <stdlib.h>
+#include <string.h>
+
+#include <jansson.h>
+#include "hashtable.h"
+
+#define max(a, b) ((a) > (b) ? (a) : (b))
+
+#define container_of(ptr_, type_, member_) \
+ ((type_ *)((char *)ptr_ - (size_t)&((type_ *)0)->member_))
+
+typedef struct {
+ json_t json;
+ hashtable_t *hashtable;
+} json_object_t;
+
+typedef struct {
+ json_t json;
+ unsigned int size;
+ unsigned int entries;
+ json_t **table;
+} json_array_t;
+
+typedef struct {
+ json_t json;
+ char *value;
+} json_string_t;
+
+typedef struct {
+ json_t json;
+ double value;
+} json_number_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_number(json_) container_of(json_, json_number_t, json)
+
+static inline void json_init(json_t *json, json_type type)
+{
+ json->type = type;
+ json->refcount = 1;
+}
+
+
+/*** object ***/
+
+static unsigned int hash_string(const void *key)
+{
+ const char *str = (const char *)key;
+ unsigned int hash = 5381;
+ unsigned int c;
+
+ while((c = (unsigned int)*str))
+ {
+ hash = ((hash << 5) + hash) + c;
+ str++;
+ }
+
+ return hash;
+}
+
+static int string_equal(const void *key1, const void *key2)
+{
+ return strcmp((const char *)key1, (const char *)key2) == 0;
+}
+
+static void value_decref(void *value)
+{
+ json_decref((json_t *)value);
+}
+
+json_t *json_object(void)
+{
+ json_object_t *object = malloc(sizeof(json_object_t));
+ if(!object)
+ return NULL;
+ json_init(&object->json, JSON_OBJECT);
+
+ object->hashtable =
+ hashtable_new(hash_string, string_equal, free, value_decref);
+ if(!object->hashtable)
+ {
+ free(object);
+ return NULL;
+ }
+ return &object->json;
+}
+
+static void json_delete_object(json_object_t *object)
+{
+ hashtable_free(object->hashtable);
+ free(object);
+}
+
+json_t *json_object_get(const json_t *json, const char *key)
+{
+ json_object_t *object;
+
+ if(!json_is_object(json))
+ return NULL;
+
+ return hashtable_get(object->hashtable, key);
+}
+
+int json_object_del(json_t *json, const char *key)
+{
+ json_object_t *object;
+
+ if(!json_is_object(json))
+ return -1;
+
+ object = json_to_object(json);
+ return hashtable_del(object->hashtable, key);
+}
+
+int json_object_set(json_t *json, const char *key, json_t *value)
+{
+ json_object_t *object;
+
+ if(!json_is_object(json))
+ return -1;
+
+ object = json_to_object(json);
+ return hashtable_set(object->hashtable, strdup(key), json_incref(value));
+}
+
+
+/*** array ***/
+
+json_t *json_array(void)
+{
+ json_array_t *array = malloc(sizeof(json_array_t));
+ if(!array)
+ return NULL;
+ json_init(&array->json, JSON_ARRAY);
+
+ array->entries = 0;
+ array->size = 0;
+ array->table = NULL;
+
+ return &array->json;
+}
+
+static void json_delete_array(json_array_t *array)
+{
+ unsigned int i;
+
+ for(i = 0; i < array->entries; i++)
+ json_decref(array->table[i]);
+
+ free(array->table);
+ free(array);
+}
+
+unsigned int json_array_size(const json_t *json)
+{
+ if(!json_is_array(json))
+ return 0;
+
+ return json_to_array(json)->entries;
+}
+
+json_t *json_array_get(const json_t *json, unsigned int index)
+{
+ json_array_t *array;
+ if(!json_is_array(json))
+ return NULL;
+ array = json_to_array(json);
+
+ if(index >= array->size)
+ return NULL;
+
+ return array->table[index];
+}
+
+int json_array_set(json_t *json, unsigned int index, json_t *value)
+{
+ json_array_t *array;
+ if(!json_is_array(json))
+ return -1;
+ array = json_to_array(json);
+
+ if(index >= array->size)
+ return -1;
+
+ array->table[index] = json_incref(value);
+ return 0;
+}
+
+int json_array_append(json_t *json, json_t *value)
+{
+ json_array_t *array;
+ if(!json_is_array(json))
+ return -1;
+ array = json_to_array(json);
+
+ if(array->entries == array->size) {
+ array->size = max(8, array->size * 2);
+ array->table = realloc(array->table, array->size * sizeof(json_t *));
+ if(!array->table)
+ return -1;
+ }
+
+ array->table[array->entries] = json_incref(value);
+ array->entries++;
+
+ return 0;
+}
+
+
+/*** string ***/
+
+json_t *json_string(const char *value)
+{
+ json_string_t *string = malloc(sizeof(json_string_t));
+ if(!string)
+ return NULL;
+ json_init(&string->json, JSON_STRING);
+
+ string->value = strdup(value);
+ return &string->json;
+}
+
+const char *json_string_value(const json_t *json)
+{
+ if(!json_is_string(json))
+ return NULL;
+
+ return json_to_string(json)->value;
+}
+
+static void json_delete_string(json_string_t *string)
+{
+ free(string->value);
+ free(string);
+}
+
+json_t *json_number(double value)
+{
+ json_number_t *number = malloc(sizeof(json_number_t));
+ if(!number)
+ return NULL;
+ json_init(&number->json, JSON_NUMBER);
+
+ number->value = value;
+ return &number->json;
+}
+
+
+/*** number ***/
+
+double json_number_value(const json_t *json)
+{
+ if(!json_is_number(json))
+ return 0.0;
+
+ return json_to_number(json)->value;
+}
+
+static void json_delete_number(json_number_t *number)
+{
+ free(number);
+}
+
+
+/*** simple values ***/
+
+json_t *json_true(void)
+{
+ static json_t the_true = {
+ .type = JSON_TRUE,
+ .refcount = 1
+ };
+ return json_incref(&the_true);
+}
+
+
+json_t *json_false(void)
+{
+ static json_t the_false = {
+ .type = JSON_FALSE,
+ .refcount = 1
+ };
+ return json_incref(&the_false);
+}
+
+
+json_t *json_null(void)
+{
+ static json_t the_null = {
+ .type = JSON_NULL,
+ .refcount = 1
+ };
+ return json_incref(&the_null);
+}
+
+
+/*** deletion ***/
+
+void json_delete(json_t *json)
+{
+ if(json_is_object(json))
+ json_delete_object(json_to_object(json));
+
+ else if(json_is_array(json))
+ json_delete_array(json_to_array(json));
+
+ else if(json_is_string(json))
+ json_delete_string(json_to_string(json));
+
+ else if(json_is_number(json))
+ json_delete_number(json_to_number(json));
+
+ /* json_delete is not called for true, false or null */
+}
projects / jansson.git / commitdiff