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

indenting & Android support (one big lib)

Browse Source
This commit is contained in:
vscosta 2016-04-05 02:25:05 +01:00
parent abe5953da7
commit 24e6924769
2 changed files with 267 additions and 285 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

18
CXX/CMakeLists.txt
View File

@ -4,8 +4,7 @@ set(SO_MAJOR 1)
set(SO_MINOR 0) set(SO_MINOR 0)
set(SO_PATCH 0) set(SO_PATCH 0)
set (CXX_SOURCES
add_library (Yap++ SHARED
yapa.hh yapa.hh
yapdb.hh yapdb.hh
yapi.cpp yapi.cpp
@ -13,9 +12,17 @@ add_library (Yap++ SHARED
yapie.hh yapie.hh
yapq.hh yapq.hh
yapt.hh yapt.hh
) )
include_directories (H include ${CMAKE_BINARY_DIR} ${GMP_INCLUDE_DIR})
if (ANDROID)
add_library (Yap++ OBJECT
${CXX_SOURCES}
)
else()
add_library (Yap++ SHARED
${CXX_SOURCES}
)
target_link_libraries(Yap++ ${CMAKE_DL_LIBS} libYap) target_link_libraries(Yap++ ${CMAKE_DL_LIBS} libYap)
@ -23,6 +30,9 @@ install(TARGETS Yap++
LIBRARY DESTINATION ${libdir} LIBRARY DESTINATION ${libdir}
ARCHIVE DESTINATION ${libdir} ARCHIVE DESTINATION ${libdir}
) )
endif()
include_directories (H include ${CMAKE_BINARY_DIR} ${GMP_INCLUDE_DIR})
set( CMAKE_REQUIRED_INCLUDES ${CMAKE_REQUIRED_INCLUDES} ${GMP_INCLUDE_DIR} ) set( CMAKE_REQUIRED_INCLUDES ${CMAKE_REQUIRED_INCLUDES} ${GMP_INCLUDE_DIR} )
#set( CMAKE_REQUIRED_LIBRARIES ${CMAKE_REQUIRED_LIBRARIES} ${GMP_LIBRARIES} ) #set( CMAKE_REQUIRED_LIBRARIES ${CMAKE_REQUIRED_LIBRARIES} ${GMP_LIBRARIES} )

354
CXX/yapi.cpp
View File

