clingo.h

Go to the documentation of this file.

// {{{ MIT License
 
// Copyright 2017 Roland Kaminski
 
// Permission is hereby granted, free of charge, to any person obtaining a copy
// of this software and associated documentation files (the "Software"), to
// deal in the Software without restriction, including without limitation the
// rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
// sell copies of the Software, and to permit persons to whom the Software is
// furnished to do so, subject to the following conditions:
 
// The above copyright notice and this permission notice shall be included in
// all copies or substantial portions of the Software.
 
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
// IN THE SOFTWARE.
 
// }}}
 
 
 
#ifndef CLINGO_H
#define CLINGO_H
 
#ifdef __cplusplus
extern "C" {
#endif
 
#include <stdbool.h>
#include <stddef.h>
#include <stdint.h>
 
#if defined _WIN32 || defined __CYGWIN__
#define CLINGO_WIN
#endif
#ifdef CLINGO_NO_VISIBILITY
#define CLINGO_VISIBILITY_DEFAULT
#define CLINGO_VISIBILITY_PRIVATE
#else
#ifdef CLINGO_WIN
#ifdef CLINGO_BUILD_LIBRARY
#define CLINGO_VISIBILITY_DEFAULT __declspec(dllexport)
#else
#define CLINGO_VISIBILITY_DEFAULT __declspec(dllimport)
#endif
#define CLINGO_VISIBILITY_PRIVATE
#else
#if __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
#endif
#endif
 
#if defined __GNUC__
#define CLINGO_DEPRECATED __attribute__((deprecated))
#elif defined _MSC_VER
#define CLINGO_DEPRECATED __declspec(deprecated)
#else
#define CLINGO_DEPRECATED
#endif
 
// {{{1 basic types and error/warning handling
 
 
 
 
#define CLINGO_VERSION_MAJOR 5
#define CLINGO_VERSION_MINOR 8
#define CLINGO_VERSION_REVISION 0
#define CLINGO_VERSION "5.8.0"
 
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;
 
enum clingo_error_e {
    clingo_error_success = 0,   
    clingo_error_runtime = 1,   
    clingo_error_logic = 2,     
    clingo_error_bad_alloc = 3, 
    clingo_error_unknown = 4    
};
typedef int clingo_error_t;
CLINGO_VISIBILITY_DEFAULT char const *clingo_error_string(clingo_error_t code);
CLINGO_VISIBILITY_DEFAULT clingo_error_t clingo_error_code();
CLINGO_VISIBILITY_DEFAULT char const *clingo_error_message();
CLINGO_VISIBILITY_DEFAULT void clingo_set_error(clingo_error_t code, char const *message);
 
enum clingo_warning_e {
    clingo_warning_operation_undefined = 0, 
    clingo_warning_runtime_error = 1,      
    clingo_warning_atom_undefined = 2,     
    clingo_warning_file_included = 3,      
    clingo_warning_variable_unbounded = 4, 
    clingo_warning_global_variable = 5,    
    clingo_warning_other = 6,              
};
typedef int clingo_warning_t;
CLINGO_VISIBILITY_DEFAULT char const *clingo_warning_string(clingo_warning_t code);
typedef void (*clingo_logger_t)(clingo_warning_t code, char const *message, void *data);
 
CLINGO_VISIBILITY_DEFAULT void clingo_version(int *major, int *minor, int *revision);
 
enum clingo_truth_value_e {
    clingo_truth_value_free = 0, 
    clingo_truth_value_true = 1, 
    clingo_truth_value_false = 2 
};
typedef int clingo_truth_value_t;
 
typedef struct clingo_location {
    char const *begin_file; 
    char const *end_file;   
    size_t begin_line;      
    size_t end_line;        
    size_t begin_column;    
    size_t end_column;      
} clingo_location_t;
 
 
// {{{1 signature and symbols
 
 
 
 
typedef uint64_t clingo_signature_t;
 
 
CLINGO_VISIBILITY_DEFAULT bool clingo_signature_create(char const *name, uint32_t arity, bool positive,
                                                       clingo_signature_t *signature);
CLINGO_VISIBILITY_DEFAULT char const *clingo_signature_name(clingo_signature_t signature);
CLINGO_VISIBILITY_DEFAULT uint32_t clingo_signature_arity(clingo_signature_t signature);
CLINGO_VISIBILITY_DEFAULT bool clingo_signature_is_positive(clingo_signature_t signature);
CLINGO_VISIBILITY_DEFAULT bool clingo_signature_is_negative(clingo_signature_t signature);
CLINGO_VISIBILITY_DEFAULT bool clingo_signature_is_equal_to(clingo_signature_t a, clingo_signature_t b);
CLINGO_VISIBILITY_DEFAULT bool clingo_signature_is_less_than(clingo_signature_t a, clingo_signature_t b);
CLINGO_VISIBILITY_DEFAULT size_t clingo_signature_hash(clingo_signature_t signature);
 
 
enum clingo_symbol_type_e {
    clingo_symbol_type_infimum = 0,  
    clingo_symbol_type_number = 1,   
    clingo_symbol_type_string = 4,   
    clingo_symbol_type_function = 5, 
    clingo_symbol_type_supremum = 7  
};
typedef int clingo_symbol_type_t;
 
typedef uint64_t clingo_symbol_t;
 
 
CLINGO_VISIBILITY_DEFAULT void clingo_symbol_create_number(int number, clingo_symbol_t *symbol);
CLINGO_VISIBILITY_DEFAULT void clingo_symbol_create_supremum(clingo_symbol_t *symbol);
CLINGO_VISIBILITY_DEFAULT void clingo_symbol_create_infimum(clingo_symbol_t *symbol);
CLINGO_VISIBILITY_DEFAULT bool clingo_symbol_create_string(char const *string, clingo_symbol_t *symbol);
CLINGO_VISIBILITY_DEFAULT bool clingo_symbol_create_id(char const *name, bool positive, clingo_symbol_t *symbol);
CLINGO_VISIBILITY_DEFAULT bool clingo_symbol_create_function(char const *name, clingo_symbol_t const *arguments,
                                                             size_t arguments_size, bool positive,
                                                             clingo_symbol_t *symbol);
 
 
 
CLINGO_VISIBILITY_DEFAULT bool clingo_symbol_number(clingo_symbol_t symbol, int *number);
CLINGO_VISIBILITY_DEFAULT bool clingo_symbol_name(clingo_symbol_t symbol, char const **name);
CLINGO_VISIBILITY_DEFAULT bool clingo_symbol_string(clingo_symbol_t symbol, char const **string);
CLINGO_VISIBILITY_DEFAULT bool clingo_symbol_is_positive(clingo_symbol_t symbol, bool *positive);
CLINGO_VISIBILITY_DEFAULT bool clingo_symbol_is_negative(clingo_symbol_t symbol, bool *negative);
CLINGO_VISIBILITY_DEFAULT bool clingo_symbol_arguments(clingo_symbol_t symbol, clingo_symbol_t const **arguments,
                                                       size_t *arguments_size);
CLINGO_VISIBILITY_DEFAULT clingo_symbol_type_t clingo_symbol_type(clingo_symbol_t symbol);
CLINGO_VISIBILITY_DEFAULT bool clingo_symbol_to_string_size(clingo_symbol_t symbol, size_t *size);
CLINGO_VISIBILITY_DEFAULT bool clingo_symbol_to_string(clingo_symbol_t symbol, char *string, size_t size);
 
 
 
CLINGO_VISIBILITY_DEFAULT bool clingo_symbol_is_equal_to(clingo_symbol_t a, clingo_symbol_t b);
CLINGO_VISIBILITY_DEFAULT bool clingo_symbol_is_less_than(clingo_symbol_t a, clingo_symbol_t b);
CLINGO_VISIBILITY_DEFAULT size_t clingo_symbol_hash(clingo_symbol_t symbol);
 
 
CLINGO_VISIBILITY_DEFAULT bool clingo_add_string(char const *string, char const **result);
CLINGO_VISIBILITY_DEFAULT bool clingo_parse_term(char const *string, clingo_logger_t logger, void *logger_data,
                                                 unsigned message_limit, clingo_symbol_t *symbol);
 
 
// {{{1 symbolic atoms
 
 
 
 
typedef struct clingo_symbolic_atoms clingo_symbolic_atoms_t;
typedef uint64_t clingo_symbolic_atom_iterator_t;
CLINGO_VISIBILITY_DEFAULT bool clingo_symbolic_atoms_size(clingo_symbolic_atoms_t const *atoms, size_t *size);
CLINGO_VISIBILITY_DEFAULT bool clingo_symbolic_atoms_begin(clingo_symbolic_atoms_t const *atoms,
                                                           clingo_signature_t const *signature,
                                                           clingo_symbolic_atom_iterator_t *iterator);
CLINGO_VISIBILITY_DEFAULT bool clingo_symbolic_atoms_end(clingo_symbolic_atoms_t const *atoms,
                                                         clingo_symbolic_atom_iterator_t *iterator);
CLINGO_VISIBILITY_DEFAULT bool clingo_symbolic_atoms_find(clingo_symbolic_atoms_t const *atoms, clingo_symbol_t symbol,
                                                          clingo_symbolic_atom_iterator_t *iterator);
CLINGO_VISIBILITY_DEFAULT bool clingo_symbolic_atoms_iterator_is_equal_to(clingo_symbolic_atoms_t const *atoms,
                                                                          clingo_symbolic_atom_iterator_t a,
                                                                          clingo_symbolic_atom_iterator_t b,
                                                                          bool *equal);
CLINGO_VISIBILITY_DEFAULT bool clingo_symbolic_atoms_symbol(clingo_symbolic_atoms_t const *atoms,
                                                            clingo_symbolic_atom_iterator_t iterator,
                                                            clingo_symbol_t *symbol);
CLINGO_VISIBILITY_DEFAULT bool clingo_symbolic_atoms_is_fact(clingo_symbolic_atoms_t const *atoms,
                                                             clingo_symbolic_atom_iterator_t iterator, bool *fact);
CLINGO_VISIBILITY_DEFAULT bool clingo_symbolic_atoms_is_external(clingo_symbolic_atoms_t const *atoms,
                                                                 clingo_symbolic_atom_iterator_t iterator,
                                                                 bool *external);
CLINGO_VISIBILITY_DEFAULT bool clingo_symbolic_atoms_literal(clingo_symbolic_atoms_t const *atoms,
                                                             clingo_symbolic_atom_iterator_t iterator,
                                                             clingo_literal_t *literal);
CLINGO_VISIBILITY_DEFAULT bool clingo_symbolic_atoms_signatures_size(clingo_symbolic_atoms_t const *atoms,
                                                                     size_t *size);
CLINGO_VISIBILITY_DEFAULT bool clingo_symbolic_atoms_signatures(clingo_symbolic_atoms_t const *atoms,
                                                                clingo_signature_t *signatures, size_t size);
CLINGO_VISIBILITY_DEFAULT bool clingo_symbolic_atoms_next(clingo_symbolic_atoms_t const *atoms,
                                                          clingo_symbolic_atom_iterator_t iterator,
                                                          clingo_symbolic_atom_iterator_t *next);
CLINGO_VISIBILITY_DEFAULT bool clingo_symbolic_atoms_is_valid(clingo_symbolic_atoms_t const *atoms,
                                                              clingo_symbolic_atom_iterator_t iterator, bool *valid);
 
typedef bool (*clingo_symbol_callback_t)(clingo_symbol_t const *symbols, size_t symbols_size, void *data);
 
// {{{1 theory atoms
 
 
 
 
enum clingo_theory_term_type_e {
    clingo_theory_term_type_tuple = 0,    
    clingo_theory_term_type_list = 1,     
    clingo_theory_term_type_set = 2,      
    clingo_theory_term_type_function = 3, 
    clingo_theory_term_type_number = 4,   
    clingo_theory_term_type_symbol = 5    
};
typedef int clingo_theory_term_type_t;
 
typedef struct clingo_theory_atoms clingo_theory_atoms_t;
 
 
CLINGO_VISIBILITY_DEFAULT bool clingo_theory_atoms_term_type(clingo_theory_atoms_t const *atoms, clingo_id_t term,
                                                             clingo_theory_term_type_t *type);
CLINGO_VISIBILITY_DEFAULT bool clingo_theory_atoms_term_number(clingo_theory_atoms_t const *atoms, clingo_id_t term,
                                                               int *number);
CLINGO_VISIBILITY_DEFAULT bool clingo_theory_atoms_term_name(clingo_theory_atoms_t const *atoms, clingo_id_t term,
                                                             char const **name);
CLINGO_VISIBILITY_DEFAULT bool clingo_theory_atoms_term_arguments(clingo_theory_atoms_t const *atoms, clingo_id_t term,
                                                                  clingo_id_t const **arguments, size_t *size);
CLINGO_VISIBILITY_DEFAULT bool clingo_theory_atoms_term_to_string_size(clingo_theory_atoms_t const *atoms,
                                                                       clingo_id_t term, size_t *size);
CLINGO_VISIBILITY_DEFAULT bool clingo_theory_atoms_term_to_string(clingo_theory_atoms_t const *atoms, clingo_id_t term,
                                                                  char *string, size_t size);
 
 
CLINGO_VISIBILITY_DEFAULT bool clingo_theory_atoms_element_tuple(clingo_theory_atoms_t const *atoms,
                                                                 clingo_id_t element, clingo_id_t const **tuple,
                                                                 size_t *size);
CLINGO_VISIBILITY_DEFAULT bool clingo_theory_atoms_element_condition(clingo_theory_atoms_t const *atoms,
                                                                     clingo_id_t element,
                                                                     clingo_literal_t const **condition, size_t *size);
CLINGO_VISIBILITY_DEFAULT bool clingo_theory_atoms_element_condition_id(clingo_theory_atoms_t const *atoms,
                                                                        clingo_id_t element,
                                                                        clingo_literal_t *condition);
CLINGO_VISIBILITY_DEFAULT bool clingo_theory_atoms_element_to_string_size(clingo_theory_atoms_t const *atoms,
                                                                          clingo_id_t element, size_t *size);
CLINGO_VISIBILITY_DEFAULT bool clingo_theory_atoms_element_to_string(clingo_theory_atoms_t const *atoms,
                                                                     clingo_id_t element, char *string, size_t size);
 
 
CLINGO_VISIBILITY_DEFAULT bool clingo_theory_atoms_size(clingo_theory_atoms_t const *atoms, size_t *size);
CLINGO_VISIBILITY_DEFAULT bool clingo_theory_atoms_atom_term(clingo_theory_atoms_t const *atoms, clingo_id_t atom,
                                                             clingo_id_t *term);
CLINGO_VISIBILITY_DEFAULT bool clingo_theory_atoms_atom_elements(clingo_theory_atoms_t const *atoms, clingo_id_t atom,
                                                                 clingo_id_t const **elements, size_t *size);
CLINGO_VISIBILITY_DEFAULT bool clingo_theory_atoms_atom_has_guard(clingo_theory_atoms_t const *atoms, clingo_id_t atom,
                                                                  bool *has_guard);
CLINGO_VISIBILITY_DEFAULT bool clingo_theory_atoms_atom_guard(clingo_theory_atoms_t const *atoms, clingo_id_t atom,
                                                              char const **connective, clingo_id_t *term);
CLINGO_VISIBILITY_DEFAULT bool clingo_theory_atoms_atom_literal(clingo_theory_atoms_t const *atoms, clingo_id_t atom,
                                                                clingo_literal_t *literal);
CLINGO_VISIBILITY_DEFAULT bool clingo_theory_atoms_atom_to_string_size(clingo_theory_atoms_t const *atoms,
                                                                       clingo_id_t atom, size_t *size);
CLINGO_VISIBILITY_DEFAULT bool clingo_theory_atoms_atom_to_string(clingo_theory_atoms_t const *atoms, clingo_id_t atom,
                                                                  char *string, size_t size);
 
 
// {{{1 propagator
 
 
 
 
typedef struct clingo_assignment clingo_assignment_t;
 
 
CLINGO_VISIBILITY_DEFAULT uint32_t clingo_assignment_decision_level(clingo_assignment_t const *assignment);
CLINGO_VISIBILITY_DEFAULT uint32_t clingo_assignment_root_level(clingo_assignment_t const *assignment);
CLINGO_VISIBILITY_DEFAULT bool clingo_assignment_has_conflict(clingo_assignment_t const *assignment);
CLINGO_VISIBILITY_DEFAULT bool clingo_assignment_has_literal(clingo_assignment_t const *assignment,
                                                             clingo_literal_t literal);
CLINGO_VISIBILITY_DEFAULT bool clingo_assignment_level(clingo_assignment_t const *assignment, clingo_literal_t literal,
                                                       uint32_t *level);
CLINGO_VISIBILITY_DEFAULT bool clingo_assignment_decision(clingo_assignment_t const *assignment, uint32_t level,
                                                          clingo_literal_t *literal);
CLINGO_VISIBILITY_DEFAULT bool clingo_assignment_is_fixed(clingo_assignment_t const *assignment,
                                                          clingo_literal_t literal, bool *is_fixed);
CLINGO_VISIBILITY_DEFAULT bool clingo_assignment_is_true(clingo_assignment_t const *assignment,
                                                         clingo_literal_t literal, bool *is_true);
CLINGO_VISIBILITY_DEFAULT bool clingo_assignment_is_false(clingo_assignment_t const *assignment,
                                                          clingo_literal_t literal, bool *is_false);
CLINGO_VISIBILITY_DEFAULT bool clingo_assignment_truth_value(clingo_assignment_t const *assignment,
                                                             clingo_literal_t literal, clingo_truth_value_t *value);
CLINGO_VISIBILITY_DEFAULT size_t clingo_assignment_size(clingo_assignment_t const *assignment);
CLINGO_VISIBILITY_DEFAULT bool clingo_assignment_at(clingo_assignment_t const *assignment, size_t offset,
                                                    clingo_literal_t *literal);
CLINGO_VISIBILITY_DEFAULT bool clingo_assignment_is_total(clingo_assignment_t const *assignment);
CLINGO_VISIBILITY_DEFAULT bool clingo_assignment_trail_size(clingo_assignment_t const *assignment, uint32_t *size);
CLINGO_VISIBILITY_DEFAULT bool clingo_assignment_trail_begin(clingo_assignment_t const *assignment, uint32_t level,
                                                             uint32_t *offset);
CLINGO_VISIBILITY_DEFAULT bool clingo_assignment_trail_end(clingo_assignment_t const *assignment, uint32_t level,
                                                           uint32_t *offset);
CLINGO_VISIBILITY_DEFAULT bool clingo_assignment_trail_at(clingo_assignment_t const *assignment, uint32_t offset,
                                                          clingo_literal_t *literal);
 
 
enum clingo_propagator_check_mode_e {
    clingo_propagator_check_mode_none = 0,     
    clingo_propagator_check_mode_total = 1,    
    clingo_propagator_check_mode_fixpoint = 2, 
    clingo_propagator_check_mode_both =
        3, 
};
typedef int clingo_propagator_check_mode_t;
 
enum clingo_propagator_undo_mode_e {
    clingo_propagator_undo_mode_default = 0, 
    clingo_propagator_undo_mode_always = 1,  
};
typedef int clingo_propagator_undo_mode_t;
 
enum clingo_weight_constraint_type_e {
    clingo_weight_constraint_type_implication_left = -1, 
    clingo_weight_constraint_type_implication_right = 1, 
    clingo_weight_constraint_type_equivalence = 0,       
};
typedef int clingo_weight_constraint_type_t;
 
typedef struct clingo_propagate_init clingo_propagate_init_t;
 
 
CLINGO_VISIBILITY_DEFAULT bool clingo_propagate_init_solver_literal(clingo_propagate_init_t const *init,
                                                                    clingo_literal_t aspif_literal,
                                                                    clingo_literal_t *solver_literal);
CLINGO_VISIBILITY_DEFAULT bool clingo_propagate_init_add_watch(clingo_propagate_init_t *init,
                                                               clingo_literal_t solver_literal);
CLINGO_VISIBILITY_DEFAULT bool clingo_propagate_init_add_watch_to_thread(clingo_propagate_init_t *init,
                                                                         clingo_literal_t solver_literal,
                                                                         clingo_id_t thread_id);
CLINGO_VISIBILITY_DEFAULT bool clingo_propagate_init_remove_watch(clingo_propagate_init_t *init,
                                                                  clingo_literal_t solver_literal);
CLINGO_VISIBILITY_DEFAULT bool clingo_propagate_init_remove_watch_from_thread(clingo_propagate_init_t *init,
                                                                              clingo_literal_t solver_literal,
                                                                              uint32_t thread_id);
CLINGO_VISIBILITY_DEFAULT bool clingo_propagate_init_freeze_literal(clingo_propagate_init_t *init,
                                                                    clingo_literal_t solver_literal);
CLINGO_VISIBILITY_DEFAULT bool clingo_propagate_init_symbolic_atoms(clingo_propagate_init_t const *init,
                                                                    clingo_symbolic_atoms_t const **atoms);
CLINGO_VISIBILITY_DEFAULT bool clingo_propagate_init_theory_atoms(clingo_propagate_init_t const *init,
                                                                  clingo_theory_atoms_t const **atoms);
CLINGO_VISIBILITY_DEFAULT int clingo_propagate_init_number_of_threads(clingo_propagate_init_t const *init);
CLINGO_VISIBILITY_DEFAULT void clingo_propagate_init_set_check_mode(clingo_propagate_init_t *init,
                                                                    clingo_propagator_check_mode_t mode);
CLINGO_VISIBILITY_DEFAULT clingo_propagator_check_mode_t
clingo_propagate_init_get_check_mode(clingo_propagate_init_t const *init);
CLINGO_VISIBILITY_DEFAULT void clingo_propagate_init_set_undo_mode(clingo_propagate_init_t *init,
                                                                   clingo_propagator_undo_mode_t mode);
CLINGO_VISIBILITY_DEFAULT clingo_propagator_undo_mode_t
clingo_propagate_init_get_undo_mode(clingo_propagate_init_t const *init);
CLINGO_VISIBILITY_DEFAULT clingo_assignment_t const *
clingo_propagate_init_assignment(clingo_propagate_init_t const *init);
CLINGO_VISIBILITY_DEFAULT bool clingo_propagate_init_add_literal(clingo_propagate_init_t *init, bool freeze,
                                                                 clingo_literal_t *result);
CLINGO_VISIBILITY_DEFAULT bool clingo_propagate_init_add_clause(clingo_propagate_init_t *init,
                                                                clingo_literal_t const *clause, size_t size,
                                                                bool *result);
CLINGO_VISIBILITY_DEFAULT bool clingo_propagate_init_add_weight_constraint(
    clingo_propagate_init_t *init, clingo_literal_t literal, clingo_weighted_literal_t const *literals, size_t size,
    clingo_weight_t bound, clingo_weight_constraint_type_t type, bool compare_equal, bool *result);
CLINGO_VISIBILITY_DEFAULT bool clingo_propagate_init_add_minimize(clingo_propagate_init_t *init,
                                                                  clingo_literal_t literal, clingo_weight_t weight,
                                                                  clingo_weight_t priority);
CLINGO_VISIBILITY_DEFAULT bool clingo_propagate_init_propagate(clingo_propagate_init_t *init, bool *result);
 
 
enum clingo_clause_type_e {
    clingo_clause_type_learnt = 0, 
    clingo_clause_type_static = 1, 
    clingo_clause_type_volatile =
        2, 
    clingo_clause_type_volatile_static =
        3 
};
typedef int clingo_clause_type_t;
 
typedef struct clingo_propagate_control clingo_propagate_control_t;
 
 
CLINGO_VISIBILITY_DEFAULT clingo_id_t clingo_propagate_control_thread_id(clingo_propagate_control_t const *control);
CLINGO_VISIBILITY_DEFAULT clingo_assignment_t const *
clingo_propagate_control_assignment(clingo_propagate_control_t const *control);
CLINGO_VISIBILITY_DEFAULT bool clingo_propagate_control_add_literal(clingo_propagate_control_t *control,
                                                                    clingo_literal_t *result);
CLINGO_VISIBILITY_DEFAULT bool clingo_propagate_control_add_watch(clingo_propagate_control_t *control,
                                                                  clingo_literal_t literal);
CLINGO_VISIBILITY_DEFAULT bool clingo_propagate_control_has_watch(clingo_propagate_control_t const *control,
                                                                  clingo_literal_t literal);
CLINGO_VISIBILITY_DEFAULT void clingo_propagate_control_remove_watch(clingo_propagate_control_t *control,
                                                                     clingo_literal_t literal);
CLINGO_VISIBILITY_DEFAULT bool clingo_propagate_control_add_clause(clingo_propagate_control_t *control,
                                                                   clingo_literal_t const *clause, size_t size,
                                                                   clingo_clause_type_t type, bool *result);
CLINGO_VISIBILITY_DEFAULT bool clingo_propagate_control_propagate(clingo_propagate_control_t *control, bool *result);
 
 
typedef bool (*clingo_propagator_init_callback_t)(clingo_propagate_init_t *, void *);
 
typedef bool (*clingo_propagator_propagate_callback_t)(clingo_propagate_control_t *, clingo_literal_t const *, size_t,
                                                       void *);
 
typedef void (*clingo_propagator_undo_callback_t)(clingo_propagate_control_t const *, clingo_literal_t const *, size_t,
                                                  void *);
 
typedef bool (*clingo_propagator_check_callback_t)(clingo_propagate_control_t *, void *);
 
typedef struct clingo_propagator {
    bool (*init)(clingo_propagate_init_t *init, void *data);
    bool (*propagate)(clingo_propagate_control_t *control, clingo_literal_t const *changes, size_t size, void *data);
    void (*undo)(clingo_propagate_control_t const *control, clingo_literal_t const *changes, size_t size, void *data);
    bool (*check)(clingo_propagate_control_t *control, void *data);
    bool (*decide)(clingo_id_t thread_id, clingo_assignment_t const *assignment, clingo_literal_t fallback, void *data,
                   clingo_literal_t *decision);
} clingo_propagator_t;
 
 
// {{{1 backend
 
 
 
 
enum clingo_comment_type_e {
    clingo_comment_type_line,  
    clingo_comment_type_block, 
};
typedef int clingo_comment_type_t;
 
enum clingo_theory_sequence_type_e {
    clingo_theory_sequence_type_tuple = 0, 
    clingo_theory_sequence_type_set = 1,   
    clingo_theory_sequence_type_list = 2   
};
typedef int clingo_theory_sequence_type_t;
 
enum clingo_heuristic_type_e {
    clingo_heuristic_type_level = 0,  
    clingo_heuristic_type_sign = 1,   
    clingo_heuristic_type_factor = 2, 
    clingo_heuristic_type_init = 3,   
    clingo_heuristic_type_true = 4,   
    clingo_heuristic_type_false = 5   
};
typedef int clingo_heuristic_type_t;
 
enum clingo_external_type_e {
    clingo_external_type_free = 0,    
    clingo_external_type_true = 1,    
    clingo_external_type_false = 2,   
    clingo_external_type_release = 3, 
};
typedef int clingo_external_type_t;
 
typedef struct clingo_backend clingo_backend_t;
 
CLINGO_VISIBILITY_DEFAULT bool clingo_backend_begin(clingo_backend_t *backend);
CLINGO_VISIBILITY_DEFAULT bool clingo_backend_end(clingo_backend_t *backend);
CLINGO_VISIBILITY_DEFAULT bool clingo_backend_rule(clingo_backend_t *backend, bool choice, clingo_atom_t const *head,
                                                   size_t head_size, clingo_literal_t const *body, size_t body_size);
CLINGO_VISIBILITY_DEFAULT bool clingo_backend_weight_rule(clingo_backend_t *backend, bool choice,
                                                          clingo_atom_t const *head, size_t head_size,
                                                          clingo_weight_t lower_bound,
                                                          clingo_weighted_literal_t const *body, size_t body_size);
CLINGO_VISIBILITY_DEFAULT bool clingo_backend_minimize(clingo_backend_t *backend, clingo_weight_t priority,
                                                       clingo_weighted_literal_t const *literals, size_t size);
CLINGO_VISIBILITY_DEFAULT bool clingo_backend_project(clingo_backend_t *backend, clingo_atom_t const *atoms,
                                                      size_t size);
CLINGO_VISIBILITY_DEFAULT bool clingo_backend_external(clingo_backend_t *backend, clingo_atom_t atom,
                                                       clingo_external_type_t type);
CLINGO_VISIBILITY_DEFAULT bool clingo_backend_assume(clingo_backend_t *backend, clingo_literal_t const *literals,
                                                     size_t size);
CLINGO_VISIBILITY_DEFAULT bool clingo_backend_heuristic(clingo_backend_t *backend, clingo_atom_t atom,
                                                        clingo_heuristic_type_t type, int bias, unsigned priority,
                                                        clingo_literal_t const *condition, size_t size);
CLINGO_VISIBILITY_DEFAULT bool clingo_backend_acyc_edge(clingo_backend_t *backend, int node_u, int node_v,
                                                        clingo_literal_t const *condition, size_t size);
CLINGO_VISIBILITY_DEFAULT bool clingo_backend_add_atom(clingo_backend_t *backend, clingo_symbol_t *symbol,
                                                       clingo_atom_t *atom);
CLINGO_VISIBILITY_DEFAULT bool clingo_backend_theory_term_number(clingo_backend_t *backend, int number,
                                                                 clingo_id_t *term_id);
CLINGO_VISIBILITY_DEFAULT bool clingo_backend_theory_term_string(clingo_backend_t *backend, char const *string,
                                                                 clingo_id_t *term_id);
CLINGO_VISIBILITY_DEFAULT bool clingo_backend_theory_term_sequence(clingo_backend_t *backend,
                                                                   clingo_theory_sequence_type_t type,
                                                                   clingo_id_t const *arguments, size_t size,
                                                                   clingo_id_t *term_id);
CLINGO_VISIBILITY_DEFAULT bool clingo_backend_theory_term_function(clingo_backend_t *backend, char const *name,
                                                                   clingo_id_t const *arguments, size_t size,
                                                                   clingo_id_t *term_id);
CLINGO_VISIBILITY_DEFAULT bool clingo_backend_theory_term_symbol(clingo_backend_t *backend, clingo_symbol_t symbol,
                                                                 clingo_id_t *term_id);
CLINGO_VISIBILITY_DEFAULT bool clingo_backend_theory_element(clingo_backend_t *backend, clingo_id_t const *tuple,
                                                             size_t tuple_size, clingo_literal_t const *condition,
                                                             size_t condition_size, clingo_id_t *element_id);
CLINGO_VISIBILITY_DEFAULT bool clingo_backend_theory_atom(clingo_backend_t *backend, clingo_atom_t atom,
                                                          clingo_id_t term_id, clingo_id_t const *elements, size_t size,
                                                          clingo_atom_t *atom_id);
CLINGO_VISIBILITY_DEFAULT bool clingo_backend_theory_atom_with_guard(clingo_backend_t *backend, clingo_atom_t atom,
                                                                     clingo_id_t term_id, clingo_id_t const *elements,
                                                                     size_t size, char const *operator_name,
                                                                     clingo_id_t right_hand_side_id,
                                                                     clingo_atom_t *atom_id);
 
 
// {{{1 configuration
 
 
 
 
enum clingo_configuration_type_e {
    clingo_configuration_type_value = 1, 
    clingo_configuration_type_array = 2, 
    clingo_configuration_type_map = 4    
};
typedef unsigned clingo_configuration_type_bitset_t;
 
typedef struct clingo_configuration clingo_configuration_t;
 
CLINGO_VISIBILITY_DEFAULT bool clingo_configuration_root(clingo_configuration_t const *configuration, clingo_id_t *key);
CLINGO_VISIBILITY_DEFAULT bool clingo_configuration_type(clingo_configuration_t const *configuration, clingo_id_t key,
                                                         clingo_configuration_type_bitset_t *type);
CLINGO_VISIBILITY_DEFAULT bool clingo_configuration_description(clingo_configuration_t const *configuration,
                                                                clingo_id_t key, char const **description);
 
 
CLINGO_VISIBILITY_DEFAULT bool clingo_configuration_array_size(clingo_configuration_t const *configuration,
                                                               clingo_id_t key, size_t *size);
CLINGO_VISIBILITY_DEFAULT bool clingo_configuration_array_at(clingo_configuration_t const *configuration,
                                                             clingo_id_t key, size_t offset, clingo_id_t *subkey);
 
 
CLINGO_VISIBILITY_DEFAULT bool clingo_configuration_map_size(clingo_configuration_t const *configuration,
                                                             clingo_id_t key, size_t *size);
CLINGO_VISIBILITY_DEFAULT bool clingo_configuration_map_has_subkey(clingo_configuration_t const *configuration,
                                                                   clingo_id_t key, char const *name, bool *result);
CLINGO_VISIBILITY_DEFAULT bool clingo_configuration_map_subkey_name(clingo_configuration_t const *configuration,
                                                                    clingo_id_t key, size_t offset, char const **name);
CLINGO_VISIBILITY_DEFAULT bool clingo_configuration_map_at(clingo_configuration_t const *configuration, clingo_id_t key,
                                                           char const *name, clingo_id_t *subkey);
 
 
CLINGO_VISIBILITY_DEFAULT bool clingo_configuration_value_is_assigned(clingo_configuration_t const *configuration,
                                                                      clingo_id_t key, bool *assigned);
CLINGO_VISIBILITY_DEFAULT bool clingo_configuration_value_get_size(clingo_configuration_t const *configuration,
                                                                   clingo_id_t key, size_t *size);
CLINGO_VISIBILITY_DEFAULT bool clingo_configuration_value_get(clingo_configuration_t const *configuration,
                                                              clingo_id_t key, char *value, size_t size);
CLINGO_VISIBILITY_DEFAULT bool clingo_configuration_value_set(clingo_configuration_t *configuration, clingo_id_t key,
                                                              char const *value);
 
 
// {{{1 statistics
 
 
 
 
enum clingo_statistics_type_e {
    clingo_statistics_type_empty = 0, 
    clingo_statistics_type_value = 1, 
    clingo_statistics_type_array = 2, 
    clingo_statistics_type_map = 3    
};
typedef int clingo_statistics_type_t;
 
typedef struct clingo_statistic clingo_statistics_t;
 
CLINGO_VISIBILITY_DEFAULT bool clingo_statistics_root(clingo_statistics_t const *statistics, uint64_t *key);
CLINGO_VISIBILITY_DEFAULT bool clingo_statistics_type(clingo_statistics_t const *statistics, uint64_t key,
                                                      clingo_statistics_type_t *type);
 
 
CLINGO_VISIBILITY_DEFAULT bool clingo_statistics_array_size(clingo_statistics_t const *statistics, uint64_t key,
                                                            size_t *size);
CLINGO_VISIBILITY_DEFAULT bool clingo_statistics_array_at(clingo_statistics_t const *statistics, uint64_t key,
                                                          size_t offset, uint64_t *subkey);
CLINGO_VISIBILITY_DEFAULT bool clingo_statistics_array_push(clingo_statistics_t *statistics, uint64_t key,
                                                            clingo_statistics_type_t type, uint64_t *subkey);
 
 
CLINGO_VISIBILITY_DEFAULT bool clingo_statistics_map_size(clingo_statistics_t const *statistics, uint64_t key,
                                                          size_t *size);
CLINGO_VISIBILITY_DEFAULT bool clingo_statistics_map_has_subkey(clingo_statistics_t const *statistics, uint64_t key,
                                                                char const *name, bool *result);
CLINGO_VISIBILITY_DEFAULT bool clingo_statistics_map_subkey_name(clingo_statistics_t const *statistics, uint64_t key,
                                                                 size_t offset, char const **name);
CLINGO_VISIBILITY_DEFAULT bool clingo_statistics_map_at(clingo_statistics_t const *statistics, uint64_t key,
                                                        char const *name, uint64_t *subkey);
CLINGO_VISIBILITY_DEFAULT bool clingo_statistics_map_add_subkey(clingo_statistics_t *statistics, uint64_t key,
                                                                char const *name, clingo_statistics_type_t type,
                                                                uint64_t *subkey);
 
 
CLINGO_VISIBILITY_DEFAULT bool clingo_statistics_value_get(clingo_statistics_t const *statistics, uint64_t key,
                                                           double *value);
CLINGO_VISIBILITY_DEFAULT bool clingo_statistics_value_set(clingo_statistics_t *statistics, uint64_t key, double value);
 
 
// {{{1 model and solve control
 
 
 
 
typedef struct clingo_solve_control clingo_solve_control_t;
 
typedef struct clingo_model clingo_model_t;
 
enum clingo_model_type_e {
    clingo_model_type_stable_model = 0,         
    clingo_model_type_brave_consequences = 1,   
    clingo_model_type_cautious_consequences = 2 
};
typedef int clingo_model_type_t;
 
enum clingo_show_type_e {
    clingo_show_type_shown = 2,   
    clingo_show_type_atoms = 4,   
    clingo_show_type_terms = 8,   
    clingo_show_type_theory = 16, 
    clingo_show_type_all = 31,    
    clingo_show_type_complement =
        32 
};
typedef unsigned clingo_show_type_bitset_t;
 
enum clingo_consequence_e {
    clingo_consequence_false = 0,   
    clingo_consequence_true = 1,    
    clingo_consequence_unknown = 2, 
};
typedef int clingo_consequence_t;
 
 
 
CLINGO_VISIBILITY_DEFAULT bool clingo_model_type(clingo_model_t const *model, clingo_model_type_t *type);
CLINGO_VISIBILITY_DEFAULT bool clingo_model_number(clingo_model_t const *model, uint64_t *number);
CLINGO_VISIBILITY_DEFAULT bool clingo_model_symbols_size(clingo_model_t const *model, clingo_show_type_bitset_t show,
                                                         size_t *size);
CLINGO_VISIBILITY_DEFAULT bool clingo_model_symbols(clingo_model_t const *model, clingo_show_type_bitset_t show,
                                                    clingo_symbol_t *symbols, size_t size);
CLINGO_VISIBILITY_DEFAULT bool clingo_model_contains(clingo_model_t const *model, clingo_symbol_t atom,
                                                     bool *contained);
CLINGO_VISIBILITY_DEFAULT bool clingo_model_is_true(clingo_model_t const *model, clingo_literal_t literal,
                                                    bool *result);
CLINGO_VISIBILITY_DEFAULT bool clingo_model_is_consequence(clingo_model_t const *model, clingo_literal_t literal,
                                                           clingo_consequence_t *result);
CLINGO_VISIBILITY_DEFAULT bool clingo_model_cost_size(clingo_model_t const *model, size_t *size);
CLINGO_VISIBILITY_DEFAULT bool clingo_model_cost(clingo_model_t const *model, int64_t *costs, size_t size);
CLINGO_VISIBILITY_DEFAULT bool clingo_model_priority(clingo_model_t const *model, clingo_weight_t *priorities,
                                                     size_t size);
CLINGO_VISIBILITY_DEFAULT bool clingo_model_optimality_proven(clingo_model_t const *model, bool *proven);
CLINGO_VISIBILITY_DEFAULT bool clingo_model_thread_id(clingo_model_t const *model, clingo_id_t *id);
CLINGO_VISIBILITY_DEFAULT bool clingo_model_extend(clingo_model_t *model, clingo_symbol_t const *symbols, size_t size);
 
 
CLINGO_VISIBILITY_DEFAULT bool clingo_model_context(clingo_model_t const *model, clingo_solve_control_t **control);
CLINGO_VISIBILITY_DEFAULT bool clingo_solve_control_symbolic_atoms(clingo_solve_control_t const *control,
                                                                   clingo_symbolic_atoms_t const **atoms);
CLINGO_VISIBILITY_DEFAULT bool clingo_solve_control_add_clause(clingo_solve_control_t *control,
                                                               clingo_literal_t const *clause, size_t size);
 
 
// {{{1 solve result
 
// NOTE: documented in Control Module
enum clingo_solve_result_e {
    clingo_solve_result_satisfiable = 1,
    clingo_solve_result_unsatisfiable = 2,
    clingo_solve_result_exhausted = 4,
    clingo_solve_result_interrupted = 8
};
typedef unsigned clingo_solve_result_bitset_t;
 
// {{{1 solve handle
 
 
 
 
enum clingo_solve_mode_e {
    clingo_solve_mode_async = 1, 
    clingo_solve_mode_yield = 2, 
};
typedef unsigned clingo_solve_mode_bitset_t;
 
enum clingo_solve_event_type_e {
    clingo_solve_event_type_model = 0,      
    clingo_solve_event_type_unsat = 1,      
    clingo_solve_event_type_statistics = 2, 
    clingo_solve_event_type_finish = 3,     
};
typedef unsigned clingo_solve_event_type_t;
 
typedef bool (*clingo_solve_event_callback_t)(clingo_solve_event_type_t type, void *event, void *data, bool *goon);
 
typedef struct clingo_solve_handle clingo_solve_handle_t;
 
CLINGO_VISIBILITY_DEFAULT bool clingo_solve_handle_get(clingo_solve_handle_t *handle,
                                                       clingo_solve_result_bitset_t *result);
CLINGO_VISIBILITY_DEFAULT void clingo_solve_handle_wait(clingo_solve_handle_t *handle, double timeout, bool *result);
CLINGO_VISIBILITY_DEFAULT bool clingo_solve_handle_model(clingo_solve_handle_t *handle, clingo_model_t const **model);
CLINGO_VISIBILITY_DEFAULT bool clingo_solve_handle_core(clingo_solve_handle_t *handle, clingo_literal_t const **core,
                                                        size_t *size);
CLINGO_VISIBILITY_DEFAULT bool clingo_solve_handle_last(clingo_solve_handle_t *handle, clingo_model_t const **model);
CLINGO_VISIBILITY_DEFAULT bool clingo_solve_handle_resume(clingo_solve_handle_t *handle);
CLINGO_VISIBILITY_DEFAULT bool clingo_solve_handle_cancel(clingo_solve_handle_t *handle);
CLINGO_VISIBILITY_DEFAULT bool clingo_solve_handle_close(clingo_solve_handle_t *handle);
 
// {{{1 ground program observer
 
 
 
typedef struct clingo_ground_program_observer {
    bool (*init_program)(bool incremental, void *data);
    bool (*begin_step)(void *data);
    bool (*end_step)(void *data);
 
    bool (*rule)(bool choice, clingo_atom_t const *head, size_t head_size, clingo_literal_t const *body,
                 size_t body_size, void *data);
    bool (*weight_rule)(bool choice, clingo_atom_t const *head, size_t head_size, clingo_weight_t lower_bound,
                        clingo_weighted_literal_t const *body, size_t body_size, void *data);
    bool (*minimize)(clingo_weight_t priority, clingo_weighted_literal_t const *literals, size_t size, void *data);
    bool (*project)(clingo_atom_t const *atoms, size_t size, void *data);
    bool (*output_atom)(clingo_symbol_t symbol, clingo_atom_t atom, void *data);
    bool (*output_term)(clingo_symbol_t symbol, clingo_literal_t const *condition, size_t size, void *data);
    bool (*external)(clingo_atom_t atom, clingo_external_type_t type, void *data);
    bool (*assume)(clingo_literal_t const *literals, size_t size, void *data);
    bool (*heuristic)(clingo_atom_t atom, clingo_heuristic_type_t type, int bias, unsigned priority,
                      clingo_literal_t const *condition, size_t size, void *data);
    bool (*acyc_edge)(int node_u, int node_v, clingo_literal_t const *condition, size_t size, void *data);
 
    bool (*theory_term_number)(clingo_id_t term_id, int number, void *data);
    bool (*theory_term_string)(clingo_id_t term_id, char const *name, void *data);
    bool (*theory_term_compound)(clingo_id_t term_id, int name_id_or_type, clingo_id_t const *arguments, size_t size,
                                 void *data);
    bool (*theory_element)(clingo_id_t element_id, clingo_id_t const *terms, size_t terms_size,
                           clingo_literal_t const *condition, size_t condition_size, void *data);
    bool (*theory_atom)(clingo_id_t atom_id_or_zero, clingo_id_t term_id, clingo_id_t const *elements, size_t size,
                        void *data);
    bool (*theory_atom_with_guard)(clingo_id_t atom_id_or_zero, clingo_id_t term_id, clingo_id_t const *elements,
                                   size_t size, clingo_id_t operator_id, clingo_id_t right_hand_side_id, void *data);
} clingo_ground_program_observer_t;
 
 
// {{{1 control
 
 
 
 
 
 
typedef struct clingo_part {
    char const *name;              
    clingo_symbol_t const *params; 
    size_t size;                   
} clingo_part_t;
 
typedef bool (*clingo_ground_callback_t)(clingo_location_t const *location, char const *name,
                                         clingo_symbol_t const *arguments, size_t arguments_size, void *data,
                                         clingo_symbol_callback_t symbol_callback, void *symbol_callback_data);
 
enum clingo_backend_type_e {
    clingo_backend_type_reify = 0,       
    clingo_backend_type_reify_sccs = 1,  
    clingo_backend_type_reify_steps = 2, 
    clingo_backend_type_aspif = 4,       
    clingo_backend_type_smodels = 5,     
};
typedef unsigned clingo_backend_type_t;
 
typedef struct clingo_control clingo_control_t;
 
CLINGO_VISIBILITY_DEFAULT bool clingo_control_new(char const *const *arguments, size_t arguments_size,
                                                  clingo_logger_t logger, void *logger_data, unsigned message_limit,
                                                  clingo_control_t **control);
 
CLINGO_VISIBILITY_DEFAULT void clingo_control_free(clingo_control_t *control);
 
 
CLINGO_VISIBILITY_DEFAULT bool clingo_control_load(clingo_control_t *control, char const *file);
 
CLINGO_VISIBILITY_DEFAULT bool clingo_control_load_aspif(clingo_control_t *control, char const **files, size_t size);
 
CLINGO_VISIBILITY_DEFAULT bool clingo_control_add(clingo_control_t *control, char const *name,
                                                  char const *const *parameters, size_t parameters_size,
                                                  char const *program);
 
CLINGO_VISIBILITY_DEFAULT bool clingo_control_ground(clingo_control_t *control, clingo_part_t const *parts,
                                                     size_t parts_size, clingo_ground_callback_t ground_callback,
                                                     void *ground_callback_data);
 
 
 
CLINGO_VISIBILITY_DEFAULT bool clingo_control_solve(clingo_control_t *control, clingo_solve_mode_bitset_t mode,
                                                    clingo_literal_t const *assumptions, size_t assumptions_size,
                                                    clingo_solve_event_callback_t notify, void *data,
                                                    clingo_solve_handle_t **handle);
//
CLINGO_VISIBILITY_DEFAULT bool clingo_control_cleanup(clingo_control_t *control);
CLINGO_VISIBILITY_DEFAULT bool clingo_control_assign_external(clingo_control_t *control, clingo_literal_t literal,
                                                              clingo_truth_value_t value);
CLINGO_VISIBILITY_DEFAULT bool clingo_control_release_external(clingo_control_t *control, clingo_literal_t literal);
CLINGO_VISIBILITY_DEFAULT bool clingo_control_remove_minimize(clingo_control_t *control);
CLINGO_VISIBILITY_DEFAULT bool clingo_control_update_project(clingo_control_t *control, clingo_atom_t const *atoms,
                                                             size_t size, bool append);
 
CLINGO_VISIBILITY_DEFAULT bool clingo_control_register_propagator(clingo_control_t *control,
                                                                  clingo_propagator_t const *propagator, void *data,
                                                                  bool sequential);
CLINGO_VISIBILITY_DEFAULT bool clingo_control_is_conflicting(clingo_control_t const *control);
 
CLINGO_VISIBILITY_DEFAULT bool clingo_control_statistics(clingo_control_t const *control,
                                                         clingo_statistics_t const **statistics);
CLINGO_VISIBILITY_DEFAULT void clingo_control_interrupt(clingo_control_t *control);
CLINGO_VISIBILITY_DEFAULT bool clingo_control_clasp_facade(clingo_control_t *control, void **clasp);
 
 
 
CLINGO_VISIBILITY_DEFAULT bool clingo_control_configuration(clingo_control_t *control,
                                                            clingo_configuration_t **configuration);
 
CLINGO_VISIBILITY_DEFAULT bool clingo_control_set_enable_enumeration_assumption(clingo_control_t *control, bool enable);
CLINGO_VISIBILITY_DEFAULT bool clingo_control_get_enable_enumeration_assumption(clingo_control_t *control);
 
CLINGO_VISIBILITY_DEFAULT bool clingo_control_set_enable_cleanup(clingo_control_t *control, bool enable);
CLINGO_VISIBILITY_DEFAULT bool clingo_control_get_enable_cleanup(clingo_control_t *control);
 
 
 
CLINGO_VISIBILITY_DEFAULT bool clingo_control_get_const(clingo_control_t const *control, char const *name,
                                                        clingo_symbol_t *symbol);
CLINGO_VISIBILITY_DEFAULT bool clingo_control_has_const(clingo_control_t const *control, char const *name,
                                                        bool *exists);
CLINGO_VISIBILITY_DEFAULT bool clingo_control_symbolic_atoms(clingo_control_t const *control,
                                                             clingo_symbolic_atoms_t const **atoms);
CLINGO_VISIBILITY_DEFAULT bool clingo_control_theory_atoms(clingo_control_t const *control,
                                                           clingo_theory_atoms_t const **atoms);
CLINGO_VISIBILITY_DEFAULT bool clingo_control_register_observer(clingo_control_t *control,
                                                                clingo_ground_program_observer_t const *observer,
                                                                bool replace, void *data);
CLINGO_VISIBILITY_DEFAULT bool clingo_control_register_backend(clingo_control_t *control, clingo_backend_type_t type,
                                                               char const *file, bool replace);
 
 
CLINGO_VISIBILITY_DEFAULT bool clingo_control_backend(clingo_control_t *control, clingo_backend_t **backend);
 
 
// {{{1 ast
 
 
 
 
enum clingo_ast_theory_sequence_type_e {
    clingo_ast_theory_sequence_type_tuple = clingo_theory_sequence_type_tuple, 
    clingo_ast_theory_sequence_type_list = clingo_theory_sequence_type_list,   
    clingo_ast_theory_sequence_type_set = clingo_theory_sequence_type_set      
};
typedef int clingo_ast_theory_sequence_type_t;
 
enum clingo_ast_comparison_operator_e {
    clingo_ast_comparison_operator_greater_than = 0,  
    clingo_ast_comparison_operator_less_than = 1,     
    clingo_ast_comparison_operator_less_equal = 2,    
    clingo_ast_comparison_operator_greater_equal = 3, 
    clingo_ast_comparison_operator_not_equal = 4,     
    clingo_ast_comparison_operator_equal = 5          
};
typedef int clingo_ast_comparison_operator_t;
 
enum clingo_ast_sign_e {
    clingo_ast_sign_no_sign = 0,        
    clingo_ast_sign_negation = 1,       
    clingo_ast_sign_double_negation = 2 
};
typedef int clingo_ast_sign_t;
 
enum clingo_ast_unary_operator_e {
    clingo_ast_unary_operator_minus = 0,    
    clingo_ast_unary_operator_negation = 1, 
    clingo_ast_unary_operator_absolute = 2  
};
typedef int clingo_ast_unary_operator_t;
 
enum clingo_ast_binary_operator_e {
    clingo_ast_binary_operator_xor = 0,            
    clingo_ast_binary_operator_or = 1,             
    clingo_ast_binary_operator_and = 2,            
    clingo_ast_binary_operator_plus = 3,           
    clingo_ast_binary_operator_minus = 4,          
    clingo_ast_binary_operator_multiplication = 5, 
    clingo_ast_binary_operator_division = 6,       
    clingo_ast_binary_operator_modulo = 7,         
    clingo_ast_binary_operator_power = 8           
};
typedef int clingo_ast_binary_operator_t;
 
enum clingo_ast_aggregate_function_e {
    clingo_ast_aggregate_function_count = 0, 
    clingo_ast_aggregate_function_sum = 1,   
    clingo_ast_aggregate_function_sump = 2,  
    clingo_ast_aggregate_function_min = 3,   
    clingo_ast_aggregate_function_max = 4    
};
typedef int clingo_ast_aggregate_function_t;
 
enum clingo_ast_theory_operator_type_e {
    clingo_ast_theory_operator_type_unary = 0,       
    clingo_ast_theory_operator_type_binary_left = 1, 
    clingo_ast_theory_operator_type_binary_right = 2 
};
typedef int clingo_ast_theory_operator_type_t;
 
enum clingo_ast_theory_atom_definition_type_e {
    clingo_ast_theory_atom_definition_type_head = 0,     
    clingo_ast_theory_atom_definition_type_body = 1,     
    clingo_ast_theory_atom_definition_type_any = 2,      
    clingo_ast_theory_atom_definition_type_directive = 3 
};
typedef int clingo_ast_theory_atom_definition_type_t;
 
enum clingo_ast_type_e {
    // terms
    clingo_ast_type_id,
    clingo_ast_type_variable,
    clingo_ast_type_symbolic_term,
    clingo_ast_type_unary_operation,
    clingo_ast_type_binary_operation,
    clingo_ast_type_interval,
    clingo_ast_type_function,
    clingo_ast_type_pool,
    // simple atoms
    clingo_ast_type_boolean_constant,
    clingo_ast_type_symbolic_atom,
    clingo_ast_type_comparison,
    // aggregates
    clingo_ast_type_guard,
    clingo_ast_type_conditional_literal,
    clingo_ast_type_aggregate,
    clingo_ast_type_body_aggregate_element,
    clingo_ast_type_body_aggregate,
    clingo_ast_type_head_aggregate_element,
    clingo_ast_type_head_aggregate,
    clingo_ast_type_disjunction,
    // theory atoms
    clingo_ast_type_theory_sequence,
    clingo_ast_type_theory_function,
    clingo_ast_type_theory_unparsed_term_element,
    clingo_ast_type_theory_unparsed_term,
    clingo_ast_type_theory_guard,
    clingo_ast_type_theory_atom_element,
    clingo_ast_type_theory_atom,
    // literals
    clingo_ast_type_literal,
    // theory definition
    clingo_ast_type_theory_operator_definition,
    clingo_ast_type_theory_term_definition,
    clingo_ast_type_theory_guard_definition,
    clingo_ast_type_theory_atom_definition,
    // statements
    clingo_ast_type_rule,
    clingo_ast_type_definition,
    clingo_ast_type_show_signature,
    clingo_ast_type_show_term,
    clingo_ast_type_minimize,
    clingo_ast_type_script,
    clingo_ast_type_program,
    clingo_ast_type_external,
    clingo_ast_type_edge,
    clingo_ast_type_heuristic,
    clingo_ast_type_project_atom,
    clingo_ast_type_project_signature,
    clingo_ast_type_defined,
    clingo_ast_type_theory_definition,
    clingo_ast_type_comment
};
typedef int clingo_ast_type_t;
 
enum clingo_ast_attribute_type_e {
    clingo_ast_attribute_type_number = 0,       
    clingo_ast_attribute_type_symbol = 1,       
    clingo_ast_attribute_type_location = 2,     
    clingo_ast_attribute_type_string = 3,       
    clingo_ast_attribute_type_ast = 4,          
    clingo_ast_attribute_type_optional_ast = 5, 
    clingo_ast_attribute_type_string_array = 6, 
    clingo_ast_attribute_type_ast_array = 7,    
};
typedef int clingo_ast_attribute_type_t;
 
enum clingo_ast_attribute_e {
    clingo_ast_attribute_argument,
    clingo_ast_attribute_arguments,
    clingo_ast_attribute_arity,
    clingo_ast_attribute_atom,
    clingo_ast_attribute_atoms,
    clingo_ast_attribute_atom_type,
    clingo_ast_attribute_bias,
    clingo_ast_attribute_body,
    clingo_ast_attribute_code,
    clingo_ast_attribute_coefficient,
    clingo_ast_attribute_comparison,
    clingo_ast_attribute_condition,
    clingo_ast_attribute_elements,
    clingo_ast_attribute_external,
    clingo_ast_attribute_external_type,
    clingo_ast_attribute_function,
    clingo_ast_attribute_guard,
    clingo_ast_attribute_guards,
    clingo_ast_attribute_head,
    clingo_ast_attribute_is_default,
    clingo_ast_attribute_left,
    clingo_ast_attribute_left_guard,
    clingo_ast_attribute_literal,
    clingo_ast_attribute_location,
    clingo_ast_attribute_modifier,
    clingo_ast_attribute_name,
    clingo_ast_attribute_node_u,
    clingo_ast_attribute_node_v,
    clingo_ast_attribute_operator_name,
    clingo_ast_attribute_operator_type,
    clingo_ast_attribute_operators,
    clingo_ast_attribute_parameters,
    clingo_ast_attribute_positive,
    clingo_ast_attribute_priority,
    clingo_ast_attribute_right,
    clingo_ast_attribute_right_guard,
    clingo_ast_attribute_sequence_type,
    clingo_ast_attribute_sign,
    clingo_ast_attribute_symbol,
    clingo_ast_attribute_term,
    clingo_ast_attribute_terms,
    clingo_ast_attribute_value,
    clingo_ast_attribute_variable,
    clingo_ast_attribute_weight,
    clingo_ast_attribute_comment_type,
};
typedef int clingo_ast_attribute_t;
 
typedef struct clingo_ast_attribute_names {
    char const *const *names;
    size_t size;
} clingo_ast_attribute_names_t;
 
CLINGO_VISIBILITY_DEFAULT extern clingo_ast_attribute_names_t g_clingo_ast_attribute_names;
 
typedef struct clingo_ast_argument {
    clingo_ast_attribute_t attribute;
    clingo_ast_attribute_type_t type;
} clingo_ast_argument_t;
 
typedef struct clingo_ast_constructor {
    char const *name;
    clingo_ast_argument_t const *arguments;
    size_t size;
} clingo_ast_constructor_t;
 
typedef struct clingo_ast_constructors {
    clingo_ast_constructor_t const *constructors;
    size_t size;
} clingo_ast_constructors_t;
 
CLINGO_VISIBILITY_DEFAULT extern clingo_ast_constructors_t g_clingo_ast_constructors;
 
typedef struct clingo_ast clingo_ast_t;
 
 
CLINGO_VISIBILITY_DEFAULT bool clingo_ast_build(clingo_ast_type_t type, clingo_ast_t **ast, ...);
 
 
 
CLINGO_VISIBILITY_DEFAULT void clingo_ast_acquire(clingo_ast_t *ast);
CLINGO_VISIBILITY_DEFAULT void clingo_ast_release(clingo_ast_t *ast);
 
 
 
CLINGO_VISIBILITY_DEFAULT bool clingo_ast_copy(clingo_ast_t *ast, clingo_ast_t **copy);
CLINGO_VISIBILITY_DEFAULT bool clingo_ast_deep_copy(clingo_ast_t *ast, clingo_ast_t **copy);
 
 
 
CLINGO_VISIBILITY_DEFAULT bool clingo_ast_less_than(clingo_ast_t *a, clingo_ast_t *b);
CLINGO_VISIBILITY_DEFAULT bool clingo_ast_equal(clingo_ast_t *a, clingo_ast_t *b);
CLINGO_VISIBILITY_DEFAULT size_t clingo_ast_hash(clingo_ast_t *ast);
 
 
 
CLINGO_VISIBILITY_DEFAULT bool clingo_ast_to_string_size(clingo_ast_t *ast, size_t *size);
CLINGO_VISIBILITY_DEFAULT bool clingo_ast_to_string(clingo_ast_t *ast, char *string, size_t size);
 
 
 
CLINGO_VISIBILITY_DEFAULT bool clingo_ast_get_type(clingo_ast_t *ast, clingo_ast_type_t *type);
CLINGO_VISIBILITY_DEFAULT bool clingo_ast_has_attribute(clingo_ast_t *ast, clingo_ast_attribute_t attribute,
                                                        bool *has_attribute);
CLINGO_VISIBILITY_DEFAULT bool clingo_ast_attribute_type(clingo_ast_t *ast, clingo_ast_attribute_t attribute,
                                                         clingo_ast_attribute_type_t *type);
 
 
 
CLINGO_VISIBILITY_DEFAULT bool clingo_ast_attribute_get_number(clingo_ast_t *ast, clingo_ast_attribute_t attribute,
                                                               int *value);
CLINGO_VISIBILITY_DEFAULT bool clingo_ast_attribute_set_number(clingo_ast_t *ast, clingo_ast_attribute_t attribute,
                                                               int value);
 
 
 
CLINGO_VISIBILITY_DEFAULT bool clingo_ast_attribute_get_symbol(clingo_ast_t *ast, clingo_ast_attribute_t attribute,
                                                               clingo_symbol_t *value);
CLINGO_VISIBILITY_DEFAULT bool clingo_ast_attribute_set_symbol(clingo_ast_t *ast, clingo_ast_attribute_t attribute,
                                                               clingo_symbol_t value);
 
 
 
CLINGO_VISIBILITY_DEFAULT bool clingo_ast_attribute_get_location(clingo_ast_t *ast, clingo_ast_attribute_t attribute,
                                                                 clingo_location_t *value);
CLINGO_VISIBILITY_DEFAULT bool clingo_ast_attribute_set_location(clingo_ast_t *ast, clingo_ast_attribute_t attribute,
                                                                 clingo_location_t const *value);
 
 
 
CLINGO_VISIBILITY_DEFAULT bool clingo_ast_attribute_get_string(clingo_ast_t *ast, clingo_ast_attribute_t attribute,
                                                               char const **value);
CLINGO_VISIBILITY_DEFAULT bool clingo_ast_attribute_set_string(clingo_ast_t *ast, clingo_ast_attribute_t attribute,
                                                               char const *value);
 
 
 
CLINGO_VISIBILITY_DEFAULT bool clingo_ast_attribute_get_ast(clingo_ast_t *ast, clingo_ast_attribute_t attribute,
                                                            clingo_ast_t **value);
CLINGO_VISIBILITY_DEFAULT bool clingo_ast_attribute_set_ast(clingo_ast_t *ast, clingo_ast_attribute_t attribute,
                                                            clingo_ast_t *value);
 
 
 
CLINGO_VISIBILITY_DEFAULT bool
clingo_ast_attribute_get_optional_ast(clingo_ast_t *ast, clingo_ast_attribute_t attribute, clingo_ast_t **value);
CLINGO_VISIBILITY_DEFAULT bool
clingo_ast_attribute_set_optional_ast(clingo_ast_t *ast, clingo_ast_attribute_t attribute, clingo_ast_t *value);
 
 
 
CLINGO_VISIBILITY_DEFAULT bool clingo_ast_attribute_get_string_at(clingo_ast_t *ast, clingo_ast_attribute_t attribute,
                                                                  size_t index, char const **value);
CLINGO_VISIBILITY_DEFAULT bool clingo_ast_attribute_set_string_at(clingo_ast_t *ast, clingo_ast_attribute_t attribute,
                                                                  size_t index, char const *value);
CLINGO_VISIBILITY_DEFAULT bool clingo_ast_attribute_delete_string_at(clingo_ast_t *ast,
                                                                     clingo_ast_attribute_t attribute, size_t index);
CLINGO_VISIBILITY_DEFAULT bool clingo_ast_attribute_size_string_array(clingo_ast_t *ast,
                                                                      clingo_ast_attribute_t attribute, size_t *size);
CLINGO_VISIBILITY_DEFAULT bool clingo_ast_attribute_insert_string_at(clingo_ast_t *ast,
                                                                     clingo_ast_attribute_t attribute, size_t index,
                                                                     char const *value);
 
 
 
CLINGO_VISIBILITY_DEFAULT bool clingo_ast_attribute_get_ast_at(clingo_ast_t *ast, clingo_ast_attribute_t attribute,
                                                               size_t index, clingo_ast_t **value);
CLINGO_VISIBILITY_DEFAULT bool clingo_ast_attribute_set_ast_at(clingo_ast_t *ast, clingo_ast_attribute_t attribute,
                                                               size_t index, clingo_ast_t *value);
CLINGO_VISIBILITY_DEFAULT bool clingo_ast_attribute_delete_ast_at(clingo_ast_t *ast, clingo_ast_attribute_t attribute,
                                                                  size_t index);
CLINGO_VISIBILITY_DEFAULT bool clingo_ast_attribute_size_ast_array(clingo_ast_t *ast, clingo_ast_attribute_t attribute,
                                                                   size_t *size);
CLINGO_VISIBILITY_DEFAULT bool clingo_ast_attribute_insert_ast_at(clingo_ast_t *ast, clingo_ast_attribute_t attribute,
                                                                  size_t index, clingo_ast_t *value);
 
 
 
typedef bool (*clingo_ast_callback_t)(clingo_ast_t *ast, void *data);
CLINGO_VISIBILITY_DEFAULT bool clingo_ast_parse_string(char const *program, clingo_ast_callback_t callback,
                                                       void *callback_data, clingo_control_t *control,
                                                       clingo_logger_t logger, void *logger_data,
                                                       unsigned message_limit);
CLINGO_VISIBILITY_DEFAULT bool clingo_ast_parse_files(char const *const *files, size_t size,
                                                      clingo_ast_callback_t callback, void *callback_data,
                                                      clingo_control_t *control, clingo_logger_t logger,
                                                      void *logger_data, unsigned message_limit);
 
 
typedef struct clingo_program_builder clingo_program_builder_t;
 
 
CLINGO_VISIBILITY_DEFAULT bool clingo_program_builder_init(clingo_control_t *control,
                                                           clingo_program_builder_t **builder);
CLINGO_VISIBILITY_DEFAULT bool clingo_program_builder_begin(clingo_program_builder_t *builder);
CLINGO_VISIBILITY_DEFAULT bool clingo_program_builder_end(clingo_program_builder_t *builder);
CLINGO_VISIBILITY_DEFAULT bool clingo_program_builder_add(clingo_program_builder_t *builder, clingo_ast_t *ast);
 
 
 
enum clingo_ast_unpool_type_e {
    clingo_ast_unpool_type_condition = 1, 
    clingo_ast_unpool_type_other = 2,     
    clingo_ast_unpool_type_all = 3,       
};
typedef int clingo_ast_unpool_type_bitset_t;
 
CLINGO_VISIBILITY_DEFAULT bool clingo_ast_unpool(clingo_ast_t *ast, clingo_ast_unpool_type_bitset_t unpool_type,
                                                 clingo_ast_callback_t callback, void *callback_data);
 
 
 
// {{{1 extending clingo
 
 
 
 
typedef struct clingo_options clingo_options_t;
 
typedef bool (*clingo_main_function_t)(clingo_control_t *control, char const *const *files, size_t size, void *data);
 
typedef bool (*clingo_default_model_printer_t)(void *data);
 
typedef bool (*clingo_model_printer_t)(clingo_model_t const *model, clingo_default_model_printer_t printer,
                                       void *printer_data, void *data);
 
typedef struct clingo_application {
    char const *(*program_name)(void *data);                         
    char const *(*version)(void *data);                              
    unsigned (*message_limit)(void *data);                           
    clingo_main_function_t main;                                     
    clingo_logger_t logger;                                          
    clingo_model_printer_t printer;                                  
    bool (*register_options)(clingo_options_t *options, void *data); 
    bool (*validate_options)(void *data);                            
} clingo_application_t;
 
CLINGO_VISIBILITY_DEFAULT bool clingo_options_add(clingo_options_t *options, char const *group, char const *option,
                                                  char const *description, bool (*parse)(char const *value, void *data),
                                                  void *data, bool multi, char const *argument);
CLINGO_VISIBILITY_DEFAULT bool clingo_options_add_flag(clingo_options_t *options, char const *group, char const *option,
                                                       char const *description, bool *target);
 
CLINGO_VISIBILITY_DEFAULT int clingo_main(clingo_application_t *application, char const *const *arguments, size_t size,
                                          void *data);
 
typedef struct clingo_script {
    bool (*execute)(clingo_location_t const *location, char const *code, void *data);
    bool (*call)(clingo_location_t const *location, char const *name, clingo_symbol_t const *arguments,
                 size_t arguments_size, clingo_symbol_callback_t symbol_callback, void *symbol_callback_data,
                 void *data);
    bool (*callable)(char const *name, bool *result, void *data);
    bool (*main)(clingo_control_t *control, void *data);
    void (*free)(void *data);
    char const *version;
} clingo_script_t;
 
CLINGO_VISIBILITY_DEFAULT bool clingo_register_script(char const *name, clingo_script_t const *script, void *data);
CLINGO_VISIBILITY_DEFAULT char const *clingo_script_version(char const *name);
 
 
// }}}1
 
#ifdef __cplusplus
}
#endif
 
#endif