The interoperability between the runtime Prolog and an
application is provided via a set of interface objects. The
objects hide the details of the runtime Prolog implementation. The
dominant objects are interpreter objects and term objects. But we
also find predicate and reference objects.
- Interpreter Objects: The
of a Prolog goal is an activity. Since Prolog goals are
non-deterministic their activity will leave some trace which is
beyond the side effects of the Prolog goals themselves. The
trace will be some data structure suitable for backtracking. The
interpreter objects circle around this data structures. More...
- Knowledgebase Objects: The
based on defined predicates and built-in predicates. These
predicates are found inside a knowledge base. The Prolog
interpreter initializes a knowledge base with system defined
predicates and system built-in predicates. The Prolog API allows
the application programmer to define custom built-ins in the
form of Java foreign predicates. More...
- Term Objects: Prolog
does not feature the kind of variables and data structures that
are usually found in imperative programming languages. The value
of a variable is tight to the progress of the search procedure
and as a data structure we usually find the term model. The
Prolog API allows the creation and inspection of these
- Special Objects: We
extend the term model by reference objects and decimals. The
reference objects can then participate in the proof search and
can be used to wrap objects from the application. Among the
possible uses we find resource access and synchronization
primitives. The decimals give better support to some financial
- Interaction Protocol: The
predicate are minimized in that the interpreter automatically
performs some housekeeping. The housekeeping includes rolling
back the variable creations and instantiations made by the
foreign predicate. The housekeeping varies on whether the
foreign predicate is deterministic or not. More...
- Foreign Function Interface: The Prolog interpreter
provides an internal API that allows defining built-in
predicates and evaluable functions. This internal API is not
public available since it is an unsafe API. For less time
critical and specialized predicates and evaluable functions we
provide an external API here. More...
- Auto Loaded Classes: With release 1.0.9 the Prolog
interpreter provides auto loading of modules. This happens when
a qualified predicate or evaluable function call is specified
and the specified module has not yet been loaded. The auto
loader will try Prolog modules and Java classes. More...
- Proxy Generated Classes: With release 1.0.10 the
Prolog interpreter can generate Java classes from modules. The
module must be either a Prolog text loaded from a text source or
a dynamic module. The Java class will be a Java proxy class with
an invocation handler. This invocation handler will dispatch
method calls to the module. More...
- Execution Supervision: With release 1.1.6 the
execution supervision of a set of slave threads by a master
thread has been improved. To understand this supervision we
explain here the basic underlying concepts of Java threads that
execute inside the Java class Interpreter with respect to their