cheax.h

Go to the documentation of this file.

 
#ifndef CHEAX_H
#define CHEAX_H
 
#include <stdbool.h>
#include <stdint.h>
#include <stdio.h>
 
#include <cheax/export.h>
 
#ifdef __GNUC__
#define CHX_PURE                      __attribute__((pure))
#define CHX_CONST                     __attribute__((const))
#define CHX_FORMAT(like, first, args) __attribute__((format(like, first, args)))
#else
#define CHX_PURE
#define CHX_CONST
#define CHX_FORMAT(like, first, args)
#endif
 
typedef struct cheax CHEAX;
 
enum {
        CHEAX_LIST,          
        CHEAX_INT,           
        CHEAX_BOOL,          
        CHEAX_DOUBLE,        
        CHEAX_USER_PTR,
 
        CHEAX_ID,            
        CHEAX_FUNC,          
        CHEAX_EXT_FUNC,      
        CHEAX_SPECIAL_OP,    
        CHEAX_QUOTE,         
        CHEAX_BACKQUOTE,     
        CHEAX_COMMA,         
        CHEAX_SPLICE,        
        CHEAX_STRING,        
        CHEAX_ENV,           
        CHEAX_LAST_BASIC_TYPE = CHEAX_ENV,
        CHEAX_TYPESTORE_BIAS,
 
        CHEAX_TYPECODE = CHEAX_TYPESTORE_BIAS + 0,
        CHEAX_ERRORCODE,     
};
 
#define CHX_INT_MIN INT_LEAST64_MIN
#define CHX_INT_MAX INT_LEAST64_MAX
 
#define PRIdCHX PRIdLEAST64
 
#define PRIiCHX PRIiLEAST64
 
#define SCNdCHX SCNdLEAST64
 
#define SCNiCHX SCNiLEAST64
 
typedef int_least64_t chx_int;
 
typedef double chx_double;
 
struct chx_list;
struct chx_id;
struct chx_string;
struct chx_quote;
struct chx_func;
struct chx_ext_func;
struct chx_special_op;
struct chx_env;
 
struct chx_value {
        int type; 
#if __STDC_VERSION__ >= 201112L
        union {
                chx_int as_int;
                chx_double as_double;
                struct chx_list *as_list;
                struct chx_id *as_id;
                struct chx_string *as_string;
                struct chx_quote *as_quote;
                struct chx_func *as_func;
                struct chx_ext_func *as_ext_func;
                struct chx_special_op *as_special_op;
                struct chx_env *as_env;
                void *user_ptr;
 
                unsigned *rtflags_ptr;
#endif
 
        union {
                chx_int as_int;
                chx_double as_double;
                struct chx_list *as_list;
                struct chx_id *as_id;
                struct chx_string *as_string;
                struct chx_quote *as_quote;
                struct chx_func *as_func;
                struct chx_ext_func *as_ext_func;
                struct chx_special_op *as_special_op;
                struct chx_env *as_env;
                void *user_ptr;
 
                unsigned *rtflags_ptr;
        } data;
#if __STDC_VERSION__ + 0 >= 201112L
        };
#endif
};
 
#define CHEAX_NIL ((struct chx_value){ 0 })
 
CHX_API struct chx_value cheax_nil(void) CHX_CONST;
 
CHX_API bool cheax_is_nil(struct chx_value v) CHX_CONST;
 
struct chx_id {
        unsigned rtflags;       
        char *value;            
};
 
struct chx_quote {
        unsigned rtflags;       
        struct chx_value value; 
};
 
CHX_API struct chx_value cheax_id(CHEAX *c, const char *id) CHX_PURE;
 
#define cheax_id_value(X) ((struct chx_value){ .type = CHEAX_ID, .data.as_id = (X) })
 
CHX_API struct chx_value cheax_id_value_proc(struct chx_id *id) CHX_CONST;
 
#define cheax_int(X) ((struct chx_value){ .type = CHEAX_INT, .data.as_int = (X) })
 
CHX_API struct chx_value cheax_int_proc(chx_int value) CHX_CONST;
 
