diogo/yap-6.3
Archived
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

;Merge ../../yap-6.3

Browse Source
This commit is contained in:
Vitor Santos Costa
2018-06-15 13:50:55 +01:00
parent 521a5df611 d2024c1aed
commit a4dd2efbe7
3178 changed files with 59028 additions and 67702 deletions
Download Patch File Download Diff File Expand all files Collapse all files

8
CXX/CMakeLists.txt
View File

@@ -5,7 +5,7 @@ set(SO_MINOR 0)
set(SO_PATCH 0)
set (CXX_SOURCES
yapi.cpp
yapi.cpp
)
list(APPEND LIBYAP_SOURCES ${CXX_SOURCES} PARENT_SCOPE)
@@ -15,7 +15,11 @@ if ( WIN32 OR ANDROID)
set_property( DIRECTORY APPEND PROPERTY COMPILE_DEFINITIONS "_YAP_NOT_INSTALLED_=1;HAVE_CONFIG_H=1;_GNU_SOURCE;YAP_KERNEL=1" )
else()
add_lib(YAP++ ${CXX_SOURCES} )
target_link_libraries(YAP++ ${CMAKE_DL_LIBS} libYap)
if (WITH_PYTHON)
target_link_libraries(YAP++ Py4YAP )
endif()
target_link_libraries(YAP++ ${CMAKE_DL_LIBS} libYap)
MY_install(TARGETS YAP++
LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}

74
CXX/yapdb.hh
View File

