/*
- * Copyright (c) 2009 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 <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 ***/
-static unsigned int hash_string(const void *key)
+/* 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)
{
- const char *str = (const char *)key;
- unsigned int hash = 5381;
- unsigned int c;
+ const char *str = ((const object_key_t *)ptr)->key;
+
+ size_t hash = 5381;
+ size_t c;
- while((c = (unsigned int)*str))
+ while((c = (size_t)*str))
{
hash = ((hash << 5) + hash) + c;
str++;
return hash;
}
-static int string_equal(const void *key1, const void *key2)
+static int key_equal(const void *ptr1, const void *ptr2)
{
- return strcmp((const char *)key1, (const char *)key2) == 0;
+ return strcmp(((const object_key_t *)ptr1)->key,
+ ((const object_key_t *)ptr2)->key) == 0;
}
static void value_decref(void *value)
return NULL;
json_init(&object->json, JSON_OBJECT);
- if(hashtable_init(&object->hashtable, hash_string, string_equal,
+ if(hashtable_init(&object->hashtable, hash_key, key_equal,
free, value_decref))
{
free(object);
return NULL;
}
+ object->serial = 0;
object->visited = 0;
return &object->json;
free(object);
}
-unsigned int json_object_size(const json_t *json)
+size_t json_object_size(const json_t *json)
{
json_object_t *object;
return NULL;
object = json_to_object(json);
- return hashtable_get(&object->hashtable, key);
+ return hashtable_get(&object->hashtable, string_to_key(key));
}
int json_object_set_new_nocheck(json_t *json, const char *key, json_t *value)
{
json_object_t *object;
+ object_key_t *k;
if(!key || !value)
return -1;
}
object = json_to_object(json);
- if(hashtable_set(&object->hashtable, strdup(key), value))
+ /* offsetof(...) returns the size of object_key_t without the
+ last, flexible member. This way, the correct amount is
+ allocated. */
+ k = malloc(offsetof(object_key_t, key) +
+ strlen(key) + 1); if(!k) return -1;
+
+ k->serial = object->serial++;
+ strcpy(k->key, key);
+
+ if(hashtable_set(&object->hashtable, k, value))
{
json_decref(value);
return -1;
return -1;
object = json_to_object(json);
- return hashtable_del(&object->hashtable, key);
+ return hashtable_del(&object->hashtable, string_to_key(key));
}
int json_object_clear(json_t *json)
return NULL;
object = json_to_object(json);
- return hashtable_iter_at(&object->hashtable, key);
+ return hashtable_iter_at(&object->hashtable, string_to_key(key));
}
void *json_object_iter_next(json_t *json, void *iter)
return hashtable_iter_next(&object->hashtable, iter);
}
+const object_key_t *jsonp_object_iter_fullkey(void *iter)
+{
+ if(!iter)
+ return NULL;
+
+ return hashtable_iter_key(iter);
+}
+
const char *json_object_iter_key(void *iter)
{
if(!iter)
return NULL;
- return (const char *)hashtable_iter_key(iter);
+ return jsonp_object_iter_fullkey(iter)->key;
}
json_t *json_object_iter_value(void *iter)
static void json_delete_array(json_array_t *array)
{
- unsigned int i;
+ size_t i;
for(i = 0; i < array->entries; i++)
json_decref(array->table[i]);
free(array);
}
-unsigned int json_array_size(const json_t *json)
+size_t 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_t *json_array_get(const json_t *json, size_t index)
{
json_array_t *array;
if(!json_is_array(json))
return array->table[index];
}
-int json_array_set_new(json_t *json, unsigned int index, json_t *value)
+int json_array_set_new(json_t *json, size_t index, json_t *value)
{
json_array_t *array;
return 0;
}
-static void array_move(json_array_t *array, unsigned int dest,
- unsigned int src, unsigned int count)
+static void array_move(json_array_t *array, size_t dest,
+ size_t src, size_t 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)
+static void array_copy(json_t **dest, size_t dpos,
+ json_t **src, size_t spos,
+ size_t count)
{
memcpy(&dest[dpos], &src[spos], count * sizeof(json_t *));
}
static json_t **json_array_grow(json_array_t *array,
- unsigned int amount,
+ size_t amount,
int copy)
{
- unsigned int new_size;
+ size_t new_size;
json_t **old_table, **new_table;
if(array->entries + amount <= array->size)
return 0;
}
-int json_array_insert_new(json_t *json, unsigned int index, json_t *value)
+int json_array_insert_new(json_t *json, size_t index, json_t *value)
{
json_array_t *array;
json_t **old_table;
return 0;
}
-int json_array_remove(json_t *json, unsigned int index)
+int json_array_remove(json_t *json, size_t index)
{
json_array_t *array;
int json_array_clear(json_t *json)
{
json_array_t *array;
- unsigned int i;
+ size_t i;
if(!json_is_array(json))
return -1;
int json_array_extend(json_t *json, json_t *other_json)
{
json_array_t *array, *other;
- unsigned int i;
+ size_t i;
if(!json_is_array(json) || !json_is_array(other_json))
return -1;
static int json_array_equal(json_t *array1, json_t *array2)
{
- unsigned int i, size;
+ size_t i, size;
size = json_array_size(array1);
if(size != json_array_size(array2))
static json_t *json_array_copy(json_t *array)
{
json_t *result;
- unsigned int i;
+ size_t i;
result = json_array();
if(!result)
static json_t *json_array_deep_copy(json_t *array)
{
json_t *result;
- unsigned int i;
+ size_t i;
result = json_array();
if(!result)
/*** integer ***/
-json_t *json_integer(int value)
+json_t *json_integer(json_int_t value)
{
json_integer_t *integer = malloc(sizeof(json_integer_t));
if(!integer)
return &integer->json;
}
-int 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, int value)
+int json_integer_set(json_t *json, json_int_t value)
{
if(!json_is_integer(json))
return -1;
json_t *json_true(void)
{
- static json_t the_true = {
- .type = JSON_TRUE,
- .refcount = (unsigned int)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 = (unsigned int)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 = (unsigned int)1
- };
+ static json_t the_null = {JSON_NULL, (size_t)-1};
return &the_null;
}
projects / jansson.git / blobdiff