@ -8,14 +8,16 @@ extern "C" {
#include "YapInterface.h" #include "YapInterface.h"
#include "blobs.h" #include "blobs.h"
char *Yap_TermToString(Term t, char *s, size_t sz, size_t *length, encoding_t *encodingp, int flags); char *Yap_TermToString(Term t, char *s, size_t sz, size_t *length,
encoding_t *encodingp, int flags);
void YAP_UserCPredicate(const char *, YAP_UserCPred, YAP_Arity arity); void YAP_UserCPredicate(const char *, YAP_UserCPred, YAP_Arity arity);
void YAP_UserCPredicateWithArgs(const char *, YAP_UserCPred, YAP_Arity, YAP_Term); void YAP_UserCPredicateWithArgs(const char *, YAP_UserCPred, YAP_Arity,
void YAP_UserBackCPredicate(const char *, YAP_UserCPred, YAP_UserCPred, YAP_Arity, YAP_Arity); YAP_Term);
void YAP_UserBackCPredicate(const char *, YAP_UserCPred, YAP_UserCPred,
YAP_Arity, YAP_Arity);
} }
YAPAtomTerm::YAPAtomTerm(char *s) { // build string YAPAtomTerm::YAPAtomTerm(char *s) { // build string
BACKUP_H(); BACKUP_H();
@ -25,12 +27,12 @@ YAPAtomTerm::YAPAtomTerm(char *s) { // build string
inp.type = YAP_STRING_CHARS; inp.type = YAP_STRING_CHARS;
out.type = YAP_STRING_ATOM; out.type = YAP_STRING_ATOM;
if (Yap_CVT_Text(&inp, &out PASS_REGS)) if (Yap_CVT_Text(&inp, &out PASS_REGS))
mk ( MkAtomTerm(out.val.a) ); mk(MkAtomTerm(out.val.a));
else t = 0L; else
t = 0L;
RECOVER_H(); RECOVER_H();
} }
YAPAtomTerm::YAPAtomTerm(char *s, size_t len) { // build string YAPAtomTerm::YAPAtomTerm(char *s, size_t len) { // build string
BACKUP_H(); BACKUP_H();
@ -38,16 +40,17 @@ YAPAtomTerm::YAPAtomTerm(char *s, size_t len) { // build string
seq_tv_t inp, out; seq_tv_t inp, out;
inp.val.c = s; inp.val.c = s;
inp.type = YAP_STRING_CHARS; inp.type = YAP_STRING_CHARS;
out.type = YAP_STRING_ATOM|YAP_STRING_NCHARS|YAP_STRING_TRUNC; out.type = YAP_STRING_ATOM | YAP_STRING_NCHARS | YAP_STRING_TRUNC;
out.sz = len; out.sz = len;
out.max = len; out.max = len;
if (Yap_CVT_Text(&inp, &out PASS_REGS)) if (Yap_CVT_Text(&inp, &out PASS_REGS))
mk ( MkAtomTerm(out.val.a) ); mk(MkAtomTerm(out.val.a));
else t = 0L; else
t = 0L;
RECOVER_H(); RECOVER_H();
} }
YAPAtomTerm::YAPAtomTerm(wchar_t *s): YAPTerm() { // build string YAPAtomTerm::YAPAtomTerm(wchar_t *s) : YAPTerm() { // build string
BACKUP_H(); BACKUP_H();
CACHE_REGS CACHE_REGS
@ -56,12 +59,12 @@ YAPAtomTerm::YAPAtomTerm(wchar_t *s): YAPTerm() { // build string
inp.type = YAP_STRING_WCHARS; inp.type = YAP_STRING_WCHARS;
out.type = YAP_STRING_ATOM; out.type = YAP_STRING_ATOM;
if (Yap_CVT_Text(&inp, &out PASS_REGS)) if (Yap_CVT_Text(&inp, &out PASS_REGS))
mk ( MkAtomTerm(out.val.a) ); mk(MkAtomTerm(out.val.a));
else t = 0L; else
t = 0L;
RECOVER_H(); RECOVER_H();
} }
YAPAtomTerm::YAPAtomTerm(wchar_t *s, size_t len) : YAPTerm() { // build string YAPAtomTerm::YAPAtomTerm(wchar_t *s, size_t len) : YAPTerm() { // build string
BACKUP_H(); BACKUP_H();
@ -69,16 +72,16 @@ YAPAtomTerm::YAPAtomTerm(wchar_t *s, size_t len) : YAPTerm() { // build string
seq_tv_t inp, out; seq_tv_t inp, out;
inp.val.w = s; inp.val.w = s;
inp.type = YAP_STRING_WCHARS; inp.type = YAP_STRING_WCHARS;
out.type = YAP_STRING_ATOM|YAP_STRING_NCHARS|YAP_STRING_TRUNC; out.type = YAP_STRING_ATOM | YAP_STRING_NCHARS | YAP_STRING_TRUNC;
out.sz = len; out.sz = len;
out.max = len; out.max = len;
if (Yap_CVT_Text(&inp, &out PASS_REGS)) if (Yap_CVT_Text(&inp, &out PASS_REGS))
mk ( MkAtomTerm(out.val.a) ); mk(MkAtomTerm(out.val.a));
else t = 0L; else
t = 0L;
RECOVER_H(); RECOVER_H();
} }
YAPStringTerm::YAPStringTerm(char *s) { // build string YAPStringTerm::YAPStringTerm(char *s) { // build string
BACKUP_H(); BACKUP_H();
@ -88,12 +91,12 @@ YAPStringTerm::YAPStringTerm(char *s) { // build string
inp.type = YAP_STRING_CHARS; inp.type = YAP_STRING_CHARS;
out.type = YAP_STRING_STRING; out.type = YAP_STRING_STRING;
if (Yap_CVT_Text(&inp, &out PASS_REGS)) if (Yap_CVT_Text(&inp, &out PASS_REGS))
mk ( out.val.t ); mk(out.val.t);
else t = 0L; else
t = 0L;
RECOVER_H(); RECOVER_H();
} }
YAPStringTerm::YAPStringTerm(char *s, size_t len) { // build string YAPStringTerm::YAPStringTerm(char *s, size_t len) { // build string
BACKUP_H(); BACKUP_H();
@ -102,16 +105,17 @@ YAPStringTerm::YAPStringTerm(char *s, size_t len) { // build string
seq_tv_t inp, out; seq_tv_t inp, out;
inp.val.c = s; inp.val.c = s;
inp.type = YAP_STRING_CHARS; inp.type = YAP_STRING_CHARS;
out.type = YAP_STRING_STRING|YAP_STRING_NCHARS|YAP_STRING_TRUNC; out.type = YAP_STRING_STRING | YAP_STRING_NCHARS | YAP_STRING_TRUNC;
out.sz = len; out.sz = len;
out.max = len; out.max = len;
if (Yap_CVT_Text(&inp, &out PASS_REGS)) if (Yap_CVT_Text(&inp, &out PASS_REGS))
mk ( out.val.t ); mk(out.val.t);
else t = 0L; else
t = 0L;
RECOVER_H(); RECOVER_H();
} }
YAPStringTerm::YAPStringTerm(wchar_t *s): YAPTerm() { // build string YAPStringTerm::YAPStringTerm(wchar_t *s) : YAPTerm() { // build string
BACKUP_H(); BACKUP_H();
CACHE_REGS CACHE_REGS
@ -121,13 +125,14 @@ YAPStringTerm::YAPStringTerm(wchar_t *s): YAPTerm() { // build string
inp.type = YAP_STRING_WCHARS; inp.type = YAP_STRING_WCHARS;
out.type = YAP_STRING_STRING; out.type = YAP_STRING_STRING;
if (Yap_CVT_Text(&inp, &out PASS_REGS)) if (Yap_CVT_Text(&inp, &out PASS_REGS))
mk ( out.val.t ); mk(out.val.t);
else t = 0L; else
t = 0L;
RECOVER_H(); RECOVER_H();
} }
YAPStringTerm::YAPStringTerm(wchar_t *s, size_t len)
YAPStringTerm::YAPStringTerm(wchar_t *s, size_t len) : YAPTerm() { // build string : YAPTerm() { // build string
BACKUP_H(); BACKUP_H();
CACHE_REGS CACHE_REGS
@ -135,60 +140,58 @@ YAPStringTerm::YAPStringTerm(wchar_t *s, size_t len) : YAPTerm() { // build stri
seq_tv_t inp, out; seq_tv_t inp, out;
inp.val.w = s; inp.val.w = s;
inp.type = YAP_STRING_WCHARS; inp.type = YAP_STRING_WCHARS;
out.type = YAP_STRING_STRING|YAP_STRING_NCHARS|YAP_STRING_TRUNC; out.type = YAP_STRING_STRING | YAP_STRING_NCHARS | YAP_STRING_TRUNC;
out.sz = len; out.sz = len;
out.max = len; out.max = len;
if (Yap_CVT_Text(&inp, &out PASS_REGS)) if (Yap_CVT_Text(&inp, &out PASS_REGS))
mk ( out.val.t ); mk(out.val.t);
else t = 0L; else
t = 0L;
RECOVER_H(); RECOVER_H();
} }
YAPApplTerm::YAPApplTerm(YAPFunctor f, YAPTerm ts[]) : YAPTerm() { YAPApplTerm::YAPApplTerm(YAPFunctor f, YAPTerm ts[]) : YAPTerm() {
BACKUP_H(); BACKUP_H();
UInt arity = ArityOfFunctor(f.f); UInt arity = ArityOfFunctor(f.f);
mk ( Yap_MkApplTerm( f.f, arity, (Term *)ts) ); mk(Yap_MkApplTerm(f.f, arity, (Term *)ts));
RECOVER_H(); RECOVER_H();
} }
YAPApplTerm::YAPApplTerm(YAPFunctor f) : YAPTerm() { YAPApplTerm::YAPApplTerm(YAPFunctor f) : YAPTerm() {
BACKUP_H(); BACKUP_H();
UInt arity = ArityOfFunctor(f.f); UInt arity = ArityOfFunctor(f.f);
mk ( Yap_MkNewApplTerm( f.f, arity) ); mk(Yap_MkNewApplTerm(f.f, arity));
RECOVER_H(); RECOVER_H();
} }
YAPTerm YAPApplTerm::getArg(int arg) { YAPTerm YAPApplTerm::getArg(int arg) {
BACKUP_H(); BACKUP_H();
YAPTerm to = YAPTerm( ArgOfTerm(arg, gt() ) ); YAPTerm to = YAPTerm(ArgOfTerm(arg, gt()));
RECOVER_H(); RECOVER_H();
return to; return to;
} }
YAPFunctor YAPApplTerm::getFunctor() { YAPFunctor YAPApplTerm::getFunctor() { return YAPFunctor(FunctorOfTerm(gt())); }
return YAPFunctor( FunctorOfTerm( gt( )) );
}
YAPPairTerm::YAPPairTerm(YAPTerm th, YAPTerm tl) : YAPTerm() { YAPPairTerm::YAPPairTerm(YAPTerm th, YAPTerm tl) : YAPTerm() {
CACHE_REGS CACHE_REGS
BACKUP_H(); BACKUP_H();
mk ( MkPairTerm( th.term(), tl.term() ) ); mk(MkPairTerm(th.term(), tl.term()));
RECOVER_H(); RECOVER_H();
} }
YAPPairTerm::YAPPairTerm() : YAPTerm() { YAPPairTerm::YAPPairTerm() : YAPTerm() {
BACKUP_H(); BACKUP_H();
t = Yap_MkNewPairTerm( ); t = Yap_MkNewPairTerm();
RECOVER_H(); RECOVER_H();
} }
void YAPTerm::mk(Term t0) { CACHE_REGS t = Yap_InitSlot( t0 ); } void YAPTerm::mk(Term t0) { CACHE_REGS t = Yap_InitSlot(t0); }
Term YAPTerm::gt() { CACHE_REGS return Yap_GetFromSlot( t ); } Term YAPTerm::gt() { CACHE_REGS return Yap_GetFromSlot(t); }
YAP_tag_t YAPTerm::tag() { YAP_tag_t YAPTerm::tag() {
Term tt = gt( ); Term tt = gt();
if (IsVarTerm(tt)) { if (IsVarTerm(tt)) {
CELL *pt = VarOfTerm(tt); CELL *pt = VarOfTerm(tt);
if (IsUnboundVar(pt)) { if (IsUnboundVar(pt)) {
@ -235,10 +238,10 @@ YAPTerm YAPTerm::deepCopy() {
Term tn; Term tn;
BACKUP_MACHINE_REGS(); BACKUP_MACHINE_REGS();
tn = Yap_CopyTerm( gt() ); tn = Yap_CopyTerm(gt());
RECOVER_MACHINE_REGS(); RECOVER_MACHINE_REGS();
return new YAPTerm( tn ); return new YAPTerm(tn);
} }
bool YAPTerm::exactlyEqual(YAPTerm t1) { bool YAPTerm::exactlyEqual(YAPTerm t1) {
@ -286,7 +289,7 @@ intptr_t YAPTerm::hashTerm(size_t sz, size_t depth, bool variant) {
BACKUP_MACHINE_REGS(); BACKUP_MACHINE_REGS();
out = Yap_TermHash(gt(), sz, depth, variant) ; out = Yap_TermHash(gt(), sz, depth, variant);
RECOVER_MACHINE_REGS(); RECOVER_MACHINE_REGS();
return out; return out;
@ -299,23 +302,21 @@ const char *YAPTerm::text() {
encoding_t enc = LOCAL_encoding; encoding_t enc = LOCAL_encoding;
BACKUP_MACHINE_REGS(); BACKUP_MACHINE_REGS();
if (!(os = Yap_TermToString(Yap_GetFromSlot(t), os, sze, &length, &enc, 0))) { RECOVER_MACHINE_REGS(); if (!(os = Yap_TermToString(Yap_GetFromSlot(t), os, sze, &length, &enc, 0))) {
RECOVER_MACHINE_REGS();
return (char *)NULL; return (char *)NULL;
} }
RECOVER_MACHINE_REGS(); RECOVER_MACHINE_REGS();
return os; return os;
} }
const char *YAPQuery::text() { const char *YAPQuery::text() { return goal.text(); }
return goal.text(); YAPIntegerTerm::YAPIntegerTerm(intptr_t i) {
CACHE_REGS Term tn = MkIntegerTerm(i);
mk(tn);
} }
YAPIntegerTerm::YAPIntegerTerm(intptr_t i) { CACHE_REGS Term tn = MkIntegerTerm( i ); mk( tn ); }
/* /*
YAPTerm *YAPTerm::vars() YAPTerm *YAPTerm::vars()
{ {
@ -329,18 +330,17 @@ YAPTerm *YAPTerm::vars()
YAPTerm::YAPTerm(void *ptr) { YAPTerm::YAPTerm(void *ptr) {
CACHE_REGS CACHE_REGS
mk( MkIntegerTerm( (Int)ptr ) ); mk(MkIntegerTerm((Int)ptr));
} }
YAPTerm::YAPTerm(intptr_t i) { YAPTerm::YAPTerm(intptr_t i) {
CACHE_REGS Term tn = MkIntegerTerm( i ); CACHE_REGS Term tn = MkIntegerTerm(i);
mk( tn ); mk(tn);
} }
YAPTerm YAPListTerm::car() YAPTerm YAPListTerm::car() {
{
Term to = gt(); Term to = gt();
{ LOG( "to=%lx", to) ; } { LOG("to=%lx", to); }
if (IsPairTerm(to)) if (IsPairTerm(to))
return YAPTerm(HeadOfTerm(to)); return YAPTerm(HeadOfTerm(to));
else else
@ -349,30 +349,29 @@ YAPTerm YAPListTerm::car()
YAPVarTerm::YAPVarTerm() { YAPVarTerm::YAPVarTerm() {
CACHE_REGS CACHE_REGS
mk( MkVarTerm( ) ); mk(MkVarTerm());
} }
char *YAPAtom::getName(void) { char *YAPAtom::getName(void) {
if (IsWideAtom(a)) { if (IsWideAtom(a)) {
// return an UTF-8 version // return an UTF-8 version
size_t sz = 512; size_t sz = 512;
wchar_t * ptr = a->WStrOfAE; wchar_t *ptr = a->WStrOfAE;
utf8proc_int32_t ch = -1; utf8proc_int32_t ch = -1;
char *s = new char[sz], *op = s; char *s = new char[sz], *op = s;
while (ch) { while (ch) {
ch = *ptr++; ch = *ptr++;
op += put_utf8( (unsigned char *)op, ch); op += put_utf8((unsigned char *)op, ch);
} }
sz = strlen(s)+1; sz = strlen(s) + 1;
char *os = new char[sz]; char *os = new char[sz];
memcpy(os, s, sz); memcpy(os, s, sz);
delete[] s; delete[] s;
return os; return os;
} else if (IsBlob(a)) { } else if (IsBlob(a)) {
size_t sz = 1024; size_t sz = 1024;
char *s = new char [sz+1]; char *s = new char[sz + 1];
return Yap_blob_to_string( RepAtom(a) , s, sz); return Yap_blob_to_string(RepAtom(a), s, sz);
} else { } else {
return (char *)a->StrOfAE; return (char *)a->StrOfAE;
} }
@ -382,36 +381,25 @@ void YAPQuery::initOpenQ() {
CACHE_REGS CACHE_REGS
oq = LOCAL_execution; oq = LOCAL_execution;
LOCAL_execution = this; LOCAL_execution = this;
q_open=1; q_open = 1;
q_state=0; q_state = 0;
q_flags = true ; //PL_Q_PASS_EXCEPTION; q_flags = true; // PL_Q_PASS_EXCEPTION;
q_p = P; q_p = P;
q_cp = CP; q_cp = CP;
} }
int int YAPError::get() { return errNo; }
YAPError::get( )
{
return errNo;
}
const char * const char *YAPError::text() { return "YAP Error"; }
YAPError::text()
{
return "YAP Error";
}
void YAPQuery::initQuery(Term t) {
void
YAPQuery::initQuery( Term t )
{
CACHE_REGS CACHE_REGS
BACKUP_MACHINE_REGS(); BACKUP_MACHINE_REGS();
arity_t arity = ap->ArityOfPE; arity_t arity = ap->ArityOfPE;
goal = YAPTerm( t ); goal = YAPTerm(t);
if (arity) { if (arity) {
q_g = Yap_InitSlots( arity, RepAppl(t) + 1); q_g = Yap_InitSlots(arity, RepAppl(t) + 1);
} else { } else {
q_g = 0; q_g = 0;
} }
@ -419,69 +407,69 @@ YAPQuery::initQuery( Term t )
RECOVER_MACHINE_REGS(); RECOVER_MACHINE_REGS();
} }
void void YAPQuery::initQuery(YAPTerm ts[], arity_t arity) {
YAPQuery::initQuery( YAPTerm ts[], arity_t arity )
{
CACHE_REGS CACHE_REGS
BACKUP_MACHINE_REGS(); BACKUP_MACHINE_REGS();
if (arity) { if (arity) {
q_g = Yap_NewSlots( arity ); q_g = Yap_NewSlots(arity);
for (arity_t i=0; i < arity; i++) { for (arity_t i = 0; i < arity; i++) {
Yap_PutInSlot(q_g+i, ts[i].term()); Yap_PutInSlot(q_g + i, ts[i].term());
} }
Term t = Yap_MkApplTerm(ap->FunctorOfPred, ap->ArityOfPE, Yap_AddressFromSlot(q_g)); Term t = Yap_MkApplTerm(ap->FunctorOfPred, ap->ArityOfPE,
goal = YAPTerm( t ); Yap_AddressFromSlot(q_g));
goal = YAPTerm(t);
} else { } else {
q_g = 0; q_g = 0;
goal = YAPTerm( MkAtomTerm((Atom)ap->FunctorOfPred) ); goal = YAPTerm(MkAtomTerm((Atom)ap->FunctorOfPred));
} }
initOpenQ(); initOpenQ();
RECOVER_MACHINE_REGS(); RECOVER_MACHINE_REGS();
} }
YAPQuery::YAPQuery(YAPFunctor f, YAPTerm mod, YAPTerm ts[])
YAPQuery::YAPQuery(YAPFunctor f, YAPTerm mod, YAPTerm ts[]): YAPPredicate(f, mod) : YAPPredicate(f, mod) {
{
/* ignore flags for now */ /* ignore flags for now */
initQuery( ts , f.arity()); initQuery(ts, f.arity());
} }
YAPQuery::YAPQuery(YAPFunctor f, YAPTerm ts[]): YAPPredicate(f) YAPQuery::YAPQuery(YAPFunctor f, YAPTerm ts[]) : YAPPredicate(f) {
{
/* ignore flags for now */ /* ignore flags for now */
initQuery( ts , f.arity()); initQuery(ts, f.arity());
} }
YAPQuery::YAPQuery(YAPPredicate p, YAPTerm ts[]): YAPPredicate(p.ap) YAPQuery::YAPQuery(YAPPredicate p, YAPTerm ts[]) : YAPPredicate(p.ap) {
{ initQuery(ts, p.ap->ArityOfPE);
initQuery( ts , p.ap->ArityOfPE);
} }
YAPListTerm YAPQuery::namedVars() { YAPListTerm YAPQuery::namedVars() {
CACHE_REGS CACHE_REGS
Term o = vnames.term(); Term o = vnames.term();
Yap_DebugPlWrite(o); printf("<<<<<<<<<<<<<<<<-------------------------\n"); Yap_DebugPlWrite(o);
printf("<<<<<<<<<<<<<<<<-------------------------\n");
return o; // should be o return o; // should be o
} }
bool YAPQuery::next() bool YAPQuery::next() {
{
CACHE_REGS CACHE_REGS
int result; int result;
Yap_DebugPlWrite(vnames.term()); fprintf(stderr,"++++++++++++++\n"); Yap_DebugPlWrite(vnames.term());
fprintf(stderr, "++++++++++++++\n");
BACKUP_MACHINE_REGS(); BACKUP_MACHINE_REGS();
if (q_open != 1) return false; if (q_open != 1)
return false;
if (setjmp(q_env)) if (setjmp(q_env))
return false; return false;
// don't forget, on success these guys must create slots // don't forget, on success these guys must create slots
if (this->q_state == 0) { if (this->q_state == 0) {
fprintf(stderr,"+++++ ap=%p +++++++++\n", ap); fprintf(stderr, "+++++ ap=%p +++++++++\n", ap);
Yap_DebugPlWrite(Yap_GetFromSlot(q_g)); fprintf(stderr,"+++++ ap +++++++++\n"); Yap_DebugPlWrite(Yap_GetFromSlot(q_g));
result = (bool)YAP_EnterGoal((YAP_PredEntryPtr)ap, q_g, &q_h); fprintf(stderr, "+++++ ap +++++++++\n");
Yap_DebugPlWrite(Yap_GetFromSlot(q_g)); fprintf(stderr,"+++++ ap=%d +++++++++\n", result); result = (bool)YAP_EnterGoal((YAP_PredEntryPtr)ap, q_g, &q_h);
Yap_DebugPlWrite(Yap_GetFromSlot(q_g));
fprintf(stderr, "+++++ ap=%d +++++++++\n", result);
} else { } else {
LOCAL_AllowRestart = q_open; LOCAL_AllowRestart = q_open;
result = (bool)YAP_RetryGoal(&q_h); result = (bool)YAP_RetryGoal(&q_h);
@ -495,20 +483,19 @@ result = (bool)YAP_EnterGoal((YAP_PredEntryPtr)ap, q_g, &q_h);
return result; return result;
} }
void YAPQuery::cut() void YAPQuery::cut() {
{
CACHE_REGS CACHE_REGS
BACKUP_MACHINE_REGS(); BACKUP_MACHINE_REGS();
if (q_open != 1 || q_state == 0) return; if (q_open != 1 || q_state == 0)
return;
YAP_LeaveGoal(FALSE, &q_h); YAP_LeaveGoal(FALSE, &q_h);
q_open = 0; q_open = 0;
LOCAL_execution = this; LOCAL_execution = this;
RECOVER_MACHINE_REGS(); RECOVER_MACHINE_REGS();
} }
void YAPQuery::close() void YAPQuery::close() {
{
CACHE_REGS CACHE_REGS
RECOVER_MACHINE_REGS(); RECOVER_MACHINE_REGS();
@ -533,73 +520,67 @@ static YAPEngine *curren;
JNIEnv *Yap_jenv; JNIEnv *Yap_jenv;
JNIEXPORT jint JNICALL JNI_OnLoad(JavaVM* vm, void* reserved) { extern JNIEXPORT jint JNICALL JNI_MySQLOnLoad(JavaVM *vm, void *reserved);
JNIEnv* env;
if (vm->GetEnv(reinterpret_cast<void**>(&env), JNI_VERSION_1_6) != JNI_OK) { JNIEXPORT jint JNICALL JNI_MySQLOnLoad(JavaVM *vm, void *reserved) {
JNIEnv *env;
if (vm->GetEnv(reinterpret_cast<void **>(&env), JNI_VERSION_1_6) != JNI_OK) {
return -1; return -1;
} }
Yap_jenv = env; Yap_jenv = env;
return JNI_VERSION_1_6; return JNI_VERSION_1_6;
} }
extern char *Yap_AndroidBufp; char *Yap_AndroidBufp;
static size_t Yap_AndroidMax, Yap_AndroidSz; static size_t Yap_AndroidMax, Yap_AndroidSz;
extern void(*Yap_DisplayWithJava)(int c); extern void (*Yap_DisplayWithJava)(int c);
static void void Yap_displayWithJava(int c) {
displayWithJava(int c)
{
char *ptr = Yap_AndroidBufp; char *ptr = Yap_AndroidBufp;
ptr[ Yap_AndroidSz++ ] = c; if (!ptr)
if (Yap_AndroidMax-1 == Yap_AndroidSz) { ptr = Yap_AndroidBufp = (char *)malloc(Yap_AndroidSz);
if (Yap_AndroidMax < 32*1024) { ptr[Yap_AndroidSz++] = c;
if (Yap_AndroidMax - 1 == Yap_AndroidSz) {
if (Yap_AndroidMax < 32 * 1024) {
Yap_AndroidMax *= 2; Yap_AndroidMax *= 2;
} else { } else {
Yap_AndroidMax += 32*1024; Yap_AndroidMax += 32 * 1024;
} }
Yap_AndroidBufp = (char *)realloc( ptr, Yap_AndroidMax); Yap_AndroidBufp = (char *)realloc(ptr, Yap_AndroidMax);
} }
Yap_AndroidBufp[Yap_AndroidSz] = '\0'; Yap_AndroidBufp[Yap_AndroidSz] = '\0';
if (c == '\n' ) { if (c == '\n') {
Yap_AndroidBufp[Yap_AndroidSz] = '\0'; Yap_AndroidBufp[Yap_AndroidSz] = '\0';
curren->run(Yap_AndroidBufp); curren->run(Yap_AndroidBufp);
Yap_AndroidSz = 0; Yap_AndroidSz = 0;
} }
} }
extern "C" void Java_pt_up_fc_dcc_yap_JavaYap_load(JNIEnv *env0, jobject obj, jobject mgr); extern "C" void Java_pt_up_fc_dcc_yap_JavaYap_load(JNIEnv *env0, jobject obj,
jobject mgr);
extern "C" void Java_pt_up_fc_dcc_yap_JavaYap_load extern "C" void Java_pt_up_fc_dcc_yap_JavaYap_load(JNIEnv *env0, jobject obj,
(JNIEnv *env0, jobject obj, jobject asset_manager) jobject asset_manager) {
{
AAssetManager *mgr = AAssetManager_fromJava(Yap_jenv, asset_manager); AAssetManager *mgr = AAssetManager_fromJava(Yap_jenv, asset_manager);
if (mgr == NULL) { if (mgr == NULL) {
LOG( "we're doomed, mgr = 0; bip bip bip"); LOG("we're doomed, mgr = 0; bip bip bip");
} else { } else {
Yap_assetManager = mgr; Yap_assetManager = mgr;
} }
} }
#endif #endif
YAPEngine::YAPEngine(char *savedState, size_t stackSize, size_t trailSize,
YAPEngine::YAPEngine( char *savedState, size_t maxStackSize, size_t maxTrailSize, char *libDir,
size_t stackSize, char *bootFile, char *goal, char *topLevel, bool script,
size_t trailSize,
size_t maxStackSize,
size_t maxTrailSize,
char *libDir,
char *bootFile,
char *goal,
char *topLevel,
bool script,
bool fastBoot, bool fastBoot,
YAPCallback *cb): _callback(0) YAPCallback *cb)
{ // a single engine can be active : _callback(0) { // a single engine can be active
#if __ANDROID__ #if __ANDROID__
Yap_DisplayWithJava = displayWithJava;
Yap_AndroidBufp = (char *)malloc(Yap_AndroidMax = 4096); Yap_AndroidBufp = (char *)malloc(Yap_AndroidMax = 4096);
Yap_AndroidBufp[0] = '\0'; Yap_AndroidBufp[0] = '\0';
Yap_AndroidSz = 0; Yap_AndroidSz = 0;
@ -618,32 +599,32 @@ YAPEngine::YAPEngine( char *savedState,
init_args.FastBoot = fastBoot; init_args.FastBoot = fastBoot;
yerror = YAPError(); yerror = YAPError();
delYAPCallback(); delYAPCallback();
if (cb) setYAPCallback(cb); if (cb)
setYAPCallback(cb);
curren = this; curren = this;
if (YAP_Init( &init_args ) == YAP_BOOT_ERROR) if (YAP_Init(&init_args) == YAP_BOOT_ERROR)
throw(YAPError(SYSTEM_ERROR_INTERNAL)); throw(YAPError(SYSTEM_ERROR_INTERNAL));
} }
YAPPredicate::YAPPredicate(YAPAtom at) { YAPPredicate::YAPPredicate(YAPAtom at) {
CACHE_REGS CACHE_REGS
ap = RepPredProp(PredPropByAtom(at.a,Yap_CurrentModule())); ap = RepPredProp(PredPropByAtom(at.a, Yap_CurrentModule()));
} }
YAPPredicate::YAPPredicate(YAPAtom at, arity_t arity) { YAPPredicate::YAPPredicate(YAPAtom at, arity_t arity) {
CACHE_REGS CACHE_REGS
if (arity) { if (arity) {
Functor f = Yap_MkFunctor(at.a, arity); Functor f = Yap_MkFunctor(at.a, arity);
ap = RepPredProp(PredPropByFunc(f,Yap_CurrentModule())); ap = RepPredProp(PredPropByFunc(f, Yap_CurrentModule()));
} else { } else {
ap = RepPredProp(PredPropByAtom(at.a,Yap_CurrentModule())); ap = RepPredProp(PredPropByAtom(at.a, Yap_CurrentModule()));
} }
} }
/// auxiliary routine to find a predicate in the current module. /// auxiliary routine to find a predicate in the current module.
PredEntry *YAPPredicate::getPred( Term &t, Term* &outp ) { PredEntry *YAPPredicate::getPred(Term &t, Term *&outp) {
CACHE_REGS CACHE_REGS
Term m = Yap_CurrentModule() ; Term m = Yap_CurrentModule();
t = Yap_StripModule(t, &m); t = Yap_StripModule(t, &m);
if (IsVarTerm(t) || IsNumTerm(t)) { if (IsVarTerm(t) || IsNumTerm(t)) {
throw YAPError(TYPE_ERROR_NUMBER); throw YAPError(TYPE_ERROR_NUMBER);
@ -663,34 +644,24 @@ PredEntry *YAPPredicate::getPred( Term &t, Term* &outp ) {
throw YAPError(TYPE_ERROR_NUMBER); throw YAPError(TYPE_ERROR_NUMBER);
} else { } else {
ap = RepPredProp(PredPropByFunc(f, m)); ap = RepPredProp(PredPropByFunc(f, m));
outp = RepAppl(t)+1; outp = RepAppl(t) + 1;
} }
return ap; return ap;
} }
YAPPrologPredicate::YAPPrologPredicate(
YAPPrologPredicate::YAPPrologPredicate(YAPAtom name, YAPAtom name, arity_t arity, YAPModule mod, bool tabled,
arity_t arity, bool logical_updates, bool is_thread_local, bool sourced,
YAPModule mod, bool discontiguous, bool multiFile, bool hidden, bool untraceable,
bool tabled, bool unspyable, bool meta, bool moduleTransparent, bool quasiQuotable,
bool logical_updates, size_t mega_clause)
bool is_thread_local, : YAPPredicate(name, arity, mod) {
bool sourced, if (!ap)
bool discontiguous, return;
bool multiFile,
bool hidden,
bool untraceable,
bool unspyable,
bool meta,
bool moduleTransparent,
bool quasiQuotable,
size_t mega_clause
) : YAPPredicate(name, arity, mod) {
if (!ap) return;
if (is_thread_local) { if (is_thread_local) {
if (ap->cs.p_code.NOfClauses || tabled) if (ap->cs.p_code.NOfClauses || tabled)
return; return;
ap->PredFlags |= (ThreadLocalPredFlag|LogUpdatePredFlag); ap->PredFlags |= (ThreadLocalPredFlag | LogUpdatePredFlag);
} else if (logical_updates) { } else if (logical_updates) {
if (ap->cs.p_code.NOfClauses || tabled) if (ap->cs.p_code.NOfClauses || tabled)
return; return;
@ -738,13 +709,15 @@ YAPPrologPredicate::YAPPrologPredicate(YAPAtom name,
} }
} }
void *YAPPrologPredicate::assertClause( YAPTerm clause, bool last, YAPTerm source) { void *YAPPrologPredicate::assertClause(YAPTerm clause, bool last,
YAPTerm source) {
CACHE_REGS CACHE_REGS
RECOVER_MACHINE_REGS(); RECOVER_MACHINE_REGS();
Term tt = clause.gt(); Term tt = clause.gt();
Term sourcet = source.gt(); Term sourcet = source.gt();
yamop *codeaddr = Yap_cclause(tt, PP->ArityOfPE, Yap_CurrentModule(), sourcet); /* vsc: give the number of arguments yamop *codeaddr = Yap_cclause(tt, PP->ArityOfPE, Yap_CurrentModule(),
sourcet); /* vsc: give the number of arguments
to cclause in case there is overflow */ to cclause in case there is overflow */
Term ntt = clause.gt(); Term ntt = clause.gt();
if (LOCAL_ErrorMessage) { if (LOCAL_ErrorMessage) {
@ -752,15 +725,14 @@ void *YAPPrologPredicate::assertClause( YAPTerm clause, bool last, YAPTerm sourc
return 0; return 0;
} }
Term *tref = &ntt; Term *tref = &ntt;
if (Yap_addclause(ntt, codeaddr, (last ? TermAssertz : TermAsserta), Yap_CurrentModule(), tref)) { if (Yap_addclause(ntt, codeaddr, (last ? TermAssertz : TermAsserta),
Yap_CurrentModule(), tref)) {
RECOVER_MACHINE_REGS(); RECOVER_MACHINE_REGS();
} }
return tref; return tref;
return 0; return 0;
} }
void* YAPPrologPredicate::retractClause( YAPTerm skeleton, bool all) { void *YAPPrologPredicate::retractClause(YAPTerm skeleton, bool all) {
return 0;
}
void* YAPPrologPredicate::clause( YAPTerm skeleton, YAPTerm &body ) {
return 0; return 0;
} }
void *YAPPrologPredicate::clause(YAPTerm skeleton, YAPTerm &body) { return 0; }