void ATinit(int argc, char *argv[], ATerm *bottomOfStack)

Initialize the ATerm library.

See the section called “Initializing and using the ATerm library”.

ATerm ATmake(const char *pattern, ...)

Create an ATerm from a string pattern and a variable number of arguments. Creates an ATerm given a pattern and corresponding values. Table 1.3, “Argument types for ATmake” shows which patterns can be used, and which type of arguments should be passed if such a pattern is used.

Types <appl> and <str> should contain a pattern consisting of the function symbol to be used and the types of the arguments. This pattern must be followed by exactly the number of arguments that are used in the pattern. The types of the arguments must match the respective types used in the pattern. Both <appl> and <str> create function applications. The difference is that <appl> creates one with an unquoted function symbol, whereas <str> yields a quoted version. Here are some examples of ATmake:

#include <aterm2.h>

int    ival = 42;
char  *sval = "example";
char  *blob = "12345678";
double rval = 3.14;
char  *func = "f";

void foo()
{
    ATerm term[4];
    ATerm list[3];
    ATerm appl[3];

    term[0] = ATmake("<int>" , ival);    
    term[1] = ATmake("<str>" , func);       
    term[2] = ATmake("<real>", rval);    
    term[3] = ATmake("<blob>", 8, blob); 

    list[0] = ATmake("[]");
    list[1] = ATmake("[1,<int>,<real>]", ival, rval);
    list[2] = ATmake("[<int>,<list>]", ival+1, list[1]);

    appl[0] = ATmake("<appl>", func);
    appl[1] = ATmake("<appl(<int>)>", func, ival);
    appl[2] = ATmake("<appl(<int>, <term>, <list>)>", 
                     func, 42, term[3], list[2]);

    ATprintf("appl[2] = %t\n", appl[2]);
}

int main(int argc, char *argv[])
{
    ATerm bottomOfStack;

    ATinit(argc, argv, &bottomOfStack);
    foo();
    return 0;
}

Notes:

	Integer value 42.
	Quoted application of "f", no arguments.
	Real value 3.14.
	Blob of size 8, and data 12345678.

ATerm ATmakeTerm(ATerm pattern, ...)

Create an ATerm from an ATerm pattern and a variable number of arguments.

Note that pattern is here declared as ATerm and not as a string as in ATmake. It does not have to be parsed as in the case of ATmake and therefore ATmakeTerm is more efficient.

See the section called “ATmake”.

ATerm ATvmake(const char *pattern, va_list args)

Create an ATerm from a string pattern and a list of arguments} See the section called “ATmake”.

ATerm ATvmakeTerm(ATerm pattern, va_list args)

Create an ATerm from an ATerm pattern and a list of arguments.

See the section called “ATmake”.

ATbool ATmatch(ATerm t, const char *pattern, ...)

Match an ATerm against a string pattern.

