hyperon.h

Go to the documentation of this file.

#ifndef HYPERON_H
#define HYPERON_H

/* Warning, this file is autogenerated by cbindgen. Don't modify this manually. */
 
 
#include <stdarg.h>
#include <stdbool.h>
#include <stdint.h>
#include <stdlib.h>
struct gnd_t;

typedef enum serial_result_t {
  OK,
  NOT_SUPPORTED,
} serial_result_t;

typedef enum atom_type_t {
  SYMBOL,
  VARIABLE,
  EXPR,
  GROUNDED,
} atom_type_t;

typedef enum space_event_type_t {
  SPACE_EVENT_TYPE_ADD,
  SPACE_EVENT_TYPE_REMOVE,
  SPACE_EVENT_TYPE_REPLACE,
} space_event_type_t;

typedef enum space_event_field_t {
  SPACE_EVENT_FIELD_ADD,
  SPACE_EVENT_FIELD_REMOVE,
  SPACE_EVENT_FIELD_REPLACE_PATTERN,
  SPACE_EVENT_FIELD_REPLACE_TEMPLATE,
} space_event_field_t;

typedef enum syntax_node_type_t {
  COMMENT,
  VARIABLE_TOKEN,
  STRING_TOKEN,
  WORD_TOKEN,
  OPEN_PAREN,
  CLOSE_PAREN,
  WHITESPACE,
  LEFTOVER_TEXT,
  EXPRESSION_GROUP,
  ERROR_GROUP,
} syntax_node_type_t;
 
typedef struct RustBindings RustBindings;
 
typedef struct RustBindingsSet RustBindingsSet;
 
typedef struct RustEnvBuilder RustEnvBuilder;
 
typedef struct RustMetta RustMetta;

typedef struct RustMettaModRef RustMettaModRef;
 
typedef struct RustModuleDescriptor RustModuleDescriptor;
 
typedef struct RustOpaqueAtom RustOpaqueAtom;
 
typedef struct RustOpaqueExecError RustOpaqueExecError;
 
typedef struct RustOpaqueSpace RustOpaqueSpace;
 
typedef struct RustRunContext RustRunContext;
 
typedef struct RustRunnerState RustRunnerState;
 
typedef struct RustSpaceCommonData RustSpaceCommonData;
 
typedef struct RustSpaceEvent RustSpaceEvent;
 
typedef struct RustSpaceObserver RustSpaceObserver;
 
typedef struct RustStepResult RustStepResult;
 
typedef struct RustSyntaxNode RustSyntaxNode;
 
typedef struct RustTokenizer RustTokenizer;

typedef struct write_t {
  const void *_0;
} write_t;
 
typedef enum RustAtom_Tag {
  None,
  Owned,
  Borrowed,
} RustAtom_Tag;
 
typedef struct RustAtom {
  RustAtom_Tag tag;
  union {
    struct {
      struct RustOpaqueAtom *owned;
    };
    struct {
      const struct RustOpaqueAtom *borrowed;
    };
  };
} RustAtom;

typedef struct RustAtom atom_ref_t;

typedef struct RustAtom atom_t;

typedef struct atom_vec_t {
  struct RustOpaqueAtom *ptr;
  uintptr_t len;
  uintptr_t capacity;
  bool owned;
} atom_vec_t;

typedef enum exec_error_t_Tag {
  NoErr,
  Status,
} exec_error_t_Tag;
 
typedef struct exec_error_t {
  exec_error_t_Tag tag;
  union {
    struct {
      struct RustOpaqueExecError *status;
    };
  };
} exec_error_t;

typedef struct bindings_set_t {
  struct RustBindingsSet *set;
} bindings_set_t;

typedef struct serializer_api_t {
  enum serial_result_t (*serialize_bool)(void *context, bool v);
  enum serial_result_t (*serialize_longlong)(void *context, long long v);
  enum serial_result_t (*serialize_double)(void *context, double v);
  enum serial_result_t (*serialize_str)(void *context, const char *v);
} serializer_api_t;

