core.h

#ifndef CLINGO_CORE_H
#define CLINGO_CORE_H
 
#include <stdbool.h>
#include <stddef.h>
#include <stdint.h>
 
#if defined CLINGO_NO_VISIBILITY
#define CLINGO_VISIBILITY_DEFAULT
#define CLINGO_VISIBILITY_PRIVATE
#elif defined __EMSCRIPTEN__
#include <emscripten.h>
#define CLINGO_VISIBILITY_DEFAULT EMSCRIPTEN_KEEPALIVE
#define CLINGO_VISIBILITY_PRIVATE
#elif defined _WIN32 || defined __CYGWIN__
#ifdef CLINGO_BUILD_LIBRARY
#define CLINGO_VISIBILITY_DEFAULT __declspec(dllexport)
#else
#define CLINGO_VISIBILITY_DEFAULT __declspec(dllimport)
#endif
#define CLINGO_VISIBILITY_PRIVATE
#elif __GNUC__ >= 4
#define CLINGO_VISIBILITY_DEFAULT __attribute__((visibility("default")))
#define CLINGO_VISIBILITY_PRIVATE __attribute__((visibility("hidden")))
#else
#define CLINGO_VISIBILITY_DEFAULT
#define CLINGO_VISIBILITY_PRIVATE
#endif
 
#if defined __GNUC__
#define CLINGO_DEPRECATED __attribute__((deprecated))
#elif defined _MSC_VER
#define CLINGO_DEPRECATED __declspec(deprecated)
#else
#define CLINGO_DEPRECATED
#endif
 