Matches an ATerm against a pattern, attempting to fill the `holes'. If the ATerm matches the pattern, ATtrue is returned and the variables will be filled according to the pattern, otherwise ATfalse is returned. The <list> pattern can be used to match the tail of a list as well as a variable number of arguments in a function application. Thus the first few arguments may be matched explicitly while the tail of the arguments is directed to a list.

Here are a few examples of ATmatch:

#include <aterm2.h>

void foo()
{
    ATbool result;
    ATerm  list;
    double rval;
    int    ival;

    /* Sets result to ATtrue and ival to 16. */
    result = ATmatch(ATmake("f(16)"), "f(<int>)", &ival);

    /* Sets result to ATtrue and rval to 3.14. */
    result = ATmatch(ATmake("3.14"), "<real>", &rval);

    /* Sets result to ATfalse because f(g) != g(f) */
    result = ATmatch(ATmake("f(g)"), "g(f)");

    /* fills ival with 1 and list with [2,3] */
    result = ATmatch(ATmake("[1,2,3]"), 
                     "[<int>,<list>]", &ival, &list);
}

int main(int argc, char *argv[])
{
    ATerm bottomOfStack;

    ATinit(argc, argv, &bottomOfStack);
    foo();
    return 0;
}

ATbool ATmatch(ATerm t, ATerm pattern, ...)

Match an ATerm t against a term pattern pattern. Since the pattern is pre-constructed and needs not be parsed, this is a more efficient variant of ATmatch.

ATerm ATreadFromFile(FILE *file)

Read an ATerm from binary or text file.

This function reads an ATerm from a file. A test is performed to see if the file is in plain text, BAF, TAF, or SAF format.

ATerm ATreadFromNamendFile(char *filename)

Read an ATerm from named binary or text file.

This function reads an ATerm file filename. A test is performed to see if the file is in plain text, TAF, BAF, or SAF format. "-" is standard input's filename.

ATerm ATreadFromString(const char *string)

Read an ATerm from an ASCII text string.

This function parses a character string into an ATerm.

ATerm ATreadFromTextFile(FILE *file)

Read an ATerm from an ASCII text file.

This function reads a text file and parses the contents into an ATerm.

ATerm ATreadFromSharedString(const char *string, int size)

Read a ATerm from a string in TAF format.

This function decodes a TAF-encoded character string into an ATerm.

ATerm ATreadFromBinaryFile(FILE *file)

Read an ATerm from a shared text (TAF) file.

This function reads a shared text file and builds an ATerm.

ATerm ATreadFromBinaryString(const unsigned char *string, int size)

Read a ATerm from a string in BAF format.

This function decodes a BAF-encoded character string into an ATerm.

ATerm ATreadFromBinaryFile(FILE *file)

Read an ATerm from a binary (BAF) file.

This function reads a BAF file and builds an ATerm.

ATerm ATreadFromSAFFile(FILE *file)

Read an ATerm from a streaming (SAF) file.

This function reads a SAF file and builds an ATerm.

int ATgetType(ATerm term)

Return the type of term.

A macro that returns the type of an ATerm. Result is one of AT_APPL, AT_INT, AT_REAL, AT_LIST, AT_PLACEHOLDER, or AT_BLOB.

ATBool ATisEqual(ATerm t1, ATerm t2)

A macro that tests equality of ATerms t1 and t2.

As ATerms are created using maximal sharing (see Section~\ref{sharing}), testing equality is performed in constant time by comparing the addresses of t1 and t2. Note however that ATisEqual only returns ATtrue when t1 and t2 are completely equal, inclusive any annotations they might have!

ATBool ATwriteToTextFile(ATerm t, FILE *f)

Writes term t to file f in textual format.

This function writes ATerm t to the file f in textual format. This term can later be read again by ATreadFromTextFile.

ATbool ATwriteToNamedTextFile(ATerm t, char *filename)

Writes term t to file named filename in textual format.

This function writes ATerm t in textual representation to file filename. "-" is standard output's filename.

char *ATwriteToString(ATerm t)

Writes term t to a string.

Writes term t to an internal string buffer. The start of this buffer is returned. Note that the contents of this buffer are volatile and may be overwritten by any call to the ATerm library.

long ATwriteToSharedTextFile(ATerm t, FILE *f)

Writes term t to file f in shared Textual ATerm Format (TAF).

This function writes ATerm t to the file f in TAF format, and returns the number of characters written. This term can later be read again by ATreadFromSharedTextFile.

char *ATwriteToSharedString(ATerm t, int *len)

Writes term t to a shared text string in TAF.

Writes term t to an internal string buffer in TAF. The start of this buffer is returned, and the length of the resulting string is stored in len. Note that the contents of this buffer are volatile and may be overwritten by any call to the ATerm library.

ATbool ATwriteToBinaryFile(ATerm t, FILE *f)

Writes term t to file f in Binary ATerm Format (BAF).

This function writes ATerm t to the file f in BAF. This term can later be read again by ATreadFromBinaryFile.

ATbool ATwriteToNamedBinaryFile(ATerm t, char *filename)

Writes term t to file named filename in Binary ATerm Format (BAF).

This function writes ATerm t in binary representation to file filename. "-" is standard output's filename.

char *ATwriteToBinaryString(ATerm t, int *len)

Writes term t to a shared text string in BAF.

Writes term t to an internal string buffer in BAF. The start of this buffer is returned, and the length of the resulting string is stored in len. Note that the contents of this buffer are volatile and may be overwritten by any call to the ATerm library.

ATbool ATwriteToSAFFile(ATerm t, char *filename)

Writes term t to file named filename in Streaming ATerm Format (SAF).

This function writes ATerm t in streaming representation to file filename. "-" is standard output's filename.

int ATprintf(const char *format, ...)

ATerm version of printf.

See ATvfprintf.

int ATfprintf(FILE *stream, const char *format, ...)

ATerm version of fprintf.

See ATvfprintf.

int ATvfprintf(File *stream, const char *format, va_list args)

ATerm version of vfprintf.

The functions ATprintf, ATfprintf and ATvfprintf are used for formatted output to file. The conversion specifiers c, d, i, o, u, x, X, e, E, f, g, G, p, s behave as can be expected from fprintf. In addition the conversion specifiers a, h, l, n and t are supported as summarized in Table 1.4, “Specifiers for print conversion”

ATerm ATsetAnnotation(ATerm t, ATerm label, ATerm anno)

Annotate a term with a labeled annotation.

Creates a version of t that is annotated with annotation anno which is labeled by label.

ATerm ATgetAnnotation(ATerm t, ATerm label)

Retrieves annotation of t with label label.

This function can be used to retrieve a specific annotation of a term. If t has no annotations, or no annotation labeled with label exists, NULL is returned. Otherwise the annotation is returned.

ATerm ATremoveAnnotation(ATerm t, ATerm label)

Remove a specific annotation from a term.

This function returns a version of t which has its annotation with label label removed. If t has no annotations, or no annotation labeled with label exists, t itself is returned.

void ATsetWarningHandler(void (*handler)(const char *format, va_list args))

Specify a warning handler for the ATerm library.

Sets a warning handler for the ATerm library. This handler will be called when an error message is issued via ATwarning.

void ATwarning(const char *format, ...)

Issue a warning message.

If an error handler has been installed through a call to ATsetWarningHandler, this handler will be called. Otherwise ATwarning uses ATvfprintf to print a formatted message to stderr and returns.

void ATsetErrorHandler(void (*handler)(const char *format, va_list args))

Specify an error handler for the ATerm library.

Sets an error handler for the ATerm library This handler will be called when an error message is issued via ATerror.

void ATerror(const char *format, ...)

Issue an error message and exit the ATerm library.

If an error handler has been installed through a call to ATsetErrorHandler, this handler will be called. Otherwise ATerror uses ATvfprintf to print a formatted message to stderr and exits with errorcode 1.

void ATsetAbortHandler(void (*handler)(const char *format, va_list args))

Specify an abort handler for the ATerm library.

Sets an abort handler for the ATerm library. This handler will be called when an error message is issued via ATabort.

void ATabort(const char *format, ...)

Issue a error message and abort the ATerm library.

If an abort handler has been installed through a call to ATsetAbortHandler, this handler will be called. Otherwise ATabort uses ATvfprintf to print a formatted message to stderr and calls abort.

void ATprotect(ATerm *atp)

Protect an ATerm.

Protects an ATerm from being freed by the garbage collector. See the section called “Memory Management of ATerms”.

void ATunprotect(ATerm *atp)

Unprotect an ATerm.

Releases protection of an ATerm which has previously been protected through a call to ATprotect. Seethe section called “Memory Management of ATerms” .

void ATprotectArray(ATerm *start, int size)

Protect an array of ATerms.

Protects an entire array of size ATerms starting at start.

void ATunprotectArray(ATerm *start)

Unprotect an array of ATerms.

Releases protection of the array of ATerms which starts at start.

ATermInt ATmakeInt(int value)

Build an ATerm Int from an integer value.

int ATgetInt(ATermInt t)

Macro to get the integer value from the ATerm t.

ATermReal ATmakeReal(double value)

Build an ATerm Real from a real value.

double ATgetReal(ATermInt t)

Macro to get the real value from the ATerm t.

AFun ATmakeAFun(char *name, int arity, ATbool quoted)

Creates a function symbol (AFun).

Creates an AFun, representing a function symbol with name name and arity arity. Quoting of the function application is defined via the quoted argument.

void ATprotectAFun(AFun sym)

Just as ATerms which are not on the stack or in registers must be protected through a call to ATprotect, so must AFuns be protected by calling ATprotectAFun.

void ATunprotectAFun(AFun sym)

Release an AFun's protection.

char *ATgetName(AFun sym)

Return the name of an AFun.

int ATgetArity(AFun sym)

Return the arity (number of arguments) of a function symbol (AFun).

ATbool ATisQuoted(AFun sym)

Determine if a function symbol (AFun) is quoted or not.

ATermAppl ATmakeAppl(AFun sym, ...)

Build an application from an AFun and a variable number of arguments.

The arity is taken from the first argument sym, the other arguments of ATmakeAppl should be the arguments for the application. For arity N = 0, 1, ... 6 the corresponding ATmakeApplN can be used instead for greater efficiency.

ATermAppl ATmakeAppl0(AFun sym)

Make a function application with zero arguments.

ATermAppl ATmakeAppl1(AFun sym, ATerm a1)

Make a function application with one argument.

ATermAppl ATmakeAppl2(AFun sym, ATerm a1, a2)

Make a function application with two arguments.

ATermAppl ATmakeAppl3(AFun sym, ATerm a1, a2, a3)

Make a function application with three arguments.

ATermAppl ATmakeAppl4(AFun sym, ATerm a1, a2, a3, a4)

Make a function application with four arguments.

ATermAppl ATmakeAppl5(AFun sym, ATerm a1, a2, a3, a4, a5)

Make a function application with five arguments.

ATermAppl ATmakeAppl6(AFun sym, ATerm a1, a2, a3, a4, a5, a6)

Make a function application with six arguments.

AFun ATgetAFun(ATermAppl appl)

Get the function symbol (AFun) of an application.

ATerm ATgetArgument(ATermAppl appl, int n)

Get the n-th argument of an application.

ATermAppl ATsetArgument(ATermAppl appl, ATerm arg, int n)

Set the n-th argument of an application to arg.

This function returns a copy of appl with argument n replaced by arg.

ATermList ATgetArguments(ATermAppl appl)

Get a list of arguments of an application.

Return the arguments of appl in ATermList format. Note: traversing the arguments of appl can be done more efficiently using the ATgetArgument macro.

ATermAppl ATmakeApplList(AFun sym, ATermList args)

Build an application given an AFun and a list of arguments.

Build an application from sym and the argument list args. Note: unless the arguments are already in an ATermList, it is probably more efficient to use the appropriate ATmakeApplN.

ATermAppl ATmakeApplArray(AFun sym, ATerm args[])

Build an application given an AFun and an array of arguments.

ATermList ATmakeList(int n, ...)

Create an ATermList of n elements. The elements should be passed as arguments 1, ..., n.

ATermList ATmakeList0()

Macro that yields the empty list [].

ATermList ATmakeList1(ATerm a1)

Construct a list of one element.

ATermList ATmakeList2(ATerm a1, a2)

Construct a list of two elements.

ATermList ATmakeList3(ATerm a1, a2, a3)

Construct a list of three elements.

ATermList ATmakeList4(ATerm a1, a2, a3, a4)

Construct a list of four elements.

ATermList ATmakeList5(ATerm a1, a2, a3, a4, a5)

Construct a list of five elements.

ATermList ATmakeList6(ATerm a1, a2, a3, a4, a5, a6)

Construct a list of six elements.

int ATgetLength(ATermList l)

Macro to get the length of list l.

ATerm ATgetFirst(ATermList l)

Macro to get the first element of list l.

ATermList ATgetNext(ATermList l)

Macro to get the next part (the tail) of list l.

ATbool ATisEmpty(ATermList l)

Macro to test if list l is empty.

ATermList ATgetTail(ATermList l, int start)

Return the sublist from start to the end of l.

ATermList ATreplaceTail(ATermList l, ATermList tail, int start)

Replace the tail of l from position start with tail.

ATermList ATgetPrefix(ATermList l)

Return all but the last element of l.

ATermList ATgetSlice(ATermList l, int start, int end)

Get a portion (slice) of a list.

Return the portion of l that lies between start and end. Thus start is included, end is not.

ATermList ATinsert(ATermList l, ATerm a)

Return list l with element a inserted. The behaviour of ATinsert is of constant complexity. That is, the behaviour of ATinsert does not degrade as the length of l increases.

ATermList ATinsertAt(ATermList l, ATerm a, int idx)

Return l with a inserted at position idx.

ATermList ATappend(ATermList l, ATerm a)

Return l with a appended to it.

ATappend is implemented in terms of ATinsert by making a new list with a as the first element and then ATinserting all elements from l. As such, the complexity of ATappend is linear in the number of elements in l. When ATappend is needed inside a loop that traverses a list (see Example 1.1, “Parse lists, version 1”), behaviour of the loop will demonstrate quadratic complexity.

/* Example of parse_list that demonstrates quadratic complexity */
ATermList parse_list1(ATermList list)
{
    ATerm     elem;
    ATermList result = ATempty;

    /* while list has elements */
    while (!ATisEmpty(list))
    {
        /* Get head of list */
        elem = ATgetFirst(list);

        /* If elem satisfies some predicate (not shown here)
           then APPEND it to result */
        if (some_predicate(elem) == ATtrue)
            result = ATappend(result, elem);

        /* Continue with tail of list */
        list = ATgetNext(list);
    }

    /* Return the result list */
    return result;
}

To avoid this behaviour, the inner loop could use ATinsert instead of ATappend to make the new list. This will cause the resulting list to be in reverse order. A single ATreverse must therefore be performed, but this can be done after the loop has terminated, bringing the behaviour down from quadratic to linear complexity, but at the cost of two ATinserts per element (one for each ATinsert in the loop, and an implicit one for each element through the use of ATreverse). An example in Example 1.2, “Parse lists, version 2”.

/* Example of parse_list that demonstrates linear complexity,
 * using ATinsert instead of ATappend and reversing the list
 * outside the loop just once.  */
ATermList parse_list2(ATermList list)
{
    ATerm     elem;
    ATermList result = ATempty;

    /* while list has elements */
    while (!ATisEmpty(list))
    {
        /* Get head of list */
        elem = ATgetFirst(list);

        /* If elem satisfies some predicate (not shown here)
           then INSERT it to result */
        if (some_predicate(elem) == ATtrue)
            result = ATinsert(result, elem);

        /* Continue with tail of list */
        list = ATgetNext(list);
    }

    /* Return result after reversal */
    return ATreverse(result);
}

An even further optimisation could make use of a locally allocated buffer. While traversing the list, all elements that would normally be ATappended, are now placed in this buffer. Finally, the result is obtained by starting with an empty list and ATinserting all elements from this buffer in reverse order. As the cost of allocating and freeing a local buffer is by no means marginal, this solution should probably only be applied when the loop appends more than just a few elements. This is shown in Example 1.3, “Parse lists, version 3”

/* Example of parse_list that demonstrates linear complexity,
 * but which avoids using ATinsert twice, by inlining ATreverse
 * using a local buffer. */
ATermList parse_list3(ATermList list)
{
    int        pos = 0;
    ATerm      elem;
    ATerm     *buffer = NULL;
    ATermList  result = ATempty;

    /* Allocate local buffer that can hold all elements of list */
    buffer = (ATerm *) calloc(ATgetLength(list), sizeof(ATerm));
    if (buffer == NULL) abort();

    /* while list has elements */
    while (!ATisEmpty(list))
    {
        /* Get head of list */
        elem = ATgetFirst(list);

        /* If elem satisfies some predicate (not shown here)
         * then add it to buffer at next available position */
        if (some_predicate(elem) == ATtrue)
            buffer[pos++] = elem;

        /* Continue with tail of list */
        list = ATgetNext(list);
    }

    /* Now insert all elems in buffer to result */
    for(--pos; pos >= 0; pos--)
        result = ATinsert(result, buffer[pos]);

    /* Release allocated resources */
    free(buffer);

    /* Return result */
    return result;
}

ATermList ATconcat(ATermList l1, ATermList l2)

Return the concatenation of l1 and l2.

int ATindexOf(ATermList l, ATerm a, int start)

Return the index of an ATerm in a list. Return the index where element a can be found in the list l. Start looking at position start. Returns -1 if a is not in the list.

int ATlastIndexOf(ATermList l, ATerm a, int start)

Return the index of an ATerm in a list (searching in reverse order).

Search backwards for element a in the list l. Start searching at position start. Return the index of the first occurrence of a encountered, or -1 when a is not present before start.

ATerm ATelementAt(ATermList l, int idx)

Return a specific element of a list. Return the element at position idx in list l. Return NULL when idx is not in the list.

ATermList ATremoveElement(ATermList l, ATerm a)

Return the list l with one occurrence of element a removed.

ATermList ATremoveAll(ATermList l, ATerm a)

Return the list l with all occurrences of element a removed.

ATermList ATremoveElementAt(ATermList l, int idx)

Return the list l with the element at position idx removed.

ATermList ATreplace(ATermList l, ATerm a, int idx)

Return the list l with the element at position idx replaced by a.

ATermList ATreplace(ATermList l, ATerm a, int idx)

Return the list l with its elements in reverse order.

ATermList ATsort(ATermList l, int (*compare)(ATerm t1, const ATerm t2))

Sort the list l given a comparison function compare. The result is a new list.

ATermList ATsort(ATermList l, ATbool (*predicate)(ATerm t))

Create a new list that consists of all elements of list l that satisfy the predicate predicate.

ATermPlaceholder ATmakePlaceholder(ATerm type)

Build an ATerm Placeholder of a specific type. The type is taken from the type parameter. See Example 1.4, “Examples of place holders”.

ATerm ATgetPlaceholder(ATermPlaceholder ph)

Get the type of an ATerm Placeholder.

#include <assert.h>
#include <aterm2.h>

/* This example demonstrates the use of an ATermPlaceholder. 
 * It creates the function application "add" defined on two 
 * integers without actually using a specific integer:  
 * add(<int>,<int>).
 */
void demo_placeholder()
{
    Symbol           sym_int, sym_add;
    ATermAppl        app_add;
    ATermPlaceholder ph_int;

    /* Construct placeholder <int> using zero-arity function 
       symbol "int" */
    sym_int = ATmakeSymbol("int", 0, ATfalse);
    ph_int = ATmakePlaceholder((ATerm)ATmakeAppl0(sym_int));

    /* Construct add(<int>,<int>) using function symbol 
       "add" with 2 args */
    sym_add = ATmakeSymbol("add", 2, ATfalse);
    app_add = ATmakeAppl2(sym_add, (ATerm)ph_int, (ATerm)ph_int);

    /* Equal to constructing it using the level one interface */
    assert(ATisEqual(app_add, ATparse("add(<int>,<int>)")));

    /* Prints: Placeholder <int> is of type: int */
    ATprintf("Placeholder %t is of type: %t\n", 
             ph_int, ATgetPlaceholder(ph_int));
}

int main(int argc, char *argv[])
{
    ATerm bottomOfStack;

    ATinit(argc, argv, &bottomOfStack);
    demo_placeholder();
    return 0;
}

ATermBlob ATmakeBlob(unsigned int size, void *data)

Build a Binary Large OBject given size (in bytes) of data. This function can be used to create an ATerm of type blob, holding the data pointed to by data. No copy of this data area is made, so the user should allocate this himself. The size of a blob is limited by the maximal value of integers.

void *ATgetBlobData(ATermBlob blob)

Macro to get the data section of a given blob.

int ATgetBlobSize(ATermBlob blob)

Macro to get the size (in bytes) of the data section of a given blob.

void ATregisterBlobDestructor(ATbool (*destructor)(ATermBlob))

Register a blob-destructor function. When a blob-destructor function has been registered, it will be called whenever the garbage collector deletes an ATermBlob. The destructor function can then handle the deletion of the data area of the blob. At most 16 blob destructor functions can be registered in the current implementation.

void ATunregisterBlobDestructor(ATbool (*destructor)(ATermBlob))

Unregister a blob-destructor function that has been previously registered through a call to ATregisterBlobDestructor.

ATerm ATdictCreate()

Create a new dictionary.

ATerm ATdictGet(ATerm dict, ATerm key)

Get the value belonging to a given key in a dictionary.

ATerm ATdictPut(ATerm dict, ATerm key, ATerm value)

Add / update a (key, value)-pair in a dictionary. If key does not already exist in the dictionary, this function adds the (key, value)-pair to the dictionary. Otherwise, it updates the value associated with key to value. The modified dictionary is returned.

ATerm ATdictRemove(ATerm dict, ATerm key)

Remove a (key, value)-pair from a dictionary. If the entry was actually in the dictionary, the modified dictionary is returned. If the entry was not in the dictionary, the (unmodified) dictionary itself is returned.

ATermTable ATtableCreate(int initial_size, int max_load_pct)

Create an ATermTable given an initial size and a maximum load percentage. Whenever this percentage is exceeded (which is detected when a new entry is added using ATtablePut), the table is automatically expanded and all existing entries are rehashed into the new table. If you know in advance approximately how many items will be in the table, you may set it up in such a way that no resizing (and thus no rehashing) is necessary. For example, if you expect about 1000 items in the table, you can create it with its initial size set to 1333 and a maximum load percentage of 75%. You are not required to do this, it merely saves a runtime expansion and rehashing of the table which increases efficiency.

void ATtableDestroy(ATermTable table)

Destroy an ATermTable. As opposed to ATermDictionaries, ATermTables are themselves not ATerms. This means they are not freed by the garbage collector when they are no longer referred to. Therefore, when the table is no longer needed, the user should release the resources allocated by the table by calling ATtableDestroy. All references the table has to ATerms will then also be removed, so that those may be freed by the garbage collector (if no other references to them exist of course).

void ATtableReset(ATermTable table)

Reset an ATermTable. This function resets an ATermTable, without freeing the memory it occupies. Its effect is the same as the subsequent execution of a destroy and a create of a table, but as no memory is released and obtained from the C memory management system this function is generally cheaper. However, if subsequent tables differ very much in size, the use of ATtableDestroy and ATtableCreate may be preferred, because in such a way the sizes of the table adapt automatically to the requirements of the application.

void ATtablePut(ATermTable table, ATerm key, ATerm value)

Add / update a (key, value)-pair in a table. If key does not already exist in the table, this function adds the (key, value)-pair to the table. Otherwise, it updates the value associated with key to value.

ATerm ATtableGet(ATermTable table, ATerm key)

Get the value associated with a given key in a table.

void ATtableRemove(ATermTable table, ATerm key)

Remove the pair with the key key from table.

ATermList ATtableKeys(ATermTable table)

Get an ATermList of all the keys in a table. This function can be useful if you need to iterate over all elements in a table.

ATermList ATtableValues(ATermTable table)

Get an ATermList of all the values in a table. This function can be useful if you need to iterate over all values in a table.

ATermIndexedSet ATindexedSetCreate(long initial_size, 
                                   int max_load_pct)

Create a new ATermIndexedSet with approximately the size initial_size, where it guarantees that the internal hash table, will be filled up to max_load_pct percent. If needed, the size of the hash table is dynamically extended to hold the entries inserted into it. If extension of the hash table fails due to lack of memory, it is attempted to fill the hash table up to 100%. All elements entered into the indexed set are automatically protected. Note that for each ATindexedSetCreate an ATindexedSetDestroy must be carried out to free memory, and to allow inserted elements to be released by the automatic garbage system of the ATerm library. Carrying out a ATindexedSetReset does not free the memory, but allows inserted elements to be garbage collected.

void ATindexedSetDestroy(ATermIndexedSet set)

Releases all memory occupied by set.

void ATindexedSetReset(ATermIndexedSet set)

Clear the hash table in the set, but do not release the memory. Using ATindexedSetReset instead of ATindexedSetDestroy is preferable when indexed sets of approximately the same size are being used.

long ATindexedSetPut(ATermIndexedSet set, ATerm elem, ATbool *isnew}

Enter elem into the set. If elem was already in the set the previously assigned index of elem is returned, and isnew is set to false. If elem did not yet occur in set a new number is assigned and returned, and isnew is set to true. This number can either be the number of an element that has been removed, or, if such a number is not available, the lowest not-used number. The lowest number that is used is 0.

long ATindexedSetGetIndex(ATermIndexedSet set, ATerm elem}

Find the index of elem in set. When elem is not in the set, a negative number is returned.

ATerm ATindexedSetGetElem(ATermIndexedSet set, long index)

Retrieve the element at index in set. This function must be invoked with a valid index and it returns the element assigned to this index. If it is invoked with an invalid index, effects are not predictable.

void ATindexedSetRemove(ATermIndexedSet set, ATerm elem}

Remove elem from set. If a number was assigned to elem, it is freed to be reassigned to an element that may be put into the set at some later on.

ATermList ATindexedSetElements(ATermIndexedSet set)

Retrieve all elements in set. The resulting list is ordered from element with index 0 onwards.