typedef struct gnd_api_t {
  struct exec_error_t (*execute)(const struct gnd_t *gnd,
                                 const struct atom_vec_t *args,
                                 struct atom_vec_t *out);
  struct bindings_set_t (*match_)(const struct gnd_t *gnd, const atom_ref_t *other);
  enum serial_result_t (*serialize)(const struct gnd_t *gnd,
                                    const struct serializer_api_t *api,
                                    void *context);
  bool (*eq)(const struct gnd_t *gnd, const struct gnd_t *other);
  struct gnd_t *(*clone)(const struct gnd_t *gnd);
  uintptr_t (*display)(const struct gnd_t *gnd, char *buf, uintptr_t buf_len);
  void (*free)(struct gnd_t *gnd);
} gnd_api_t;

typedef struct gnd_t {
  const struct gnd_api_t *api;
  atom_t typ;
} gnd_t;

typedef struct space_t {
  const struct RustOpaqueSpace *space;
} space_t;

typedef void (*c_atom_vec_callback_t)(const struct atom_vec_t *vec, void *context);

typedef void (*c_atom_callback_t)(atom_ref_t atom, void *context);

typedef struct bindings_t {
  struct RustBindings *bindings;
} bindings_t;

typedef void (*c_var_binding_callback_t)(atom_ref_t var, atom_ref_t value, void *context);

typedef void (*bindings_mut_callback_t)(struct bindings_t *bindings, void *context);

typedef struct space_params_t {
  void *payload;
  struct RustSpaceCommonData *common;
} space_params_t;

typedef struct space_api_t {
  struct bindings_set_t (*query)(const struct space_params_t *params, const atom_ref_t *atom);
  struct atom_vec_t (*subst)(const struct space_params_t *params,
                             const atom_ref_t *pattern,
                             const atom_ref_t *tmpl);
  void (*add)(const struct space_params_t *params, atom_t atom);
  bool (*remove)(const struct space_params_t *params, const atom_ref_t *atom);
  bool (*replace)(const struct space_params_t *params, const atom_ref_t *from, atom_t to);
  intptr_t (*atom_count)(const struct space_params_t *params);
  void *(*new_atom_iterator_state)(const struct space_params_t *params);
  atom_ref_t (*next_atom)(const struct space_params_t *params, void *state);
  void (*free_atom_iterator_state)(const struct space_params_t *params, void *state);
  void (*free_payload)(void *payload);
} space_api_t;

typedef struct space_event_t {
  struct RustSpaceEvent *event;
} space_event_t;

typedef struct space_observer_t {
  const struct RustSpaceObserver *observer;
} space_observer_t;

typedef struct space_observer_api_t {
  void (*notify)(void *payload, const struct space_event_t *event);
  void (*free_payload)(void *payload);
} space_observer_api_t;

typedef struct tokenizer_t {
  const struct RustTokenizer *tokenizer;
} tokenizer_t;

typedef struct token_api_t {
  atom_t (*construct_atom)(const char *str, void *context);
  void (*free_context)(void *context);
} token_api_t;

typedef struct sexpr_parser_t {
  void *parser;
  char *err_string;
} sexpr_parser_t;

typedef struct syntax_node_t {
  struct RustSyntaxNode *node;
} syntax_node_t;

typedef void (*c_syntax_node_callback_t)(const struct syntax_node_t *node, void *context);

typedef struct step_result_t {
  struct RustStepResult *result;
} step_result_t;

typedef struct metta_t {
  struct RustMetta *metta;
  char *err_string;
} metta_t;

typedef struct run_context_t {
  struct RustRunContext *context;
  char *err_string;
} run_context_t;

typedef struct metta_mod_ref_t {
  const struct RustMettaModRef *module;
} metta_mod_ref_t;

typedef struct module_loader_t {
  intptr_t (*load)(const void *payload, struct run_context_t *context, struct write_t err);
  intptr_t (*load_tokens)(const void *payload,
                          struct metta_mod_ref_t target,
                          struct metta_t metta,
                          struct write_t err);
  void (*to_string)(const void *payload, struct write_t text);
  void (*free)(void *payload);
} module_loader_t;