#ifdef __cplusplus
extern "C" {
#endif
 
 
 
#define CLINGO_VERSION_MAJOR 6
#define CLINGO_VERSION_MINOR 0
#define CLINGO_VERSION_REVISION 0
#define CLINGO_VERSION "6.0.0"
#define CLINGO_EXECUTABLE "clingo"
 
typedef int32_t clingo_literal_t;
typedef uint32_t clingo_atom_t;
typedef uint32_t clingo_id_t;
typedef int32_t clingo_weight_t;
typedef struct clingo_weighted_literal {
    clingo_literal_t literal; 
    clingo_weight_t weight;   
} clingo_weighted_literal_t;
typedef struct clingo_string {
    char const *data; 
    size_t size;      
} clingo_string_t;
 
enum clingo_result_e {
    clingo_result_success = 0,   
    clingo_result_runtime = 1,   
    clingo_result_logic = 2,     
    clingo_result_bad_alloc = 3, 
    clingo_result_invalid = 4,   
    clingo_result_range = 5,     
};
typedef int clingo_result_t;
 
CLINGO_VISIBILITY_DEFAULT bool clingo_set_error(clingo_result_t code, char const *message, size_t size);
 
CLINGO_VISIBILITY_DEFAULT void clingo_get_error(clingo_result_t *code, clingo_string_t *message);
 
CLINGO_VISIBILITY_DEFAULT void clingo_clear_error(void);
 
enum clingo_message_e {
    clingo_message_trace = 0,               
    clingo_message_debug = 1,               
    clingo_message_info = 2,                
    clingo_message_operation_undefined = 3, 
    clingo_message_atom_undefined = 4,      
    clingo_message_file_included = 5,       
    clingo_message_global_variable = 6,     
    clingo_message_warn = 7,                
    clingo_message_error = 8, 
};
typedef int clingo_message_t;
 
enum clingo_log_level_e {
    clingo_log_level_trace = clingo_message_trace, 
    clingo_log_level_debug = clingo_message_debug, 
    clingo_log_level_info = clingo_message_info,   
    clingo_log_level_warn = clingo_message_warn,   
    clingo_log_level_error = clingo_message_error, 
};
typedef int clingo_log_level_t;
 
typedef struct clingo_logger {
    void (*log)(clingo_message_t code, char const *message, size_t size, void *data);
    void (*free)(void *data);
} clingo_logger_t;
 
typedef struct clingo_lib clingo_lib_t;
 
enum clingo_lib_flags_e {
    clingo_lib_flags_slotted = 1,      
    clingo_lib_flags_shared = 2,       
    clingo_lib_flags_fast_release = 4, 
};
typedef uint32_t clingo_lib_flags_t;
 
CLINGO_VISIBILITY_DEFAULT void clingo_version(int *major, int *minor, int *revision);
 
CLINGO_VISIBILITY_DEFAULT void clingo_result_string(clingo_result_t code, clingo_string_t *value);
 
CLINGO_VISIBILITY_DEFAULT void clingo_message_string(clingo_message_t code, clingo_string_t *value);
 
CLINGO_VISIBILITY_DEFAULT bool clingo_lib_new(clingo_lib_flags_t flags, clingo_log_level_t level,
                                              clingo_logger_t const *logger, void *data, size_t limit,
                                              clingo_lib_t **lib);
 
CLINGO_VISIBILITY_DEFAULT void clingo_lib_acquire(clingo_lib_t *lib);
 
CLINGO_VISIBILITY_DEFAULT void clingo_lib_release(clingo_lib_t *lib);
 
CLINGO_VISIBILITY_DEFAULT void clingo_lib_report(clingo_lib_t *lib, clingo_message_t code, char const *message,
                                                 size_t size);
 
typedef struct clingo_string_builder clingo_string_builder_t;
 
CLINGO_VISIBILITY_DEFAULT bool clingo_string_builder_new(clingo_string_builder_t **bld);
CLINGO_VISIBILITY_DEFAULT bool clingo_string_builder_copy(clingo_string_builder_t const *src,
                                                          clingo_string_builder_t **dst);
CLINGO_VISIBILITY_DEFAULT void clingo_string_builder_free(clingo_string_builder_t const *bld);
 
CLINGO_VISIBILITY_DEFAULT bool clingo_string_builder_string(clingo_string_builder_t const *bld, clingo_string_t *value);
CLINGO_VISIBILITY_DEFAULT void clingo_string_builder_clear(clingo_string_builder_t *bld);
 
typedef struct clingo_position clingo_position_t;
 
CLINGO_VISIBILITY_DEFAULT bool clingo_position_new(clingo_lib_t *lib, char const *file, size_t size, size_t line,
                                                   size_t column, clingo_position_t const **pos);
CLINGO_VISIBILITY_DEFAULT bool clingo_position_copy(clingo_position_t const *src, clingo_position_t const **dst);
CLINGO_VISIBILITY_DEFAULT void clingo_position_free(clingo_position_t const *pos);
 
CLINGO_VISIBILITY_DEFAULT void clingo_position_file(clingo_position_t const *pos, clingo_string_t *value);
CLINGO_VISIBILITY_DEFAULT size_t clingo_position_line(clingo_position_t const *pos);
CLINGO_VISIBILITY_DEFAULT size_t clingo_position_column(clingo_position_t const *pos);
CLINGO_VISIBILITY_DEFAULT size_t clingo_position_hash(clingo_position_t const *pos);
CLINGO_VISIBILITY_DEFAULT bool clingo_position_equal(clingo_position_t const *a, clingo_position_t const *b);
CLINGO_VISIBILITY_DEFAULT int clingo_position_compare(clingo_position_t const *a, clingo_position_t const *b);
CLINGO_VISIBILITY_DEFAULT bool clingo_position_to_string(clingo_position_t const *pos, clingo_string_builder_t *str);
 
typedef struct clingo_location clingo_location_t;
 
CLINGO_VISIBILITY_DEFAULT bool clingo_location_new(clingo_position_t const *begin, clingo_position_t const *end,
                                                   clingo_location_t const **loc);
CLINGO_VISIBILITY_DEFAULT bool clingo_location_copy(clingo_location_t const *src, clingo_location_t const **dst);
CLINGO_VISIBILITY_DEFAULT void clingo_location_free(clingo_location_t const *loc);
 
CLINGO_VISIBILITY_DEFAULT clingo_position_t const *clingo_location_begin(clingo_location_t const *loc);
CLINGO_VISIBILITY_DEFAULT clingo_position_t const *clingo_location_end(clingo_location_t const *loc);
CLINGO_VISIBILITY_DEFAULT size_t clingo_location_hash(clingo_location_t const *loc);
CLINGO_VISIBILITY_DEFAULT bool clingo_location_equal(clingo_location_t const *a, clingo_location_t const *b);
CLINGO_VISIBILITY_DEFAULT int clingo_location_compare(clingo_location_t const *a, clingo_location_t const *b);
CLINGO_VISIBILITY_DEFAULT bool clingo_location_to_string(clingo_location_t const *loc, clingo_string_builder_t *str);
 
 
#ifdef __cplusplus
}
#endif
 
#endif