#define cheax_true() ((struct chx_value){ .type = CHEAX_BOOL, .data.as_int = 1 })
 
#define cheax_false() ((struct chx_value){ .type = CHEAX_BOOL, .data.as_int = 0 })
 
#define cheax_bool(X) ((struct chx_value){ .type = CHEAX_BOOL, .data.as_int = (X) ? 1 : 0 })
 
CHX_API struct chx_value cheax_bool_proc(bool value) CHX_CONST;
 
#define cheax_double(X) ((struct chx_value){ .type = CHEAX_DOUBLE, .data.as_double = (X) })
 
CHX_API struct chx_value cheax_double_proc(chx_double value) CHX_CONST;
 
struct chx_list {
        unsigned rtflags;       
        struct chx_value value; 
        struct chx_list *next;  
};
 
CHX_API struct chx_value cheax_list(CHEAX *c, struct chx_value car, struct chx_list *cdr);
 
#define cheax_list_value(X) ((struct chx_value){ .type = CHEAX_LIST, .data.as_list = (X) })
 
CHX_API struct chx_value cheax_list_value_proc(struct chx_list *list) CHX_CONST;
 
struct chx_func {
        unsigned rtflags;
        struct chx_value args;       
        struct chx_list *body;       
        struct chx_env *lexenv;      
};
 
#define cheax_func_value(X) ((struct chx_value){ .type = CHEAX_FUNC, .data.as_func = (X) })
CHX_API struct chx_value cheax_func_value_proc(struct chx_func *fn) CHX_CONST;
 
typedef struct chx_value (*chx_func_ptr)(CHEAX *c, struct chx_list *args, void *info);
 
enum {
        CHEAX_VALUE_OUT, CHEAX_TAIL_OUT,
};
 
union chx_eval_out {
        struct {
                struct chx_value tail;
                struct chx_env *pop_stop;
        } ts;
 
        struct chx_value value;
};
 
typedef int (*chx_tail_func_ptr)(CHEAX *c,
                                 struct chx_list *args,
                                 void *info,
                                 struct chx_env *pop_stop,
                                 union chx_eval_out *out);
 
struct chx_ext_func {
        unsigned rtflags;
        const char *name;     
        chx_func_ptr perform;
        void *info;           
};
 
CHX_API struct chx_value cheax_ext_func(CHEAX *c,
                                        const char *name,
                                        chx_func_ptr perform,
                                        void *info);
 
#define cheax_ext_func_value(X) ((struct chx_value){ .type = CHEAX_EXT_FUNC, .data.as_ext_func = (X) })
CHX_API struct chx_value cheax_ext_func_value_proc(struct chx_ext_func *sf) CHX_CONST;
 
CHX_API struct chx_value cheax_quote(CHEAX *c, struct chx_value value);
 
#define cheax_quote_value(X) ((struct chx_value){ .type = CHEAX_QUOTE, .data.as_quote = (X) })
CHX_API struct chx_value cheax_quote_value_proc(struct chx_quote *quote) CHX_CONST;
 
CHX_API struct chx_value cheax_backquote(CHEAX *c, struct chx_value value);
 
#define cheax_backquote_value(X) ((struct chx_value){ .type = CHEAX_BACKQUOTE, .data.as_quote = (X) })
CHX_API struct chx_value cheax_backquote_value_proc(struct chx_quote *bkquote) CHX_CONST;
 
CHX_API struct chx_value cheax_comma(CHEAX *c, struct chx_value value);
 
#define cheax_comma_value(X) ((struct chx_value){ .type = CHEAX_COMMA, .data.as_quote = (X) })
CHX_API struct chx_value cheax_comma_value_proc(struct chx_quote *comma) CHX_CONST;
 
CHX_API struct chx_value cheax_splice(CHEAX *c, struct chx_value value);
 
#define cheax_splice_value(X) ((struct chx_value){ .type = CHEAX_SPLICE, .data.as_quote = (X) })
CHX_API struct chx_value cheax_splice_value_proc(struct chx_quote *splice) CHX_CONST;
 
