+/*
+ * Copyright (c) 2009 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 <stdlib.h>
#include <string.h>
#include <jansson.h>
#include "hashtable.h"
+#include "jansson_private.h"
+#include "utf.h"
#include "util.h"
-#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_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)
static inline void json_init(json_t *json, json_type type)
{
free(object);
return NULL;
}
+
+ object->visited = 0;
+
return &object->json;
}
free(object);
}
+unsigned int json_object_size(const json_t *json)
+{
+ json_object_t *object;
+
+ if(!json_is_object(json))
+ return -1;
+
+ object = json_to_object(json);
+ return object->hashtable.size;
+}
+
json_t *json_object_get(const json_t *json, const char *key)
{
json_object_t *object;
return hashtable_get(&object->hashtable, key);
}
-int json_object_set(json_t *json, const char *key, json_t *value)
+int json_object_set_new_nocheck(json_t *json, const char *key, json_t *value)
{
json_object_t *object;
- if(!json_is_object(json))
+ if(!key || !value)
return -1;
+ if(!json_is_object(json) || json == value)
+ {
+ json_decref(value);
+ return -1;
+ }
object = json_to_object(json);
- return hashtable_set(&object->hashtable, strdup(key), json_incref(value));
+
+ if(hashtable_set(&object->hashtable, strdup(key), value))
+ {
+ json_decref(value);
+ return -1;
+ }
+
+ return 0;
+}
+
+int json_object_set_nocheck(json_t *json, const char *key, json_t *value)
+{
+ return json_object_set_new_nocheck(json, key, json_incref(value));
+}
+
+int json_object_set_new(json_t *json, const char *key, json_t *value)
+{
+ if(!key || !utf8_check_string(key, -1))
+ {
+ json_decref(value);
+ return -1;
+ }
+
+ return json_object_set_new_nocheck(json, key, value);
}
int json_object_del(json_t *json, const char *key)
return hashtable_del(&object->hashtable, key);
}
+int json_object_clear(json_t *json)
+{
+ json_object_t *object;
+
+ if(!json_is_object(json))
+ return -1;
+
+ object = json_to_object(json);
+ hashtable_clear(&object->hashtable);
+
+ return 0;
+}
+
+int json_object_update(json_t *object, json_t *other)
+{
+ void *iter;
+
+ if(!json_is_object(object) || !json_is_object(other))
+ return -1;
+
+ iter = json_object_iter(other);
+ while(iter) {
+ const char *key;
+ json_t *value;
+
+ key = json_object_iter_key(iter);
+ value = json_object_iter_value(iter);
+
+ if(json_object_set(object, key, value))
+ return -1;
+
+ iter = json_object_iter_next(other, iter);
+ }
+
+ return 0;
+}
+
void *json_object_iter(json_t *json)
{
json_object_t *object;
{
json_array_t *array = malloc(sizeof(json_array_t));
if(!array)
- return NULL;
+ return NULL;
json_init(&array->json, JSON_ARRAY);
array->entries = 0;
- array->size = 0;
- array->table = NULL;
+ array->size = 8;
+
+ array->table = malloc(array->size * sizeof(json_t *));
+ if(!array->table) {
+ free(array);
+ return NULL;
+ }
+
+ array->visited = 0;
return &array->json;
}
return NULL;
array = json_to_array(json);
- if(index >= array->size)
+ if(index >= array->entries)
return NULL;
return array->table[index];
}
-int json_array_set(json_t *json, unsigned int index, json_t *value)
+int json_array_set_new(json_t *json, unsigned int index, json_t *value)
{
json_array_t *array;
- if(!json_is_array(json))
+
+ if(!value)
+ return -1;
+
+ if(!json_is_array(json) || json == value)
+ {
+ json_decref(value);
return -1;
+ }
array = json_to_array(json);
- if(index >= array->size)
+ if(index >= array->entries)
+ {
+ json_decref(value);
return -1;
+ }
+
+ json_decref(array->table[index]);
+ array->table[index] = value;
- array->table[index] = json_incref(value);
return 0;
}
-int json_array_append(json_t *json, json_t *value)
+static void array_move(json_array_t *array, unsigned int dest,
+ unsigned int src, unsigned int count)
+{
+ memmove(&array->table[dest], &array->table[src], count * sizeof(json_t *));
+}
+
+static void array_copy(json_t **dest, unsigned int dpos,
+ json_t **src, unsigned int spos,
+ unsigned int count)
+{
+ memcpy(&dest[dpos], &src[spos], count * sizeof(json_t *));
+}
+
+static json_t **json_array_grow(json_array_t *array,
+ unsigned int amount,
+ int copy)
+{
+ unsigned int new_size;
+ json_t **old_table, **new_table;
+
+ if(array->entries + amount <= array->size)
+ return array->table;
+
+ old_table = array->table;
+
+ new_size = max(array->size + amount, array->size * 2);
+ new_table = malloc(new_size * sizeof(json_t *));
+ if(!new_table)
+ return NULL;
+
+ array->size = new_size;
+ array->table = new_table;
+
+ if(copy) {
+ array_copy(array->table, 0, old_table, 0, array->entries);
+ free(old_table);
+ return array->table;
+ }
+
+ return old_table;
+}
+
+int json_array_append_new(json_t *json, json_t *value)
{
json_array_t *array;
- if(!json_is_array(json))
+
+ if(!value)
return -1;
+
+ if(!json_is_array(json) || json == value)
+ {
+ json_decref(value);
+ 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;
+ if(!json_array_grow(array, 1, 1)) {
+ json_decref(value);
+ return -1;
}
- array->table[array->entries] = json_incref(value);
+ array->table[array->entries] = value;
array->entries++;
return 0;
}
+int json_array_insert_new(json_t *json, unsigned int index, json_t *value)
+{
+ json_array_t *array;
+ json_t **old_table;
+
+ if(!value)
+ return -1;
+
+ if(!json_is_array(json) || json == value) {
+ json_decref(value);
+ return -1;
+ }
+ array = json_to_array(json);
+
+ if(index > array->entries) {
+ json_decref(value);
+ return -1;
+ }
+
+ old_table = json_array_grow(array, 1, 0);
+ if(!old_table) {
+ json_decref(value);
+ return -1;
+ }
+
+ if(old_table != array->table) {
+ array_copy(array->table, 0, old_table, 0, index);
+ array_copy(array->table, index + 1, old_table, index,
+ array->entries - index);
+ free(old_table);
+ }
+ else
+ array_move(array, index + 1, index, array->entries - index);
+
+ array->table[index] = value;
+ array->entries++;
+
+ return 0;
+}
+
+int json_array_remove(json_t *json, unsigned int index)
+{
+ json_array_t *array;
+
+ if(!json_is_array(json))
+ return -1;
+ array = json_to_array(json);
+
+ if(index >= array->entries)
+ return -1;
+
+ json_decref(array->table[index]);
+
+ array_move(array, index, index + 1, array->entries - index);
+ array->entries--;
+
+ return 0;
+}
+
+int json_array_clear(json_t *json)
+{
+ json_array_t *array;
+ unsigned int i;
+
+ if(!json_is_array(json))
+ return -1;
+ array = json_to_array(json);
+
+ for(i = 0; i < array->entries; i++)
+ json_decref(array->table[i]);
+
+ array->entries = 0;
+ return 0;
+}
+
+int json_array_extend(json_t *json, json_t *other_json)
+{
+ json_array_t *array, *other;
+ unsigned int i;
+
+ if(!json_is_array(json) || !json_is_array(other_json))
+ return -1;
+ array = json_to_array(json);
+ other = json_to_array(other_json);
+
+ if(!json_array_grow(array, other->entries, 1))
+ return -1;
+
+ for(i = 0; i < other->entries; i++)
+ json_incref(other->table[i]);
+
+ array_copy(array->table, array->entries, other->table, 0, other->entries);
+
+ array->entries += other->entries;
+ return 0;
+}
+
/*** string ***/
-json_t *json_string(const char *value)
+json_t *json_string_nocheck(const char *value)
{
- json_string_t *string = malloc(sizeof(json_string_t));
+ json_string_t *string;
+
+ if(!value)
+ return NULL;
+
+ string = malloc(sizeof(json_string_t));
if(!string)
- return NULL;
+ return NULL;
json_init(&string->json, JSON_STRING);
string->value = strdup(value);
+ if(!string->value) {
+ free(string);
+ return NULL;
+ }
+
return &string->json;
}
+json_t *json_string(const char *value)
+{
+ if(!value || !utf8_check_string(value, -1))
+ return NULL;
+
+ return json_string_nocheck(value);
+}
+
const char *json_string_value(const json_t *json)
{
if(!json_is_string(json))
return json_to_string(json)->value;
}
+int json_string_set(const json_t *json, const char *value)
+{
+ char *dup;
+ json_string_t *string;
+
+ if(!json_is_string(json) || !value || !utf8_check_string(value, -1))
+ return -1;
+
+ dup = strdup(value);
+ if(!dup)
+ return -1;
+
+ string = json_to_string(json);
+ free(string->value);
+ string->value = dup;
+
+ return 0;
+}
+
static void json_delete_string(json_string_t *string)
{
free(string->value);
{
json_integer_t *integer = malloc(sizeof(json_integer_t));
if(!integer)
- return NULL;
+ return NULL;
json_init(&integer->json, JSON_INTEGER);
integer->value = value;
return json_to_integer(json)->value;
}
+int json_integer_set(const json_t *json, int value)
+{
+ if(!json_is_integer(json))
+ return -1;
+
+ json_to_integer(json)->value = value;
+
+ return 0;
+}
+
static void json_delete_integer(json_integer_t *integer)
{
free(integer);
{
json_real_t *real = malloc(sizeof(json_real_t));
if(!real)
- return NULL;
+ return NULL;
json_init(&real->json, JSON_REAL);
real->value = value;
return json_to_real(json)->value;
}
-static void json_delete_real (json_real_t *real)
+int json_real_set(const json_t *json, double value)
+{
+ if(!json_is_real(json))
+ return 0;
+
+ json_to_real(json)->value = value;
+
+ return 0;
+}
+
+static void json_delete_real(json_real_t *real)
{
free(real);
}
{
static json_t the_true = {
.type = JSON_TRUE,
- .refcount = 1
+ .refcount = (unsigned int)1
};
- return json_incref(&the_true);
+ return &the_true;
}
{
static json_t the_false = {
.type = JSON_FALSE,
- .refcount = 1
+ .refcount = (unsigned int)1
};
- return json_incref(&the_false);
+ return &the_false;
}
{
static json_t the_null = {
.type = JSON_NULL,
- .refcount = 1
+ .refcount = (unsigned int)1
};
- return json_incref(&the_null);
+ return &the_null;
}