json-parser.h

Go to the documentation of this file.

/*  JSON Parser version 1.0 -- Copyright (c) 2014-2022 David Winterburn <info@fwsentry.org> */


#ifndef JSON_PARSER_H
#define JSON_PARSER_H

#ifdef __cplusplus
#include <string.h>
extern "C" {
#endif


/* inttypes.h support is broken MS Visual Studio compilers */
#if !defined(_WIN32) || !defined(_MSC_VER)
#include <inttypes.h>
#else
#include <basetsd.h>
typedef     UINT8       uint8_t;
typedef     INT8        int8_t;
typedef     UINT16      uint16_t;
typedef     INT16       int16_t;
typedef     ULONG32     uint32_t;
typedef     LONG32      int32_t;
typedef     UINT64      uint64_t;
typedef     INT64       int64_t;
#endif

/* Support for old compilers */
#ifdef __STDC_VERSION__
#   if __STDC_VERSION__ >= 199901L
    /* "inline" and "restrict" are already builtin keywords */
#else
    /* Stop compiler errors */
#define inline
#define restrict
#ifndef __func__
#define     __func__    "unknown_function"
#endif
#endif
#endif      /* (__STDC_VERSION__) */



#if __STDC_VERSION__ >- 199901L
#include <stdbool.h>
#endif      /* __STDC_VERSION__ >- 199901L */

#ifdef __bool_true_false_are_defined
#define TRUE                                        true
#define FALSE                                       false
#define boolean                                     _Bool

#else

/* for environments with no stdbool.h */
typedef int bool
#define false                                       (bool)0
#define true                                        (bool)1

#ifndef TRUE
#define TRUE                                        (bool)1
#endif      /* !TRUE */
#ifndef FALSE
#define FALSE                                       (bool)0
#endif      /* !FALSE */

#endif      /* __bool_true_false_are_defined */

    */

/* The available JSON value types for elements in JSON block lists.
    
    VERY IMPORTANT: Do not alter the ordering of this value types list
                    It will destroy the semantics of mixed value type
                    evaluations.

    Note:   invalid_empty   is never used, it is a place holder for an 
                            incomplete element
            JSON_value      is never used in elements, but can be returned 
                            by the function parse_json_data_block() to alert
                            the caller that the parsed JSON block returned
                            contains a value element (type described in that
                            element), instead of a JSON array or JSON object.           */
typedef unsigned int JSON_value_types;
#define invalid_empty           0
#define JSON_object             1
#define JSON_array              2
#define JSON_value              3               /* NOT a valid types for list elements */
#define JSON_null               4
#define JSON_boolean            5
#define JSON_integer            6
#define JSON_double             7
#define JSON_float_str          8
#define JSON_string             9

typedef int64_t json_integer_t;
typedef long double json_double_t;


typedef struct {
    JSON_value_types value_type;                /* the value type of this name/value pair (from JSON_value_types) */
    char *member_name;                          /* Member name for JSON_object Member elements, NULL for all other value types */
    union {
        list_object *object;                    /* ptr to list_object for a JSON_object, or JSON_array, or NULL */
        char *string;                           /* For JSON_string or JSON_float_str if requested */
        json_integer_t integer;                 /* For integer (JSON_integer) */
        json_double_t double_number;            /* For non integer (JSON_double) user must deal with the conversion issues */
        boolean boolean_value;                  /* For JSON_boolean either TRUE or FALSE */
    } value;
    boolean free_string_ptr;                    /* TRUE, remove function will free() the string and member_name pointer, FALSE it will not */
} json_element_t;


/* This typedef is used to describe JSON Object paths to either find data or
    express where data is in a JSON hierarchy. 
    
    So for example to express a JSON Object path of
        "bakery.product.[0].name" 
    would take an array of 4 json_path_t entries
        {JSON_object, "bakery"}, 
        {JSON_object, "product"}, 
        {JSON_array, 0}, 
        {JSON_object, "name"},
        {invalid_empty, NULL}               can be used to terminate, or a count can be provided */
typedef struct {
    JSON_value_types value_type;                /* the type of the link link in the JSON Object path, JSON_object or JSON_array */
    union {
        unsigned int array_index;
        char *member_name;                      /* AKA keys in javascript land etc */
    } link;
} json_path_t;

/* the json_member_list_t struct is used by various JSON support functions
    that perform searches of hierarchical JSON data list_objects. If a list
    of members or array values is returned to a caller, this is the form of 
    each element returned. Additionally the support functions that accept
    JSON paths also use this structure to transfer data to and from the 
    callers.
    
    The pointer to the parent list_object of this element is required for
    quick access to other Members of the same JSON Object this element came
    from.

    The pointer to the element reference is required, in combination with 
    the parent list_object, to access or manage the element using D-List. 
    Without the element reference, you would have to search for the again.
    
    The pointer to the element itself is provided so you can access or update
    the JSON Member data value, or change it. However having the address of
    the element will not assist you when attempting to access or manage the
    element in D-List. D-List deliberately abstracts the address of an
    element away from managing the element. That is why you need the 
    list_object and the element reference. Please refer to the D_list 
    documentation if you need more information about abstract element
    references and using them to access and manipulate elements.
    
    The path and path segment count, replicate the JSON dotted syntax used
    to describe paths in JSON data blocks. These can also be used as input
    to the various json_path_xxx functions                                      */
typedef struct {
    list_object *json_owner_object;         /* parent list_object of this JSON Member element, use to locate element in D-List */
    element_reference *reference;           /* D-List element reference of this JSON Member element, use to manipulate element in D-List */
    json_element_t *json_member;            /* Pointer to the actual JSON Member Element, use to access the Member data */
    JSON_value_types value_type;            /* the Value type of the JSON Member value */
    unsigned int path_segments;             /* the number of elements in the path array (e.g. 4 in the example below)  */
    json_path_t path[];                     /* the JSON path of the Member as recorded when found (e.g. bakery.product.[19]."curry pan") */
} json_member_list_t;


typedef struct {
    element_search object_search_function;
    element_compare object_compare_function;
    element_search array_search_function;
    element_compare array_compare_function;
} functions_globals_t;


/* the environment variables we can use */
#define ENVIRONMENT_VAR_DEBUGGING           "JSON_PARSER_DEBUG"

/* global debugging flags */

#if defined( INITIALIZE_DEBUGGING_FLAG )
    boolean json_parser_debugging = FALSE;
#else
    extern boolean json_parser_debugging;
#endif


/*  ===================================================================

    JSON Conversion Functions for JSON Parser D-List hierarchical lists.

    ===================================================================*/


list_object *json_parse_data_block( char *json_data_block, 
                                    JSON_value_types *json_data_type,
                                    element_search object_search_function,
                                    element_compare object_compare_function,
                                    element_search array_search_function,
                                    element_compare array_compare_function,
                                    const boolean keep_exponent);




boolean json_valid_data_block(  const char *json_object, 
                                char **object_error, 
                                unsigned long int *line_number,
                                const boolean suppress_warnings);

int json_generate_data_block(   list_object *json_data, 
                                JSON_value_types json_data_type,
                                char **json_text_buffer);





/*  ================================================================

    JSON D_list Functions for JSON Parser D-List hierarchical lists.

    ================================================================*/


/*  Default D-List user functions for JSON Parser lists.
    ====================================================*/
    
boolean default_search_function_member_name(const void *element, const void *key);  

boolean default_search_function_partial_member_name(const void *element, const void *key);

boolean default_search_function_array_values(const void *element, const void *key);
    
boolean default_search_function_array_string_value(const void *element, const void *key);

boolean default_search_function_array_partial_string_value(const void *element, const void *key);

boolean default_search_function_array_integer_value(const void *element, const void *key);

boolean default_search_function_array_double_value(const void *element, const void *key);

boolean default_search_function_precise_array_double_value(const void *element, const void *key);

boolean default_search_function_sloppy_array_double_value(const void *element, const void *key);



int default_compare_function_member_names(const void *element, const void *key);


int default_compare_function_array_values(const void *element, const void *key);



int default_compare_function_array_number_values(const void *element, const void *key);


int default_compare_function_array_string_values(const void *element, const void *key);

int default_compare_function_array_integer_values(const void *element, const void *key);

int default_compare_function_array_double_values(const void *element, const void *key);









list_object *json_find_members_value_string(    list_object *json_data, 
                                                const char *member_name, 
                                                const boolean partial_name,
                                                const char *string_value,
                                                const boolean partial_value);

list_object *json_find_members_value_integer(   list_object *json_data, 
                                                char *member_name, 
                                                const boolean partial_name,
                                                const json_integer_t minimum_value,
                                                const json_integer_t maximum_value,
                                                const boolean value_range);

list_object *json_find_members_value_double(    list_object *json_data, 
                                                char *member_name, 
                                                const boolean partial_name,
                                                const json_double_t minimum_value,
                                                const json_double_t maximum_value,
                                                const boolean value_range);

list_object *json_find_members_value_type(  list_object *json_data, 
                                            const char *member_name, 
                                            const boolean partial_name,
                                            const JSON_value_types value_type);

int json_find_member_value( json_member_list_t *result,
                            list_object *json_data, 
                            const char *member_name, 
                            const boolean partial_name,
                            const char *string_value,
                            const boolean partial_value);

json_member_list_t *json_path_locate(   list_object *json_data,
                                        json_member_list_t *path_to_find, 
                                        const boolean strict_path,
                                        const boolean suppress_errors);


list_object *json_create_new_list_object(   const JSON_value_types list_type, 
                                            const functions_globals_t *functions);

JSON_value_types json_report_list_object_type(list_object *list);

int json_list_object_member_add_string( list_object *list_to_add, 
                                        const char *member_name,
                                        const char *string_value);


int json_list_object_member_add_number( list_object *list_to_add, 
                                        const char *member_name,
                                        const json_integer_t integer_number,
                                        const json_double_t double_number);


int json_list_object_member_add_float_str(  list_object *list_to_add, 
                                            const char *member_name,
                                            const char *float_str);

int json_list_object_member_add_boolean(    list_object *list_to_add, 
                                            const char *member_name,
                                            const boolean boolean_value);

int json_list_object_member_add_null(   list_object *list_to_add, 
                                        const char *member_name);

int json_list_object_member_add_list(   list_object *list_to_add, 
                                        const char *member_name,
                                        list_object *new_list,
                                        const JSON_value_types list_type);


int json_list_object_array_value_add_string(    list_object *list_to_add, 
                                                const char *string_value);

int json_list_object_array_value_add_number(    list_object *list_to_add, 
                                                const json_integer_t *integer_number,
                                                const json_double_t *double_number,
                                                const unsigned int item_count);


int json_list_object_array_value_add_float_str( list_object *list_to_add, 
                                                const char *float_str);

int json_list_object_array_value_add_boolean(   list_object *list_to_add, 
                                                const boolean boolean_value);

int json_list_object_array_value_add_null(  list_object *list_to_add);

int json_list_object_array_value_add_list(  list_object *list_to_add, 
                                            list_object *new_list,
                                            const JSON_value_types list_type);






/*  ======================================================================

    JSON Support Functions for Reporting hierarchical lists and JSON data.

        create character strings from data for display, convert paths, etc

    =======================================================================*/



list_object *json_path_to_list_object(  list_object *json_data,
                                        const char *path);


json_member_list_t *json_parse_dotted_path(const char *dotted_path);

char *json_generate_path_from_links(    json_path_t path[],
                                        unsigned int count);

void json_print_path_from_links(    json_path_t path[],
                                    unsigned int count);


void display_parsed_json_object(    list_object* json_object, 
                                    const char *list_name, 
                                    const int list_type, 
                                    const boolean dig_down);




#ifdef __cplusplus
}
#endif      /* __cplusplus */

#endif      /* JSON_PARSER_H */