- Reference manual
- int PL_compare(term_t t1, term_t t2)
- Compares two terms using the standard order of terms and returns -1, 0 or 1. See also compare/3.
- int PL_same_compound(term_t t1, term_t t2)
TRUEif t1 and t2 refer to physically the same compound term and
In some applications it is useful to store and retrieve Prolog terms from C code. For example, the XPCE graphical environment does this for storing arbitrary Prolog data as slot-data of XPCE objects.
Please note that the returned handles have no meaning at the Prolog level and the recorded terms are not visible from Prolog. The functions PL_recorded() and PL_erase() are the only functions that can operate on the stored term.
Two groups of functions are provided. The first group (PL_record() and friends) store Prolog terms on the Prolog heap for retrieval during the same session. These functions are also used by recorda/3 and friends. The recorded database may be used to communicate Prolog terms between threads.
- record_t PL_record(term_t +t)
- Record the term t into the Prolog database as recorda/3 and return an opaque handle to the term. The returned handle remains valid until PL_erase() is called on it. PL_recorded() is used to copy recorded terms back to the Prolog stack.
- record_t PL_duplicate_record(record_t record)
- Return a duplicate of record. As records are read-only objects this function merely increments the records reference count.
- int PL_recorded(record_t record, term_t -t)
- Copy a recorded term back to the Prolog stack. The same record may be
used to copy multiple instances at any time to the Prolog stack. Returns
TRUEon success, and
FALSEif there is not enough space on the stack to accommodate the term. See also PL_record() and PL_erase().
- void PL_erase(record_t record)
- Remove the recorded term from the Prolog database, reclaiming all associated memory resources.
The second group (headed by PL_record_external()) provides the same functionality, but the returned data has properties that enable storing the data on an external device. It has been designed to make it possible to store Prolog terms fast and compact in an external database. Here are the main features:
- Independent of session
Records can be communicated to another Prolog session and made visible using PL_recorded_external().
The representation is binary for maximum performance. The returned data may contain zero bytes.
- Byte-order independent
The representation can be transferred between machines with different byte order.
- No alignment restrictions
There are no memory alignment restrictions and copies of the record can thus be moved freely. For example, it is possible to use this representation to exchange terms using shared memory between different Prolog processes.
It is assumed that a smaller memory footprint will eventually outperform slightly faster representations.
The format is designed for future enhancements without breaking compatibility with older records.
- char * PL_record_external(term_t +t, size_t *len)
- Record the term t into the Prolog database as recorda/3
and return an opaque handle to the term. The returned handle remains
valid until PL_erase_external()
is called on it.
It is allowed to copy the data and use PL_recorded_external() on the copy. The user is responsible for the memory management of the copy. After copying, the original may be discarded usi