131 lines
2.9 KiB
C++
131 lines
2.9 KiB
C++
#include <Rcpp.h>
|
|
|
|
#undef Realloc
|
|
#undef Malloc
|
|
#undef Free
|
|
#include <yapi.hh>
|
|
|
|
#include <string>
|
|
#include <vector>
|
|
|
|
#include "real.h"
|
|
|
|
using namespace Rcpp;
|
|
|
|
class yap4r {
|
|
|
|
YAPEngine *yap;
|
|
YAPQuery *q;
|
|
std::vector<YAPTerm> args;
|
|
bool failed;
|
|
|
|
public:
|
|
SEXP qsexp;
|
|
yap4r();
|
|
bool query(std::string p_name, GenericVector sexps = R_NilValue,
|
|
std::string p_module = "user");
|
|
bool more();
|
|
bool done();
|
|
SEXP peek(int i);
|
|
bool compile(std::string s);
|
|
bool library(std::string s);
|
|
};
|
|
|
|
yap4r::yap4r() {
|
|
YAPEngineArgs *yargs = new YAPEngineArgs();
|
|
yap = new YAPEngine(yargs);
|
|
};
|
|
|
|
bool yap4r::query(std::string p_name, GenericVector sexps,
|
|
std::string p_module) {
|
|
if (q) {
|
|
q->close();
|
|
q = nullptr;
|
|
}
|
|
yhandle_t t;
|
|
arity_t arity;
|
|
if (sexps.isNULL()) {
|
|
YAPTerm qt = YAPAtomTerm(p_name.c_str());
|
|
q = new YAPQuery(qt);
|
|
t = qt.handle();
|
|
} else {
|
|
arity = sexps.length();
|
|
std::vector<YAPTerm> args = std::vector<YAPTerm>();
|
|
yhandle_t sls = Yap_NewHandles(sexps.length());
|
|
for (int i = 0; i < sexps.length(); i++) {
|
|
if (!sexp_to_pl(sls + i, sexps[i]))
|
|
return false;
|
|
args.push_back(YAPTerm(Yap_GetFromSlot(sls + i)));
|
|
}
|
|
YAPFunctor f = YAPFunctor(p_name.c_str(), arity);
|
|
YAPAtomTerm mod = YAPAtomTerm(p_module.c_str());
|
|
t = YAPApplTerm(p_name.c_str(), args.data()).handle();
|
|
q = new YAPQuery(f, mod, args.data());
|
|
}
|
|
if (q == nullptr)
|
|
return false;
|
|
bool rc = q->next();
|
|
if (!rc) {
|
|
failed = true;
|
|
q = nullptr;
|
|
}
|
|
if (rc)
|
|
qsexp = term_to_sexp(t, false);
|
|
|
|
return rc;
|
|
}
|
|
|
|
bool yap4r::compile(std::string s) {
|
|
YAPTerm fs[1];
|
|
fs[0] = YAPAtomTerm(s.c_str());
|
|
return yap->mgoal(YAPApplTerm("compile", fs).term(), USER_MODULE);
|
|
}
|
|
bool yap4r::library(std::string s) {
|
|
YAPTerm fs[1], l[1];
|
|
l[0] = YAPAtomTerm(s.c_str());
|
|
fs[0] = YAPApplTerm("library", l);
|
|
return yap->mgoal(YAPApplTerm("compile", fs).term(), USER_MODULE);
|
|
}
|
|
|
|
bool yap4r::more() {
|
|
bool rc = true;
|
|
if (failed)
|
|
return false;
|
|
if (q)
|
|
rc = q->next();
|
|
if (!rc) {
|
|
failed = true;
|
|
}
|
|
return rc;
|
|
}
|
|
|
|
bool yap4r::done() {
|
|
|
|
if (failed)
|
|
return false;
|
|
if (q)
|
|
q->cut();
|
|
q = NULL;
|
|
return true;
|
|
}
|
|
|
|
SEXP yap4r::peek(int i) {
|
|
if (failed || q == nullptr)
|
|
return R_MissingArg;
|
|
if (i == 0)
|
|
return qsexp;
|
|
return term_to_sexp(Yap_InitSlot(Yap_XREGS[i]), false);
|
|
}
|
|
|
|
RCPP_MODULE(mod_yap4r) {
|
|
class_<yap4r>("yap4r")
|
|
.constructor("create an object encapsulating a Prolog engine")
|
|
.method("query", &yap4r::query,
|
|
"create an active query within the engine")
|
|
.method("more", &yap4r::more, "ask for an extra solution")
|
|
.method("done", &yap4r::done, "terminate the query")
|
|
.method("compile", &yap4r::compile, "compile the file")
|
|
.method("library", &yap4r::library, "compile the library")
|
|
.method("peek", &yap4r::peek, "load arg[i] into R");
|
|
}
|