@@ -90,7 +90,7 @@ protected:
/// auxiliary routine to find a predicate in the current module.
/// auxiliary routine to find a predicate in the current module.
PredEntry *getPred(YAPTerm &t, CELL *& outp);
PredEntry *getPred(Term &t, CELL *& outp);
PredEntry *asPred() { return ap; };
@@ -99,43 +99,36 @@ protected:
/// Just do nothing.
inline YAPPredicate() {
}
/// String constructor for predicates
///
/// It also communicates the array of arguments t[]
/// and the array of variables
/// back to yapquery
YAPPredicate(const char *s0, Term &tout, Term &tnames) {
CACHE_REGS
Term *modp = NULL;
const unsigned char *us = (const unsigned char *)s0;
tnames = MkVarTerm();
tout =
Yap_BufferToTermWithPrioBindings(us, TermNil, tnames, strlen(s0), 1200);
// fprintf(stderr,"ap=%p arity=%d text=%s", ap, ap->ArityOfPE, s);
// Yap_DebugPlWrite(out);
if (tout == 0L) {
Yap_ThrowError(TYPE_ERROR_PREDICATE_INDICATOR, MkStringTerm(s0), "YAPPredicate");
}
YAPTerm tt = YAPTerm(tout);
ap = getPred(tt, modp);
}
YAPPredicate(Term &t, Term &tmod, CELL * &ts, const char *pname);
YAPPredicate(Term &to, Term &tmod, CELL * &ts, const char *pname);
/// Term constructor for predicates
///
/// It is just a call to getPred
inline YAPPredicate(Term t) {
CELL *v = nullptr;
YAPTerm tt = YAPTerm(t);
ap = getPred(tt, v);
inline YAPPredicate(Term t, CELL *&v) {
if (t) {
ap = getPred(t, v);
}
}
inline YAPPredicate(Term t) {
if (t) {
CELL *v = nullptr;
ap = getPred(t, v);
}
}
/// Term constructor for predicates
///
/// It is just a call to getPred
inline YAPPredicate(YAPTerm t) {
CELL *v = nullptr;
ap = getPred(t, v);
inline YAPPredicate(YAPTerm t, CELL *&v) {
Term tp = t.term();
ap = getPred(tp, v);
}
inline YAPPredicate(YAPTerm t) {
CELL *v = nullptr;
Term tp = t.term();
ap = getPred(tp, v);
}
/// Cast constructor for predicates,
@@ -152,6 +145,28 @@ protected:
public:
/// String constructor for predicates
///
/// It also communicates the array of arguments t[]
/// and the array of variables
/// back to yapquery
YAPPredicate(const char *s0, Term &tout, Term &tnames, CELL *&nts) {
CACHE_REGS
const char *s = (const char *)s0;
tnames = MkVarTerm();
tout =
Yap_BufferToTermWithPrioBindings(s, TermNil, tnames, strlen(s0), 1200);
// fprintf(stderr,"ap=%p arity=%d text=%s", ap, ap->ArityOfPE, s);
// Yap_DebugPlWrite(out);
if (tout == 0L) {
throw YAPError();
}
ap = getPred(tout, nts);
tout = Yap_SaveTerm(tout);
tnames = Yap_SaveTerm(tnames);
}
/// Functor constructor for predicates
///
/// Asssumes that we use the current module.
@@ -176,6 +191,7 @@ public:
///
YAPPredicate(YAPAtom at);
/// Mod:Name/Arity constructor for predicates.
///
inline YAPPredicate(YAPAtom at, uintptr_t arity, YAPModule mod) {

676
CXX/yapi.cpp
View File

@@ -1,5 +1,4 @@
#define _EXPORT_KERNEL 1
#include "yapi.hh"
@@ -10,8 +9,12 @@ extern "C" {
#include "android/log.h"
#endif
#include "YapInterface.h"
#if YAP_PYTHON
#include "Python.h"
#endif
#include "YapBlobs.h"
#include "YapInterface.h"
#include "iopreds.h"
X_API char *Yap_TermToBuffer(Term t, encoding_t encodingp, int flags);
@@ -25,48 +28,89 @@ X_API void YAP_UserBackCPredicate(const char *, YAP_UserCPred, YAP_UserCPred,
#if YAP_PYTHON
X_API bool do_init_python(void);
#endif
}
static void YAPCatchError()
{
if (LOCAL_CommittedError != nullptr &&
LOCAL_CommittedError->errorNo != YAP_NO_ERROR ) {
// Yap_PopTermFromDB(info->errorTerm);
// throw throw YAPError( );
Term es[2];
es[0] = TermError;
es[1] = MkErrorTerm(LOCAL_CommittedError);
Functor f = Yap_MkFunctor(Yap_LookupAtom("print_message"), 2);
YAP_RunGoalOnce(Yap_MkApplTerm(f, 2, es));
// Yap_PopTermFromDB(info->errorTerm);
// throw throw YAPError( SOURCE(), );
}
}
YAPPredicate::YAPPredicate(Term &t, Term &tmod, CELL * &ts, const char *pname) {
Term t0 = t;
ap = nullptr;
restart:
if (IsVarTerm(t)) {
Yap_Error(INSTANTIATION_ERROR, t0, pname);
} else if (IsAtomTerm(t)) {
ap = RepPredProp(Yap_GetPredPropByAtom(AtomOfTerm(t), tmod));
ts = nullptr;
} else if (IsIntegerTerm(t) && tmod == IDB_MODULE) {
ts = nullptr;
ap = Yap_FindLUIntKey(IntegerOfTerm(t));
} else if (IsPairTerm(t)) {
t = Yap_MkApplTerm(FunctorCsult, 1, &t);
goto restart;
} else if (IsApplTerm(t)) {
Functor fun = FunctorOfTerm(t);
if (IsExtensionFunctor(fun)) {
Yap_Error(TYPE_ERROR_CALLABLE, Yap_PredicateIndicator(t, tmod), pname);
}
if (fun == FunctorModule) {
tmod = ArgOfTerm(1, t);
if (IsVarTerm(tmod)) {
Yap_Error(INSTANTIATION_ERROR, t0, pname);
}
if (!IsAtomTerm(tmod)) {
Yap_Error(TYPE_ERROR_ATOM, t0, pname);
}
t = ArgOfTerm(2, t);
goto restart;
}
ap = RepPredProp(Yap_GetPredPropByFunc(fun, tmod));
ts = RepAppl(t)+1;
} else {
Yap_Error(TYPE_ERROR_CALLABLE, t0, pname);
YAPPredicate::YAPPredicate(Term &t, Term &tmod, CELL *&ts, const char *pname) {
Term t0 = t;
ap = nullptr;
restart:
if (IsVarTerm(t)) {
throw YAPError(SOURCE(), INSTANTIATION_ERROR, t0, pname);
} else if (IsAtomTerm(t)) {
ap = RepPredProp(Yap_GetPredPropByAtom(AtomOfTerm(t), tmod));
ts = nullptr;
} else if (IsIntegerTerm(t) && tmod == IDB_MODULE) {
ts = nullptr;
ap = Yap_FindLUIntKey(IntegerOfTerm(t));
} else if (IsPairTerm(t)) {
t = Yap_MkApplTerm(FunctorCsult, 1, &t);
goto restart;
} else if (IsApplTerm(t)) {
Functor fun = FunctorOfTerm(t);
if (IsExtensionFunctor(fun)) {
throw YAPError(SOURCE(), TYPE_ERROR_CALLABLE,
Yap_PredicateIndicator(t, tmod), pname);
}
if (fun == FunctorModule) {
tmod = ArgOfTerm(1, t);
if (IsVarTerm(tmod)) {
throw YAPError(SOURCE(), INSTANTIATION_ERROR, t0, pname);
}
if (!IsAtomTerm(tmod)) {
throw YAPError(SOURCE(), TYPE_ERROR_ATOM, t0, pname);
}
t = ArgOfTerm(2, t);
goto restart;
}
ap = RepPredProp(Yap_GetPredPropByFunc(fun, tmod));
ts = RepAppl(t) + 1;
} else {
throw YAPError(SOURCE(), TYPE_ERROR_CALLABLE, t0, pname);
}
}
YAPAtomTerm::YAPAtomTerm(char *s) { // build string
Term YAPTerm::getArg(arity_t i) {
BACKUP_MACHINE_REGS();
Term tf = 0;
Term t0 = gt();
if (IsApplTerm(t0)) {
if (i > ArityOfFunctor(FunctorOfTerm(t0)))
throw YAPError(SOURCE(), DOMAIN_ERROR_OUT_OF_RANGE, t0, "t0.getArg()");
tf = (ArgOfTerm(i, t0));
} else if (IsPairTerm(t0)) {
if (i == 1)
tf = (HeadOfTerm(t0));
else if (i == 2)
tf = (TailOfTerm(t0));
else
throw YAPError(SOURCE(), DOMAIN_ERROR_OUT_OF_RANGE, t0, "t0.getArg()");
} else {
throw YAPError(SOURCE(), TYPE_ERROR_COMPOUND, t0, "t0.getArg()");
}
RECOVER_MACHINE_REGS();
return tf;
}
YAPAtomTerm::YAPAtomTerm(char s[]) { // build string
BACKUP_H();
CACHE_REGS
@@ -226,23 +270,23 @@ YAPApplTerm::YAPApplTerm(YAPFunctor f) : YAPTerm() {
Term &YAPTerm::operator[](arity_t i) {
BACKUP_MACHINE_REGS();
Term t0 = gt();
Term tf = 0;
Term *tf = nullptr;
if (IsApplTerm(t0)) {
// Functor f = FunctorOfTerm(t0);
// if (IsExtensionFunctor(f))
// return 0;
tf = RepAppl(t0)[(i + 1)];
tf = RepAppl(t0) + (i + 1);
} else if (IsPairTerm(t0)) {
if (i == 0)
tf = HeadOfTerm(t0);
tf = RepPair(t0);
else if (i == 1)
tf = TailOfTerm(t0);
tf = RepPair(t0) + 1;
RECOVER_MACHINE_REGS();
tf = RepPair(tf)[i];
} else {
throw YAPError(SOURCE(), TYPE_ERROR_COMPOUND, t0, "");
}
RECOVER_MACHINE_REGS();
Yap_Error(TYPE_ERROR_COMPOUND, tf, "");
throw YAPError();
return *tf;
}
Term &YAPListTerm::operator[](arity_t i) {
@@ -251,6 +295,7 @@ Term &YAPListTerm::operator[](arity_t i) {
Term tf = 0;
while (IsPairTerm(t0)) {
if (i == 0) {
tf = HeadOfTerm(t0);
break;
} else {
@@ -275,6 +320,23 @@ YAPPairTerm::YAPPairTerm() {
RECOVER_H();
}
std::vector<Term> YAPPairTerm::listToArray() {
Term *tailp;
Term t1 = gt();
Int l = Yap_SkipList(&t1, &tailp);
if (l < 0) {
throw YAPError(SOURCE(), TYPE_ERROR_LIST, (t), nullptr);
}
std::vector<Term> o = std::vector<Term>(l);
int i = 0;
Term t = gt();
while (t != TermNil) {
o[i++] = HeadOfTerm(t);
t = TailOfTerm(t);
}
return o;
}
YAP_tag_t YAPTerm::tag() {
Term tt = gt();
if (IsVarTerm(tt)) {
@@ -329,6 +391,16 @@ Term YAPTerm::deepCopy() {
return (tn);
}
Term YAPListTerm::cdr() {
Term to = gt();
if (IsPairTerm(to))
return (TailOfTerm(to));
else if (to == TermNil)
return TermNil;
/* error */
throw YAPError(SOURCE(), TYPE_ERROR_LIST, to, "");
}
Term YAPListTerm::dup() {
yhandle_t tn;
BACKUP_MACHINE_REGS();
@@ -376,9 +448,8 @@ Term YAPListTerm::car() {
if (IsPairTerm(to))
return (HeadOfTerm(to));
else {
Yap_Error(TYPE_ERROR_LIST, to, "");
return 0;
throw YAPError();
throw YAPError(SOURCE(), TYPE_ERROR_LIST, to, "");
return TermUnique;
}
}
@@ -405,103 +476,89 @@ const char *YAPAtom::getName(void) { return Yap_AtomToUTF8Text(a); }
void YAPQuery::openQuery() {
CACHE_REGS
if (ap == NULL || ap->OpcodeOfPred == UNDEF_OPCODE) {
if (ap == NULL || ap->OpcodeOfPred == UNDEF_OPCODE) {
ap = rewriteUndefQuery();
}
setNext();
}
bool YAPEngine::call(YAPPredicate ap, YAPTerm ts[]) {
sigjmp_buf *oj = LOCAL_RestartEnv, buf;
try {
CACHE_REGS
if (ap.ap == NULL)
return false;
BACKUP_MACHINE_REGS();
arity_t arity = ap.getArity();
bool result;
YAP_dogoalinfo q;
CACHE_REGS
if (ap.ap == NULL)
return false;
BACKUP_MACHINE_REGS();
arity_t arity = ap.getArity();
bool result;
YAP_dogoalinfo q;
for (arity_t i = 0; i < arity; i++)
XREGS[i + 1] = ts[i].term();
q.CurSlot = Yap_StartSlots();
q.p = P;
q.CurSlot = Yap_StartSlots();
q.p = P;
q.cp = CP;
for (arity_t i = 0; i < arity; i++)
XREGS[i + 1] = ts[i].term();
q.cp = CP;
// allow Prolog style exceotion handling
LOCAL_RestartEnv = &buf;
if (sigsetjmp(*LOCAL_RestartEnv, false)) {
return 0;
throw YAPError();
}
// don't forget, on success these bindings will still be there);
result = YAP_LeaveGoal(false, &q);
Yap_CloseHandles(q.CurSlot);
LOCAL_RestartEnv = oj;
RECOVER_MACHINE_REGS();
return result;
} catch (YAPError e) {
YAP_LeaveGoal(false, &q);
Yap_CloseHandles(q.CurSlot);
std::cerr << "Exception received by "
<< YAPApplTerm(ap.functor(), ts).text() << ".\n Forwarded...\n\n";
LOCAL_RestartEnv = oj;
return 0;
throw e;
}
// allow Prolog style exceotion handling
// don't forget, on success these bindings will still be there);
result = YAP_LeaveGoal(true, &q);
YAPCatchError();
Yap_CloseHandles(q.CurSlot);
pop_text_stack(q.lvl+1);
RECOVER_MACHINE_REGS();
return result;
}
bool YAPEngine::mgoal(Term t, Term tmod) {
sigjmp_buf buf, *oldp = LOCAL_RestartEnv;
try {
CACHE_REGS
BACKUP_MACHINE_REGS();
Term *ts = nullptr;
if (IsStringTerm(tmod))
tmod = MkAtomTerm(Yap_LookupAtom(StringOfTerm(tmod)));
PredEntry *ap = (new YAPPredicate(t, tmod, ts, "C++"))->ap;
if (ap == nullptr || ap->OpcodeOfPred == UNDEF_OPCODE) {
bool YAPEngine::mgoal(Term t, Term tmod, bool release) {
#if YAP_PYTHON
// PyThreadState *_save;
//std::cerr << "mgoal " << YAPTerm(t).text() << "\n";
// _save = PyEval_SaveThread();
#endif
CACHE_REGS
BACKUP_MACHINE_REGS();
Term *ts = nullptr;
q.CurSlot = Yap_StartSlots();
q.p = P;
q.cp = CP;
PredEntry *ap = nullptr;
if (IsStringTerm(tmod))
tmod = MkAtomTerm(Yap_LookupAtom(StringOfTerm(tmod)));
YAPPredicate *p = new YAPPredicate(t, tmod, ts, "C++");
if (p == nullptr || (ap = p->ap) == nullptr ||
ap->OpcodeOfPred == UNDEF_OPCODE) {
ap = rewriteUndefEngineQuery(ap, t, tmod);
}
if (IsApplTerm(t)) ts = RepAppl(t)+1;
else if (IsPairTerm(t)) ts = RepPair(t);
if (IsApplTerm(t))
ts = RepAppl(t) + 1;
else if (IsPairTerm(t))
ts = RepPair(t);
/* legal ap */
arity_t arity = ap->ArityOfPE;
for (arity_t i = 0; i < arity; i++) {
XREGS[i + 1] = ts[i];
for (arity_t i = 0; i < arity; i++) {
XREGS[i + 1] = ts[i];
}
ts = nullptr;
ts = nullptr;
bool result;
q.CurSlot = Yap_StartSlots();
q.p = P;
q.cp = CP;
// allow Prolog style exception handling
LOCAL_RestartEnv = &buf;
if (sigsetjmp(*LOCAL_RestartEnv, false)) {
return false;
//throw YAPError();
}
// don't forget, on success these guys may create slots
__android_log_print(ANDROID_LOG_INFO, "YAPDroid", "exec ");
result = (bool)YAP_EnterGoal(ap, nullptr, &q);
{
YAP_LeaveGoal(false, &q);
LOCAL_RestartEnv = oldp;
YAP_LeaveGoal(result && !release, &q);
// PyEval_RestoreThread(_save);
RECOVER_MACHINE_REGS();
return result;
}
} catch (YAPError e) {
YAP_LeaveGoal(false, &q);
Yap_CloseHandles(q.CurSlot);
LOCAL_RestartEnv = oldp;
return 0;
//throw e;
}
}
/**
* called when a query must be terminated and its state fully recovered,
* @type {[type]}
*/
void YAPEngine::release() {
BACKUP_MACHINE_REGS();
@@ -511,81 +568,56 @@ void YAPEngine::release() {
Term YAPEngine::fun(Term t) {
CACHE_REGS
try {
BACKUP_MACHINE_REGS();
Term tmod = CurrentModule, *ts = nullptr;
PredEntry *ap;
arity_t arity;
Functor f;
Atom name;
BACKUP_MACHINE_REGS();
Term tmod = CurrentModule, *ts = nullptr;
PredEntry *ap;
arity_t arity;
Functor f;
Atom name;
if (IsApplTerm(t)) {
ts = RepAppl(t) + 1;
f = (Functor)ts[-1];
name = NameOfFunctor(f);
arity = ArityOfFunctor(f);
for (arity_t i = 0; i < arity; i++)
XREGS[i + 1] = ts[i];
} else if (IsAtomTerm(t)) {
name = AtomOfTerm(t);
f = nullptr;
arity = 0;
} else if (IsPairTerm(t)) {
XREGS[1] = ts[0];
XREGS[2] = ts[1];
arity = 2;
name = AtomDot;
f = FunctorDot;
} else {
Yap_ThrowError(TYPE_ERROR_CALLABLE, t, 0);
return 0L;
}
XREGS[arity + 1] = MkVarTerm();
arity++;
f = Yap_MkFunctor(name, arity);
ap = (PredEntry *)(PredPropByFunc(f, tmod));
if (ap == nullptr || ap->OpcodeOfPred == UNDEF_OPCODE) {
Term g = (Yap_MkApplTerm(f, arity, ts));
ap = rewriteUndefEngineQuery(ap, g, (ap->ModuleOfPred));
}
q.CurSlot = Yap_StartSlots();
q.p = P;
q.cp = CP;
// make sure this is safe
yhandle_t o = Yap_InitHandle(XREGS[arity]);
// allow Prolog style exception handling
sigjmp_buf buf, *oldp = LOCAL_RestartEnv;
LOCAL_RestartEnv = &buf;
if (sigsetjmp(*LOCAL_RestartEnv, false)) {
// throw YAPError();
LOCAL_RestartEnv = oldp;
RECOVER_MACHINE_REGS();
return 0;
}
// don't forget, on success these guys may create slots
__android_log_print(ANDROID_LOG_INFO, "YAPDroid", "exec ");
if (IsApplTerm(t)) {
ts = RepAppl(t) + 1;
f = (Functor)ts[-1];
name = NameOfFunctor(f);
arity = ArityOfFunctor(f);
for (arity_t i = 0; i < arity; i++)
XREGS[i + 1] = ts[i];
} else if (IsAtomTerm(t)) {
name = AtomOfTerm(t);
f = nullptr;
arity = 0;
} else if (IsPairTerm(t)) {
XREGS[1] = ts[0];
XREGS[2] = ts[1];
arity = 2;
name = AtomDot;
f = FunctorDot;
} else {
throw YAPError(SOURCE(), TYPE_ERROR_CALLABLE, t, 0);
return 0L;
}
XREGS[arity + 1] = MkVarTerm();
arity++;
f = Yap_MkFunctor(name, arity);
ap = (PredEntry *)(PredPropByFunc(f, tmod));
if (ap == nullptr || ap->OpcodeOfPred == UNDEF_OPCODE) {
Term g = (Yap_MkApplTerm(f, arity, ts));
ap = rewriteUndefEngineQuery(ap, g, (ap->ModuleOfPred));
}
q.CurSlot = Yap_StartSlots();
q.p = P;
q.cp = CP;
// make sure this is safe
// allow Prolog style exception handling
__android_log_print(ANDROID_LOG_INFO, "YAPDroid", "exec ");
if (YAP_EnterGoal(ap, nullptr, &q) == 0) {
#if DEBUG
fprintf(stderr, "function call failed:\n");
#endif
LOCAL_RestartEnv = oldp;
return 0;
}
DBTerm *pt = Yap_StoreTermInDB(Yap_GetFromSlot(o), arity);
__android_log_print(ANDROID_LOG_INFO, "YAPDroid", "out %d", o);
YAP_LeaveGoal(false, &q);
Yap_CloseHandles(q.CurSlot);
Term rc = Yap_PopTermFromDB(pt);
LOCAL_RestartEnv = oldp;
bool result = (bool)YAP_EnterGoal(ap, nullptr, &q);
YAPCatchError();
{
YAP_LeaveGoal(result, &q);
// PyEval_RestoreThread(_save);
RECOVER_MACHINE_REGS();
return rc;
} catch (YAPError e) {
YAP_LeaveGoal(false, &q);
Yap_CloseHandles(q.CurSlot);
std::cerr << "Exception received by " << __func__ << "( "
<< YAPTerm(t).text() << ").\n Forwarded...";
throw e;
return result;
}
}
@@ -594,7 +626,6 @@ YAPQuery::YAPQuery(YAPFunctor f, YAPTerm mod, YAPTerm ts[])
/* ignore flags for now */
BACKUP_MACHINE_REGS();
Term *nts;
Term goal;
if (ts) {
@@ -608,7 +639,7 @@ YAPQuery::YAPQuery(YAPFunctor f, YAPTerm mod, YAPTerm ts[])
goal = MkVarTerm();
}
openQuery();
names = YAPPairTerm(TermNil);
names = TermNil;
RECOVER_MACHINE_REGS();
}
@@ -616,9 +647,8 @@ YAPQuery::YAPQuery(YAPFunctor f, YAPTerm mod, YAPTerm ts[])
YAPQuery::YAPQuery(YAPFunctor f, YAPTerm ts[]) : YAPPredicate(f) {
/* ignore flags for now */
BACKUP_MACHINE_REGS();
CELL *nts;
if (ts) {
goal = YAPApplTerm(f, nts);
goal = YAPApplTerm(f, nts);
} else {
goal = YAPVarTerm();
nts = nullptr;
@@ -629,126 +659,73 @@ YAPQuery::YAPQuery(YAPFunctor f, YAPTerm ts[]) : YAPPredicate(f) {
}
#endif
YAPQuery::YAPQuery(YAPTerm t) : YAPPredicate(t) {
BACKUP_MACHINE_REGS();
CELL *nts;
Term tt = t.term();
if (IsPairTerm(tt)) {
nts = RepPair(tt);
tt = Yap_MkApplTerm(FunctorCsult, 1, nts);
}
goal = *new YAPTerm(tt);
if (IsApplTerm(tt)) {
Functor f = FunctorOfTerm(tt);
if (!IsExtensionFunctor(f)) {
nts = nullptr;
arity_t arity = ArityOfFunctor(f);
if (arity) {
nts = RepAppl(tt) + 1;
for (arity_t i = 0; i < arity; i++)
XREGS[i + 1] = nts[i];
}
}
}
openQuery();
names = YAPPairTerm(TermNil);
RECOVER_MACHINE_REGS();
}
YAPQuery::YAPQuery(YAPPredicate p, YAPTerm ts[]) : YAPPredicate(p.ap) {
BACKUP_MACHINE_REGS();
arity_t arity = p.ap->ArityOfPE;
try {
arity_t arity = p.ap->ArityOfPE;
if (arity) {
goal = YAPApplTerm(YAPFunctor(p.ap->FunctorOfPred), ts).term();
for (arity_t i = 0; i < arity; i++)
XREGS[i + 1] = ts[i].term();
openQuery();
} else {
goal = YAPAtomTerm((Atom)(p.ap->FunctorOfPred));
goal = MkAtomTerm((Atom)(p.ap->FunctorOfPred));
openQuery();
}
names = TermNil;
RECOVER_MACHINE_REGS();
} catch (...) {
}
RECOVER_MACHINE_REGS();
}
bool YAPQuery::next() {
CACHE_REGS
bool result = false;
//std::cerr << "next " << YAPTerm(goal).text() << "\n";
sigjmp_buf buf, *oldp = LOCAL_RestartEnv;
Term terr;
try {
BACKUP_MACHINE_REGS();
if (!q_open)
return false;
LOCAL_RestartEnv = &buf;
if (sigsetjmp(*LOCAL_RestartEnv, false)) {
// throw YAPError();
return false;
}
// don't forget, on success these guys may create slots
__android_log_print(ANDROID_LOG_INFO, "YAPDroid", "exec ");
e = nullptr;
BACKUP_MACHINE_REGS();
if (!q_open)
return false;
LOCAL_RestartEnv = &buf;
// don't forget, on success these guys may create slots
__android_log_print(ANDROID_LOG_INFO, "YAPDroid", "exec ");
if (q_state == 0) {
result = (bool)YAP_EnterGoal(ap, nullptr, &q_h);
} else {
LOCAL_AllowRestart = q_open;
result = (bool)YAP_RetryGoal(&q_h);
}
if (result) {
__android_log_print(ANDROID_LOG_INFO, "YAPDroid", "vnames %d %s %d",
q_state, names.text(), LOCAL_CurSlot);
} else {
__android_log_print(ANDROID_LOG_INFO, "YAPDroid", "fail");
}
q_state = 1;
if ((terr = Yap_GetException())) {
if ((terr = Yap_GetException())) {
LOCAL_RestartEnv = &buf;
throw YAPError();
}
}
__android_log_print(ANDROID_LOG_INFO, "YAPDroid", "out %d", result);
if (!result) {
YAP_LeaveGoal(false, &q_h);
Yap_CloseHandles(q_handles);
q_open = false;
} else {
q_handles = Yap_StartSlots();
}
RECOVER_MACHINE_REGS();
LOCAL_RestartEnv = oldp;
return result;
} catch (YAPError e) {
q_open = false;
Yap_PopTermFromDB(LOCAL_ActiveError->errorTerm);
memset(LOCAL_ActiveError, 0, sizeof(*LOCAL_ActiveError));
YAP_LeaveGoal(false, &q_h);
Yap_CloseHandles(q_handles);
q_open = false;
std::cerr << "Exception received by " << __func__ << "( "
<< YAPTerm(terr).text() << ").\n Forwarded...\n\n";
LOCAL_RestartEnv = oldp;
throw e;
if (q_state == 0) {
result = (bool)YAP_EnterGoal(ap, nullptr, &q_h);
} else {
LOCAL_AllowRestart = q_open;
result = (bool)YAP_RetryGoal(&q_h);
}
q_state = 1;
__android_log_print(ANDROID_LOG_INFO, "YAPDroid", "out %d", result);
if (!result) {
YAP_LeaveGoal(result, &q_h);
q_open = false;
}
YAPCatchError();
RECOVER_MACHINE_REGS();
LOCAL_RestartEnv = oldp;
return result;
}
PredEntry *YAPQuery::rewriteUndefQuery() {
ARG1 = goal.term();
goal = YAPApplTerm(FunctorMetaCall, &ARG1);
Term ts[2];
ts[0] = CurrentModule;
ts[1] = goal;
ARG1 = goal = Yap_SaveTerm(Yap_MkApplTerm(FunctorCall
, 1, &goal));
return ap = PredCall;
}
PredEntry *YAPEngine::rewriteUndefEngineQuery(PredEntry *a, Term &tgoal,
Term mod) {
Term ts[2];
ts[0] = mod;
ts[1] = tgoal;
ARG1 = tgoal = Yap_MkApplTerm(FunctorModule, 2, ts);
//goal = YAPTerm(Yap_MkApplTerm(FunctorMetaCall, 1, &ARG1));
tgoal = Yap_MkApplTerm(FunctorCall, 1, &tgoal);
return PredCall;
// return YAPApplTerm(FunctorUndefinedQuery, ts);
}
@@ -758,7 +735,7 @@ void YAPQuery::cut() {
BACKUP_MACHINE_REGS();
if (!q_open || q_state == 0)
return;
YAP_LeaveGoal(FALSE, &q_h);
YAP_LeaveGoal(true, &q_h);
q_open = false;
// LOCAL_execution = this;
RECOVER_MACHINE_REGS();
@@ -787,7 +764,7 @@ void YAPQuery::close() {
RECOVER_MACHINE_REGS();
return;
}
YAP_LeaveGoal(FALSE, &q_h);
YAP_LeaveGoal(false, &q_h);
q_open = 0;
Yap_CloseHandles(q_handles);
// LOCAL_execution = this;
@@ -845,13 +822,16 @@ void Yap_displayWithJava(int c) {
#endif
void YAPEngine::doInit(YAP_file_type_t BootMode, YAPEngineArgs *engineArgs) {
if ((BootMode = YAP_Init(engineArgs)) == YAP_FOUND_BOOT_ERROR) {
if (BootMode == YAP_FOUND_BOOT_ERROR) {
std::cerr << "Exception received by " << __func__ << "( "
<< "while booting"
<< ").\n Forwarded...\n\n";
return;
throw YAPError();
}
YAP_Init(engineArgs);
/* Begin preprocessor code */
/* live */
// yerror = YAPError();
// yerror = throw YAPError( SOURCE(), );
#if YAP_PYTHON
do_init_python();
#endif
@@ -894,38 +874,39 @@ YAPPredicate::YAPPredicate(YAPAtom at, uintptr_t arity) {
}
/// auxiliary routine to find a predicate in the current module.
PredEntry *YAPPredicate::getPred(YAPTerm &tt, CELL *&outp) {
PredEntry *YAPPredicate::getPred(Term &t, CELL *&out) {
CACHE_REGS
Term m = Yap_CurrentModule(), t = tt.term();
Term m = Yap_CurrentModule();
t = Yap_StripModule(t, &m);
if (IsVarTerm(t) || IsNumTerm(t)) {
if (IsVarTerm(t))
Yap_ThrowError(INSTANTIATION_ERROR, tt.term(), 0);
throw YAPError(SOURCE(), INSTANTIATION_ERROR, t, 0);
else if (IsNumTerm(t))
Yap_ThrowError(TYPE_ERROR_CALLABLE, tt.term(), 0);
throw YAPError();
throw YAPError(SOURCE(), TYPE_ERROR_CALLABLE, t, 0);
}
tt.put(t);
if (IsAtomTerm(t)) {
ap = RepPredProp(PredPropByAtom(AtomOfTerm(t), m));
outp = (Term *)NULL;
return ap;
} else if (IsPairTerm(t)) {
Term ts[2];
Term ts[2], *s = ( out ? out : ts );
Functor FunctorConsult = Yap_MkFunctor(Yap_LookupAtom("consult"), 1);
ts[1] = t;
ts[0] = m;
t = Yap_MkApplTerm(FunctorModule, 2, ts);
s[1] = t;
s[0] = m;
t = Yap_MkApplTerm(FunctorModule, 2, s);
t = Yap_MkApplTerm(FunctorConsult, 1, &t);
tt.put(t);
outp = RepAppl(t) + 1;
if (!out)
out = RepAppl(t) + 1;
}
Functor f = FunctorOfTerm(t);
if (IsExtensionFunctor(f)) {
Yap_ThrowError(TYPE_ERROR_CALLABLE, t, 0);
throw YAPError(SOURCE(), TYPE_ERROR_CALLABLE, t, 0);
} else {
ap = RepPredProp(PredPropByFunc(f, m));
outp = RepAppl(t) + 1;
if (out)
memcpy( out, RepAppl(t) + 1, ap->ArityOfPE*sizeof(CELL) );
else
out = RepAppl(t) + 1;
}
return ap;
}
@@ -985,73 +966,60 @@ void *YAPPrologPredicate::retractClause(YAPTerm skeleton, bool all) {
}
std::string YAPError::text() {
char buf[256];
std::string s = "";
if (LOCAL_ActiveError->errorFunction) {
s += LOCAL_ActiveError->errorFile;
return "Error";
#if 0
std::stringstream s;
s << "";
if (info->errorNo == YAP_NO_ERROR)
return 0;
if (info->errorFunction) {
s += info->errorFile;
s += ":";
sprintf(buf, "%ld", (long int)LOCAL_ActiveError->errorLine);
sprintf(buf, "%ld", (long int)info->errorLine);
s += buf;
s += ":0 in C-code";
}
if (LOCAL_ActiveError->prologPredLine) {
return s;
if (info->prologPredLine) {
s += "\n";
s += LOCAL_ActiveError->prologPredFile;
s += info->prologPredFile;
s += ":";
sprintf(buf, "%ld", (long int)LOCAL_ActiveError->prologPredLine);
s += buf; // std::to_string(LOCAL_ActiveError->prologPredLine) ;
// YAPIntegerTerm(LOCAL_ActiveError->prologPredLine).text();
s << info->prologPredLine;
// YAPIntegerTerm(info->prologPredLine).text();
s += ":0 ";
s += LOCAL_ActiveError->prologPredModule;
s += info->prologPredModule;
s += ":";
s += (LOCAL_ActiveError->prologPredName);
s += (info->prologPredName);
s += "/";
sprintf(buf, "%ld", (long int)LOCAL_ActiveError->prologPredArity);
s += // std::to_string(LOCAL_ActiveError->prologPredArity);
buf;
s << info->prologPredArity;
}
s += " error ";
if (LOCAL_ActiveError->classAsText != nullptr)
s += LOCAL_ActiveError->classAsText;
if (info->classAsText == nullptr)
info->classAsText = Yap_errorClassName(info->errorClass);
if (info->classAsText != nullptr)
s += info->classAsText;
s += ".";
s += LOCAL_ActiveError->errorAsText;
if (info->errorAsText == nullptr)
info->errorAsText = Yap_errorName(info->errorNo);
if (info->errorAsText != nullptr)
s += info->errorAsText;
s += ".\n";
if (LOCAL_ActiveError->errorTerm) {
Term t = Yap_PopTermFromDB(LOCAL_ActiveError->errorTerm);
if (t) {
s += "error term is: ";
s += YAPTerm(t).text();
s += "\n";
}
}
// printf("%s\n", s.c_str());
return s.c_str();
#endif
}
void YAPEngine::reSet() {
/* ignore flags for now */
BACKUP_MACHINE_REGS();
Yap_RebootHandles(worker_id);
while (B && B->cp_b)
B = B->cp_b;
if (B) {
P = FAILCODE;
Yap_exec_absmi(true, YAP_EXEC_ABSMI);
/* recover stack space */
HR = B->cp_h;
TR = B->cp_tr;
#ifdef DEPTH_LIMIT
DEPTH = B->cp_depth;
#endif /* DEPTH_LIMIT */
YENV = ENV = B->cp_env;
if (B && B->cp_b && B->cp_ap != NOCODE )
YAP_LeaveGoal(false, &q);
LOCAL_ActiveError->errorNo = YAP_NO_ERROR;
if (LOCAL_CommittedError) {
LOCAL_CommittedError->errorNo = YAP_NO_ERROR;
free(LOCAL_CommittedError );
LOCAL_CommittedError = NULL;
}
RECOVER_MACHINE_REGS();
}
YAPError::YAPError(yap_error_number id, YAPTerm culprit, std::string txt) {
ID = id;
goal = culprit.text();
info = txt;
}
Term YAPEngine::top_level(std::string s) {
@@ -1062,7 +1030,7 @@ Term YAPEngine::top_level(std::string s) {
ARG2 = tp;
ARG3 = MkVarTerm();
if (ARG1 == 0)
YAPError(SYNTAX_ERROR);
throw YAPError(SOURCE(), SYNTAX_ERROR, ARG1, "in input query");
YAPPredicate p = YAPPredicate(YAP_TopGoal());
YAPQuery *Q = new YAPQuery(p, 0);
Term ts[2];

18
CXX/yapi.hh
View File

@@ -15,7 +15,7 @@
/*!
*
* @ingroup fli_c_cx
* @ingroup fli_c_cxx
* @defgroup yap-cplus-interface An object oriented interface for YAP.
*
* @{
@@ -42,6 +42,14 @@ extern "C" {
#include <stddef.h>
#if YAP_PYTHON
#include <Python.h>
extern bool python_in_python;
#endif
#include "Yap.h"
#include "Yatom.h"
@@ -100,13 +108,6 @@ X_API extern void YAP_UserBackCutCPredicate(const char *name,
X_API extern YAP_Term YAP_ReadBuffer(const char *s, YAP_Term *tp);
#if YAP_PYTHON
#include <Python.h>
extern bool python_in_python;
#endif
}
@@ -120,6 +121,7 @@ class YAPModule;
class YAPError;
class YAPPredicate;
#include "yapa.hh"
#include "yapie.hh"

63
CXX/yapie.hh
View File

@@ -1,12 +1,12 @@
/**
* @file yapie.hh
*
* @defgroup yap-cplus-error-hanadlinge Errir Handling in the YAP interface.
* @defgroup yap-cplus-error-hanadlinge Error Handling in the YAP interface.
*
* @brief this is an attempt at supporting error
* @brief error handling in C++ and OO languages
*
* @ingroup yap-cplus-interface
* @tableofcontents
*
*
* @{
*
@@ -15,7 +15,7 @@
* YAP itself. One can also define one's own error objects.
*
* Errors will be thrown from the `C++` code, and may be processed in
* very different ways. The error object should provide as much data asa
* very different ways. The error object should provide as much data as
* possible.
*/
@@ -24,34 +24,65 @@
#define YAPIE_HH
class X_API YAPPPredicate;
class X_API YAPTerm;
/// take information on a Prolog error:
class X_API YAPError {
yap_error_number ID;
std::string goal, info;
int swigcode;
yap_error_descriptor_t *info;
public:
YAPError(){
//ID = LOCAL_ActiveError->errorNo;
/// wraps the default error descriptor
YAPError() {
info = LOCAL_ActiveError;
if (!info)
LOCAL_ActiveError = info = (yap_error_descriptor_t *)calloc( sizeof( yap_error_descriptor_t ), 1);
// if (info->errorNo != YAP_NO_ERROR) {};
//std::cerr << "Error detected" << info->errorNo << "\n";
}
/// if des != nullptr, wrap a preexisting error descriptor;
/// otherwise, generate a new one
YAPError(yap_error_descriptor_t *des) {
if (des)
info= des;
else info = (yap_error_descriptor_t *)calloc( sizeof( yap_error_descriptor_t ), 1);
// if (info->errorNo != YAP_NO_ERROR) {};
//std::cerr << "Error detected" << info->errorNo << "\n";
}
/// error handler object with initial data when receiving the error term
YAPError(yap_error_number id, YAPTerm culprit, std::string txt);
// YAPError( std::string file, std::string function, int lineno,
// yap_error_number id, YAPTerm culprit, std::string txt) {
// info = new yap_error_descriptor_t;
// Yap_MkErrorRecord(info, file.c_str(), function.c_str(), lineno, id, culprit.term(), txt.c_str());
//}
/// error handler object with initial data when receiving the error term
YAPError( const char * file, const char * function, int lineno,
yap_error_number id, YAP_Term culprit, const char * txt) {
info = (yap_error_descriptor_t *)calloc( sizeof( yap_error_descriptor_t ), 1);
Yap_MkErrorRecord(info, file, function, lineno, id, culprit, txt);
}
/// short version
#define SOURCE() __FILE__, __FUNCTION__, __LINE__
/// we just know the error number
/// exact error ID
yap_error_number getID() { return LOCAL_ActiveError->errorNo; };
yap_error_number getID() { return info->errorNo; };
/// class of error
yap_error_class_number getErrorClass() {
return Yap_errorClass(LOCAL_ActiveError->errorNo);
return Yap_errorClass(info->errorNo);
};
/// where in the code things happened;
const char *getFile() { return LOCAL_ActiveError->errorFile; };
const char *getFile() { return info->errorFile; };
/// predicate things happened;
Int getLine() { return LOCAL_ActiveError->errorLine; };
Int getLine() { return info->errorLine; };
/// the term that caused the bug
// YAPTerm getCulprit(LOCAL_ActiveError->errorFile){};
// YAPTerm getCulprit(info->errorFile){};
/// text describing the Error
std::string text();
};

65
CXX/yapq.hh
View File

@@ -42,10 +42,11 @@ class X_API YAPQuery : public YAPPredicate {
struct yami *q_p, *q_cp;
int q_flags;
YAP_dogoalinfo q_h;
YAPPairTerm names;
YAPTerm goal;
Term names;
Term goal;
CELL *nts;
// temporaries
Term tnames, tgoal;
YAPError *e;
inline void setNext() { // oq = LOCAL_execution;
// LOCAL_execution = this;
@@ -68,6 +69,7 @@ public:
goal = TermTrue;
openQuery();
};
inline ~YAPQuery() { close(); }
/// main constructor, uses a predicate and an array of terms
///
/// It is given a YAPPredicate _p_ , and an array of terms that must have at
@@ -91,31 +93,10 @@ public:
/// It is given a string, calls the parser and obtains a Prolog term that
/// should be a callable
/// goal.
inline YAPQuery(const char *s) : YAPPredicate(s, tgoal, tnames) {
CELL *qt = nullptr;
inline YAPQuery(const char *s) : YAPPredicate(s, goal, names, (nts = &ARG1)) {
__android_log_print(ANDROID_LOG_INFO, "YAPDroid", "got game %d",
LOCAL_CurSlot);
if (!ap)
return;
__android_log_print(ANDROID_LOG_INFO, "YAPDroid", "%s", names.text());
if (IsPairTerm(tgoal)) {
qt = RepPair(tgoal);
tgoal = Yap_MkApplTerm(FunctorCsult, 1, qt);
ap = RepPredProp(PredPropByFunc(FunctorCsult, TermProlog));
}
goal = YAPTerm(tgoal);
if (IsApplTerm(tgoal)) {
Functor f = FunctorOfTerm(tgoal);
if (!IsExtensionFunctor(f)) {
arity_t arity = ap->ArityOfPE;
if (arity) {
qt = RepAppl(tgoal) + 1;
for (arity_t i = 0; i < arity; i++)
XREGS[i + 1] = qt[i];
}
}
}
names = YAPPairTerm(tnames);
openQuery();
};
// inline YAPQuery() : YAPPredicate(s, tgoal, tnames)
@@ -132,7 +113,13 @@ public:
///
/// It i;
///};
YAPQuery(YAPTerm t);
/// build a query from a term
YAPQuery(YAPTerm t) : YAPPredicate((goal = t.term()),(nts=Yap_XREGS+1)) {
BACKUP_MACHINE_REGS();
openQuery();
names = TermNil ;
RECOVER_MACHINE_REGS();
}
/// set flags for query execution, currently only for exception handling
void setFlag(int flag) { q_flags |= flag; }
/// reset flags for query execution, currently only for exception handling
@@ -155,10 +142,10 @@ public:
void close();
/// query variables.
void cut();
Term namedVars() { return names.term(); };
Term namedVars() { return names; };
YAPPairTerm namedVarTerms() { return names; };
/// query variables, but copied out
std::vector<Term> namedVarsVector() { return names.listToArray(); };
std::vector<Term> namedVarsVector() { return YAPPairTerm(names).listToArray(); };
/// convert a ref to a binding.
YAPTerm getTerm(yhandle_t t);
/// simple YAP Query;
@@ -262,9 +249,9 @@ public:
inline const char *getPrologTopLevelGoal() { return PrologTopLevelGoal; };
inline void setHaltAfterConsult(bool fl) { HaltAfterConsult = fl; };
inline void setHaltAfterBoot(bool fl) { HaltAfterBoot = fl; };
inline bool getHaltAfterConsult() { return HaltAfterConsult; };
inline bool getHaltAfterBoot() { return HaltAfterBoot; };
inline void setFastBoot(bool fl) { FastBoot = fl; };
@@ -292,7 +279,8 @@ private:
YAPError yerror;
void doInit(YAP_file_type_t BootMode, YAPEngineArgs *cargs);
YAP_dogoalinfo q;
PredEntry *rewriteUndefEngineQuery(PredEntry *ap, Term &t, Term tmod);
YAPError e;
PredEntry *rewriteUndefEngineQuery(PredEntry *ap, Term &t, Term tmod);
public:
/// construct a new engine; may use a variable number of arguments
@@ -338,12 +326,17 @@ public:
/// current directory for the engine
bool call(YAPPredicate ap, YAPTerm ts[]);
/// current directory for the engine
bool goalt(YAPTerm Yt) { return Yt.term(); };
/// current directory for the engine
bool mgoal(Term t, Term tmod);
bool goal(YAPTerm Yt, YAPModule module, bool release=false)
{ return mgoal(Yt.term(),module.term(), release); };
/// ru1n a goal in a module.
///
/// By default, memory will only be fully
/// recovered on backtracking. The release option ensures
/// backtracking is called at the very end.
bool mgoal(Term t, Term tmod, bool release= false);
/// current directory for the engine
bool goal(Term t) { return mgoal(t, CurrentModule); }
bool goal(Term t, bool release=false) { return mgoal(t, CurrentModule, release); }
/// reset Prolog state
void reSet();
/// assune that there are no stack pointers, just release memory

79
CXX/yapt.hh
View File

@@ -195,29 +195,8 @@ public:
virtual bool isList() { return Yap_IsListTerm(gt()); } /// term is a list
/// extract the argument i of the term, where i in 1...arityvoid *Yap_RepStreamFromId(int sno)
virtual Term getArg(arity_t i) {
BACKUP_MACHINE_REGS();
Term tf = 0;
Term t0 = gt();
if (IsApplTerm(t0)) {
if (i > ArityOfFunctor(FunctorOfTerm(t0)))
YAPError(DOMAIN_ERROR_OUT_OF_RANGE, t0, "t0.getArg()");
tf = (ArgOfTerm(i, t0));
} else if (IsPairTerm(t0)) {
if (i == 1)
tf = (HeadOfTerm(t0));
else if (i == 2)
tf = (TailOfTerm(t0));
else
YAPError(DOMAIN_ERROR_OUT_OF_RANGE, t0, "t0.getArg()");
} else {
YAPError(TYPE_ERROR_COMPOUND, t0, "t0.getArg()");
}
RECOVER_MACHINE_REGS();
return tf;
}
virtual Term getArg(arity_t i);
/// extract the arity of the term
/// variables have arity 0
virtual inline arity_t arity() {
@@ -322,20 +301,27 @@ public:
RECOVER_MACHINE_REGS();
};
YAPApplTerm(YAPFunctor f, YAPTerm ts[]);
YAPApplTerm(const std::string s, std::vector<YAPTerm> ts);
YAPApplTerm(const std::string s, unsigned int arity) { mk(Yap_MkNewApplTerm(Yap_MkFunctor(Yap_LookupAtom(s.c_str()), arity), arity)); };
YAPApplTerm(const std::string s, std::vector<YAPTerm> ts);
YAPApplTerm(YAPFunctor f);
inline Functor functor() { return FunctorOfTerm(gt()); }
inline YAPFunctor getFunctor() { return YAPFunctor(FunctorOfTerm(gt())); }
Term getArg(arity_t i) {
BACKUP_MACHINE_REGS();
Term t0 = gt();
Term tf;
tf = ArgOfTerm(i, t0);
RECOVER_MACHINE_REGS();
return tf;
};
virtual bool isVar() { return false; } /// type check for unbound
Term getArg(arity_t i) {
BACKUP_MACHINE_REGS();
Term t0 = gt();
Term tf;
tf = ArgOfTerm(i, t0);
RECOVER_MACHINE_REGS();
return tf;
};
void putArg(int i, YAPTerm t) {
BACKUP_MACHINE_REGS();
Term t0 = gt();
RepAppl(t0)[i] = t.term();
RECOVER_MACHINE_REGS();
};
virtual bool isVar() { return false; } /// type check for unbound
virtual bool isAtom() { return false; } /// type check for atom
virtual bool isInteger() { return false; } /// type check for integer
virtual bool isFloat() { return false; } /// type check for floating-point
@@ -368,22 +354,7 @@ public:
YAPTerm car() { return YAPTerm(HeadOfTerm(gt())); }
bool nil() { return gt() == TermNil; }
YAPPairTerm cdr() { return YAPPairTerm(TailOfTerm(gt())); }
std::vector<Term> listToArray() {
Term *tailp;
Term t1 = gt();
Int l = Yap_SkipList(&t1, &tailp);
if (l < 0) {
throw YAPError(TYPE_ERROR_LIST, YAPTerm(t), "");
}
std::vector<Term> o = std::vector<Term>(l);
int i = 0;
Term t = gt();
while (t != TermNil) {
o[i++] = HeadOfTerm(t);
t = TailOfTerm(t);
}
return o;
}
std::vector<Term> listToArray();
};
/**
@@ -448,15 +419,7 @@ public:
/// Extract the tail elements of a list.
///
/// @param[in] the list
Term cdr() {
Term to = gt();
if (IsPairTerm(to))
return (TailOfTerm(to));
else if (to == TermNil)
return TermNil;
/* error */
throw YAPError(TYPE_ERROR_LIST, YAPTerm(to), "");
}
Term cdr();
/// copy a list.
///
/// @param[in] the list