symbol.c

The example shows how to create and inspect symbols.

The example shows how to create and inspect symbols.

Output

$ ./symbol 0
the hash of 42 is 281474976710698
the hash of x is 562949963481760
the hash of x(42,x) is 1407374893613792
42 is equal to 42
42 is not equal to x
42 is less than x

Code

#define __STDC_FORMAT_MACROS
#include <assert.h>
#include <clingo.h>
#include <inttypes.h>
#include <stdio.h>
#include <stdlib.h>
 
typedef struct {
    char *string;
    size_t string_n;
} string_buffer_t;
 
void free_string_buffer(string_buffer_t *buf) {
    if (buf->string) {
        free(buf->string);
        buf->string = NULL;
        buf->string_n = 0;
    }
}
 
bool print_symbol(clingo_symbol_t symbol, string_buffer_t *buf) {
    bool ret = true;
    char *string;
    size_t n;
 
    // determine size of the string representation of the next symbol in the model
    if (!clingo_symbol_to_string_size(symbol, &n)) {
        goto error;
    }
 
    if (buf->string_n < n) {
        // allocate required memory to hold the symbol's string
        if (!(string = (char *)realloc(buf->string, sizeof(*buf->string) * n))) {
            clingo_set_error(clingo_error_bad_alloc, "could not allocate memory for symbol's string");
            goto error;
        }
 
        buf->string = string;
        buf->string_n = n;
    }
 
    // retrieve the symbol's string
    if (!clingo_symbol_to_string(symbol, buf->string, n)) {
        goto error;
    }
    printf("%s", buf->string);
    goto out;
 
error:
    ret = false;
 
out:
    return ret;
}
 
int main() {
    char const *error_message;
    int ret = 0;
    clingo_symbol_t symbols[3];
    string_buffer_t buf = {NULL, 0};
    clingo_symbol_t const *args;
    size_t size;
 
    // create a number, identifier (function without arguments), and a function symbol
    clingo_symbol_create_number(42, &symbols[0]);
    if (!clingo_symbol_create_id("x", true, &symbols[1])) {
        goto error;
    }
    if (!clingo_symbol_create_function("x", symbols, 2, true, &symbols[2])) {
        goto error;
    }
 
    // print the symbols along with their hash values
    for (size_t i = 0; i < sizeof(symbols) / sizeof(*symbols); ++i) {
        printf("the hash of ");
        if (!print_symbol(symbols[i], &buf)) {
            goto error;
        }
        printf(" is %zu\n", clingo_symbol_hash(symbols[i]));
    }
 
    // compare symbols
    if (!clingo_symbol_arguments(symbols[2], &args, &size)) {
        goto error;
    }
    assert(size == 2);
    // equal to comparison
    for (size_t i = 0; i < size; ++i) {
        if (!print_symbol(symbols[0], &buf)) {
            goto error;
        }
        printf(" %s ", clingo_symbol_is_equal_to(symbols[0], args[i]) ? "is equal to" : "is not equal to");
        if (!print_symbol(args[i], &buf)) {
            goto error;
        }
        printf("\n");
    }
    // less than comparison
    if (!print_symbol(symbols[0], &buf)) {
        goto error;
    }
    printf(" %s ", clingo_symbol_is_less_than(symbols[0], symbols[1]) ? "is less than" : "is not less than");
    if (!print_symbol(symbols[1], &buf)) {
        goto error;
    }
    printf("\n");
 
    goto out;
 
error:
    if (!(error_message = clingo_error_message())) {
        error_message = "error";
    }
 
    printf("%s\n", error_message);
    ret = clingo_error_code();
 
out:
    free_string_buffer(&buf);
 
    return ret;
}