struct chx_string;
 
CHX_API size_t cheax_strlen(CHEAX *c, struct chx_string *str) CHX_PURE;
 
CHX_API struct chx_value cheax_string(CHEAX *c, const char *value);
 
CHX_API struct chx_value cheax_nstring(CHEAX *c, const char *value, size_t len);
 
#define cheax_string_value(X) ((struct chx_value){ .type = CHEAX_STRING, .data.as_string = (X) })
CHX_API struct chx_value cheax_string_value_proc(struct chx_string *string) CHX_CONST;
 
CHX_API struct chx_value cheax_substr(CHEAX *c, struct chx_string *str, size_t pos, size_t len);
 
CHX_API char *cheax_strdup(struct chx_string *str);
 
CHX_API struct chx_value cheax_user_ptr(CHEAX *c, void *value, int type);
 
struct chx_env;
 
CHX_API struct chx_value cheax_env(CHEAX *c);
 
#define cheax_env_value(X) ((struct chx_value){ .type = CHEAX_ENV, .data.as_env = (X) })
CHX_API struct chx_value cheax_env_value_proc(struct chx_env *env) CHX_CONST;
 
#if __STDC_VERSION__ + 0 >= 201112L
#define cheax_value(v)                                              \
        (_Generic((0,v),                                            \
                int:                 cheax_int_proc,                \
                chx_int:             cheax_int_proc,                \
                double:              cheax_double_proc,             \
                float:               cheax_double_proc,             \
                struct chx_env *:    cheax_env_value_proc,          \
                struct chx_id *:     cheax_id_value_proc,           \
                struct chx_string *: cheax_string_value_proc,       \
                struct chx_list *:   cheax_list_value_proc)(v))
#endif
 
struct chx_sym;
 
typedef struct chx_value (*chx_getter)(CHEAX *c, struct chx_sym *sym);
typedef void (*chx_setter)(CHEAX *c, struct chx_sym *sym, struct chx_value value);
typedef void (*chx_finalizer)(CHEAX *c, struct chx_sym *sym);
 
struct chx_sym {
        void *user_info;          
        chx_getter get;           
        chx_setter set;           
        chx_finalizer fin;        
        struct chx_value protect; 
};
 
typedef int chx_ref;
 
CHX_API chx_ref cheax_ref(CHEAX *c, struct chx_value value);
CHX_API chx_ref cheax_ref_ptr(CHEAX *c, void *obj);
 
CHX_API void cheax_unref(CHEAX *c, struct chx_value value, chx_ref ref);
CHX_API void cheax_unref_ptr(CHEAX *c, void *obj, chx_ref ref);
 
CHX_API int cheax_new_type(CHEAX *c, const char *name, int base_type);
 
CHX_API int cheax_find_type(CHEAX *c, const char *name);
 
CHX_API bool cheax_is_valid_type(CHEAX *c, int type) CHX_PURE;
 
CHX_API bool cheax_is_basic_type(CHEAX *c, int type) CHX_PURE;
 
CHX_API bool cheax_is_user_type(CHEAX *c, int type) CHX_PURE;
 
CHX_API int cheax_get_base_type(CHEAX *c, int type);
 
CHX_API int cheax_resolve_type(CHEAX *c, int type);
 
enum {
        CHEAX_ENOERR     = 0x0000, 
        /* Read errors */
        CHEAX_EREAD      = 0x0001, 
        CHEAX_EEOF       = 0x0002, 
        /* Eval/runtime errors */
        CHEAX_EEVAL      = 0x0101, 
        CHEAX_ENOSYM     = 0x0102, 
        CHEAX_ESTACK     = 0x0103, 
        CHEAX_ETYPE      = 0x0104, 
        CHEAX_EMATCH     = 0x0105, 
        CHEAX_ESTATIC    = 0x0106, 
        CHEAX_EDIVZERO   = 0x0107, 
        CHEAX_EREADONLY  = 0x0108, 
        CHEAX_EWRITEONLY = 0x0109, 
        CHEAX_EEXIST     = 0x010A, 
        CHEAX_EVALUE     = 0x010B, 
        CHEAX_EOVERFLOW  = 0x010C, 
        CHEAX_EINDEX     = 0x010D, 
        CHEAX_EIO        = 0x010E, 
        CHEAX_EAPI       = 0x0200, 
        CHEAX_ENOMEM     = 0x0201, 
        CHEAX_EUSER0     = 0x0400, 
};
 
