/*
- * Copyright (c) 2009, 2010 Petri Lehtinen <petri@digip.org>
+ * Copyright (c) 2009-2011 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 <config.h>
-
+#include <stddef.h>
#include <stdlib.h>
#include <string.h>
#include "hashtable.h"
#include "jansson_private.h"
#include "utf.h"
-#include "util.h"
-static inline void json_init(json_t *json, json_type type)
+static JSON_INLINE void json_init(json_t *json, json_type type)
{
json->type = type;
json->refcount = 1;
/*** object ***/
-/* This macro just returns a pointer that's a few bytes backwards from
- string. This makes it possible to pass a pointer to object_key_t
- when only the string inside it is used, without actually creating
- an object_key_t instance. */
-#define string_to_key(string) container_of(string, object_key_t, key)
-
-static size_t hash_key(const void *ptr)
+/* From http://www.cse.yorku.ca/~oz/hash.html */
+size_t jsonp_hash_str(const void *ptr)
{
- const char *str = ((const object_key_t *)ptr)->key;
+ const char *str = (const char *)ptr;
size_t hash = 5381;
size_t c;
return hash;
}
+int jsonp_str_equal(const void *ptr1, const void *ptr2)
+{
+ return strcmp((const char *)ptr1, (const char *)ptr2) == 0;
+}
+
+/* This macro just returns a pointer that's a few bytes backwards from
+ string. This makes it possible to pass a pointer to object_key_t
+ when only the string inside it is used, without actually creating
+ an object_key_t instance. */
+#define string_to_key(string) container_of(string, object_key_t, key)
+
+static size_t hash_key(const void *ptr)
+{
+ return jsonp_hash_str(((const object_key_t *)ptr)->key);
+}
+
static int key_equal(const void *ptr1, const void *ptr2)
{
- return strcmp(((const object_key_t *)ptr1)->key,
- ((const object_key_t *)ptr2)->key) == 0;
+ return jsonp_str_equal(((const object_key_t *)ptr1)->key,
+ ((const object_key_t *)ptr2)->key);
}
static void value_decref(void *value)
json_t *json_object(void)
{
- json_object_t *object = malloc(sizeof(json_object_t));
+ json_object_t *object = jsonp_malloc(sizeof(json_object_t));
if(!object)
return NULL;
json_init(&object->json, JSON_OBJECT);
- if(hashtable_init(&object->hashtable, hash_key, key_equal,
- free, value_decref))
+ if(hashtable_init(&object->hashtable,
+ hash_key, key_equal,
+ jsonp_free, value_decref))
{
- free(object);
+ jsonp_free(object);
return NULL;
}
static void json_delete_object(json_object_t *object)
{
hashtable_close(&object->hashtable);
- free(object);
+ jsonp_free(object);
}
size_t json_object_size(const json_t *json)
json_object_t *object;
if(!json_is_object(json))
- return -1;
+ return 0;
object = json_to_object(json);
return object->hashtable.size;
json_object_t *object;
object_key_t *k;
- if(!key || !value)
+ if(!value)
return -1;
- if(!json_is_object(json) || json == value)
+ if(!key || !json_is_object(json) || json == value)
{
json_decref(value);
return -1;
}
object = json_to_object(json);
- k = malloc(sizeof(object_key_t) + strlen(key) + 1);
+ /* offsetof(...) returns the size of object_key_t without the
+ last, flexible member. This way, the correct amount is
+ allocated. */
+ k = jsonp_malloc(offsetof(object_key_t, key) + strlen(key) + 1);
if(!k)
+ {
+ json_decref(value);
return -1;
+ }
k->serial = object->serial++;
strcpy(k->key, key);
return -1;
object = json_to_object(json);
+
hashtable_clear(&object->hashtable);
+ object->serial = 0;
return 0;
}
json_t *json_array(void)
{
- json_array_t *array = malloc(sizeof(json_array_t));
+ json_array_t *array = jsonp_malloc(sizeof(json_array_t));
if(!array)
return NULL;
json_init(&array->json, JSON_ARRAY);
array->entries = 0;
array->size = 8;
- array->table = malloc(array->size * sizeof(json_t *));
+ array->table = jsonp_malloc(array->size * sizeof(json_t *));
if(!array->table) {
- free(array);
+ jsonp_free(array);
return NULL;
}
for(i = 0; i < array->entries; i++)
json_decref(array->table[i]);
- free(array->table);
- free(array);
+ jsonp_free(array->table);
+ jsonp_free(array);
}
size_t json_array_size(const json_t *json)
old_table = array->table;
new_size = max(array->size + amount, array->size * 2);
- new_table = malloc(new_size * sizeof(json_t *));
+ new_table = jsonp_malloc(new_size * sizeof(json_t *));
if(!new_table)
return NULL;
if(copy) {
array_copy(array->table, 0, old_table, 0, array->entries);
- free(old_table);
+ jsonp_free(old_table);
return 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);
+ jsonp_free(old_table);
}
else
array_move(array, index + 1, index, array->entries - index);
if(!value)
return NULL;
- string = malloc(sizeof(json_string_t));
+ string = jsonp_malloc(sizeof(json_string_t));
if(!string)
return NULL;
json_init(&string->json, JSON_STRING);
- string->value = strdup(value);
+ string->value = jsonp_strdup(value);
if(!string->value) {
- free(string);
+ jsonp_free(string);
return NULL;
}
char *dup;
json_string_t *string;
- dup = strdup(value);
+ if(!json_is_string(json) || !value)
+ return -1;
+
+ dup = jsonp_strdup(value);
if(!dup)
return -1;
string = json_to_string(json);
- free(string->value);
+ jsonp_free(string->value);
string->value = dup;
return 0;
static void json_delete_string(json_string_t *string)
{
- free(string->value);
- free(string);
+ jsonp_free(string->value);
+ jsonp_free(string);
}
static int json_string_equal(json_t *string1, json_t *string2)
/*** integer ***/
-json_t *json_integer(long value)
+json_t *json_integer(json_int_t value)
{
- json_integer_t *integer = malloc(sizeof(json_integer_t));
+ json_integer_t *integer = jsonp_malloc(sizeof(json_integer_t));
if(!integer)
return NULL;
json_init(&integer->json, JSON_INTEGER);
return &integer->json;
}
-long json_integer_value(const json_t *json)
+json_int_t json_integer_value(const json_t *json)
{
if(!json_is_integer(json))
return 0;
return json_to_integer(json)->value;
}
-int json_integer_set(json_t *json, long value)
+int json_integer_set(json_t *json, json_int_t value)
{
if(!json_is_integer(json))
return -1;
static void json_delete_integer(json_integer_t *integer)
{
- free(integer);
+ jsonp_free(integer);
}
static int json_integer_equal(json_t *integer1, json_t *integer2)
json_t *json_real(double value)
{
- json_real_t *real = malloc(sizeof(json_real_t));
+ json_real_t *real = jsonp_malloc(sizeof(json_real_t));
if(!real)
return NULL;
json_init(&real->json, JSON_REAL);
static void json_delete_real(json_real_t *real)
{
- free(real);
+ jsonp_free(real);
}
static int json_real_equal(json_t *real1, json_t *real2)
json_t *json_true(void)
{
- static json_t the_true = {
- .type = JSON_TRUE,
- .refcount = (size_t)-1
- };
+ static json_t the_true = {JSON_TRUE, (size_t)-1};
return &the_true;
}
json_t *json_false(void)
{
- static json_t the_false = {
- .type = JSON_FALSE,
- .refcount = (size_t)-1
- };
+ static json_t the_false = {JSON_FALSE, (size_t)-1};
return &the_false;
}
json_t *json_null(void)
{
- static json_t the_null = {
- .type = JSON_NULL,
- .refcount = (size_t)-1
- };
+ static json_t the_null = {JSON_NULL, (size_t)-1};
return &the_null;
}