int main(int argc, char const **argv) {
char const *error_message;
int ret = 0;
clingo_solve_iteratively_t *it = NULL;
clingo_model_t *model;
clingo_control_t *ctl = NULL;
clingo_part_t parts[] = {{ "base", NULL, 0 }};
// create a control object and pass command line arguments
if (clingo_control_new(argv+1, argc-1, NULL, NULL, 20, &ctl) != 0) { goto error; }
// add a logic program to the base part
if (clingo_control_add(ctl, "base", NULL, 0, "a :- not b. b :- not a.")) { goto error; }
// ground the base part
if (clingo_control_ground(ctl, parts, 1, NULL, NULL)) { goto error; }
// solve using a model callback
if (clingo_control_solve_iteratively(ctl, NULL, 0, &it)) { goto error; }
for (;;) {
// get the next model
if (clingo_solve_iteratively_next(it, &model)) { goto error; }
// stop if the search space has been exhausted or the requested number of models found
if (!model) { break; }
if (print_model(model)) { goto error; }
}
goto out;
error:
if (!(error_message = clingo_error_message())) { error_message = "error"; }
printf("%s\n", error_message);
ret = 1;
out:
if (it) { clingo_solve_iteratively_close(it); }
if (ctl) { clingo_control_free(ctl); }
return ret;
}
int run(clingo_control_t *ctl) {
char const *base_params[] = { 0 };
if (report_error(clingo_control_add(ctl, "base", base_params, "a :- not b. b :- not a."))) { return 0; }
clingo_value_t empty[] = {};
clingo_part_t part_vec[] = { {"base", { empty, 0 } } };
clingo_part_span_t part_span = { part_vec, 1 };
if (report_error(clingo_control_ground(ctl, part_span, 0, 0))) { return 0; }
if (!solve(ctl)) { return 0; }
if (!solve_iter(ctl)) { return 0; }
return 1;
}
static foreign_t pl_clingo_add(term_t ccontrol, term_t params, term_t program) {
char *prog;
clingo_env *ctl;
atom_t name;
size_t arity;
char *param_buf[FAST_PARAMS];
char **prog_params = param_buf;
term_t arg = PL_new_term_ref();
int rc;
if (!(rc = get_clingo(ccontrol, &ctl))) {
goto out;
}
if (!get_name_arity(params, &name, &arity)) {
rc = PL_type_error("callable", params);
goto out;
}
if (arity + 1 > FAST_PARAMS &&
!(prog_params = malloc(sizeof(char *) * arity))) {
rc = PL_resource_error("memory");
goto out;
}
for (size_t i = 0; i < arity; i++) {
_PL_get_arg(i + 1, params, arg);
if (!(rc =
get_null_terminated_string(arg, &prog_params[i], CVT_ATOM))) {
goto out;
}
}
if (!(rc = get_null_terminated_string(program, &prog,
CVT_ATOM | CVT_STRING | CVT_LIST |
BUF_DISCARDABLE))) {
goto out;
}
if (!(rc = clingo_status(
clingo_control_add(ctl->control, PL_atom_chars(name),
(const char **)prog_params, arity, prog)))) {
goto out;
}
out:
if (prog_params != param_buf) {
free(prog_params);
}
return rc;
}
int main(int argc, char const **argv) {
clingo_error_t ret;
clingo_control_t *ctl = NULL;
clingo_solve_iteratively_t *solve_it = NULL;
clingo_part_t parts[] = {{ "base", NULL, 0 }};
clingo_symbol_t *atoms = NULL;
size_t n;
size_t atoms_n = 0;
char *str = NULL;
size_t str_n = 0;
E(clingo_control_new(argv+1, argc-1, &logger, NULL, 20, &ctl));
E(clingo_control_add(ctl, "base", NULL, 0, "a :- not b. b :- not a."));
E(clingo_control_ground(ctl, parts, 1, NULL, NULL));
E(clingo_control_solve_iteratively(ctl, NULL, 0, &solve_it));
for (;;) {
clingo_model_t *m;
clingo_symbol_t const *atoms_it, *atoms_ie;
E(clingo_solve_iteratively_next(solve_it, &m));
if (!m) { break; }
E(clingo_model_symbols_size(m, clingo_show_type_atoms | clingo_show_type_csp, &n));
A(atoms, clingo_symbol_t, atoms_n, n, "failed to allocate memory for atoms");
E(clingo_model_symbols(m, clingo_show_type_atoms | clingo_show_type_csp, atoms, n));
printf("Model:");
for (atoms_it = atoms, atoms_ie = atoms + n; atoms_it != atoms_ie; ++atoms_it) {
E(clingo_symbol_to_string_size(*atoms_it, &n));
A(str, char, str_n, n, "failed to allocate memory for symbol's string");
E(clingo_symbol_to_string(*atoms_it, str, n));
printf(" %s", str);
}
printf("\n");
}
cleanup:
if (str) { free(str); }
if (atoms) { free(atoms); }
if (solve_it) { clingo_solve_iteratively_close(solve_it); }
if (ctl) { clingo_control_free(ctl); }
return ret;
}
int main(int argc, char const **argv) {
char const *error_message;
int ret = 0;
size_t offset;
clingo_solve_result_bitset_t solve_ret;
clingo_control_t *ctl;
clingo_symbolic_atoms_t *atoms;
clingo_backend_t *backend;
clingo_atom_t atom_ids[4];
char const *atom_strings[] = {"a", "b", "c"};
clingo_literal_t body[2];
clingo_part_t parts[] = {{ "base", NULL, 0 }};
// create a control object and pass command line arguments
if (!clingo_control_new(argv+1, argc-1, NULL, NULL, 20, &ctl) != 0) { goto error; }
// add a logic program to the base part
if (!clingo_control_add(ctl, "base", NULL, 0, "{a; b; c}.")) { goto error; }
// ground the base part
if (!clingo_control_ground(ctl, parts, 1, NULL, NULL)) { goto error; }
// get the container for symbolic atoms
if (!clingo_control_symbolic_atoms(ctl, &atoms)) { goto error; }
// get the ids of atoms a, b, and c
offset = 0;
for (char const **it = atom_strings, **ie = it + sizeof(atom_strings) / sizeof(*atom_strings); it != ie; ++it) {
clingo_symbol_t sym;
clingo_symbolic_atom_iterator_t atom_it, atom_ie;
clingo_literal_t lit;
bool equal;
// lookup the atom
if (!clingo_symbol_create_id(*it, true, &sym)) { goto error; }
if (!clingo_symbolic_atoms_find(atoms, sym, &atom_it)) { goto error; }
if (!clingo_symbolic_atoms_end(atoms, &atom_ie)) { goto error; }
if (!clingo_symbolic_atoms_iterator_is_equal_to(atoms, atom_it, atom_ie, &equal)) { goto error; }
assert(!equal); (void)equal;
// get the atom's id
if (!clingo_symbolic_atoms_literal(atoms, atom_it, &lit)) { goto error; }
atom_ids[offset++] = lit;
}
// get the backend
if (!clingo_control_backend(ctl, &backend)) { goto error; }
// prepare the backend for adding rules
if (!clingo_backend_begin(backend)) { goto error; }
// add an additional atom (called d below)
if (!clingo_backend_add_atom(backend, NULL, &atom_ids[3])) { goto error; }
// add rule: d :- a, b.
body[0] = atom_ids[0];
body[1] = atom_ids[1];
if (!clingo_backend_rule(backend, false, &atom_ids[3], 1, body, sizeof(body)/sizeof(*body))) { goto error; }
// add rule: :- not d, c.
body[0] = -(clingo_literal_t)atom_ids[3];
body[1] = atom_ids[2];
if (!clingo_backend_rule(backend, false, NULL, 0, body, sizeof(body)/sizeof(*body))) { goto error; }
// finalize the backend
if (!clingo_backend_end(backend)) { goto error; }
// solve
if (!solve(ctl, &solve_ret)) { goto error; }
goto out;
error:
if (!(error_message = clingo_error_message())) { error_message = "error"; }
printf("%s\n", error_message);
ret = clingo_error_code();
out:
if (ctl) { clingo_control_free(ctl); }
return ret;
}