jx.h

Go to the documentation of this file.

/*
Copyright (C) 2022 The University of Notre Dame
This software is distributed under the GNU General Public License.
See the file COPYING for details.
*/
 
#ifndef JX_H
#define JX_H
 
#include <stdint.h>
#include <inttypes.h>
 
typedef enum {
        JX_NULL = 0, 
        JX_BOOLEAN,  
        JX_INTEGER,  
        JX_DOUBLE,   
        JX_STRING,   
        JX_SYMBOL,   
        JX_ARRAY,    
        JX_OBJECT,   
        JX_OPERATOR, 
        JX_ERROR,    
} jx_type_t;
 
typedef int64_t jx_int_t;
#define PRIiJX PRIi64
 
struct jx_comprehension {
        unsigned line;
        char *variable; 
        struct jx *elements; 
        struct jx *condition; 
        struct jx_comprehension *next;
};
 
struct jx_item {
        unsigned line;
        struct jx *value;       
        struct jx_comprehension *comp;
        struct jx_item *next;   
};
 
struct jx_pair {
        unsigned line;
        struct jx      *key;    
        struct jx      *value;  
        struct jx_comprehension *comp;
        struct jx_pair *next;   
};
 
typedef enum {
        JX_OP_EQ,
        JX_OP_NE,
        JX_OP_LE,
        JX_OP_LT,
        JX_OP_GE,
        JX_OP_GT,
        JX_OP_ADD,
        JX_OP_SUB,
        JX_OP_MUL,
        JX_OP_DIV,
        JX_OP_MOD,
        JX_OP_AND,
        JX_OP_OR,
        JX_OP_NOT,
        JX_OP_LOOKUP,
        JX_OP_CALL,
        JX_OP_SLICE,
        JX_OP_DOT,
        JX_OP_INVALID,
} jx_operator_t;
 
struct jx_operator {
        jx_operator_t type;
        unsigned line;
        struct jx *left;
        struct jx *right;
};
 
struct jx {
        jx_type_t type;               
        unsigned line;                
        union {
                int boolean_value;      
                jx_int_t integer_value; 
                double double_value;   
                char * string_value;  
                char * symbol_name;   
                struct jx_item *items;  
                struct jx_pair *pairs;  
                struct jx_operator oper; 
                struct jx *err;  
        } u;
};
 
struct jx * jx_null();
 
struct jx * jx_boolean( int boolean_value );
 
struct jx * jx_integer( jx_int_t integer_value );
 
struct jx * jx_double( double double_value );
 
struct jx * jx_string( const char *string_value );
 
struct jx * jx_string_nocopy( char *string_value );
 
struct jx * jx_format( const char *fmt, ... );
 
struct jx * jx_symbol( const char *symbol_name );
 
struct jx * jx_error( struct jx *err );
 
struct jx * jx_array( struct jx_item *items );
 
struct jx * jx_arrayv( struct jx *value, ... );
 
struct jx * jx_object( struct jx_pair *pairs );
 
struct jx * jx_objectv( const char *key, struct jx *value, ... );
 
struct jx * jx_operator( jx_operator_t oper, struct jx *left, struct jx *right );
 
struct jx_pair * jx_pair( struct jx *key, struct jx *value, struct jx_pair *next );
 
struct jx_item * jx_item( struct jx *value, struct jx_item *next );
 
struct jx_comprehension *jx_comprehension(const char *variable, struct jx *elements, struct jx *condition, struct jx_comprehension *next);
 
int jx_istype( struct jx *j, jx_type_t type );
 
int jx_isatomic( struct jx *j );
 
int jx_istrue( struct jx *j );
 
int jx_isfalse( struct jx *j );
 
int jx_comprehension_equals(struct jx_comprehension *j, struct jx_comprehension *k);
int jx_item_equals(struct jx_item *j, struct jx_item *k);
int jx_pair_equals(struct jx_pair *j, struct jx_pair *k);
 
int jx_equals( struct jx *j, struct jx *k );
 
int jx_array_length( struct jx *array );
 
struct jx_comprehension *jx_comprehension_copy(struct jx_comprehension *c);
struct jx_item *jx_item_copy(struct jx_item *i);
struct jx_pair *jx_pair_copy(struct jx_pair *p);
 
struct jx * jx_copy( struct jx *j );
 
void jx_delete( struct jx *j );
 
void jx_pair_delete( struct jx_pair *p );
 
void jx_item_delete( struct jx_item *i );
 
void jx_comprehension_delete(struct jx_comprehension *comp);
 
struct jx * jx_remove( struct jx *object, struct jx *key );
 
int jx_insert( struct jx *object, struct jx *key, struct jx *value );
 
int jx_insert_unless_empty( struct jx *object, struct jx *key, struct jx *value );
 
void jx_insert_boolean( struct jx *object, const char *key, int value );
 
void jx_insert_integer( struct jx *object, const char *key, jx_int_t value );
 
void jx_insert_double( struct jx *object, const char *key, double value );
 
void jx_insert_string( struct jx *object, const char *key, const char *value );
 
struct jx * jx_lookup( struct jx *object, const char *key );
 
/* Like @ref jx_lookup, but found is set to 1 when the key is found. Useful for when value is false. */
struct jx * jx_lookup_guard( struct jx *j, const char *key, int *found );
 
const char * jx_lookup_string( struct jx *object, const char *key );
 
char * jx_lookup_string_dup( struct jx *object, const char *key );
 
jx_int_t jx_lookup_integer( struct jx *object, const char *key );
 
int jx_lookup_boolean( struct jx *object, const char *key );
 
double jx_lookup_double( struct jx *object, const char *key );
 
void jx_array_insert( struct jx *array, struct jx *value );
 
void jx_array_append( struct jx *array, struct jx *value );
 
struct jx * jx_array_index( struct jx *array, int nth );
 
struct jx *jx_array_concat( struct jx *array, ...);
 
struct jx *jx_array_shift(struct jx *array);
 
int jx_is_constant( struct jx *j );
 
void jx_export( struct jx *j );
 
struct jx * jx_iterate_array(struct jx *j, void **i);
 
struct jx * jx_iterate_values(struct jx *j, void **i);
 
const char *jx_iterate_keys(struct jx *j, void **i);
 
/* Get the current key while iterating over an object.
 * The iteration variable must have been passed to jx_iterate_keys
 * or jx_iterate_values. This directly fetches the current key rather than
 * doing a lookup from the beginning, so it takes constant time and
 * can handle repeated keys.
 */
const char *jx_get_key(void **i);
 
/* Get the current value while iterating over an object.
 * The iteration variable must have been passed to jx_iterate_keys
 * or jx_iterate_values. This directly fetches the current value rather than
 * doing a lookup from the beginning, so it takes constant time and
 * can handle repeated keys.
 */
struct jx *jx_get_value(void **i);
 
 
struct jx *jx_merge(struct jx *j, ...);
 
#endif
 
/*vim: set noexpandtab tabstop=8: */