#define ERR_NAME_PAIR(NAME) {#NAME, CHEAX_##NAME}
 
#define CHEAX_BUILTIN_ERROR_NAMES(var)                        \
static const struct { const char *name; int code; } var[] = { \
        ERR_NAME_PAIR(ENOERR),                                \
                                                              \
        ERR_NAME_PAIR(EREAD), ERR_NAME_PAIR(EEOF),            \
                                                              \
        ERR_NAME_PAIR(EEVAL), ERR_NAME_PAIR(ENOSYM),          \
        ERR_NAME_PAIR(ESTACK), ERR_NAME_PAIR(ETYPE),          \
        ERR_NAME_PAIR(EMATCH), ERR_NAME_PAIR(ESTATIC),        \
        ERR_NAME_PAIR(EDIVZERO), ERR_NAME_PAIR(EREADONLY),    \
        ERR_NAME_PAIR(EWRITEONLY), ERR_NAME_PAIR(EEXIST),     \
        ERR_NAME_PAIR(EVALUE), ERR_NAME_PAIR(EOVERFLOW),      \
        ERR_NAME_PAIR(EINDEX), ERR_NAME_PAIR(EIO),            \
                                                              \
        ERR_NAME_PAIR(EAPI), ERR_NAME_PAIR(ENOMEM)            \
}
 
CHX_API int cheax_errno(CHEAX *c) CHX_PURE;
 
#define cheax_ft(c, pad) { if (cheax_errno(c) != 0) goto pad; }
 
CHX_API void cheax_perror(CHEAX *c, const char *s);
 
CHX_API void cheax_clear_errno(CHEAX *c);
 
CHX_API void cheax_throw(CHEAX *c, int code, struct chx_string *msg);
CHX_API void cheax_throwf(CHEAX *c, int code, const char *fmt, ...) CHX_FORMAT(printf, 3, 4);
 
CHX_API void cheax_add_bt(CHEAX *c);
 
CHX_API int cheax_new_error_code(CHEAX *c, const char *name);
 
CHX_API int cheax_find_error_code(CHEAX *c, const char *name);
 
CHX_API CHEAX *cheax_init(void);
 
CHX_API const char *cheax_version(void);
 
CHX_API int cheax_load_feature(CHEAX *c, const char *feat);
 
CHX_API int cheax_load_prelude(CHEAX *c);
 
CHX_API void cheax_destroy(CHEAX *c);
 
CHX_API int cheax_config_get_int(CHEAX *c, const char *opt);
 
CHX_API int cheax_config_int(CHEAX *c, const char *opt, int value);
 
CHX_API bool cheax_config_get_bool(CHEAX *c, const char *opt);
 
CHX_API int cheax_config_bool(CHEAX *c, const char *opt, bool value);
 
struct chx_config_help {
        const char *name;    
        int type;            
        const char *metavar; 
        const char *help;    
};
 
CHX_API int cheax_config_help(struct chx_config_help **help, size_t *num_opts);
 
CHX_API int cheax_list_to_array(CHEAX *c,
                                struct chx_list *list,
                                struct chx_value **array_ptr,
                                size_t *length);
 
CHX_API struct chx_value cheax_array_to_list(CHEAX *c,
                                             struct chx_value *array,
                                             size_t length);
 
enum {
        CHEAX_SYNCED     = 0x01, 
        CHEAX_READONLY   = 0x02, 
        CHEAX_WRITEONLY  = 0x04, 
        CHEAX_EVAL_NODES = 0x08,
};
 
CHX_API void cheax_push_env(CHEAX *c);
 