typedef struct env_builder_t {
  struct RustEnvBuilder *builder;
} env_builder_t;

typedef struct module_id_t {
  uintptr_t id;
} module_id_t;

typedef struct runner_state_t {
  struct RustRunnerState *state;
  char *err_string;
} runner_state_t;

typedef struct module_descriptor_t {
  struct RustModuleDescriptor *descriptor;
} module_descriptor_t;

typedef struct fs_module_format_t {
  uintptr_t (*path_for_name)(const void *payload,
                             const char *parent_dir,
                             const char *mod_name,
                             char *dst_buf,
                             uintptr_t buf_size);
  bool (*try_path)(const void *payload,
                   const char *path,
                   const char *mod_name,
                   const struct module_loader_t **mod_loader,
                   struct module_descriptor_t *mod_descriptor);
  void (*free)(void *payload);
} fs_module_format_t;
 
#ifdef __cplusplus
extern "C" {
#endif // __cplusplus

void log_error(const char *msg);

void log_warn(const char *msg);

void log_info(const char *msg);

intptr_t write_str(struct write_t cwrite, const char *text);

atom_ref_t atom_ref(const atom_t *atom);

atom_ref_t atom_ref_null(void);

atom_t atom_sym(const char *name);

atom_t atom_expr(atom_t *children,
                 uintptr_t size);

atom_t atom_expr_from_vec(struct atom_vec_t children);

atom_t atom_var(const char *name);

atom_t atom_var_parse_name(const char *name);

atom_t atom_gnd(struct gnd_t *gnd);

atom_t atom_bool(bool b);

atom_t atom_int(int64_t n);

atom_t atom_float(double f);

atom_t atom_gnd_for_space(const struct space_t *space);

void atom_free(atom_t atom);

atom_t atom_clone(const atom_ref_t *atom);

bool atom_eq(const atom_ref_t *a, const atom_ref_t *b);

bool atoms_are_equivalent(const atom_ref_t *a,
                          const atom_ref_t *b);

enum atom_type_t atom_get_metatype(const atom_ref_t *atom);

bool atom_is_null(const atom_ref_t *atom);

uintptr_t atom_to_str(const atom_ref_t *atom, char *buf, uintptr_t buf_len);

uintptr_t atom_get_name(const atom_ref_t *atom, char *buf, uintptr_t buf_len);

void atom_get_children(const atom_ref_t *atom,
                       c_atom_vec_callback_t callback,
                       void *context);

void atom_iterate(const atom_ref_t *atom,
                  c_atom_callback_t callback,
                  void *context);

atom_t atom_get_grounded_type(const atom_ref_t *atom);

struct gnd_t *atom_get_object(const atom_ref_t *atom);

bool atom_is_cgrounded(const atom_ref_t *atom);

struct space_t atom_get_space(const atom_ref_t *atom);

struct exec_error_t exec_error_runtime(const char *message);

struct exec_error_t exec_error_no_reduce(void);

struct exec_error_t exec_error_incorrect_argument(void);

struct exec_error_t exec_error_no_err(void);

void exec_error_free(struct exec_error_t error);

void throw_panic_with_message(const char *message);

struct atom_vec_t atom_vec_new(void);

struct atom_vec_t atom_vec_clone(const struct atom_vec_t *vec);

struct atom_vec_t atom_vec_from_array(atom_t *atoms,
                                      uintptr_t size);

void atom_vec_free(struct atom_vec_t vec);

uintptr_t atom_vec_len(const struct atom_vec_t *vec);

atom_t atom_vec_pop(struct atom_vec_t *vec);

void atom_vec_push(struct atom_vec_t *vec,
                   atom_t atom);

atom_ref_t atom_vec_get(const struct atom_vec_t *vec,
                        uintptr_t idx);

struct bindings_set_t atom_match_atom(const atom_ref_t *a,
                                      const atom_ref_t *b);

enum serial_result_t atom_gnd_serialize(const atom_ref_t *atom,
                                        const struct serializer_api_t *api,
                                        void *context);

struct bindings_t bindings_new(void);

void bindings_free(struct bindings_t bindings);

struct bindings_t bindings_clone(const struct bindings_t *bindings);

uintptr_t bindings_to_str(const struct bindings_t *bindings, char *buf, uintptr_t buf_len);

bool bindings_eq(const struct bindings_t *a, const struct bindings_t *b);

void bindings_traverse(const struct bindings_t *bindings,
                       c_var_binding_callback_t callback,
                       void *context);

bool bindings_add_var_binding(struct bindings_t *bindings,
                              atom_t var,
                              atom_t atom);

bool bindings_is_empty(const struct bindings_t *bindings);

atom_t bindings_resolve(const struct bindings_t *bindings,
                        atom_t var);

struct bindings_set_t bindings_merge(struct bindings_t _self,
                                     const struct bindings_t *other);

void bindings_narrow_vars(struct bindings_t *bindings,
                          const struct atom_vec_t *vars);

struct bindings_set_t bindings_set_empty(void);

struct bindings_set_t bindings_set_single(void);

struct bindings_set_t bindings_set_from_bindings(struct bindings_t bindings);

void bindings_set_push(struct bindings_set_t *set,
                       struct bindings_t bindings);

void bindings_set_free(struct bindings_set_t set);

struct bindings_set_t bindings_set_clone(const struct bindings_set_t *set);

bool bindings_set_eq(const struct bindings_set_t *a, const struct bindings_set_t *b);

uintptr_t bindings_set_to_str(const struct bindings_set_t *set, char *buf, uintptr_t buf_len);

bool bindings_set_is_empty(const struct bindings_set_t *set);

bool bindings_set_is_single(const struct bindings_set_t *set);

void bindings_set_iterate(struct bindings_set_t *set,
                          bindings_mut_callback_t callback,
                          void *context);

void bindings_set_add_var_equality(struct bindings_set_t *set,
                                   const atom_ref_t *a,
                                   const atom_ref_t *b);

void bindings_set_add_var_binding(struct bindings_set_t *set,
                                  const atom_ref_t *var,
                                  const atom_ref_t *value);

void bindings_set_merge_into(struct bindings_set_t *_self,
                             const struct bindings_set_t *other);

struct space_t space_new(const struct space_api_t *api,
                         void *payload);

void space_free(struct space_t space);

struct space_t space_clone_handle(const struct space_t *space);

bool space_eq(const struct space_t *a,
              const struct space_t *b);

void *space_get_payload(struct space_t *space);

void space_add(struct space_t *space,
               atom_t atom);

bool space_remove(struct space_t *space,
                  const atom_ref_t *atom);

bool space_replace(struct space_t *space,
                   const atom_ref_t *from,
                   atom_t to);

struct bindings_set_t space_query(const struct space_t *space,
                                  const atom_ref_t *pattern);

void space_subst(const struct space_t *space,
                 const atom_ref_t *pattern,
                 const atom_ref_t *templ,
                 c_atom_vec_callback_t callback,
                 void *context);

intptr_t space_atom_count(const struct space_t *space);

bool space_iterate(const struct space_t *space,
                   c_atom_callback_t callback,
                   void *context);

struct space_t space_new_grounding_space(void);

enum space_event_type_t space_event_get_type(const struct space_event_t *event);

atom_ref_t space_event_get_field_atom(const struct space_event_t *event,
                                      enum space_event_field_t field);

struct space_observer_t space_register_observer(struct space_t *space,
                                                const struct space_observer_api_t *observer_api,
                                                void *observer_payload);

void space_observer_free(struct space_observer_t observer);

void *space_observer_get_payload(const struct space_observer_t *observer);

void space_params_notify_all_observers(const struct space_params_t *params,
                                       const struct space_event_t *event);

struct space_event_t space_event_new_add(atom_t atom);

struct space_event_t space_event_new_remove(atom_t atom);

struct space_event_t space_event_new_replace(atom_t pattern,
                                             atom_t tmpl);

void space_event_free(struct space_event_t event);

struct tokenizer_t tokenizer_new(void);

void tokenizer_free(struct tokenizer_t tokenizer);

void tokenizer_register_token(struct tokenizer_t *tokenizer,
                              const char *regex,
                              const struct token_api_t *api,
                              void *context);

struct tokenizer_t tokenizer_clone(const struct tokenizer_t *tokenizer);

struct sexpr_parser_t sexpr_parser_new(const char *text);

void sexpr_parser_free(struct sexpr_parser_t parser);

atom_t sexpr_parser_parse(struct sexpr_parser_t *parser,
                          const struct tokenizer_t *tokenizer);

const char *sexpr_parser_err_str(const struct sexpr_parser_t *parser);

struct syntax_node_t sexpr_parser_parse_to_syntax_tree(struct sexpr_parser_t *parser);

void syntax_node_free(struct syntax_node_t node);

struct syntax_node_t syntax_node_clone(const struct syntax_node_t *node);

void syntax_node_iterate(const struct syntax_node_t *node,
                         c_syntax_node_callback_t callback,
                         void *context);

enum syntax_node_type_t syntax_node_type(const struct syntax_node_t *node);

bool syntax_node_is_null(const struct syntax_node_t *node);

bool syntax_node_is_leaf(const struct syntax_node_t *node);

void syntax_node_src_range(const struct syntax_node_t *node,
                           uintptr_t *range_start,
                           uintptr_t *range_end);

bool atom_is_error(const atom_ref_t *atom);

uintptr_t atom_error_message(const atom_ref_t *atom, char *buf, uintptr_t buf_len);

atom_t ATOM_TYPE_UNDEFINED(void);

atom_t ATOM_TYPE_TYPE(void);

atom_t ATOM_TYPE_ATOM(void);

atom_t ATOM_TYPE_SYMBOL(void);

atom_t ATOM_TYPE_VARIABLE(void);

atom_t ATOM_TYPE_EXPRESSION(void);

atom_t ATOM_TYPE_GROUNDED(void);

atom_t ATOM_TYPE_GROUNDED_SPACE(void);

atom_t ATOM_TYPE_UNIT(void);

atom_t ATOM_TYPE_NUMBER(void);

atom_t ATOM_TYPE_BOOL(void);

atom_t ATOM_TYPE_STRING(void);

atom_t EMPTY_ATOM(void);

atom_t UNIT_ATOM(void);

atom_t METTA_ATOM(void);

bool check_type(const struct space_t *space,
                const atom_ref_t *atom,
                const atom_ref_t *typ);

bool validate_atom(const struct space_t *space,
                   const atom_ref_t *atom);

void get_atom_types(const struct space_t *space,
                    const atom_ref_t *atom,
                    c_atom_vec_callback_t callback,
                    void *context);

struct step_result_t interpret_init(struct space_t *space,
                                    const atom_ref_t *expr);

struct step_result_t interpret_step(struct step_result_t step);

uintptr_t step_to_str(const struct step_result_t *step, char *buf, uintptr_t buf_len);

bool step_has_next(const struct step_result_t *step);

void step_get_result(struct step_result_t step,
                     c_atom_vec_callback_t callback,
                     void *context);

struct metta_t metta_new(void);

struct metta_t metta_new_with_stdlib_loader(struct module_loader_t *stdlib_loader_mov,
                                            struct space_t *space_ref,
                                            struct env_builder_t env_builder_mov);

struct metta_t metta_new_core(struct space_t *space,
                              struct env_builder_t env_builder);

struct metta_t metta_clone_handle(const struct metta_t *metta);

void metta_free(struct metta_t metta);

const char *metta_err_str(const struct metta_t *metta);

bool metta_eq(const struct metta_t *a, const struct metta_t *b);

struct space_t metta_space(struct metta_t *metta);

struct tokenizer_t metta_tokenizer(struct metta_t *metta);

uintptr_t metta_working_dir(const struct metta_t *metta, char *buf, uintptr_t buf_len);

void metta_run(struct metta_t *metta,
               struct sexpr_parser_t parser,
               c_atom_vec_callback_t callback,
               void *context);

void metta_evaluate_atom(struct metta_t *metta,
                         atom_t atom,
                         c_atom_vec_callback_t callback,
                         void *context);

struct module_id_t metta_load_module_direct(struct metta_t *metta_ref,
                                            const char *name_ref,
                                            struct module_loader_t *loader_mov);

struct module_id_t metta_load_module_at_path(struct metta_t *metta,
                                             const char *path,
                                             const char *name);

struct space_t metta_get_module_space(const struct metta_t *metta, struct module_id_t mod_id);

void run_context_push_parser(struct run_context_t *run_context, struct sexpr_parser_t parser);

struct metta_t run_context_get_metta(const struct run_context_t *run_context);

struct space_t run_context_get_space(const struct run_context_t *run_context);

struct tokenizer_t run_context_get_tokenizer(const struct run_context_t *run_context);

void run_context_raise_error(struct run_context_t *run_context,
                             const char *message);

struct runner_state_t runner_state_new_with_parser(const struct metta_t *metta,
                                                   struct sexpr_parser_t parser);

struct runner_state_t runner_state_new_with_atoms(const struct metta_t *metta,
                                                  const struct atom_vec_t *atoms);

void runner_state_free(struct runner_state_t state);

const char *runner_state_err_str(const struct runner_state_t *state);

void runner_state_step(struct runner_state_t *state);

bool runner_state_is_complete(const struct runner_state_t *state);

uintptr_t runner_state_to_str(const struct runner_state_t *state, char *buf, uintptr_t buf_len);

void runner_state_current_results(const struct runner_state_t *state,
                                  c_atom_vec_callback_t callback,
                                  void *context);

uintptr_t environment_config_dir(char *buf, uintptr_t buf_len);

struct env_builder_t env_builder_start(void);

struct env_builder_t env_builder_use_default(void);

struct env_builder_t env_builder_use_test_env(void);

bool env_builder_init_common_env(struct env_builder_t builder);

void env_builder_set_working_dir(struct env_builder_t *builder,
                                 const char *path);

void env_builder_set_config_dir(struct env_builder_t *builder, const char *path);

void env_builder_create_config_dir(struct env_builder_t *builder, bool should_create);

void env_builder_set_default_config_dir(struct env_builder_t *builder);

void env_builder_set_is_test(struct env_builder_t *builder, bool is_test);

void env_builder_push_include_path(struct env_builder_t *builder,
                                   const char *path);

void env_builder_push_fs_module_format(struct env_builder_t *builder,
                                       const struct fs_module_format_t *format);

void run_context_init_self_module(struct run_context_t *run_context,
                                  struct space_t *space,
                                  const char *resource_dir_path);

struct module_id_t run_context_load_module(struct run_context_t *run_context, const char *name);

void run_context_import_dependency(struct run_context_t *run_context,
                                   struct module_id_t mod_id);
 
enum serial_result_t serialize_bool_rust_adapter(void *context, bool v);
 
enum serial_result_t serialize_longlong_rust_adapter(void *context, long long v);
 
enum serial_result_t serialize_double_rust_adapter(void *context, double v);
 
enum serial_result_t serialize_str_rust_adapter(void *context, const char *v);

struct tokenizer_t metta_mod_ref_tokenizer(const struct metta_mod_ref_t *mod_ref);

struct module_descriptor_t module_descriptor_new(const char *name);
 
struct module_descriptor_t module_descriptor_new_with_path_and_fmt_id(const char *name,
                                                                      const char *path,
                                                                      uint64_t fmt_id);

struct module_descriptor_t module_descriptor_clone(const struct module_descriptor_t *descriptor);

void module_descriptor_free(struct module_descriptor_t descriptor);

bool module_id_is_valid(const struct module_id_t *mod_id);
 
#ifdef __cplusplus
}  // extern "C"
#endif  // __cplusplus
 
#endif  /* HYPERON_H */