Author(s): Jesús Correas.
Version: 1.8#2 (2002/6/14, 18:55:4 CEST)
Version of last change: 1.7#125 (2001/10/17, 13:42:47 CEST)
This module defines a low level Java to Prolog interface. This Prolog side of the Java to Prolog interface only has one public predicate: a server that listens at the socket connection with Java, and executes the commands received from the Java side.
In order to evaluate the goals received from the Java side, this module can work in two ways: executing them in the same engine, or starting a thread for each goal. The easiest way is to launch them in the same engine, but the goals must be evaluated sequentially: once a goal provides the first solution, all the subsequent goals must be finished before this goal can backtrack to provide another solution. The Prolog side of this interface works as a top-level, and the goals partially evaluated are not independent.
The solution of this goal dependence is to evaluate the goals in a different prolog engine. Although Ciao includes a mechanism to evaluate goals in different engines, the approach used in this interface is to launch each goal in a different thread.
The decision of what kind of goal evaluation is selected is done by the Java side. Each evaluation type has its own command terms, so the Java side can choose the type it needs.
A Prolog server starts by calling the prolog_server/0
predicate, or by calling prolog_server/1
predicate and providing the port number as argument. The user predicates and libraries to be called from Java must be included in the executable file, or be accesible using the built-in predicates dealing with code loading.
jtopl
):- use_module(library(jtopl)).
jtopl
)Usage:
prolog_halt
command is received.
Usage:
prolog_halt
command is received.
Arg1
is an atom.
(basic_props:atm/1
)
Usage:
No further documentation available for this predicate.
The predicate is of type concurrent.
No further documentation available for this predicate.
The predicate is of type concurrent.
No further documentation available for this predicate.
The predicate is of type concurrent.
jtopl
)
Usage: command(X)
X
is a command received from the java client, to be executed by the Prolog process. The command is represented as an atom or a functor with arity 1. The command to be executed must be one of the following types:
prolog_launch_query(Q)
Compound term to create a new query, received as single argument of this structure. A reference to the new query is returned to Java.
prolog_next_solution
Atom to get the next solution of a goal. A term representing the goal instantiated with the next solution is returned to Java.
prolog_execute
Atom to indicate that next solution of a goal must be got, without blocking the requester (it has to check if this goal is still running using prolog_is_running command).
prolog_terminate_query
Atom to indicate that a goal must be terminated.
prolog_use_module(M)
Compound term to load dynamically a module given as argument.
prolog_is_running
Atom to check if a goal is yet running a prolog_execute command.
prolog_halt
Atom to terminate the current Prolog process.
Usage: answer(X)
No further documentation available for this predicate.
Usage: solve(+Query,+JId)
query_solutions/2
data predicate.
+Query
is a term which represents a goal, i.e., an atom or a structure.
(basic_props:callable/1
)
+JId
is any term.
(basic_props:term/1
)
Usage: prolog_parse(+String,-Term)
+String
is a string (a list of character codes).
(basic_props:string/1
)
-Term
is any term.
(basic_props:term/1
)
No further documentation available for this predicate.
Usage: write_answer(+Id,+Answer)
+Id
is a prolog query identifier.
(jtopl:prolog_query_id/1
)
+Answer
is a response sent from the prolog server. Is represented as an atom or a functor with arity 1 or 2, depending on the functor name.
(jtopl:answer/1
)
Go to the first, previous, next, last section, table of contents.