PK!h arraylist.hnu[/* * $Id: arraylist.h,v 1.4 2006/01/26 02:16:28 mclark Exp $ * * Copyright (c) 2004, 2005 Metaparadigm Pte. Ltd. * Michael Clark * * This library is free software; you can redistribute it and/or modify * it under the terms of the MIT license. See COPYING for details. * */ /** * @file * @brief Internal methods for working with json_type_array objects. * Although this is exposed by the json_object_get_array() method, * it is not recommended for direct use. */ #ifndef _arraylist_h_ #define _arraylist_h_ #ifdef __cplusplus extern "C" { #endif #define ARRAY_LIST_DEFAULT_SIZE 32 typedef void (array_list_free_fn) (void *data); struct array_list { void **array; size_t length; size_t size; array_list_free_fn *free_fn; }; typedef struct array_list array_list; extern struct array_list* array_list_new(array_list_free_fn *free_fn); extern void array_list_free(struct array_list *al); extern void* array_list_get_idx(struct array_list *al, size_t i); extern int array_list_put_idx(struct array_list *al, size_t i, void *data); extern int array_list_add(struct array_list *al, void *data); extern size_t array_list_length(struct array_list *al); extern void array_list_sort(struct array_list *arr, int(*compar)(const void *, const void *)); extern void* array_list_bsearch(const void **key, struct array_list *arr, int (*sort_fn)(const void *, const void *)); extern int array_list_del_idx(struct array_list *arr, size_t idx, size_t count); #ifdef __cplusplus } #endif #endif PK!bits.hnu[/** * @file * @brief Do not use, only contains deprecated defines. * @deprecated Use json_util.h instead. * * $Id: bits.h,v 1.10 2006/01/30 23:07:57 mclark Exp $ * * Copyright (c) 2004, 2005 Metaparadigm Pte. Ltd. * Michael Clark * * This library is free software; you can redistribute it and/or modify * it under the terms of the MIT license. See COPYING for details. * */ #ifndef _bits_h_ #define _bits_h_ /** * @deprecated */ #define hexdigit(x) (((x) <= '9') ? (x) - '0' : ((x) & 7) + 9) /** * @deprecated */ #define error_ptr(error) ((void*)error) /** * @deprecated */ #define error_description(error) (json_tokener_get_error(error)) /** * @deprecated */ #define is_error(ptr) (ptr == NULL) #endif PK!Ёdebug.hnu[/* * $Id: debug.h,v 1.5 2006/01/30 23:07:57 mclark Exp $ * * Copyright (c) 2004, 2005 Metaparadigm Pte. Ltd. * Michael Clark * Copyright (c) 2009 Hewlett-Packard Development Company, L.P. * * This library is free software; you can redistribute it and/or modify * it under the terms of the MIT license. See COPYING for details. * */ /** * @file * @brief Do not use, json-c internal, may be changed or removed at any time. */ #ifndef _DEBUG_H_ #define _DEBUG_H_ #include #ifdef __cplusplus extern "C" { #endif extern void mc_set_debug(int debug); extern int mc_get_debug(void); extern void mc_set_syslog(int syslog); extern void mc_debug(const char *msg, ...); extern void mc_error(const char *msg, ...); extern void mc_info(const char *msg, ...); #ifndef __STRING #define __STRING(x) #x #endif #ifndef PARSER_BROKEN_FIXED #define JASSERT(cond) do {} while(0) #else #define JASSERT(cond) do { \ if (!(cond)) { \ mc_error("cjson assert failure %s:%d : cond \"" __STRING(cond) "failed\n", __FILE__, __LINE__); \ *(int *)0 = 1;\ abort(); \ }\ } while(0) #endif #define MC_ERROR(x, ...) mc_error(x, ##__VA_ARGS__) #ifdef MC_MAINTAINER_MODE #define MC_SET_DEBUG(x) mc_set_debug(x) #define MC_GET_DEBUG() mc_get_debug() #define MC_SET_SYSLOG(x) mc_set_syslog(x) #define MC_DEBUG(x, ...) mc_debug(x, ##__VA_ARGS__) #define MC_INFO(x, ...) mc_info(x, ##__VA_ARGS__) #else #define MC_SET_DEBUG(x) if (0) mc_set_debug(x) #define MC_GET_DEBUG() (0) #define MC_SET_SYSLOG(x) if (0) mc_set_syslog(x) #define MC_DEBUG(x, ...) if (0) mc_debug(x, ##__VA_ARGS__) #define MC_INFO(x, ...) if (0) mc_info(x, ##__VA_ARGS__) #endif #ifdef __cplusplus } #endif #endif PK!M**json.hnu[/* * $Id: json.h,v 1.6 2006/01/26 02:16:28 mclark Exp $ * * Copyright (c) 2004, 2005 Metaparadigm Pte. Ltd. * Michael Clark * Copyright (c) 2009 Hewlett-Packard Development Company, L.P. * * This library is free software; you can redistribute it and/or modify * it under the terms of the MIT license. See COPYING for details. * */ /** * @file * @brief A convenience header that may be included instead of other individual ones. */ #ifndef _json_h_ #define _json_h_ #ifdef __cplusplus extern "C" { #endif #include "debug.h" #include "linkhash.h" #include "arraylist.h" #include "json_util.h" #include "json_object.h" #include "json_pointer.h" #include "json_tokener.h" #include "json_object_iterator.h" #include "json_c_version.h" #ifdef __cplusplus } #endif #endif PK!ژjson_c_version.hnu[/* * Copyright (c) 2012,2017 Eric Haszlakiewicz * * This library is free software; you can redistribute it and/or modify * it under the terms of the MIT license. See COPYING for details. */ /** * @file * @brief Methods for retrieving the json-c version. */ #ifndef _json_c_version_h_ #define _json_c_version_h_ #define JSON_C_MAJOR_VERSION 0 #define JSON_C_MINOR_VERSION 13 #define JSON_C_MICRO_VERSION 01 #define JSON_C_VERSION_NUM ((JSON_C_MAJOR_VERSION << 16) | \ (JSON_C_MINOR_VERSION << 8) | \ JSON_C_MICRO_VERSION) #define JSON_C_VERSION "0.13.1" /** * @see JSON_C_VERSION * @return the version of the json-c library as a string */ const char *json_c_version(void); /* Returns JSON_C_VERSION */ /** * The json-c version encoded into an int, with the low order 8 bits * being the micro version, the next higher 8 bits being the minor version * and the next higher 8 bits being the major version. * For example, 7.12.99 would be 0x00070B63. * * @see JSON_C_VERSION_NUM * @return the version of the json-c library as an int */ int json_c_version_num(void); /* Returns JSON_C_VERSION_NUM */ #endif PK!nƣ json_config.hnu[/* json_config.h. Generated from json_config.h.in by configure. */ /* Define to 1 if you have the header file. */ #define JSON_C_HAVE_INTTYPES_H 1 PK!:"/^^json_inttypes.hnu[ /** * @file * @brief Do not use, json-c internal, may be changed or removed at any time. */ #ifndef _json_inttypes_h_ #define _json_inttypes_h_ #include "json_config.h" #ifdef JSON_C_HAVE_INTTYPES_H /* inttypes.h includes stdint.h */ #include #else #include #define PRId64 "I64d" #define SCNd64 "I64d" #endif #endif PK!ʷohh json_object.hnu[/* * $Id: json_object.h,v 1.12 2006/01/30 23:07:57 mclark Exp $ * * Copyright (c) 2004, 2005 Metaparadigm Pte. Ltd. * Michael Clark * Copyright (c) 2009 Hewlett-Packard Development Company, L.P. * * This library is free software; you can redistribute it and/or modify * it under the terms of the MIT license. See COPYING for details. * */ /** * @file * @brief Core json-c API. Start here, or with json_tokener.h */ #ifndef _json_object_h_ #define _json_object_h_ #ifdef __GNUC__ #define THIS_FUNCTION_IS_DEPRECATED(func) func __attribute__ ((deprecated)) #elif defined(_MSC_VER) #define THIS_FUNCTION_IS_DEPRECATED(func) __declspec(deprecated) func #elif defined(__clang__) #define THIS_FUNCTION_IS_DEPRECATED(func) func __deprecated #else #define THIS_FUNCTION_IS_DEPRECATED(func) func #endif #ifdef __GNUC__ #define JSON_C_CONST_FUNCTION(func) func __attribute__((const)) #else #define JSON_C_CONST_FUNCTION(func) func #endif #if defined(_MSC_VER) #define JSON_EXPORT __declspec(dllexport) #else #define JSON_EXPORT extern #endif #include #include "json_inttypes.h" #include "printbuf.h" #ifdef __cplusplus extern "C" { #endif #define JSON_OBJECT_DEF_HASH_ENTRIES 16 /** * A flag for the json_object_to_json_string_ext() and * json_object_to_file_ext() functions which causes the output * to have no extra whitespace or formatting applied. */ #define JSON_C_TO_STRING_PLAIN 0 /** * A flag for the json_object_to_json_string_ext() and * json_object_to_file_ext() functions which causes the output to have * minimal whitespace inserted to make things slightly more readable. */ #define JSON_C_TO_STRING_SPACED (1<<0) /** * A flag for the json_object_to_json_string_ext() and * json_object_to_file_ext() functions which causes * the output to be formatted. * * See the "Two Space Tab" option at http://jsonformatter.curiousconcept.com/ * for an example of the format. */ #define JSON_C_TO_STRING_PRETTY (1<<1) /** * A flag for the json_object_to_json_string_ext() and * json_object_to_file_ext() functions which causes * the output to be formatted. * * Instead of a "Two Space Tab" this gives a single tab character. */ #define JSON_C_TO_STRING_PRETTY_TAB (1<<3) /** * A flag to drop trailing zero for float values */ #define JSON_C_TO_STRING_NOZERO (1<<2) /** * Don't escape forward slashes. */ #define JSON_C_TO_STRING_NOSLASHESCAPE (1<<4) /** * A flag for the json_object_object_add_ex function which * causes the value to be added without a check if it already exists. * Note: it is the responsibilty of the caller to ensure that no * key is added multiple times. If this is done, results are * unpredictable. While this option is somewhat dangerous, it * permits potentially large performance savings in code that * knows for sure the key values are unique (e.g. because the * code adds a well-known set of constant key values). */ #define JSON_C_OBJECT_ADD_KEY_IS_NEW (1<<1) /** * A flag for the json_object_object_add_ex function which * flags the key as being constant memory. This means that * the key will NOT be copied via strdup(), resulting in a * potentially huge performance win (malloc, strdup and * free are usually performance hogs). It is acceptable to * use this flag for keys in non-constant memory blocks if * the caller ensure that the memory holding the key lives * longer than the corresponding json object. However, this * is somewhat dangerous and should only be done if really * justified. * The general use-case for this flag is cases where the * key is given as a real constant value in the function * call, e.g. as in * json_object_object_add_ex(obj, "ip", json, * JSON_C_OBJECT_KEY_IS_CONSTANT); */ #define JSON_C_OBJECT_KEY_IS_CONSTANT (1<<2) #undef FALSE #define FALSE ((json_bool)0) #undef TRUE #define TRUE ((json_bool)1) /** * Set the global value of an option, which will apply to all * current and future threads that have not set a thread-local value. * * @see json_c_set_serialization_double_format */ #define JSON_C_OPTION_GLOBAL (0) /** * Set a thread-local value of an option, overriding the global value. * This will fail if json-c is not compiled with threading enabled, and * with the __thread specifier (or equivalent) available. * * @see json_c_set_serialization_double_format */ #define JSON_C_OPTION_THREAD (1) /** * A structure to use with json_object_object_foreachC() loops. * Contains key, val and entry members. */ struct json_object_iter { char *key; struct json_object *val; struct lh_entry *entry; }; typedef struct json_object_iter json_object_iter; typedef int json_bool; /** * @brief The core type for all type of JSON objects handled by json-c */ typedef struct json_object json_object; /** * Type of custom user delete functions. See json_object_set_serializer. */ typedef void (json_object_delete_fn)(struct json_object *jso, void *userdata); /** * Type of a custom serialization function. See json_object_set_serializer. */ typedef int (json_object_to_json_string_fn)(struct json_object *jso, struct printbuf *pb, int level, int flags); /* supported object types */ typedef enum json_type { /* If you change this, be sure to update json_type_to_name() too */ json_type_null, json_type_boolean, json_type_double, json_type_int, json_type_object, json_type_array, json_type_string } json_type; /* reference counting functions */ /** * Increment the reference count of json_object, thereby grabbing shared * ownership of obj. * * @param obj the json_object instance */ JSON_EXPORT struct json_object* json_object_get(struct json_object *obj); /** * Decrement the reference count of json_object and free if it reaches zero. * You must have ownership of obj prior to doing this or you will cause an * imbalance in the reference count. * * @param obj the json_object instance * @returns 1 if the object was freed. */ JSON_EXPORT int json_object_put(struct json_object *obj); /** * Check if the json_object is of a given type * @param obj the json_object instance * @param type one of: json_type_null (i.e. obj == NULL), json_type_boolean, json_type_double, json_type_int, json_type_object, json_type_array, json_type_string */ JSON_EXPORT int json_object_is_type(const struct json_object *obj, enum json_type type); /** * Get the type of the json_object. See also json_type_to_name() to turn this * into a string suitable, for instance, for logging. * * @param obj the json_object instance * @returns type being one of: json_type_null (i.e. obj == NULL), json_type_boolean, json_type_double, json_type_int, json_type_object, json_type_array, json_type_string */ JSON_EXPORT enum json_type json_object_get_type(const struct json_object *obj); /** Stringify object to json format. * Equivalent to json_object_to_json_string_ext(obj, JSON_C_TO_STRING_SPACED) * The pointer you get is an internal of your json object. You don't * have to free it, later use of json_object_put() should be sufficient. * If you can not ensure there's no concurrent access to *obj use * strdup(). * @param obj the json_object instance * @returns a string in JSON format */ JSON_EXPORT const char* json_object_to_json_string(struct json_object *obj); /** Stringify object to json format * @see json_object_to_json_string() for details on how to free string. * @param obj the json_object instance * @param flags formatting options, see JSON_C_TO_STRING_PRETTY and other constants * @returns a string in JSON format */ JSON_EXPORT const char* json_object_to_json_string_ext(struct json_object *obj, int flags); /** Stringify object to json format * @see json_object_to_json_string() for details on how to free string. * @param obj the json_object instance * @param flags formatting options, see JSON_C_TO_STRING_PRETTY and other constants * @param length a pointer where, if not NULL, the length (without null) is stored * @returns a string in JSON format and the length if not NULL */ JSON_EXPORT const char* json_object_to_json_string_length(struct json_object *obj, int flags, size_t *length); /** * Returns the userdata set by json_object_set_userdata() or * json_object_set_serializer() * * @param jso the object to return the userdata for */ JSON_EXPORT void* json_object_get_userdata(json_object *jso); /** * Set an opaque userdata value for an object * * The userdata can be retrieved using json_object_get_userdata(). * * If custom userdata is already set on this object, any existing user_delete * function is called before the new one is set. * * The user_delete parameter is optional and may be passed as NULL, even if * the userdata parameter is non-NULL. It will be called just before the * json_object is deleted, after it's reference count goes to zero * (see json_object_put()). * If this is not provided, it is up to the caller to free the userdata at * an appropriate time. (i.e. after the json_object is deleted) * * Note: Objects created by parsing strings may have custom serializers set * which expect the userdata to contain specific data (due to use of * json_object_new_double_s()). In this case, json_object_set_serialiser() with * NULL as to_string_func should be used instead to set the userdata and reset * the serializer to its default value. * * @param jso the object to set the userdata for * @param userdata an optional opaque cookie * @param user_delete an optional function from freeing userdata */ JSON_EXPORT void json_object_set_userdata(json_object *jso, void *userdata, json_object_delete_fn *user_delete); /** * Set a custom serialization function to be used when this particular object * is converted to a string by json_object_to_json_string. * * If custom userdata is already set on this object, any existing user_delete * function is called before the new one is set. * * If to_string_func is NULL the default behaviour is reset (but the userdata * and user_delete fields are still set). * * The userdata parameter is optional and may be passed as NULL. It can be used * to provide additional data for to_string_func to use. This parameter may * be NULL even if user_delete is non-NULL. * * The user_delete parameter is optional and may be passed as NULL, even if * the userdata parameter is non-NULL. It will be called just before the * json_object is deleted, after it's reference count goes to zero * (see json_object_put()). * If this is not provided, it is up to the caller to free the userdata at * an appropriate time. (i.e. after the json_object is deleted) * * Note that the userdata is the same as set by json_object_set_userdata(), so * care must be taken not to overwrite the value when both a custom serializer * and json_object_set_userdata() are used. * * @param jso the object to customize * @param to_string_func the custom serialization function * @param userdata an optional opaque cookie * @param user_delete an optional function from freeing userdata */ JSON_EXPORT void json_object_set_serializer(json_object *jso, json_object_to_json_string_fn *to_string_func, void *userdata, json_object_delete_fn *user_delete); #ifdef __clang__ /* * Clang doesn't pay attention to the parameters defined in the * function typedefs used here, so turn off spurious doc warnings. * { */ #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wdocumentation" #endif /** * Simply call free on the userdata pointer. * Can be used with json_object_set_serializer(). * * @param jso unused * @param userdata the pointer that is passed to free(). */ json_object_delete_fn json_object_free_userdata; /** * Copy the jso->_userdata string over to pb as-is. * Can be used with json_object_set_serializer(). * * @param jso The object whose _userdata is used. * @param pb The destination buffer. * @param level Ignored. * @param flags Ignored. */ json_object_to_json_string_fn json_object_userdata_to_json_string; #ifdef __clang__ /* } */ #pragma clang diagnostic pop #endif /* object type methods */ /** Create a new empty object with a reference count of 1. The caller of * this object initially has sole ownership. Remember, when using * json_object_object_add or json_object_array_put_idx, ownership will * transfer to the object/array. Call json_object_get if you want to maintain * shared ownership or also add this object as a child of multiple objects or * arrays. Any ownerships you acquired but did not transfer must be released * through json_object_put. * * @returns a json_object of type json_type_object */ JSON_EXPORT struct json_object* json_object_new_object(void); /** Get the hashtable of a json_object of type json_type_object * @param obj the json_object instance * @returns a linkhash */ JSON_EXPORT struct lh_table* json_object_get_object(const struct json_object *obj); /** Get the size of an object in terms of the number of fields it has. * @param obj the json_object whose length to return */ JSON_EXPORT int json_object_object_length(const struct json_object* obj); /** Get the sizeof (struct json_object). * @returns a size_t with the sizeof (struct json_object) */ JSON_C_CONST_FUNCTION(JSON_EXPORT size_t json_c_object_sizeof(void)); /** Add an object field to a json_object of type json_type_object * * The reference count will *not* be incremented. This is to make adding * fields to objects in code more compact. If you want to retain a reference * to an added object, independent of the lifetime of obj, you must wrap the * passed object with json_object_get. * * Upon calling this, the ownership of val transfers to obj. Thus you must * make sure that you do in fact have ownership over this object. For instance, * json_object_new_object will give you ownership until you transfer it, * whereas json_object_object_get does not. * * @param obj the json_object instance * @param key the object field name (a private copy will be duplicated) * @param val a json_object or NULL member to associate with the given field * * @return On success, 0 is returned. * On error, a negative value is returned. */ JSON_EXPORT int json_object_object_add(struct json_object* obj, const char *key, struct json_object *val); /** Add an object field to a json_object of type json_type_object * * The semantics are identical to json_object_object_add, except that an * additional flag fields gives you more control over some detail aspects * of processing. See the description of JSON_C_OBJECT_ADD_* flags for more * details. * * @param obj the json_object instance * @param key the object field name (a private copy will be duplicated) * @param val a json_object or NULL member to associate with the given field * @param opts process-modifying options. To specify multiple options, use * arithmetic or (OPT1|OPT2) */ JSON_EXPORT int json_object_object_add_ex(struct json_object* obj, const char *const key, struct json_object *const val, const unsigned opts); /** Get the json_object associate with a given object field. * Deprecated/discouraged: used json_object_object_get_ex instead. * * This returns NULL if the field is found but its value is null, or if * the field is not found, or if obj is not a json_type_object. If you * need to distinguis between these cases, use json_object_object_get_ex(). * * *No* reference counts will be changed. There is no need to manually adjust * reference counts through the json_object_put/json_object_get methods unless * you need to have the child (value) reference maintain a different lifetime * than the owning parent (obj). Ownership of the returned value is retained * by obj (do not do json_object_put unless you have done a json_object_get). * If you delete the value from obj (json_object_object_del) and wish to access * the returned reference afterwards, make sure you have first gotten shared * ownership through json_object_get (& don't forget to do a json_object_put * or transfer ownership to prevent a memory leak). * * @param obj the json_object instance * @param key the object field name * @returns the json_object associated with the given field name */ JSON_EXPORT struct json_object* json_object_object_get(const struct json_object* obj, const char *key); /** Get the json_object associated with a given object field. * * This returns true if the key is found, false in all other cases (including * if obj isn't a json_type_object). * * *No* reference counts will be changed. There is no need to manually adjust * reference counts through the json_object_put/json_object_get methods unless * you need to have the child (value) reference maintain a different lifetime * than the owning parent (obj). Ownership of value is retained by obj. * * @param obj the json_object instance * @param key the object field name * @param value a pointer where to store a reference to the json_object * associated with the given field name. * * It is safe to pass a NULL value. * @returns whether or not the key exists */ JSON_EXPORT json_bool json_object_object_get_ex(const struct json_object* obj, const char *key, struct json_object **value); /** Delete the given json_object field * * The reference count will be decremented for the deleted object. If there * are no more owners of the value represented by this key, then the value is * freed. Otherwise, the reference to the value will remain in memory. * * @param obj the json_object instance * @param key the object field name */ JSON_EXPORT void json_object_object_del(struct json_object* obj, const char *key); /** * Iterate through all keys and values of an object. * * Adding keys to the object while iterating is NOT allowed. * * Deleting an existing key, or replacing an existing key with a * new value IS allowed. * * @param obj the json_object instance * @param key the local name for the char* key variable defined in the body * @param val the local name for the json_object* object variable defined in * the body */ #if defined(__GNUC__) && !defined(__STRICT_ANSI__) && __STDC_VERSION__ >= 199901L # define json_object_object_foreach(obj,key,val) \ char *key = NULL; \ struct json_object *val __attribute__((__unused__)) = NULL; \ for(struct lh_entry *entry ## key = json_object_get_object(obj)->head, *entry_next ## key = NULL; \ ({ if(entry ## key) { \ key = (char*)lh_entry_k(entry ## key); \ val = (struct json_object*)lh_entry_v(entry ## key); \ entry_next ## key = entry ## key->next; \ } ; entry ## key; }); \ entry ## key = entry_next ## key ) #else /* ANSI C or MSC */ # define json_object_object_foreach(obj,key,val) \ char *key = NULL;\ struct json_object *val = NULL; \ struct lh_entry *entry ## key; \ struct lh_entry *entry_next ## key = NULL; \ for(entry ## key = json_object_get_object(obj)->head; \ (entry ## key ? ( \ key = (char*)lh_entry_k(entry ## key), \ val = (struct json_object*)lh_entry_v(entry ## key), \ entry_next ## key = entry ## key->next, \ entry ## key) : 0); \ entry ## key = entry_next ## key) #endif /* defined(__GNUC__) && !defined(__STRICT_ANSI__) && __STDC_VERSION__ >= 199901L */ /** Iterate through all keys and values of an object (ANSI C Safe) * @param obj the json_object instance * @param iter the object iterator, use type json_object_iter */ #define json_object_object_foreachC(obj,iter) \ for(iter.entry = json_object_get_object(obj)->head; \ (iter.entry ? (iter.key = (char*)lh_entry_k(iter.entry), iter.val = (struct json_object*)lh_entry_v(iter.entry), iter.entry) : 0); \ iter.entry = iter.entry->next) /* Array type methods */ /** Create a new empty json_object of type json_type_array * @returns a json_object of type json_type_array */ JSON_EXPORT struct json_object* json_object_new_array(void); /** Get the arraylist of a json_object of type json_type_array * @param obj the json_object instance * @returns an arraylist */ JSON_EXPORT struct array_list* json_object_get_array(const struct json_object *obj); /** Get the length of a json_object of type json_type_array * @param obj the json_object instance * @returns an int */ JSON_EXPORT size_t json_object_array_length(const struct json_object *obj); /** Sorts the elements of jso of type json_type_array * * Pointers to the json_object pointers will be passed as the two arguments * to sort_fn * * @param jso the json_object instance * @param sort_fn a sorting function */ JSON_EXPORT void json_object_array_sort(struct json_object *jso, int(*sort_fn)(const void *, const void *)); /** Binary search a sorted array for a specified key object. * * It depends on your compare function what's sufficient as a key. * Usually you create some dummy object with the parameter compared in * it, to identify the right item you're actually looking for. * * @see json_object_array_sort() for hints on the compare function. * * @param key a dummy json_object with the right key * @param jso the array object we're searching * @param sort_fn the sort/compare function * * @return the wanted json_object instance */ JSON_EXPORT struct json_object* json_object_array_bsearch( const struct json_object *key, const struct json_object *jso, int (*sort_fn)(const void *, const void *)); /** Add an element to the end of a json_object of type json_type_array * * The reference count will *not* be incremented. This is to make adding * fields to objects in code more compact. If you want to retain a reference * to an added object you must wrap the passed object with json_object_get * * @param obj the json_object instance * @param val the json_object to be added */ JSON_EXPORT int json_object_array_add(struct json_object *obj, struct json_object *val); /** Insert or replace an element at a specified index in an array (a json_object of type json_type_array) * * The reference count will *not* be incremented. This is to make adding * fields to objects in code more compact. If you want to retain a reference * to an added object you must wrap the passed object with json_object_get * * The reference count of a replaced object will be decremented. * * The array size will be automatically be expanded to the size of the * index if the index is larger than the current size. * * @param obj the json_object instance * @param idx the index to insert the element at * @param val the json_object to be added */ JSON_EXPORT int json_object_array_put_idx(struct json_object *obj, size_t idx, struct json_object *val); /** Get the element at specificed index of the array (a json_object of type json_type_array) * @param obj the json_object instance * @param idx the index to get the element at * @returns the json_object at the specified index (or NULL) */ JSON_EXPORT struct json_object* json_object_array_get_idx(const struct json_object *obj, size_t idx); /** Delete an elements from a specified index in an array (a json_object of type json_type_array) * * The reference count will be decremented for each of the deleted objects. If there * are no more owners of an element that is being deleted, then the value is * freed. Otherwise, the reference to the value will remain in memory. * * @param obj the json_object instance * @param idx the index to start deleting elements at * @param count the number of elements to delete * @returns 0 if the elements were successfully deleted */ JSON_EXPORT int json_object_array_del_idx(struct json_object *obj, size_t idx, size_t count); /* json_bool type methods */ /** Create a new empty json_object of type json_type_boolean * @param b a json_bool TRUE or FALSE (1 or 0) * @returns a json_object of type json_type_boolean */ JSON_EXPORT struct json_object* json_object_new_boolean(json_bool b); /** Get the json_bool value of a json_object * * The type is coerced to a json_bool if the passed object is not a json_bool. * integer and double objects will return FALSE if there value is zero * or TRUE otherwise. If the passed object is a string it will return * TRUE if it has a non zero length. If any other object type is passed * TRUE will be returned if the object is not NULL. * * @param obj the json_object instance * @returns a json_bool */ JSON_EXPORT json_bool json_object_get_boolean(const struct json_object *obj); /** Set the json_bool value of a json_object * * The type of obj is checked to be a json_type_boolean and 0 is returned * if it is not without any further actions. If type of obj is json_type_boolean * the obect value is chaned to new_value * * @param obj the json_object instance * @param new_value the value to be set * @returns 1 if value is set correctly, 0 otherwise */ JSON_EXPORT int json_object_set_boolean(struct json_object *obj,json_bool new_value); /* int type methods */ /** Create a new empty json_object of type json_type_int * Note that values are stored as 64-bit values internally. * To ensure the full range is maintained, use json_object_new_int64 instead. * @param i the integer * @returns a json_object of type json_type_int */ JSON_EXPORT struct json_object* json_object_new_int(int32_t i); /** Create a new empty json_object of type json_type_int * @param i the integer * @returns a json_object of type json_type_int */ JSON_EXPORT struct json_object* json_object_new_int64(int64_t i); /** Get the int value of a json_object * * The type is coerced to a int if the passed object is not a int. * double objects will return their integer conversion. Strings will be * parsed as an integer. If no conversion exists then 0 is returned * and errno is set to EINVAL. null is equivalent to 0 (no error values set) * * Note that integers are stored internally as 64-bit values. * If the value of too big or too small to fit into 32-bit, INT32_MAX or * INT32_MIN are returned, respectively. * * @param obj the json_object instance * @returns an int */ JSON_EXPORT int32_t json_object_get_int(const struct json_object *obj); /** Set the int value of a json_object * * The type of obj is checked to be a json_type_int and 0 is returned * if it is not without any further actions. If type of obj is json_type_int * the obect value is changed to new_value * * @param obj the json_object instance * @param new_value the value to be set * @returns 1 if value is set correctly, 0 otherwise */ JSON_EXPORT int json_object_set_int(struct json_object *obj,int new_value); /** Increment a json_type_int object by the given amount, which may be negative. * * If the type of obj is not json_type_int then 0 is returned with no further * action taken. * If the addition would result in a overflow, the object value * is set to INT64_MAX. * If the addition would result in a underflow, the object value * is set to INT64_MIN. * Neither overflow nor underflow affect the return value. * * @param obj the json_object instance * @param val the value to add * @returns 1 if the increment succeded, 0 otherwise */ JSON_EXPORT int json_object_int_inc(struct json_object *obj, int64_t val); /** Get the int value of a json_object * * The type is coerced to a int64 if the passed object is not a int64. * double objects will return their int64 conversion. Strings will be * parsed as an int64. If no conversion exists then 0 is returned. * * NOTE: Set errno to 0 directly before a call to this function to determine * whether or not conversion was successful (it does not clear the value for * you). * * @param obj the json_object instance * @returns an int64 */ JSON_EXPORT int64_t json_object_get_int64(const struct json_object *obj); /** Set the int64_t value of a json_object * * The type of obj is checked to be a json_type_int and 0 is returned * if it is not without any further actions. If type of obj is json_type_int * the obect value is chaned to new_value * * @param obj the json_object instance * @param new_value the value to be set * @returns 1 if value is set correctly, 0 otherwise */ JSON_EXPORT int json_object_set_int64(struct json_object *obj,int64_t new_value); /* double type methods */ /** Create a new empty json_object of type json_type_double * * @see json_object_double_to_json_string() for how to set a custom format string. * * @param d the double * @returns a json_object of type json_type_double */ JSON_EXPORT struct json_object* json_object_new_double(double d); /** * Create a new json_object of type json_type_double, using * the exact serialized representation of the value. * * This allows for numbers that would otherwise get displayed * inefficiently (e.g. 12.3 => "12.300000000000001") to be * serialized with the more convenient form. * * Notes: * * This is used by json_tokener_parse_ex() to allow for * an exact re-serialization of a parsed object. * * The userdata field is used to store the string representation, so it * can't be used for other data if this function is used. * * An equivalent sequence of calls is: * @code * jso = json_object_new_double(d); * json_object_set_serializer(jso, json_object_userdata_to_json_string, * strdup(ds), json_object_free_userdata); * @endcode * * @param d the numeric value of the double. * @param ds the string representation of the double. This will be copied. */ JSON_EXPORT struct json_object* json_object_new_double_s(double d, const char *ds); /** * Set a global or thread-local json-c option, depending on whether * JSON_C_OPTION_GLOBAL or JSON_C_OPTION_THREAD is passed. * Thread-local options default to undefined, and inherit from the global * value, even if the global value is changed after the thread is created. * Attempting to set thread-local options when threading is not compiled in * will result in an error. Be sure to check the return value. * * double_format is a "%g" printf format, such as "%.20g" * * @return -1 on errors, 0 on success. */ int json_c_set_serialization_double_format(const char *double_format, int global_or_thread); /** Serialize a json_object of type json_type_double to a string. * * This function isn't meant to be called directly. Instead, you can set a * custom format string for the serialization of this double using the * following call (where "%.17g" actually is the default): * * @code * jso = json_object_new_double(d); * json_object_set_serializer(jso, json_object_double_to_json_string, * "%.17g", NULL); * @endcode * * @see printf(3) man page for format strings * * @param jso The json_type_double object that is serialized. * @param pb The destination buffer. * @param level Ignored. * @param flags Ignored. */ JSON_EXPORT int json_object_double_to_json_string(struct json_object* jso, struct printbuf *pb, int level, int flags); /** Get the double floating point value of a json_object * * The type is coerced to a double if the passed object is not a double. * integer objects will return their double conversion. Strings will be * parsed as a double. If no conversion exists then 0.0 is returned and * errno is set to EINVAL. null is equivalent to 0 (no error values set) * * If the value is too big to fit in a double, then the value is set to * the closest infinity with errno set to ERANGE. If strings cannot be * converted to their double value, then EINVAL is set & NaN is returned. * * Arrays of length 0 are interpreted as 0 (with no error flags set). * Arrays of length 1 are effectively cast to the equivalent object and * converted using the above rules. All other arrays set the error to * EINVAL & return NaN. * * NOTE: Set errno to 0 directly before a call to this function to * determine whether or not conversion was successful (it does not clear * the value for you). * * @param obj the json_object instance * @returns a double floating point number */ JSON_EXPORT double json_object_get_double(const struct json_object *obj); /** Set the double value of a json_object * * The type of obj is checked to be a json_type_double and 0 is returned * if it is not without any further actions. If type of obj is json_type_double * the obect value is chaned to new_value * * @param obj the json_object instance * @param new_value the value to be set * @returns 1 if value is set correctly, 0 otherwise */ JSON_EXPORT int json_object_set_double(struct json_object *obj,double new_value); /* string type methods */ /** Create a new empty json_object of type json_type_string * * A copy of the string is made and the memory is managed by the json_object * * @param s the string * @returns a json_object of type json_type_string */ JSON_EXPORT struct json_object* json_object_new_string(const char *s); JSON_EXPORT struct json_object* json_object_new_string_len(const char *s, int len); /** Get the string value of a json_object * * If the passed object is of type json_type_null (i.e. obj == NULL), * NULL is returned. * * If the passed object of type json_type_string, the string contents * are returned. * * Otherwise the JSON representation of the object is returned. * * The returned string memory is managed by the json_object and will * be freed when the reference count of the json_object drops to zero. * * @param obj the json_object instance * @returns a string or NULL */ JSON_EXPORT const char* json_object_get_string(struct json_object *obj); /** Get the string length of a json_object * * If the passed object is not of type json_type_string then zero * will be returned. * * @param obj the json_object instance * @returns int */ JSON_EXPORT int json_object_get_string_len(const struct json_object *obj); /** Set the string value of a json_object with zero terminated strings * equivalent to json_object_set_string_len (obj, new_value, strlen(new_value)) * @returns 1 if value is set correctly, 0 otherwise */ JSON_EXPORT int json_object_set_string(json_object* obj, const char* new_value); /** Set the string value of a json_object str * * The type of obj is checked to be a json_type_string and 0 is returned * if it is not without any further actions. If type of obj is json_type_string * the obect value is chaned to new_value * * @param obj the json_object instance * @param new_value the value to be set; Since string legth is given in len this need not be zero terminated * @param len the length of new_value * @returns 1 if value is set correctly, 0 otherwise */ JSON_EXPORT int json_object_set_string_len(json_object* obj, const char* new_value, int len); /** Check if two json_object's are equal * * If the passed objects are equal 1 will be returned. * Equality is defined as follows: * - json_objects of different types are never equal * - json_objects of the same primitive type are equal if the * c-representation of their value is equal * - json-arrays are considered equal if all values at the same * indices are equal (same order) * - Complex json_objects are considered equal if all * contained objects referenced by their key are equal, * regardless their order. * * @param obj1 the first json_object instance * @param obj2 the second json_object instance * @returns whether both objects are equal or not */ JSON_EXPORT int json_object_equal(struct json_object *obj1, struct json_object *obj2); /** * Perform a shallow copy of src into *dst as part of an overall json_object_deep_copy(). * * If src is part of a containing object or array, parent will be non-NULL, * and key or index will be provided. * When shallow_copy is called *dst will be NULL, and must be non-NULL when it returns. * src will never be NULL. * * If shallow_copy sets the serializer on an object, return 2 to indicate to * json_object_deep_copy that it should not attempt to use the standard userdata * copy function. * * @return On success 1 or 2, -1 on errors */ typedef int (json_c_shallow_copy_fn)(json_object *src, json_object *parent, const char *key, size_t index, json_object **dst); /** * The default shallow copy implementation for use with json_object_deep_copy(). * This simply calls the appropriate json_object_new_() function and * copies over the serializer function (_to_json_string internal field of * the json_object structure) but not any _userdata or _user_delete values. * * If you're writing a custom shallow_copy function, perhaps because you're using * your own custom serializer, you can call this first to create the new object * before customizing it with json_object_set_serializer(). * * @return 1 on success, -1 on errors, but never 2. */ json_c_shallow_copy_fn json_c_shallow_copy_default; /** * Copy the contents of the JSON object. * The destination object must be initialized to NULL, * to make sure this function won't overwrite an existing JSON object. * * This does roughly the same thing as * `json_tokener_parse(json_object_get_string(src))`. * * @param src source JSON object whose contents will be copied * @param dst pointer to the destination object where the contents of `src`; * make sure this pointer is initialized to NULL * @param shallow_copy an optional function to copy individual objects, needed * when custom serializers are in use. See also * json_object set_serializer. * * @returns 0 if the copy went well, -1 if an error occured during copy * or if the destination pointer is non-NULL */ JSON_EXPORT int json_object_deep_copy(struct json_object *src, struct json_object **dst, json_c_shallow_copy_fn *shallow_copy); #ifdef __cplusplus } #endif #endif PK!/SR R json_object_iterator.hnu[/** ******************************************************************************* * @file json_object_iterator.h * * Copyright (c) 2009-2012 Hewlett-Packard Development Company, L.P. * * This library is free software; you can redistribute it and/or modify * it under the terms of the MIT license. See COPYING for details. * * @brief An API for iterating over json_type_object objects, * styled to be familiar to C++ programmers. * Unlike json_object_object_foreach() and * json_object_object_foreachC(), this avoids the need to expose * json-c internals like lh_entry. * * API attributes:
* * Thread-safe: NO
* * Reentrant: NO * ******************************************************************************* */ #ifndef JSON_OBJECT_ITERATOR_H #define JSON_OBJECT_ITERATOR_H #include #ifdef __cplusplus extern "C" { #endif /** * Forward declaration for the opaque iterator information. */ struct json_object_iter_info_; /** * The opaque iterator that references a name/value pair within * a JSON Object instance or the "end" iterator value. */ struct json_object_iterator { const void* opaque_; }; /** * forward declaration of json-c's JSON value instance structure */ struct json_object; /** * Initializes an iterator structure to a "default" value that * is convenient for initializing an iterator variable to a * default state (e.g., initialization list in a class' * constructor). * * @code * struct json_object_iterator iter = json_object_iter_init_default(); * MyClass() : iter_(json_object_iter_init_default()) * @endcode * * @note The initialized value doesn't reference any specific * pair, is considered an invalid iterator, and MUST NOT * be passed to any json-c API that expects a valid * iterator. * * @note User and internal code MUST NOT make any assumptions * about and dependencies on the value of the "default" * iterator value. * * @return json_object_iterator */ struct json_object_iterator json_object_iter_init_default(void); /** Retrieves an iterator to the first pair of the JSON Object. * * @warning Any modification of the underlying pair invalidates all * iterators to that pair. * * @param obj JSON Object instance (MUST be of type json_object) * * @return json_object_iterator If the JSON Object has at * least one pair, on return, the iterator refers * to the first pair. If the JSON Object doesn't * have any pairs, the returned iterator is * equivalent to the "end" iterator for the same * JSON Object instance. * * @code * struct json_object_iterator it; * struct json_object_iterator itEnd; * struct json_object* obj; * * obj = json_tokener_parse("{'first':'george', 'age':100}"); * it = json_object_iter_begin(obj); * itEnd = json_object_iter_end(obj); * * while (!json_object_iter_equal(&it, &itEnd)) { * printf("%s\n", * json_object_iter_peek_name(&it)); * json_object_iter_next(&it); * } * * @endcode */ struct json_object_iterator json_object_iter_begin(struct json_object* obj); /** Retrieves the iterator that represents the position beyond the * last pair of the given JSON Object instance. * * @warning Do NOT write code that assumes that the "end" * iterator value is NULL, even if it is so in a * particular instance of the implementation. * * @note The reason we do not (and MUST NOT) provide * "json_object_iter_is_end(json_object_iterator* iter)" * type of API is because it would limit the underlying * representation of name/value containment (or force us * to add additional, otherwise unnecessary, fields to * the iterator structure). The "end" iterator and the * equality test method, on the other hand, permit us to * cleanly abstract pretty much any reasonable underlying * representation without burdening the iterator * structure with unnecessary data. * * @note For performance reasons, memorize the "end" iterator prior * to any loop. * * @param obj JSON Object instance (MUST be of type json_object) * * @return json_object_iterator On return, the iterator refers * to the "end" of the Object instance's pairs * (i.e., NOT the last pair, but "beyond the last * pair" value) */ struct json_object_iterator json_object_iter_end(const struct json_object* obj); /** Returns an iterator to the next pair, if any * * @warning Any modification of the underlying pair * invalidates all iterators to that pair. * * @param iter [IN/OUT] Pointer to iterator that references a * name/value pair; MUST be a valid, non-end iterator. * WARNING: bad things will happen if invalid or "end" * iterator is passed. Upon return will contain the * reference to the next pair if there is one; if there * are no more pairs, will contain the "end" iterator * value, which may be compared against the return value * of json_object_iter_end() for the same JSON Object * instance. */ void json_object_iter_next(struct json_object_iterator* iter); /** Returns a const pointer to the name of the pair referenced * by the given iterator. * * @param iter pointer to iterator that references a name/value * pair; MUST be a valid, non-end iterator. * * @warning bad things will happen if an invalid or * "end" iterator is passed. * * @return const char* Pointer to the name of the referenced * name/value pair. The name memory belongs to the * name/value pair, will be freed when the pair is * deleted or modified, and MUST NOT be modified or * freed by the user. */ const char* json_object_iter_peek_name(const struct json_object_iterator* iter); /** Returns a pointer to the json-c instance representing the * value of the referenced name/value pair, without altering * the instance's reference count. * * @param iter pointer to iterator that references a name/value * pair; MUST be a valid, non-end iterator. * * @warning bad things will happen if invalid or * "end" iterator is passed. * * @return struct json_object* Pointer to the json-c value * instance of the referenced name/value pair; the * value's reference count is not changed by this * function: if you plan to hold on to this json-c node, * take a look at json_object_get() and * json_object_put(). IMPORTANT: json-c API represents * the JSON Null value as a NULL json_object instance * pointer. */ struct json_object* json_object_iter_peek_value(const struct json_object_iterator* iter); /** Tests two iterators for equality. Typically used to test * for end of iteration by comparing an iterator to the * corresponding "end" iterator (that was derived from the same * JSON Object instance). * * @note The reason we do not (and MUST NOT) provide * "json_object_iter_is_end(json_object_iterator* iter)" * type of API is because it would limit the underlying * representation of name/value containment (or force us * to add additional, otherwise unnecessary, fields to * the iterator structure). The equality test method, on * the other hand, permits us to cleanly abstract pretty * much any reasonable underlying representation. * * @param iter1 Pointer to first valid, non-NULL iterator * @param iter2 POinter to second valid, non-NULL iterator * * @warning if a NULL iterator pointer or an uninitialized * or invalid iterator, or iterators derived from * different JSON Object instances are passed, bad things * will happen! * * @return json_bool non-zero if iterators are equal (i.e., both * reference the same name/value pair or are both at * "end"); zero if they are not equal. */ json_bool json_object_iter_equal(const struct json_object_iterator* iter1, const struct json_object_iterator* iter2); #ifdef __cplusplus } #endif #endif /* JSON_OBJECT_ITERATOR_H */ PK!ljson_pointer.hnu[/* * Copyright (c) 2016 Alexadru Ardelean. * * This is free software; you can redistribute it and/or modify * it under the terms of the MIT license. See COPYING for details. * */ /** * @file * @brief JSON Pointer (RFC 6901) implementation for retrieving * objects from a json-c object tree. */ #ifndef _json_pointer_h_ #define _json_pointer_h_ #include "json_object.h" #ifdef __cplusplus extern "C" { #endif /** * Retrieves a JSON sub-object from inside another JSON object * using the JSON pointer notation as defined in RFC 6901 * https://tools.ietf.org/html/rfc6901 * * The returned JSON sub-object is equivalent to parsing manually the * 'obj' JSON tree ; i.e. it's not a new object that is created, but rather * a pointer inside the JSON tree. * * Internally, this is equivalent to doing a series of 'json_object_object_get()' * and 'json_object_array_get_idx()' along the given 'path'. * * Note that the 'path' string supports 'printf()' type arguments, so, whatever * is added after the 'res' param will be treated as an argument for 'path' * Example: json_pointer_get(obj, "/foo/%d/%s", &res, 0, bar) * This means, that you need to escape '%' with '%%' (just like in printf()) * * @param obj the json_object instance/tree from where to retrieve sub-objects * @param path a (RFC6901) string notation for the sub-object to retrieve * @param res a pointer where to store a reference to the json_object * associated with the given path * * @return negative if an error (or not found), or 0 if succeeded */ int json_pointer_get(struct json_object *obj, const char *path, struct json_object **res); /** * This is a variant of 'json_pointer_get()' that supports printf() style arguments. * * Example: json_pointer_getf(obj, res, "/foo/%d/%s", 0, bak) * This also means that you need to escape '%' with '%%' (just like in printf()) * * Please take into consideration all recommended 'printf()' format security * aspects when using this function. * * @param obj the json_object instance/tree to which to add a sub-object * @param res a pointer where to store a reference to the json_object * associated with the given path * @param path_fmt a printf() style format for the path * * @return negative if an error (or not found), or 0 if succeeded */ int json_pointer_getf(struct json_object *obj, struct json_object **res, const char *path_fmt, ...); /** * Sets JSON object 'value' in the 'obj' tree at the location specified * by the 'path'. 'path' is JSON pointer notation as defined in RFC 6901 * https://tools.ietf.org/html/rfc6901 * * Note that 'obj' is a double pointer, mostly for the "" (empty string) * case, where the entire JSON object would be replaced by 'value'. * In the case of the "" path, the object at '*obj' will have it's refcount * decremented with 'json_object_put()' and the 'value' object will be assigned to it. * * For other cases (JSON sub-objects) ownership of 'value' will be transferred into * '*obj' via 'json_object_object_add()' & 'json_object_array_put_idx()', so the * only time the refcount should be decremented for 'value' is when the return value of * 'json_pointer_set()' is negative (meaning the 'value' object did not get set into '*obj'). * * That also implies that 'json_pointer_set()' does not do any refcount incrementing. * (Just that single decrement that was mentioned above). * * Note that the 'path' string supports 'printf()' type arguments, so, whatever * is added after the 'value' param will be treated as an argument for 'path' * Example: json_pointer_set(obj, "/foo/%d/%s", value, 0, bak) * This means, that you need to escape '%' with '%%' (just like in printf()) * * @param obj the json_object instance/tree to which to add a sub-object * @param path a (RFC6901) string notation for the sub-object to set in the tree * @param value object to set at path * * @return negative if an error (or not found), or 0 if succeeded */ int json_pointer_set(struct json_object **obj, const char *path, struct json_object *value); /** * This is a variant of 'json_pointer_set()' that supports printf() style arguments. * * Example: json_pointer_setf(obj, value, "/foo/%d/%s", 0, bak) * This also means that you need to escape '%' with '%%' (just like in printf()) * * Please take into consideration all recommended 'printf()' format security * aspects when using this function. * * @param obj the json_object instance/tree to which to add a sub-object * @param value object to set at path * @param path_fmt a printf() style format for the path * * @return negative if an error (or not found), or 0 if succeeded */ int json_pointer_setf(struct json_object **obj, struct json_object *value, const char *path_fmt, ...); #ifdef __cplusplus } #endif #endif PK!%Mjson_tokener.hnu[/* * $Id: json_tokener.h,v 1.10 2006/07/25 03:24:50 mclark Exp $ * * Copyright (c) 2004, 2005 Metaparadigm Pte. Ltd. * Michael Clark * * This library is free software; you can redistribute it and/or modify * it under the terms of the MIT license. See COPYING for details. * */ /** * @file * @brief Methods to parse an input string into a tree of json_object objects. */ #ifndef _json_tokener_h_ #define _json_tokener_h_ #include #include "json_object.h" #ifdef __cplusplus extern "C" { #endif enum json_tokener_error { json_tokener_success, json_tokener_continue, json_tokener_error_depth, json_tokener_error_parse_eof, json_tokener_error_parse_unexpected, json_tokener_error_parse_null, json_tokener_error_parse_boolean, json_tokener_error_parse_number, json_tokener_error_parse_array, json_tokener_error_parse_object_key_name, json_tokener_error_parse_object_key_sep, json_tokener_error_parse_object_value_sep, json_tokener_error_parse_string, json_tokener_error_parse_comment, json_tokener_error_size }; enum json_tokener_state { json_tokener_state_eatws, json_tokener_state_start, json_tokener_state_finish, json_tokener_state_null, json_tokener_state_comment_start, json_tokener_state_comment, json_tokener_state_comment_eol, json_tokener_state_comment_end, json_tokener_state_string, json_tokener_state_string_escape, json_tokener_state_escape_unicode, json_tokener_state_boolean, json_tokener_state_number, json_tokener_state_array, json_tokener_state_array_add, json_tokener_state_array_sep, json_tokener_state_object_field_start, json_tokener_state_object_field, json_tokener_state_object_field_end, json_tokener_state_object_value, json_tokener_state_object_value_add, json_tokener_state_object_sep, json_tokener_state_array_after_sep, json_tokener_state_object_field_start_after_sep, json_tokener_state_inf }; struct json_tokener_srec { enum json_tokener_state state, saved_state; struct json_object *obj; struct json_object *current; char *obj_field_name; }; #define JSON_TOKENER_DEFAULT_DEPTH 32 struct json_tokener { char *str; struct printbuf *pb; int max_depth, depth, is_double, st_pos, char_offset; enum json_tokener_error err; unsigned int ucs_char; char quote_char; struct json_tokener_srec *stack; int flags; }; /** * @deprecated Unused in json-c code */ typedef struct json_tokener json_tokener; /** * Be strict when parsing JSON input. Use caution with * this flag as what is considered valid may become more * restrictive from one release to the next, causing your * code to fail on previously working input. * * This flag is not set by default. * * @see json_tokener_set_flags() */ #define JSON_TOKENER_STRICT 0x01 /** * Given an error previously returned by json_tokener_get_error(), * return a human readable description of the error. * * @return a generic error message is returned if an invalid error value is provided. */ const char *json_tokener_error_desc(enum json_tokener_error jerr); /** * Retrieve the error caused by the last call to json_tokener_parse_ex(), * or json_tokener_success if there is no error. * * When parsing a JSON string in pieces, if the tokener is in the middle * of parsing this will return json_tokener_continue. * * See also json_tokener_error_desc(). */ JSON_EXPORT enum json_tokener_error json_tokener_get_error(struct json_tokener *tok); JSON_EXPORT struct json_tokener* json_tokener_new(void); JSON_EXPORT struct json_tokener* json_tokener_new_ex(int depth); JSON_EXPORT void json_tokener_free(struct json_tokener *tok); JSON_EXPORT void json_tokener_reset(struct json_tokener *tok); JSON_EXPORT struct json_object* json_tokener_parse(const char *str); JSON_EXPORT struct json_object* json_tokener_parse_verbose(const char *str, enum json_tokener_error *error); /** * Set flags that control how parsing will be done. */ JSON_EXPORT void json_tokener_set_flags(struct json_tokener *tok, int flags); /** * Parse a string and return a non-NULL json_object if a valid JSON value * is found. The string does not need to be a JSON object or array; * it can also be a string, number or boolean value. * * A partial JSON string can be parsed. If the parsing is incomplete, * NULL will be returned and json_tokener_get_error() will return * json_tokener_continue. * json_tokener_parse_ex() can then be called with additional bytes in str * to continue the parsing. * * If json_tokener_parse_ex() returns NULL and the error is anything other than * json_tokener_continue, a fatal error has occurred and parsing must be * halted. Then, the tok object must not be reused until json_tokener_reset() is * called. * * When a valid JSON value is parsed, a non-NULL json_object will be * returned. Also, json_tokener_get_error() will return json_tokener_success. * Be sure to check the type with json_object_is_type() or * json_object_get_type() before using the object. * * @b XXX this shouldn't use internal fields: * Trailing characters after the parsed value do not automatically cause an * error. It is up to the caller to decide whether to treat this as an * error or to handle the additional characters, perhaps by parsing another * json value starting from that point. * * Extra characters can be detected by comparing the tok->char_offset against * the length of the last len parameter passed in. * * The tokener does \b not maintain an internal buffer so the caller is * responsible for calling json_tokener_parse_ex with an appropriate str * parameter starting with the extra characters. * * This interface is presently not 64-bit clean due to the int len argument * so the function limits the maximum string size to INT32_MAX (2GB). * If the function is called with len == -1 then strlen is called to check * the string length is less than INT32_MAX (2GB) * * Example: * @code json_object *jobj = NULL; const char *mystring = NULL; int stringlen = 0; enum json_tokener_error jerr; do { mystring = ... // get JSON string, e.g. read from file, etc... stringlen = strlen(mystring); jobj = json_tokener_parse_ex(tok, mystring, stringlen); } while ((jerr = json_tokener_get_error(tok)) == json_tokener_continue); if (jerr != json_tokener_success) { fprintf(stderr, "Error: %s\n", json_tokener_error_desc(jerr)); // Handle errors, as appropriate for your application. } if (tok->char_offset < stringlen) // XXX shouldn't access internal fields { // Handle extra characters after parsed object as desired. // e.g. issue an error, parse another object from that point, etc... } // Success, use jobj here. @endcode * * @param tok a json_tokener previously allocated with json_tokener_new() * @param str an string with any valid JSON expression, or portion of. This does not need to be null terminated. * @param len the length of str */ JSON_EXPORT struct json_object* json_tokener_parse_ex(struct json_tokener *tok, const char *str, int len); #ifdef __cplusplus } #endif #endif PK!I json_util.hnu[/* * $Id: json_util.h,v 1.4 2006/01/30 23:07:57 mclark Exp $ * * Copyright (c) 2004, 2005 Metaparadigm Pte. Ltd. * Michael Clark * * This library is free software; you can redistribute it and/or modify * it under the terms of the MIT license. See COPYING for details. * */ /** * @file * @brief Miscllaneous utility functions and macros. */ #ifndef _json_util_h_ #define _json_util_h_ #include "json_object.h" #ifndef json_min #define json_min(a,b) ((a) < (b) ? (a) : (b)) #endif #ifndef json_max #define json_max(a,b) ((a) > (b) ? (a) : (b)) #endif #ifdef __cplusplus extern "C" { #endif #define JSON_FILE_BUF_SIZE 4096 /* utility functions */ /** * Read the full contents of the given file, then convert it to a * json_object using json_tokener_parse(). * * Returns -1 if something fails. See json_util_get_last_err() for details. */ extern struct json_object* json_object_from_file(const char *filename); /** * Create a JSON object from already opened file descriptor. * * This function can be helpful, when you opened the file already, * e.g. when you have a temp file. * Note, that the fd must be readable at the actual position, i.e. * use lseek(fd, 0, SEEK_SET) before. * * Returns -1 if something fails. See json_util_get_last_err() for details. */ extern struct json_object* json_object_from_fd(int fd); /** * Equivalent to: * json_object_to_file_ext(filename, obj, JSON_C_TO_STRING_PLAIN); * * Returns -1 if something fails. See json_util_get_last_err() for details. */ extern int json_object_to_file(const char *filename, struct json_object *obj); /** * Open and truncate the given file, creating it if necessary, then * convert the json_object to a string and write it to the file. * * Returns -1 if something fails. See json_util_get_last_err() for details. */ extern int json_object_to_file_ext(const char *filename, struct json_object *obj, int flags); /** * Convert the json_object to a string and write it to the file descriptor. * Handles partial writes and will keep writing until done, or an error * occurs. * * @param fd an open, writable file descriptor to write to * @param obj the object to serializer and write * @param flags flags to pass to json_object_to_json_string_ext() * @return -1 if something fails. See json_util_get_last_err() for details. */ extern int json_object_to_fd(int fd, struct json_object *obj, int flags); /** * Return the last error from various json-c functions, including: * json_object_to_file{,_ext}, json_object_to_fd() or * json_object_from_{file,fd}, or NULL if there is none. */ const char *json_util_get_last_err(void); extern int json_parse_int64(const char *buf, int64_t *retval); extern int json_parse_double(const char *buf, double *retval); /** * Return a string describing the type of the object. * e.g. "int", or "object", etc... */ extern const char *json_type_to_name(enum json_type o_type); #ifdef __cplusplus } #endif #endif PK!^Qm m json_visit.hnu[ #ifndef _json_c_json_visit_h_ #define _json_c_json_visit_h_ /** * @file * @brief Methods for walking a tree of objects. */ #include "json_object.h" typedef int (json_c_visit_userfunc)(json_object *jso, int flags, json_object *parent_jso, const char *jso_key, size_t *jso_index, void *userarg); /** * Visit each object in the JSON hierarchy starting at jso. * For each object, userfunc is called, passing the object and userarg. * If the object has a parent (i.e. anything other than jso itself) * its parent will be passed as parent_jso, and either jso_key or jso_index * will be set, depending on whether the parent is an object or an array. * * Nodes will be visited depth first, but containers (arrays and objects) * will be visited twice, the second time with JSON_C_VISIT_SECOND set in * flags. * * userfunc must return one of the defined return values, to indicate * whether and how to continue visiting nodes, or one of various ways to stop. * * Returns 0 if nodes were visited successfully, even if some were * intentionally skipped due to what userfunc returned. * Returns <0 if an error occurred during iteration, including if * userfunc returned JSON_C_VISIT_RETURN_ERROR. */ int json_c_visit(json_object *jso, int future_flags, json_c_visit_userfunc *userfunc, void *userarg); /** * Passed to json_c_visit_userfunc as one of the flags values to indicate * that this is the second time a container (array or object) is being * called, after all of it's members have been iterated over. */ #define JSON_C_VISIT_SECOND 0x02 /** * This json_c_visit_userfunc return value indicates that iteration * should proceed normally. */ #define JSON_C_VISIT_RETURN_CONTINUE 0 /** * This json_c_visit_userfunc return value indicates that iteration * over the members of the current object should be skipped. * If the current object isn't a container (array or object), this * is no different than JSON_C_VISIT_RETURN_CONTINUE. */ #define JSON_C_VISIT_RETURN_SKIP 7547 /** * This json_c_visit_userfunc return value indicates that iteration * of the fields/elements of the containing object should stop * and continue "popped up" a level of the object hierarchy. * For example, returning this when handling arg will result in * arg3 and any other fields being skipped. The next call to userfunc * will be the JSON_C_VISIT_SECOND call on "foo", followed by a userfunc * call on "bar". * 
 * {
 *   "foo": {
 *     "arg1": 1,
 *     "arg2": 2,
 *     "arg3": 3,
 *     ...
 *   },
 *   "bar": {
 *     ...
 *   }
 * }
 *
*/ #define JSON_C_VISIT_RETURN_POP 767 /** * This json_c_visit_userfunc return value indicates that iteration * should stop immediately, and cause json_c_visit to return success. */ #define JSON_C_VISIT_RETURN_STOP 7867 /** * This json_c_visit_userfunc return value indicates that iteration * should stop immediately, and cause json_c_visit to return an error. */ #define JSON_C_VISIT_RETURN_ERROR -1 #endif /* _json_c_json_visit_h_ */ PK!?-++ linkhash.hnu[/* * $Id: linkhash.h,v 1.6 2006/01/30 23:07:57 mclark Exp $ * * Copyright (c) 2004, 2005 Metaparadigm Pte. Ltd. * Michael Clark * Copyright (c) 2009 Hewlett-Packard Development Company, L.P. * * This library is free software; you can redistribute it and/or modify * it under the terms of the MIT license. See COPYING for details. * */ /** * @file * @brief Internal methods for working with json_type_object objects. Although * this is exposed by the json_object_get_object() function and within the * json_object_iter type, it is not recommended for direct use. */ #ifndef _linkhash_h_ #define _linkhash_h_ #include "json_object.h" #ifdef __cplusplus extern "C" { #endif /** * golden prime used in hash functions */ #define LH_PRIME 0x9e370001UL /** * The fraction of filled hash buckets until an insert will cause the table * to be resized. * This can range from just above 0 up to 1.0. */ #define LH_LOAD_FACTOR 0.66 /** * sentinel pointer value for empty slots */ #define LH_EMPTY (void*)-1 /** * sentinel pointer value for freed slots */ #define LH_FREED (void*)-2 /** * default string hash function */ #define JSON_C_STR_HASH_DFLT 0 /** * perl-like string hash function */ #define JSON_C_STR_HASH_PERLLIKE 1 /** * This function sets the hash function to be used for strings. * Must be one of the JSON_C_STR_HASH_* values. * @returns 0 - ok, -1 if parameter was invalid */ int json_global_set_string_hash(const int h); struct lh_entry; /** * callback function prototypes */ typedef void (lh_entry_free_fn) (struct lh_entry *e); /** * callback function prototypes */ typedef unsigned long (lh_hash_fn) (const void *k); /** * callback function prototypes */ typedef int (lh_equal_fn) (const void *k1, const void *k2); /** * An entry in the hash table */ struct lh_entry { /** * The key. Use lh_entry_k() instead of accessing this directly. */ const void *k; /** * A flag for users of linkhash to know whether or not they * need to free k. */ int k_is_constant; /** * The value. Use lh_entry_v() instead of accessing this directly. */ const void *v; /** * The next entry */ struct lh_entry *next; /** * The previous entry. */ struct lh_entry *prev; }; /** * The hash table structure. */ struct lh_table { /** * Size of our hash. */ int size; /** * Numbers of entries. */ int count; /** * The first entry. */ struct lh_entry *head; /** * The last entry. */ struct lh_entry *tail; struct lh_entry *table; /** * A pointer onto the function responsible for freeing an entry. */ lh_entry_free_fn *free_fn; lh_hash_fn *hash_fn; lh_equal_fn *equal_fn; }; typedef struct lh_table lh_table; /** * Convenience list iterator. */ #define lh_foreach(table, entry) \ for(entry = table->head; entry; entry = entry->next) /** * lh_foreach_safe allows calling of deletion routine while iterating. * * @param table a struct lh_table * to iterate over * @param entry a struct lh_entry * variable to hold each element * @param tmp a struct lh_entry * variable to hold a temporary pointer to the next element */ #define lh_foreach_safe(table, entry, tmp) \ for(entry = table->head; entry && ((tmp = entry->next) || 1); entry = tmp) /** * Create a new linkhash table. * * @param size initial table size. The table is automatically resized * although this incurs a performance penalty. * @param free_fn callback function used to free memory for entries * when lh_table_free or lh_table_delete is called. * If NULL is provided, then memory for keys and values * must be freed by the caller. * @param hash_fn function used to hash keys. 2 standard ones are defined: * lh_ptr_hash and lh_char_hash for hashing pointer values * and C strings respectively. * @param equal_fn comparison function to compare keys. 2 standard ones defined: * lh_ptr_hash and lh_char_hash for comparing pointer values * and C strings respectively. * @return On success, a pointer to the new linkhash table is returned. * On error, a null pointer is returned. */ extern struct lh_table* lh_table_new(int size, lh_entry_free_fn *free_fn, lh_hash_fn *hash_fn, lh_equal_fn *equal_fn); /** * Convenience function to create a new linkhash table with char keys. * * @param size initial table size. * @param free_fn callback function used to free memory for entries. * @return On success, a pointer to the new linkhash table is returned. * On error, a null pointer is returned. */ extern struct lh_table* lh_kchar_table_new(int size, lh_entry_free_fn *free_fn); /** * Convenience function to create a new linkhash table with ptr keys. * * @param size initial table size. * @param free_fn callback function used to free memory for entries. * @return On success, a pointer to the new linkhash table is returned. * On error, a null pointer is returned. */ extern struct lh_table* lh_kptr_table_new(int size, lh_entry_free_fn *free_fn); /** * Free a linkhash table. * * If a lh_entry_free_fn callback free function was provided then it is * called for all entries in the table. * * @param t table to free. */ extern void lh_table_free(struct lh_table *t); /** * Insert a record into the table. * * @param t the table to insert into. * @param k a pointer to the key to insert. * @param v a pointer to the value to insert. * * @return On success, 0 is returned. * On error, a negative value is returned. */ extern int lh_table_insert(struct lh_table *t, const void *k, const void *v); /** * Insert a record into the table using a precalculated key hash. * * The hash h, which should be calculated with lh_get_hash() on k, is provided by * the caller, to allow for optimization when multiple operations with the same * key are known to be needed. * * @param t the table to insert into. * @param k a pointer to the key to insert. * @param v a pointer to the value to insert. * @param h hash value of the key to insert * @param opts if set to JSON_C_OBJECT_KEY_IS_CONSTANT, sets lh_entry.k_is_constant * so t's free function knows to avoid freeing the key. */ extern int lh_table_insert_w_hash(struct lh_table *t, const void *k, const void *v, const unsigned long h, const unsigned opts); /** * Lookup a record in the table. * * @param t the table to lookup * @param k a pointer to the key to lookup * @return a pointer to the record structure of the value or NULL if it does not exist. */ extern struct lh_entry* lh_table_lookup_entry(struct lh_table *t, const void *k); /** * Lookup a record in the table using a precalculated key hash. * * The hash h, which should be calculated with lh_get_hash() on k, is provided by * the caller, to allow for optimization when multiple operations with the same * key are known to be needed. * * @param t the table to lookup * @param k a pointer to the key to lookup * @param h hash value of the key to lookup * @return a pointer to the record structure of the value or NULL if it does not exist. */ extern struct lh_entry* lh_table_lookup_entry_w_hash(struct lh_table *t, const void *k, const unsigned long h); /** * Lookup a record into the table. * * @param t the table to lookup * @param k a pointer to the key to lookup * @return a pointer to the found value or NULL if it does not exist. * @deprecated Use lh_table_lookup_ex() instead. */ THIS_FUNCTION_IS_DEPRECATED(extern const void* lh_table_lookup(struct lh_table *t, const void *k)); /** * Lookup a record in the table. * * @param t the table to lookup * @param k a pointer to the key to lookup * @param v a pointer to a where to store the found value (set to NULL if it doesn't exist). * @return whether or not the key was found */ extern json_bool lh_table_lookup_ex(struct lh_table *t, const void *k, void **v); /** * Delete a record from the table. * * If a callback free function is provided then it is called for the * for the item being deleted. * @param t the table to delete from. * @param e a pointer to the entry to delete. * @return 0 if the item was deleted. * @return -1 if it was not found. */ extern int lh_table_delete_entry(struct lh_table *t, struct lh_entry *e); /** * Delete a record from the table. * * If a callback free function is provided then it is called for the * for the item being deleted. * @param t the table to delete from. * @param k a pointer to the key to delete. * @return 0 if the item was deleted. * @return -1 if it was not found. */ extern int lh_table_delete(struct lh_table *t, const void *k); extern int lh_table_length(struct lh_table *t); /** * Prints a message to stdout, * then exits the program with an exit code of 1. * * @param msg Message format string, like for printf. * @param ... Format args. * * @deprecated Since it is not a good idea to exit the entire program * because of an internal library failure, json-c will no longer * use this function internally. * However, because its interface is public, it will remain part of * the API on the off chance of legacy software using it externally. */ THIS_FUNCTION_IS_DEPRECATED(void lh_abort(const char *msg, ...)); /** * Resizes the specified table. * * @param t Pointer to table to resize. * @param new_size New table size. Must be positive. * * @return On success, 0 is returned. * On error, a negative value is returned. */ int lh_table_resize(struct lh_table *t, int new_size); /** * @deprecated Don't use this outside of linkhash.h: */ #if !defined(_MSC_VER) || (_MSC_VER > 1800) /* VS2010 can't handle inline funcs, so skip it there */ #define _LH_INLINE inline #else #define _LH_INLINE #endif /** * Calculate the hash of a key for a given table. * * This is an exension to support functions that need to calculate * the hash several times and allows them to do it just once and then pass * in the hash to all utility functions. Depending on use case, this can be a * considerable performance improvement. * @param t the table (used to obtain hash function) * @param k a pointer to the key to lookup * @return the key's hash */ static _LH_INLINE unsigned long lh_get_hash(const struct lh_table *t, const void *k) { return t->hash_fn(k); } #undef _LH_INLINE /** * @deprecated Don't use this outside of linkhash.h: */ #ifdef __UNCONST #define _LH_UNCONST(a) __UNCONST(a) #else #define _LH_UNCONST(a) ((void *)(uintptr_t)(const void *)(a)) #endif /** * Return a non-const version of lh_entry.k. * * lh_entry.k is const to indicate and help ensure that linkhash itself doesn't modify * it, but callers are allowed to do what they want with it. * See also lh_entry.k_is_constant */ #define lh_entry_k(entry) _LH_UNCONST((entry)->k) /** * Return a non-const version of lh_entry.v. * * v is const to indicate and help ensure that linkhash itself doesn't modify * it, but callers are allowed to do what they want with it. */ #define lh_entry_v(entry) _LH_UNCONST((entry)->v) #ifdef __cplusplus } #endif #endif PK! TB printbuf.hnu[/* * $Id: printbuf.h,v 1.4 2006/01/26 02:16:28 mclark Exp $ * * Copyright (c) 2004, 2005 Metaparadigm Pte. Ltd. * Michael Clark * * This library is free software; you can redistribute it and/or modify * it under the terms of the MIT license. See COPYING for details. * * * Copyright (c) 2008-2009 Yahoo! Inc. All rights reserved. * The copyrights to the contents of this file are licensed under the MIT License * (http://www.opensource.org/licenses/mit-license.php) */ /** * @file * @brief Internal string buffer handing. Unless you're writing a * json_object_to_json_string_fn implementation for use with * json_object_set_serializer() direct use of this is not * recommended. */ #ifndef _printbuf_h_ #define _printbuf_h_ #ifdef __cplusplus extern "C" { #endif struct printbuf { char *buf; int bpos; int size; }; typedef struct printbuf printbuf; extern struct printbuf* printbuf_new(void); /* As an optimization, printbuf_memappend_fast() is defined as a macro * that handles copying data if the buffer is large enough; otherwise * it invokes printbuf_memappend() which performs the heavy * lifting of realloc()ing the buffer and copying data. * * Your code should not use printbuf_memappend() directly unless it * checks the return code. Use printbuf_memappend_fast() instead. */ extern int printbuf_memappend(struct printbuf *p, const char *buf, int size); #define printbuf_memappend_fast(p, bufptr, bufsize) \ do { \ if ((p->size - p->bpos) > bufsize) { \ memcpy(p->buf + p->bpos, (bufptr), bufsize); \ p->bpos += bufsize; \ p->buf[p->bpos]= '\0'; \ } else { printbuf_memappend(p, (bufptr), bufsize); } \ } while (0) #define printbuf_length(p) ((p)->bpos) /** * Results in a compile error if the argument is not a string literal. */ #define _printbuf_check_literal(mystr) ("" mystr) /** * This is an optimization wrapper around printbuf_memappend() that is useful * for appending string literals. Since the size of string constants is known * at compile time, using this macro can avoid a costly strlen() call. This is * especially helpful when a constant string must be appended many times. If * you got here because of a compilation error caused by passing something * other than a string literal, use printbuf_memappend_fast() in conjunction * with strlen(). * * See also: * printbuf_memappend_fast() * printbuf_memappend() * sprintbuf() */ #define printbuf_strappend(pb, str) \ printbuf_memappend ((pb), _printbuf_check_literal(str), sizeof(str) - 1) /** * Set len bytes of the buffer to charvalue, starting at offset offset. * Similar to calling memset(x, charvalue, len); * * The memory allocated for the buffer is extended as necessary. * * If offset is -1, this starts at the end of the current data in the buffer. */ extern int printbuf_memset(struct printbuf *pb, int offset, int charvalue, int len); /** * Formatted print to printbuf. * * This function is the most expensive of the available functions for appending * string data to a printbuf and should be used only where convenience is more * important than speed. Avoid using this function in high performance code or * tight loops; in these scenarios, consider using snprintf() with a static * buffer in conjunction with one of the printbuf_*append() functions. * * See also: * printbuf_memappend_fast() * printbuf_memappend() * printbuf_strappend() */ extern int sprintbuf(struct printbuf *p, const char *msg, ...); extern void printbuf_reset(struct printbuf *p); extern void printbuf_free(struct printbuf *p); #ifdef __cplusplus } #endif #endif PK!h arraylist.hnu[PK!Pbits.hnu[PK!Ёy debug.hnu[PK!M**ljson.hnu[PK!ژjson_c_version.hnu[PK!nƣ json_config.hnu[PK!:"/^^json_inttypes.hnu[PK!ʷohh )json_object.hnu[PK!/SR R ίjson_object_iterator.hnu[PK!lfjson_pointer.hnu[PK!%Mjson_tokener.hnu[PK!I vjson_util.hnu[PK!^Qm m f json_visit.hnu[PK!?-++ linkhash.hnu[PK! TB Cprintbuf.hnu[PKt$S