Swicli.Library
This finds things like op_Implicit/op_Explicition to
?- cliNewArray(long,10,Out),cliToString(Out,Str).
10 or [10] or [10,2]
Tagged ref to the array
Construct an array of some type
The parent array type .. not the Element type
Returns the Type when denoated by a 'namespace.type' (usefull for static instance specification)
if a @C#234234 the type of the object unless its a a class
c(a) => System.Char "sdfsdf" => System.String uint(5) => System.UInt32
instanceMaybe maybe Null.. it is passed in so the method code doesn't have to call GetInstance again
on classOrInstance
?- current_bot(Obj),cli_add_event_handler(Obj,'EachSimEvent',c(A,format(user_error,'EV = ~q.~n',[A])),Out).
this is just stuffed with a random MethodInfo
0 = SetValue
1 = Count
2 = add/append
3 = GetValue
4 = removeValue
5 = removeAll
6 = cliAddElementGeneric
7 = cliSetElementGeneric
Create a Event Handler with a ResetEvent
Add another event to be waited on
Block until ResetEvent occures and run the prolog code.. if it fails.. wait again for the reset event
if over maxTime return time_limit_exceeded
1 ?- cliToString(-1,X).
X = "4294967295".
This is no longer needed since we use atom GC (maybe)
?- cliNew('java.lang.Long',[long],[44],Out),cliToString(Out,Str).
This after the SwiPrologDir and IKVMHome is set up will update the environment
cliLoadAssembly('SwiPlCs.dll').
cliLoadAssembly('Cogbot.exe').
?- cliAddAssemblySearchPath('.').
cliRemoveAssemblySearchPath('.').
Retreves the ClazzSpec Fields and Properties into a MemberSpecList
Retreves the clazzOrInstance Members into MemberSpec List
used by cli_memb/2
=Attempt to find assembly doc of member
FIX ME!!
[] = 'Item'
libpl
Does NOT work correct if engine is_initialised
int PL_is_initialised(int *argc, char ***argv)
a SWI-PROLOG IOSTREAM defined in spl-stream.h
int PL_foreign_control(control_t)
Extracts the type of call from the control argument.
The return values are described above.
Note: that the function should be prepared to handle the PL_CUTTED case and
Note: should be aware that the other arguments are not valid in this case.
long PL_foreign_context(control_t)
Extracts the context from the context argument.
In the call type is PL_FIRST_CALL the context value is 0L.
Otherwise it is the value returned by the last PL_retry() associated
with this goal (both if the call type is PL_REDO as PL_CUTTED).
void * PL_foreign_context_address(control_t)
Extracts an address as passed in by PL_retry_address().
void PL_retry(long)
The foreign function succeeds while leaving a choice point.
On backtracking over this goal the foreign function will be called again,
but the control argument now indicates it is a `Redo' call and the macro
PL_foreign_context() will return the handle passed via PL_retry().
This handle is a 30 bits signed value (two bits are used for status indication).
void PL_retry_address(void *)
As PL_retry(), but ensures an address as returned by malloc()
is correctly recovered by PL_foreign_context_address().
The standard SWI-Prolog streams ( inout output error )
0 - Sread_function.
1 - Swrite_function.
Flags that control for the foreign predicate parameters
SWI-Prolog Manual - 9.6.16 Querying Prolog.
The default value.
Return an integer holding the number of arguments given to Prolog from Unix.
Return a char ** holding the argument vector given to Prolog from Unix.
Read character from terminal.
Return a long, representing the maximal integer value represented by a Prolog integer.
Return a long, representing the minimal integer value.
Return a long, representing the version as 10,000 × M + 100 × m + p, where M is the major, m the minor version number and p the patch-level. For example, 20717 means 2.7.17
Return the maximum number of threads that can be created in this version. Return values of PL_thread_self() are between 0 and this number.
Return the default stream encoding of Prolog (of type IOENC).
Get amount of user CPU time of the process in milliseconds.
Represents one variable of a Query result.
The name of a variable in a Query
The ManagedObject (PlTerm) of a variable in a Query
Represents the set variables of a Query if it was created from a string.
This class is also used to represent the results of a PlQuery after or was called.
This sample shows both is used to unify the variables of two nested queries
and the result
Query typeDescription
- A static callTo ask prolog for a proof. Return only true or false.
- A To get the first result of a goal
- Construct a PlQuery object by a string.The most convenient way.
- Construct a PlQuery object by compound terms.The most flexible and fast (runtime) way.
For examples see and
The query will be opened by and will be closed if NextSolution() return false.
the list of prolog record's (the copies to store the variable bindings over backtracking)
Release all resources from the query
if true all is deleted
Discards the query, but does not delete any of the data created by the query if discardData is false.
It just invalidate qid, allowing for a new PlQuery object in this context.
see
if true all bindings of the query are destroyed
With these constructors a Prolog query can be created but not opened. To get the results see
A Query can be created from a string or by a name and PlTermV. The later is a native way and available for compatibility.
If a Query is created from a string representing arbitrary prolog text
the helper classes and comes into the game.
In this case the most convenient way to get the results is to use or .
For examples see .
With this constructor a query is created from a string.
Uppercase parameters are interpreted a variables but can't be nested in sub terms.
If you need a variable in a nested term use .
See the examples for details.
Muddy Waters sang:"I'am build for comfort, I ain't build for speed"
Assert.IsTrue(PlQuery.PlCall("is_list", new PlTerm("[a,b,c,d]")));
Assert.IsTrue(PlQuery.PlCall("consult", new PlTerm("some_file_name")));
// or
Assert.IsTrue(PlQuery.PlCall("consult('some_file_name')"));
Create a PlQuery from the arguments, generates the first solution by NextSolution() and destroys the query.
defines the name of the predicate
Is a of arguments for the predicate
Return true or false as the result of NextSolution() or throw an exception.
As but locating the predicate in the named module.
locating the predicate in the named module.
Call a goal once.
Assert.IsTrue(PlQuery.PlCall("is_list([a,b,c,d])"));
Assert.IsTrue(PlQuery.PlCall("consult('some_file_name')"));
The complete goal as a string
NOTE:will be changed in the near future.
return the solution of a query which is called once by call
Throw an ArgumentException if there is no or more than one variable in the goal
a goal with *one* variable
the bound variable of the first solution
The List of of this PlQuery.
In the following example you see how the query Variables can be used to set a variable.
public void Test(int x)
{
try
{
Check.Require(x > 1, "x must be > 1");
}
catch (System.Exception ex)
{
PrologCLR.ConsoleTrace(ex.ToString());
}
}
You can direct output to a Trace listener. For example, you could insert
Trace.Cogbot.Clear();
Trace.Cogbot.Add(new TextWriterTraceListener(Console.Out));
or direct output to a file or the Event Log.
(Note: For ASP.NET clients use the Cogbot collection
of the Debug, not the Trace, object and, for a Release build, only exception-handling
is possible.)
Precondition check - should run regardless of preprocessor directives.
Precondition check - should run regardless of preprocessor directives.
Precondition check - should run regardless of preprocessor directives.
Postcondition check.
Postcondition check.
Postcondition check.
Invariant check.
Invariant check.
Invariant check.
Assertion check.
Assertion check.
Assertion check.
Set this if you wish to use Trace Assert statements
instead of exception handling.
(The Check class uses exception handling by default.)
Is exception handling being used?
Exception raised when a contract is broken.
Catch this exception type if you wish to differentiate between
any DesignByContract exception and other runtime exceptions.
Exception raised when a precondition fails.
Precondition Exception.
Precondition Exception.
Precondition Exception.
Exception raised when a postcondition fails.
Postcondition Exception.
Postcondition Exception.
Postcondition Exception.
Exception raised when an invariant fails.
Invariant Exception.
Invariant Exception.
Invariant Exception.
Exception raised when an assertion fails.
Assertion Exception.
Assertion Exception.
Assertion Exception.
The namespace SbsSW.SwiPlCs.Callback provides the delegates to register .NET methods to be
called from SWI-Prolog
It is only possible to call methods
Flags that are responsible for the foreign predicate parameters
0 - PL_FA_NOTHING: no flags.
1 - PL_FA_NOTRACE: Predicate cannot be seen in the tracer.
2 - PL_FA_TRANSPARENT: Predicate is module transparent.
4 - PL_FA_NONDETERMINISTIC: Predicate is non-deterministic. See also PL_retry().
PL_retry()
8 - PL_FA_VARARGS: (Default) Use alternative calling convention. call using t0, ac, ctx
16 - PL_FA_CREF: /* call using t0, ac, ctx */.
/* Internal: ISO core predicate */
PL_EXPORT(void) PL_on_halt(void (*)(int, void *), void *);
typedef void (*PL_abort_hook_t)(void);
See also the example in .
Overview
Prolog variables are dynamically typed and all information is passed around using the
C-interface type term_t witch is an int. In C#, term_t is embedded in the lightweight struct .
Constructors and operator definitions provide flexible operations and integration with important C#-types (string, int and double).
The list below summarises the important classes / struct defined in the C# interface.
class / structShort description
- A static class represents the prolog engine.
- A struct representing prolog data.
- A vector of .
- A class to query Prolog.
Before going into a detailed description of the CSharp classes let me present a few examples
illustrating the `feel' of the interface. The Assert class in the sample is from the test framework
and has nothing to do with the interface. It shows only which return values are expected.
Creating terms
This very simple example shows the basic creation of a Prolog term and how a Prolog term is converted to C#-data:
PlTerm t1 = new PlTerm("x(A)");
PlTerm t2 = new PlTerm("x(1)");
Assert.IsTrue(t1.Unify(t2));
Assert.AreEqual("x(1)", t1.ToString());
Calling Prolog
This example shows how to make a simple call to prolog.
PlTerm l1 = new PlTerm("[a,b,c,d]");
Assert.IsTrue(PlQuery.PlCall("is_list", l1));
Getting the solutions of a query
This example shows how to obtain all solutions of a prolog query.
takes the name of a predicate and the goal-argument vector as arguments.
From this information it deduces the arity and locates the predicate. the member-function
NextSolution() yields true if there was a solution and false otherwise.
If the goal yielded a Prolog exception it is mapped into a C# exception.
PlQuery q = new PlQuery("member", new PlTermV(new PlTerm("A"), new PlTerm("[a,b,c]")));
while (q.NextSolution())
PrologCLR.ConsoleTrace(s[0].ToString());
There is an other constructor of which simplify the sample above.
PlQuery q = new PlQuery("member(A, [a,b,c])");
foreach (PlTermV s in q.Solutions)
PrologCLR.ConsoleTrace(s[0].ToString());
An other way to get the results is to use to iterate over .
PlQuery q = new PlQuery("member(A, [a,b,c])");
foreach (PlQueryVariables vars in q.SolutionVariables)
PrologCLR.ConsoleTrace(vars["A"].ToString());
It is also possible to get all solutions in a list by .
This could be used to work with LinQ to objects which is really nice. and for further samples.
var results = from n in new PlQuery("member(A, [a,b,c])").ToList() select new {A = n["A"].ToString()};
foreach (var s in results)
PrologCLR.ConsoleTrace(s.A);
Obtain the type of a term, which should be a term returned by one of the other
interface predicates or passed as an argument. The function returns the type of
the Prolog term. The type identifiers are listed below.
see PL_term_type(term_t) in the SWI-Prolog Manual.
In this sample a Prolog variable is created in PlTerm t and the
is checked by his integer representation and his name.
PlTerm t = PlTerm.PlVar();
Assert.AreEqual(1, (int)t.PlType);
Assert.AreEqual(PlType.PlVariable, t.PlType);
0 - PL_UNKNOWN: Undefined
1 - PL_VARIABLE: An unbound variable. The value of term as such is a unique identifier for the variable.
2 - PL_ATOM: A Prolog atom.
3 - PL_INTEGER: A Prolog integer.
4 - PL_FLOAT: A Prolog floating point number.
5 - PL_STRING: A Prolog string.
6 - PL_TERM: A compound term. Note that a list is a compound term ./2.
The PlTerm plays a central role in conversion and operating on Prolog data.
PlTerm implements to support ordering in queries if PlTerm is a List.
Creating a PlTerm can be done by the Constructors or by the following static methods:
PlVar(), PlTail(), PlCompound, PlString(), PlCodeList(), PlCharList() (see remarks)
static methodDescription
- Creates a new initialised term (holding a Prolog variable).
- PlTail is for analysing and constructing lists.
- PlCompound(string)Create compound terms. E.g. by parsing (as read/1) the given text.
- Create a SWI-Prolog string.
- Create a Prolog list of ASCII codes from a 0-terminated C-string.
- Create a Prolog list of one-character atoms from a 0-terminated C-string.
Create a PlTerm but *no* new term_ref it only copies the term_ref into the new object
Used Intern by
- PlException constructor
- PlQueryQ.GetSolutions()
- PlTermV this[int index] indexer
A new PlTerm can be also created by the static methods:
static methodDescription
- Creates a new initialised term (holding a Prolog variable).
- PlTail is for analysing and constructing lists.
- PlCompound(string)Create compound terms. E.g. by parsing (as read/1) the given text.
- Create a SWI-Prolog string.
- Create a Prolog list of ASCII codes from a 0-terminated C-string.
- Create a Prolog list of one-character atoms from a 0-terminated C-string.
Creates a term-references holding a Prolog term representing text.
the text
Creates a term-references holding a Prolog integer representing value.
a integer value
Creates a term-references holding a Prolog float representing value.
a double value
Creates a new initialised term (holding a Prolog variable).
a PlTerm
PlTail is for analysing and constructing lists.
It is called PlTail as enumeration-steps make the term-reference follow the `tail' of the list.
A PlTail is created by making a new term-reference pointing to the same object.
As PlTail is used to enumerate or build a Prolog list, the initial list
term-reference keeps pointing to the head of the list.
The initial PlTerm
A PlTerm for which is_list/1 succeed.
These static methods creates a new compound .
For an example
Create a term by parsing (as read/1) the text.
If the text is not valid Prolog syntax, a syntax error exception is raised.
Otherwise a new term-reference holding the parsed text is created.
The string representing the compound term parsed by read/1.
a new
Create a compound term with the given name from the given vector of arguments. See for details.
The example below creates the Prolog term hello(world).
PlTerm t = PlTerm.PlCompound("hello", new PlTermv("world"));
The functor (name) of the compound term
the arguments as a
a new
Create a compound term with the given name ant the arguments
The functor (name) of the compound term
The first Argument as a
a new
The second Argument as a
The third Argument as a
A SWI-Prolog string represents a byte-string on the global stack.
It's lifetime is the same as for compound terms and other data living on the global stack.
Strings are not only a compound representation of text that is garbage-collected,
but as they can contain 0-bytes, they can be used to contain arbitrary C-data structures.
the string
a new PlTerm
the length of the string
Create a Prolog list of ASCII codes from a 0-terminated C-string.
The text
a new
These static methods creates a new PlCharList TODO TODO .
Create a Prolog list of one-character atoms from a C#-string.
Character lists are compliant to Prolog's atom_chars/2 predicate.
a string
A new PlTerm containing a prolog list of character
Appends element to the list and make the PlTail reference point to the new variable tail.
If A is a variable, and this method is called on it using the argument "gnat",
a list of the form [gnat|B] is created and the PlTail object now points to the new variable B.
This method returns TRUE if the unification succeeded and FALSE otherwise. No exceptions are generated.
if (!PlEngine.IsInitialized)
{
String[] empty_param = { "" };
PlEngine.Initialize(empty_param);
// do some funny things ...
PlEngine.PlCleanup();
}
// program ends here
The following sample show how a file is consult via comand-line options.
using SbsSW.SwiPlCs.Callback;
For an example see and .
Register a C# callback method
For an example see and .
a delegate to a c# method
true if registration succeed otherwise false
the name of a prolog module Using Modules
The amount of parameters
The name of the method
Initialise SWI-Prolog
The write method of the output stream is redirected to
before Initialize. The read method of the input stream just after Initialize.
A known bug: Initialize work *not* as expected if there are e.g. German umlauts in the parameters
See marshalling in the sorce NativeMethods.cs
For a complete parameter description see the SWI-Prolog reference manual section 2.4 Command-line options.
sample parameter: String[] param = { "-q", "-f", @"some\filename" };
At the first position a parameter "" is added in this method. PL_initialise
For an example see
Try a clean up but it is buggy
search the web for "possible regression from pl-5.4.7 to pl-5.6.27" to see reasons
Use this method only at the last call before run program ends
Stops the PlEngine and the program
SWI-Prolog calls internally pl_cleanup and than exit(0)
To Avoid callbackOnCollectedDelegate MDA
To Avoid callbackOnCollectedDelegate MDA
This is a primitive approach to enter the output from a stream.