1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
|
/* Part of SWI-Prolog
This example code is in the public domain
*/
/* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
This code may be compiled using
swipl-ld -shared -o test test.cpp
and subsequently loading using
swipl test.pl
Next, run example predicates such as below. Scan through this file
to find the predicates provided by this C++ code.
?- hello(world).
Hello world
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
#define PROLOG_MODULE "user"
#include "SWI-cpp.h"
#include <iostream>
#include <math.h>
using namespace std;
PREDICATE(hello, 1)
{ cout << "Hello " << (char *)A1 << endl;
return TRUE;
}
PREDICATE(add, 3)
{ return A3 = (long)A1 + (long)A2;
}
PREDICATE(name_arity, 1)
{ cout << "name = " << A1.name() << ", arity = " << A1.arity() << endl;
return TRUE;
}
PREDICATE(list_modules, 0)
{ PlTermv av(1);
PlQuery q("current_module", av);
while( q.next_solution() )
cout << (char *)av[0] << endl;
return TRUE;
}
PREDICATE(average, 3) /* average(+Templ, :Goal, -Average) */
{ long sum = 0;
long n = 0;
PlTermv av(A2); /* could be inlined in next call */
PlQuery q("call", av); /* but MSVC has a bug here */
while( q.next_solution() )
{ sum += (long)A1;
n++;
}
return A3 = (double)sum/(double)n;
}
PREDICATE(hello, 0)
{ PlQuery q("write", PlTermv("hello world\n"));
return q.next_solution();
}
PREDICATE(term, 1)
{ return A1 = PlCompound("hello", PlTermv("world"));
}
PlAtom ATOM_atom("atom");
PREDICATE(term, 2)
{ PlAtom a(A1);
if ( a == ATOM_atom )
return A2 = PlTerm("hello world");
if ( A1 == "string" )
return A2 = PlString("hello world");
if ( A1 == "code_list" )
return A2 = PlCodeList("hello world");
if ( A1 == "char_list" )
return A2 = PlCharList("hello world");
if ( A1 == "term" )
return A2 = PlCompound("hello(world)");
throw PlDomainError("type", A1);
}
PREDICATE(can_unify, 2)
{ PlFrame fr;
int rval = (A1=A2);
fr.rewind();
return rval;
}
PREDICATE(write_list, 1)
{ PlTail tail(A1);
PlTerm e;
while(tail.next(e))
cout << (char *)e << endl;
return TRUE;
}
PREDICATE(cappend, 3)
{ PlTail l1(A1);
PlTail l3(A3);
PlTerm e;
while(l1.next(e))
{ if ( !l3.append(e) )
return FALSE;
}
return A2 = l3;
}
PREDICATE(call_atom, 1)
{ try
{ return PlCall((char *)A1);
} catch ( PlTypeError &ex )
{ cerr << "Type Error caugth in C++" << endl;
cerr << "Message: \"" << (char *)ex << "\"" << endl;
return FALSE;
}
}
/* The purpose of this predicate is mostly to show that
resource errors are dealt with appropriately: with large
enough argument, this will overflow the stacks. The Prolog
error is mapped to a C++ exception and back again when
control is passed back to Prolog. So this is just fine:
?- square_roots(1000000000, L)
ERROR: Out of global stack
*/
PREDICATE(square_roots, 2)
{ int end = A1;
PlTail list(A2);
for(int i=0; i<end; i++)
list.append(sqrt((double)i));
return list.close();
}
|
