new C++ interface
This commit is contained in:
Vítor Santos Costa
parent
ed0910fe94
commit
2f852223ec
402
CXX/yapi.cpp
Normal file
402
CXX/yapi.cpp
Normal file
@ -0,0 +1,402 @@
|
||||
|
||||
#define YAP_CPP_INTERFACE 1
|
||||
|
||||
#include "yapi.hh"
|
||||
|
||||
YAPAtomTerm::YAPAtomTerm(char *s) { // build string
|
||||
BACKUP_H();
|
||||
|
||||
CACHE_REGS
|
||||
seq_tv_t inp, out;
|
||||
inp.val.c = s;
|
||||
inp.type = YAP_STRING_CHARS;
|
||||
out.type = YAP_STRING_ATOM;
|
||||
if (Yap_CVT_Text(&inp, &out PASS_REGS))
|
||||
t = MkAtomTerm(out.val.a);
|
||||
else t = 0L;
|
||||
RECOVER_H();
|
||||
}
|
||||
|
||||
|
||||
YAPAtomTerm::YAPAtomTerm(char *s, size_t len) { // build string
|
||||
BACKUP_H();
|
||||
|
||||
CACHE_REGS
|
||||
seq_tv_t inp, out;
|
||||
inp.val.c = s;
|
||||
inp.type = YAP_STRING_CHARS;
|
||||
out.type = YAP_STRING_ATOM|YAP_STRING_NCHARS|YAP_STRING_TRUNC;
|
||||
out.sz = len;
|
||||
out.max = len;
|
||||
if (Yap_CVT_Text(&inp, &out PASS_REGS))
|
||||
t = MkAtomTerm(out.val.a);
|
||||
else t = 0L;
|
||||
RECOVER_H();
|
||||
}
|
||||
|
||||
YAPAtomTerm::YAPAtomTerm(wchar_t *s): YAPTerm() { // build string
|
||||
BACKUP_H();
|
||||
|
||||
CACHE_REGS
|
||||
seq_tv_t inp, out;
|
||||
inp.val.w = s;
|
||||
inp.type = YAP_STRING_WCHARS;
|
||||
out.type = YAP_STRING_ATOM;
|
||||
if (Yap_CVT_Text(&inp, &out PASS_REGS))
|
||||
t = MkAtomTerm(out.val.a);
|
||||
else t = 0L;
|
||||
RECOVER_H();
|
||||
}
|
||||
|
||||
|
||||
YAPAtomTerm::YAPAtomTerm(wchar_t *s, size_t len) : YAPTerm() { // build string
|
||||
BACKUP_H();
|
||||
|
||||
CACHE_REGS
|
||||
seq_tv_t inp, out;
|
||||
inp.val.w = s;
|
||||
inp.type = YAP_STRING_WCHARS;
|
||||
out.type = YAP_STRING_ATOM|YAP_STRING_NCHARS|YAP_STRING_TRUNC;
|
||||
out.sz = len;
|
||||
out.max = len;
|
||||
if (Yap_CVT_Text(&inp, &out PASS_REGS))
|
||||
t = MkAtomTerm(out.val.a);
|
||||
else t = 0L;
|
||||
RECOVER_H();
|
||||
}
|
||||
|
||||
|
||||
YAPStringTerm::YAPStringTerm(char *s) { // build string
|
||||
BACKUP_H();
|
||||
|
||||
CACHE_REGS
|
||||
seq_tv_t inp, out;
|
||||
inp.val.c = s;
|
||||
inp.type = YAP_STRING_CHARS;
|
||||
out.type = YAP_STRING_STRING;
|
||||
if (Yap_CVT_Text(&inp, &out PASS_REGS))
|
||||
t = out.val.t;
|
||||
else t = 0L;
|
||||
RECOVER_H();
|
||||
}
|
||||
|
||||
|
||||
YAPStringTerm::YAPStringTerm(char *s, size_t len) { // build string
|
||||
BACKUP_H();
|
||||
|
||||
CACHE_REGS
|
||||
seq_tv_t inp, out;
|
||||
inp.val.c = s;
|
||||
inp.type = YAP_STRING_CHARS;
|
||||
out.type = YAP_STRING_STRING|YAP_STRING_NCHARS|YAP_STRING_TRUNC;
|
||||
out.sz = len;
|
||||
out.max = len;
|
||||
if (Yap_CVT_Text(&inp, &out PASS_REGS))
|
||||
t = out.val.t;
|
||||
else t = 0L;
|
||||
RECOVER_H();
|
||||
}
|
||||
|
||||
YAPStringTerm::YAPStringTerm(wchar_t *s): YAPTerm() { // build string
|
||||
BACKUP_H();
|
||||
|
||||
CACHE_REGS
|
||||
seq_tv_t inp, out;
|
||||
inp.val.w = s;
|
||||
inp.type = YAP_STRING_WCHARS;
|
||||
out.type = YAP_STRING_STRING;
|
||||
if (Yap_CVT_Text(&inp, &out PASS_REGS))
|
||||
t = out.val.t;
|
||||
else t = 0L;
|
||||
RECOVER_H();
|
||||
}
|
||||
|
||||
|
||||
YAPStringTerm::YAPStringTerm(wchar_t *s, size_t len) : YAPTerm() { // build string
|
||||
BACKUP_H();
|
||||
|
||||
CACHE_REGS
|
||||
seq_tv_t inp, out;
|
||||
inp.val.w = s;
|
||||
inp.type = YAP_STRING_WCHARS;
|
||||
out.type = YAP_STRING_STRING|YAP_STRING_NCHARS|YAP_STRING_TRUNC;
|
||||
out.sz = len;
|
||||
out.max = len;
|
||||
if (Yap_CVT_Text(&inp, &out PASS_REGS))
|
||||
t = out.val.t;
|
||||
else t = 0L;
|
||||
RECOVER_H();
|
||||
}
|
||||
|
||||
|
||||
YAPApplTerm::YAPApplTerm(YAPFunctor f, YAPTerm ts[]) : YAPTerm() {
|
||||
UInt arity = ArityOfFunctor(f.f);
|
||||
t = Yap_MkApplTerm( f.f, arity, (Term *)ts);
|
||||
}
|
||||
|
||||
YAPApplTerm::YAPApplTerm(YAPFunctor f) : YAPTerm() {
|
||||
UInt arity = ArityOfFunctor(f.f);
|
||||
t = Yap_MkNewApplTerm( f.f, arity);
|
||||
}
|
||||
|
||||
YAPPairTerm::YAPPairTerm(YAPTerm th, YAPTerm tl) : YAPTerm() {
|
||||
CACHE_REGS
|
||||
t = MkPairTerm( th.t, tl.t);
|
||||
}
|
||||
|
||||
YAPPairTerm::YAPPairTerm() : YAPTerm() {
|
||||
t = Yap_MkNewPairTerm( );
|
||||
}
|
||||
|
||||
YAP_tag_t YAPTerm::tag() {
|
||||
if (IsVarTerm(t)) {
|
||||
CELL *pt = VarOfTerm(t);
|
||||
if (IsUnboundVar(pt)) {
|
||||
CACHE_REGS
|
||||
if (IsAttVar(pt))
|
||||
return YAP_TAG_ATT;
|
||||
return YAP_TAG_UNBOUND;
|
||||
}
|
||||
return YAP_TAG_REF;
|
||||
}
|
||||
if (IsPairTerm(t))
|
||||
return YAP_TAG_PAIR;
|
||||
if (IsAtomOrIntTerm(t)) {
|
||||
if (IsAtomTerm(t))
|
||||
return YAP_TAG_ATOM;
|
||||
return YAP_TAG_INT;
|
||||
} else {
|
||||
Functor f = FunctorOfTerm(t);
|
||||
|
||||
if (IsExtensionFunctor(f)) {
|
||||
if (f == FunctorDBRef) {
|
||||
return YAP_TAG_DBREF;
|
||||
}
|
||||
if (f == FunctorLongInt) {
|
||||
return YAP_TAG_LONG_INT;
|
||||
}
|
||||
if (f == FunctorBigInt) {
|
||||
big_blob_type bt = (big_blob_type)RepAppl(t)[1];
|
||||
switch (bt) {
|
||||
case BIG_INT:
|
||||
return YAP_TAG_BIG_INT;
|
||||
case BIG_RATIONAL:
|
||||
return YAP_TAG_RATIONAL;
|
||||
default:
|
||||
return YAP_TAG_OPAQUE;
|
||||
}
|
||||
}
|
||||
}
|
||||
return YAP_TAG_APPL;
|
||||
}
|
||||
}
|
||||
|
||||
YAPTerm YAPTerm::deepCopy() {
|
||||
Term tn;
|
||||
BACKUP_MACHINE_REGS();
|
||||
|
||||
tn = Yap_CopyTerm(t);
|
||||
|
||||
RECOVER_MACHINE_REGS();
|
||||
return new YAPTerm( tn );
|
||||
}
|
||||
|
||||
bool YAPTerm::exactlyEqual(YAPTerm t1) {
|
||||
int out;
|
||||
BACKUP_MACHINE_REGS();
|
||||
|
||||
out = Yap_eq(Deref(t), Deref(t1.t));
|
||||
|
||||
RECOVER_MACHINE_REGS();
|
||||
return out;
|
||||
}
|
||||
|
||||
bool YAPTerm::unify(YAPTerm t1) {
|
||||
int out;
|
||||
BACKUP_MACHINE_REGS();
|
||||
|
||||
out = Yap_unify(Deref(t), Deref(t1.t));
|
||||
|
||||
RECOVER_MACHINE_REGS();
|
||||
return out;
|
||||
}
|
||||
|
||||
bool YAPTerm::unifiable(YAPTerm t1) {
|
||||
int out;
|
||||
BACKUP_MACHINE_REGS();
|
||||
|
||||
out = Yap_Unifiable(Deref(t), Deref(t1.t));
|
||||
|
||||
RECOVER_MACHINE_REGS();
|
||||
return out;
|
||||
}
|
||||
|
||||
bool YAPTerm::variant(YAPTerm t1) {
|
||||
int out;
|
||||
BACKUP_MACHINE_REGS();
|
||||
|
||||
out = Yap_Variant(Deref(t), Deref(t1.t));
|
||||
|
||||
RECOVER_MACHINE_REGS();
|
||||
return out;
|
||||
}
|
||||
|
||||
intptr_t YAPTerm::hash(size_t sz, size_t depth, bool variant) {
|
||||
Int out;
|
||||
|
||||
BACKUP_MACHINE_REGS();
|
||||
|
||||
out = Yap_TermHash(t, sz, depth, variant);
|
||||
|
||||
RECOVER_MACHINE_REGS();
|
||||
return out;
|
||||
}
|
||||
|
||||
|
||||
char *YAPAtom::name(void) {
|
||||
if (IsWideAtom(a)) {
|
||||
// return an UTF-8 version
|
||||
size_t sz = 512;
|
||||
wchar_t * ptr = a->WStrOfAE;
|
||||
int ch = -1;
|
||||
char *s = new char[sz], *op = s;
|
||||
while (ch) {
|
||||
ch = *ptr++;
|
||||
utf8_put_char( op, ch );
|
||||
}
|
||||
sz = strlen(s)+1;
|
||||
char *os = new char[sz];
|
||||
memcpy(os, s, sz);
|
||||
delete s;
|
||||
return os;
|
||||
} else if (IsBlob(a)) {
|
||||
PL_blob_t *type = RepBlobProp(a->PropsOfAE)->blob_t;
|
||||
size_t sz = 512;
|
||||
|
||||
if (type->write) {
|
||||
char *s = new char[sz];
|
||||
IOSTREAM *stream = Sopenmem(&s, &sz, "w");
|
||||
stream->encoding = ENC_UTF8;
|
||||
atom_t at = YAP_SWIAtomFromAtom(AbsAtom(a));
|
||||
type->write(stream, at, 0);
|
||||
Sclose(stream);
|
||||
popOutputContext();
|
||||
sz = strlen(s)+1;
|
||||
char *os = new char[sz];
|
||||
memcpy(os, s, sz);
|
||||
delete s;
|
||||
return os;
|
||||
} else {
|
||||
char *s = new char[sz];
|
||||
#if defined(__linux__) || defined(__APPLE__)
|
||||
snprintf(s, sz, "'%s'(%p)", AtomSWIStream->StrOfAE, a);
|
||||
#else
|
||||
snprintf(s, sz, "'%s'(0x%p)", AtomSWIStream->StrOfAE, a);
|
||||
#endif
|
||||
char *os = new char[sz];
|
||||
memcpy(os, s, sz);
|
||||
delete s;
|
||||
return os;
|
||||
}
|
||||
} else {
|
||||
return a->StrOfAE;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
YAPQuery::YAPQuery(YAPFunctor f, YAPTerm mod, YAPTerm t[]): YAPPredicate(f, mod)
|
||||
{
|
||||
CACHE_REGS
|
||||
|
||||
/* ignore flags and module for now */
|
||||
this->oq = (YAPQuery *)LOCAL_execution;
|
||||
LOCAL_execution = (struct open_query_struct *)this;
|
||||
this->q_open=1;
|
||||
this->q_state=0;
|
||||
this->q_flags = 0;
|
||||
this->q_g = (Term *)t;
|
||||
}
|
||||
|
||||
YAPQuery::YAPQuery(YAPFunctor f, YAPTerm t[]): YAPPredicate(f)
|
||||
{
|
||||
CACHE_REGS
|
||||
|
||||
/* ignore flags and module for now */
|
||||
this->oq = (YAPQuery *)LOCAL_execution;
|
||||
LOCAL_execution = (struct open_query_struct *)this;
|
||||
this->q_open=1;
|
||||
this->q_state=0;
|
||||
this->q_flags = 0;
|
||||
this->q_g = (Term *)t;
|
||||
}
|
||||
|
||||
YAPQuery::YAPQuery(YAPPredicate p, YAPTerm t[]): YAPPredicate(p.ap)
|
||||
{
|
||||
CACHE_REGS
|
||||
|
||||
/* ignore flags and module for now */
|
||||
this->oq = (YAPQuery *)LOCAL_execution;
|
||||
LOCAL_execution = (struct open_query_struct *)this;
|
||||
this->q_open=1;
|
||||
this->q_state=0;
|
||||
this->q_flags = 0;
|
||||
this->q_g = (Term *)t;
|
||||
}
|
||||
|
||||
|
||||
int YAPQuery::next()
|
||||
{
|
||||
CACHE_REGS
|
||||
int result;
|
||||
if (this->q_open != 1) return 0;
|
||||
if (setjmp(((YAPQuery *)LOCAL_execution)->q_env))
|
||||
return 0;
|
||||
// don't forget, on success these guys must create slots
|
||||
if (this->q_state == 0) {
|
||||
result = YAP_EnterGoal((YAP_PredEntryPtr)this->ap, this->q_g, &this->q_h);
|
||||
} else {
|
||||
LOCAL_AllowRestart = this->q_open;
|
||||
result = YAP_RetryGoal(&this->q_h);
|
||||
}
|
||||
this->q_state = 1;
|
||||
if (result == 0) {
|
||||
YAP_LeaveGoal(FALSE, &this->q_h);
|
||||
this->q_open = 0;
|
||||
}
|
||||
return result;
|
||||
}
|
||||
|
||||
void YAPQuery::cut()
|
||||
{
|
||||
CACHE_REGS
|
||||
|
||||
if (this->q_open != 1 || this->q_state == 0) return;
|
||||
YAP_LeaveGoal(FALSE, &this->q_h);
|
||||
this->q_open = 0;
|
||||
LOCAL_execution = (struct open_query_struct *)this->oq;
|
||||
}
|
||||
|
||||
void YAPQuery::close()
|
||||
{
|
||||
CACHE_REGS
|
||||
|
||||
if (EX && !(this->q_flags & (PL_Q_CATCH_EXCEPTION))) {
|
||||
EX = NULL;
|
||||
}
|
||||
/* need to implement backtracking here */
|
||||
if (this->q_open != 1 || this->q_state == 0) {
|
||||
return;
|
||||
}
|
||||
YAP_LeaveGoal(FALSE, &this->q_h);
|
||||
this->q_open = 0;
|
||||
LOCAL_execution = (struct open_query_struct *)this->oq;
|
||||
}
|
||||
|
||||
int YAPPredicate::call(YAPTerm t[])
|
||||
{
|
||||
YAPQuery q = YAPQuery(*this, t);
|
||||
int ret = q.next();
|
||||
q.cut();
|
||||
q.close();
|
||||
return ret;
|
||||
}
|
||||
257
CXX/yapi.hh
Normal file
257
CXX/yapi.hh
Normal file
@ -0,0 +1,257 @@
|
||||
|
||||
#define YAP_CPP_INTERFACE 1
|
||||
|
||||
#include <stdlib.h>
|
||||
|
||||
#include <gmp.h>
|
||||
|
||||
extern "C" {
|
||||
|
||||
#include "Yap.h"
|
||||
|
||||
#include "Yatom.h"
|
||||
|
||||
#include "YapHeap.h"
|
||||
|
||||
#include "pl-shared.h"
|
||||
|
||||
#include "clause.h"
|
||||
|
||||
#include "yapio.h"
|
||||
|
||||
#include "Foreign.h"
|
||||
|
||||
#include "attvar.h"
|
||||
|
||||
#include "SWI-Stream.h"
|
||||
|
||||
#include "YapText.h"
|
||||
|
||||
#if HAVE_STDARG_H
|
||||
#include <stdarg.h>
|
||||
#endif
|
||||
|
||||
#if HAVE_STDINT_H
|
||||
#include <stdint.h>
|
||||
#endif
|
||||
|
||||
#if HAVE_STRING_H
|
||||
#include <string.h>
|
||||
#endif
|
||||
|
||||
#if _MSC_VER || defined(__MINGW32__)
|
||||
#include <windows.h>
|
||||
#endif
|
||||
|
||||
// taken from yap_structs.h
|
||||
#include "iopreds.h"
|
||||
|
||||
// we cannot consult YapInterface.h, that conflicts with what we declare, though
|
||||
// it shouldn't
|
||||
}
|
||||
|
||||
class YAPTermHandle;
|
||||
class YAPAtom;
|
||||
class YAPFunctor;
|
||||
class YAPQuery;
|
||||
|
||||
class YAPTerm {
|
||||
friend class YAPPredicate;
|
||||
friend class YAPTermHandle;
|
||||
friend class YAPApplTerm;
|
||||
friend class YAPPairTerm;
|
||||
protected:
|
||||
Term t;
|
||||
public:
|
||||
YAPTerm() {} // do nothing constructor
|
||||
YAPTerm(int i) { CACHE_REGS t = MkIntegerTerm( i ); }
|
||||
YAPTerm(int64_t i) { CACHE_REGS t = MkIntegerTerm( i ); }
|
||||
YAPTerm(long int i) { CACHE_REGS t = MkIntegerTerm( i ); }
|
||||
YAPTerm(void *ptr) { CACHE_REGS t = MkIntegerTerm( (Int)ptr ); }
|
||||
YAPTerm(Term tn) { t = tn; }
|
||||
YAPTerm(char *s) { Term tp ; t = YAP_ReadBuffer(s,&tp); }
|
||||
|
||||
YAP_tag_t tag();
|
||||
YAPTerm deepCopy();
|
||||
bool exactlyEqual(YAPTerm t1);
|
||||
bool unify(YAPTerm t1);
|
||||
bool unifiable(YAPTerm t1);
|
||||
bool variant(YAPTerm t1);
|
||||
intptr_t hash(size_t sz, size_t depth, bool variant);
|
||||
bool isVar() { return IsVarTerm(t); }
|
||||
bool isAtom() { return IsAtomTerm(t); }
|
||||
bool isInteger() { return IsIntegerTerm(t); }
|
||||
bool isFloat() { return IsFloatTerm(t); }
|
||||
bool isCompound() { return !(IsVarTerm(t) || IsNumTerm(t)); }
|
||||
bool isAppl() { return IsApplTerm(t); }
|
||||
bool isPair() { return IsPairTerm(t); }
|
||||
bool isGround() { return Yap_IsGroundTerm(t); }
|
||||
bool isList() { return Yap_IsListTerm(t); }
|
||||
bool isString() { return IsStringTerm(t); }
|
||||
};
|
||||
|
||||
class YAPVarTerm: private YAPTerm {
|
||||
public:
|
||||
YAPVarTerm(): YAPTerm() { CACHE_REGS t = MkVarTerm(); }
|
||||
CELL *getVar() { return VarOfTerm(t); }
|
||||
bool unbound() { return IsUnboundVar(VarOfTerm(t)); }
|
||||
};
|
||||
|
||||
class YAPApplTerm: private YAPTerm {
|
||||
public:
|
||||
YAPApplTerm(YAPFunctor f, YAPTerm ts[]);
|
||||
YAPApplTerm(YAPFunctor f);
|
||||
YAPFunctor getFunctor();
|
||||
YAPTerm getArg(unsigned int i);
|
||||
};
|
||||
|
||||
class YAPPairTerm: private YAPTerm {
|
||||
public:
|
||||
YAPPairTerm(YAPTerm hd, YAPTerm tl);
|
||||
YAPPairTerm();
|
||||
YAPTerm getHead() { return YAPTerm(HeadOfTerm(t)); }
|
||||
YAPTerm getTail() { return YAPTerm(TailOfTerm(t)); }
|
||||
};
|
||||
|
||||
class YAPAtom {
|
||||
friend class YAPPredicate;
|
||||
friend class YAPFunctor;
|
||||
friend class YAPAtomTerm;
|
||||
Atom a;
|
||||
public:
|
||||
YAPAtom( Atom at ) { a = at; }
|
||||
YAPAtom( char * s) { a = Yap_LookupAtom( s ); }
|
||||
YAPAtom( wchar_t * s) { a = Yap_LookupMaybeWideAtom( s ); }
|
||||
YAPAtom( char * s, size_t len) { a = Yap_LookupAtomWithLength( s, len ); }
|
||||
YAPAtom( wchar_t * s, size_t len) { a = Yap_LookupMaybeWideAtomWithLength( s, len ); }
|
||||
char *name(void);
|
||||
};
|
||||
|
||||
class YAPStringTerm: private YAPTerm {
|
||||
public:
|
||||
YAPStringTerm(char *s) ;
|
||||
YAPStringTerm(char *s, size_t len);
|
||||
YAPStringTerm(wchar_t *s) ;
|
||||
YAPStringTerm(wchar_t *s, size_t len);
|
||||
const char *getString() { return StringOfTerm(t); }
|
||||
};
|
||||
|
||||
class YAPAtomTerm: private YAPTerm {
|
||||
public:
|
||||
YAPAtomTerm(YAPAtom a): YAPTerm() { t = MkAtomTerm(a.a); }
|
||||
YAPAtomTerm(Atom a): YAPTerm() { t = MkAtomTerm(a); }
|
||||
YAPAtomTerm(char *s) ;
|
||||
YAPAtomTerm(char *s, size_t len);
|
||||
YAPAtomTerm(wchar_t *s) ;
|
||||
YAPAtomTerm(wchar_t *s, size_t len);
|
||||
YAPAtom getAtom() { return YAPAtom(AtomOfTerm(t)); }
|
||||
};
|
||||
|
||||
class YAPFunctor {
|
||||
friend class YAPApplTerm;
|
||||
friend class YAPPredicate;
|
||||
Functor f;
|
||||
public:
|
||||
YAPFunctor( char * s, unsigned int arity) { f = Yap_MkFunctor( Yap_LookupAtom( s ), arity ); }
|
||||
YAPFunctor( wchar_t * s, unsigned int arity) { f = Yap_MkFunctor( Yap_LookupWideAtom( s ), arity ); }
|
||||
YAPFunctor( YAPAtom at, unsigned int arity) { f = Yap_MkFunctor( at.a, arity ); }
|
||||
|
||||
Atom name(void) {
|
||||
return NameOfFunctor( f );
|
||||
}
|
||||
|
||||
unsigned int arity(void) {
|
||||
return ArityOfFunctor( f );
|
||||
}
|
||||
};
|
||||
|
||||
class YAPTermHandle {
|
||||
long int handle;
|
||||
public:
|
||||
YAPTermHandle(Term t) {
|
||||
CACHE_REGS
|
||||
handle = Yap_InitSlot(t PASS_REGS);
|
||||
}
|
||||
~YAPTermHandle(void) {
|
||||
CACHE_REGS
|
||||
Yap_RecoverSlots(1 PASS_REGS);
|
||||
}
|
||||
|
||||
YAPTerm get() {
|
||||
CACHE_REGS
|
||||
return new YAPTerm( Yap_GetFromSlot(handle PASS_REGS) );
|
||||
}
|
||||
|
||||
void set(YAPTerm t) {
|
||||
CACHE_REGS
|
||||
Yap_PutInSlot(handle, t.t PASS_REGS);
|
||||
}
|
||||
};
|
||||
|
||||
class YAPPredicate {
|
||||
friend class YAPQuery;
|
||||
PredEntry *ap;
|
||||
public:
|
||||
YAPPredicate(PredEntry *pe) {
|
||||
ap = pe;
|
||||
}
|
||||
YAPPredicate(YAPFunctor f) {
|
||||
CACHE_REGS
|
||||
ap = RepPredProp(PredPropByFunc(f.f,CurrentModule));
|
||||
}
|
||||
YAPPredicate(YAPFunctor f, YAPTerm mod) {
|
||||
CACHE_REGS
|
||||
ap = RepPredProp(PredPropByFunc(f.f,mod.t));
|
||||
}
|
||||
YAPPredicate(YAPAtom at, YAPTerm mod) {
|
||||
CACHE_REGS
|
||||
ap = RepPredProp(PredPropByAtom(at.a,mod.t));
|
||||
}
|
||||
YAPPredicate(YAPAtom at) {
|
||||
CACHE_REGS
|
||||
ap = RepPredProp(PredPropByAtom(at.a,CurrentModule));
|
||||
}
|
||||
YAPPredicate(YAPAtom at, unsigned int arity, YAPTerm mod) {
|
||||
CACHE_REGS
|
||||
if (arity) {
|
||||
Functor f = Yap_MkFunctor(at.a, arity);
|
||||
ap = RepPredProp(PredPropByFunc(f,mod.t));
|
||||
} else {
|
||||
ap = RepPredProp(PredPropByAtom(at.a,mod.t));
|
||||
}
|
||||
}
|
||||
YAPPredicate(YAPAtom at, unsigned int arity) {
|
||||
CACHE_REGS
|
||||
if (arity) {
|
||||
Functor f = Yap_MkFunctor(at.a, arity);
|
||||
ap = RepPredProp(PredPropByFunc(f,CurrentModule));
|
||||
} else {
|
||||
ap = RepPredProp(PredPropByAtom(at.a,CurrentModule));
|
||||
}
|
||||
}
|
||||
|
||||
int call(YAPTerm ts[]);
|
||||
};
|
||||
|
||||
/// interface to a YAP Query
|
||||
/// uses an SWI-like status info internally
|
||||
class YAPQuery: private YAPPredicate {
|
||||
int q_open;
|
||||
int q_state;
|
||||
Term *q_g;
|
||||
yamop *q_p, *q_cp;
|
||||
jmp_buf q_env;
|
||||
int q_flags;
|
||||
YAP_dogoalinfo q_h;
|
||||
YAPQuery *oq;
|
||||
public:
|
||||
/// full constructor, is given a functor, module, and an array of terms that must hav at least
|
||||
/// the same arity as the functor.
|
||||
YAPQuery(YAPFunctor f, YAPTerm mod, YAPTerm t[]);
|
||||
YAPQuery(YAPFunctor f, YAPTerm t[]);
|
||||
YAPQuery(YAPPredicate p, YAPTerm t[]);
|
||||
YAPQuery(YAPTerm t[]);
|
||||
int next();
|
||||
void cut();
|
||||
void close();
|
||||
};
|
||||
11
Makefile.in
11
Makefile.in
@ -60,9 +60,10 @@ YAPSTARTUP=startup.yss
|
||||
#
|
||||
CC=@CC@
|
||||
MPI_CC=@MPI_CC@
|
||||
CPPFLAGS=@CPPFLAGS@ -I. -I$(srcdir)/H -I$(srcdir)/include -I$(srcdir)/os -I$(srcdir)/OPTYap -I$(srcdir)/BEAM
|
||||
CPPFLAGS=@CPPFLAGS@ -I. -I$(srcdir)/H -I$(srcdir)/include -I$(srcdir)/os -I$(srcdir)/OPTYap -I$(srcdir)/BEAM -I$(srcdir)/CXX
|
||||
EXECUTABLE_CFLAGS= @CFLAGS@ $(YAP_EXTRAS) $(DEFS) $(CPPFLAGS)
|
||||
CFLAGS= @YAPLIB_CFLAGS@ $(YAP_EXTRAS) $(DEFS) $(CPPFLAGS)
|
||||
CXXFLAGS= @CXXFLAGS@ $(YAP_EXTRAS) $(DEFS) $(CPPFLAGS)
|
||||
C_INTERF_FLAGS= @YAPLIB_CFLAGS@ $(YAP_EXTRAS) $(DEFS) $(CPPFLAGS) -Iinclude
|
||||
C_PARSER_FLAGS= @YAPLIB_CFLAGS@ $(YAP_EXTRAS) $(DEFS) $(CPPFLAGS)
|
||||
#
|
||||
@ -197,6 +198,7 @@ HEADERS = \
|
||||
H/YapText.h \
|
||||
H/cut_c.h \
|
||||
H/iatoms.h H/ratoms.h H/tatoms.h \
|
||||
CXX/yapi.hh \
|
||||
BEAM/eam.h BEAM/eamamasm.h \
|
||||
OPTYap/opt.config.h \
|
||||
OPTYap/opt.proto.h OPTYap/opt.structs.h \
|
||||
@ -273,6 +275,7 @@ C_SOURCES= \
|
||||
C/utilpreds.c C/write.c console/yap.c \
|
||||
C/yap-args.c \
|
||||
C/ypstdio.c \
|
||||
CXX/yapi.cpp \
|
||||
BEAM/eam_am.c BEAM/eam_showcode.c \
|
||||
BEAM/eamindex.c BEAM/eamamasm.c \
|
||||
BEAM/eam_gc.c BEAM/eam_split.c \
|
||||
@ -396,7 +399,7 @@ LIBTAI_OBJECTS = \
|
||||
C_INTERFACE_OBJECTS = \
|
||||
load_foreign.o load_dl.o load_dld.o load_dyld.o \
|
||||
load_none.o load_aout.o load_aix.o load_dll.o load_shl.o \
|
||||
c_interface.o clause_list.o
|
||||
c_interface.o clause_list.o yapi.o
|
||||
|
||||
OR_OBJECTS = \
|
||||
or.memory.o opt.init.o opt.preds.o \
|
||||
@ -456,6 +459,9 @@ udi.o: C/udi.c config.h
|
||||
%.o: BEAM/%.c config.h
|
||||
$(CC) -c $(CFLAGS) $< -o $@
|
||||
|
||||
yapi.o: CXX/yapi.cpp config.h
|
||||
$(CXX) -c $(CXXFLAGS) $< -o $@
|
||||
|
||||
sys.o: library/system/sys.c config.h
|
||||
$(CC) -c $(CFPLAGS) -I$(srcdir)/include -I. $< -o $@
|
||||
|
||||
@ -541,6 +547,7 @@ INSTALLED_PACKAGES= \
|
||||
@PKG_RDF@ \
|
||||
@PKG_SEMWEB@ \
|
||||
@PKG_SGML@ \
|
||||
@PKG_SWIG@ \
|
||||
@PKG_WINCONSOLE@ \
|
||||
@PKG_ZLIB@
|
||||
|
||||
|
||||
Reference in New Issue
Block a user