CHX_API void cheax_enter_env(CHEAX *c, struct chx_env *main);
 
CHX_API void cheax_pop_env(CHEAX *c);
 
CHX_API struct chx_sym *cheax_defsym(CHEAX *c, const char *id,
                                     chx_getter get, chx_setter set,
                                     chx_finalizer fin, void *user_info);
 
CHX_API void cheax_def(CHEAX *c, const char *id, struct chx_value value, int flags);
 
CHX_API struct chx_value cheax_get(CHEAX *c, const char *id);
 
CHX_API bool cheax_try_get(CHEAX *c, const char *id, struct chx_value *out);
 
CHX_API struct chx_value cheax_get_from(CHEAX *c, struct chx_env *env, const char *id);
 
CHX_API bool cheax_try_get_from(CHEAX *c,
                                struct chx_env *env,
                                const char *id,
                                struct chx_value *out);
 
CHX_API void cheax_set(CHEAX *c, const char *id, struct chx_value value);
 
CHX_API void cheax_defun(CHEAX *c, const char *id, chx_func_ptr perform, void *info);
CHX_API void cheax_defsyntax(CHEAX *c,
                             const char *id,
                             chx_tail_func_ptr perform,
                             chx_func_ptr preproc,
                             void *info);
 
CHX_API void cheax_sync_int(CHEAX *c, const char *name, int *var, int flags);
 
CHX_API void cheax_sync_bool(CHEAX *c, const char *name, bool *var, int flags);
 
CHX_API void cheax_sync_float(CHEAX *c, const char *name, float *var, int flags);
 
CHX_API void cheax_sync_double(CHEAX *c, const char *name, double *var, int flags);
 
CHX_API void cheax_sync_nstring(CHEAX *c, const char *name, char *buf, size_t size, int flags);
 
CHX_API bool cheax_match_in(CHEAX *c,
                            struct chx_env *env,
                            struct chx_value pan,
                            struct chx_value match,
                            int flags);
 
CHX_API bool cheax_match(CHEAX *c, struct chx_value pan, struct chx_value match, int flags);
 
CHX_API bool cheax_eq(CHEAX *c, struct chx_value l, struct chx_value r);
CHX_API bool cheax_equiv(struct chx_value l, struct chx_value r);
 
CHX_API struct chx_value cheax_cast(CHEAX *c, struct chx_value v, int type);
 
CHX_API struct chx_value cheax_read(CHEAX *c, FILE *f);
 
CHX_API struct chx_value cheax_read_at(CHEAX *c,
                                       FILE *f,
                                       const char *path,
                                       int *line,
                                       int *pos);
 
CHX_API struct chx_value cheax_readstr(CHEAX *c, const char *str);
 
CHX_API struct chx_value cheax_readstr_at(CHEAX *c,
                                          const char **str,
                                          const char *path,
                                          int *line,
                                          int *pos);
 
CHX_API struct chx_value cheax_macroexpand(CHEAX *c, struct chx_value expr);
 
CHX_API struct chx_value cheax_macroexpand_once(CHEAX *c, struct chx_value expr);
 
CHX_API struct chx_value cheax_preproc(CHEAX *c, struct chx_value expr);
 
CHX_API struct chx_value cheax_eval(CHEAX *c, struct chx_value expr);
 
CHX_API struct chx_value cheax_apply(CHEAX *c, struct chx_value func, struct chx_list *list);
 
CHX_API void cheax_print(CHEAX *c, FILE *output, struct chx_value expr);
 
CHX_API struct chx_value cheax_format(CHEAX *c, struct chx_string *fmt, struct chx_list *args);
 
CHX_API void cheax_exec(CHEAX *c, const char *f);
 
CHX_API void *cheax_malloc(CHEAX *c, size_t size);
CHX_API void *cheax_calloc(CHEAX *c, size_t nmemb, size_t size);
CHX_API void *cheax_realloc(CHEAX *c, void *ptr, size_t size);
CHX_API void cheax_free(CHEAX *c, void *ptr);
CHX_API void cheax_gc(CHEAX *c);
 
#endif