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

16
CXX/CMakeLists.txt
View File

@ -4,8 +4,7 @@ set(SO_MAJOR 1)
set(SO_MINOR 0)
set(SO_PATCH 0)
add_library (Yap++ SHARED
set (CXX_SOURCES
yapa.hh
yapdb.hh
yapi.cpp
@ -15,7 +14,15 @@ add_library (Yap++ SHARED
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)
@ -23,6 +30,9 @@ install(TARGETS Yap++
LIBRARY 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_LIBRARIES ${CMAKE_REQUIRED_LIBRARIES} ${GMP_LIBRARIES} )

214
CXX/yapi.cpp
View File

@ -8,14 +8,16 @@ extern "C" {
#include "YapInterface.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_UserCPredicateWithArgs(const char *, YAP_UserCPred, YAP_Arity, YAP_Term);
void YAP_UserBackCPredicate(const char *, YAP_UserCPred, YAP_UserCPred, YAP_Arity, YAP_Arity);
void YAP_UserCPredicateWithArgs(const char *, YAP_UserCPred, YAP_Arity,
YAP_Term);
void YAP_UserBackCPredicate(const char *, YAP_UserCPred, YAP_UserCPred,
YAP_Arity, YAP_Arity);
}
YAPAtomTerm::YAPAtomTerm(char *s) { // build string
BACKUP_H();
@ -26,11 +28,11 @@ YAPAtomTerm::YAPAtomTerm(char *s) { // build string
out.type = YAP_STRING_ATOM;
if (Yap_CVT_Text(&inp, &out PASS_REGS))
mk(MkAtomTerm(out.val.a));
else t = 0L;
else
t = 0L;
RECOVER_H();
}
YAPAtomTerm::YAPAtomTerm(char *s, size_t len) { // build string
BACKUP_H();
@ -43,7 +45,8 @@ YAPAtomTerm::YAPAtomTerm(char *s, size_t len) { // build string
out.max = len;
if (Yap_CVT_Text(&inp, &out PASS_REGS))
mk(MkAtomTerm(out.val.a));
else t = 0L;
else
t = 0L;
RECOVER_H();
}
@ -57,11 +60,11 @@ YAPAtomTerm::YAPAtomTerm(wchar_t *s): YAPTerm() { // build string
out.type = YAP_STRING_ATOM;
if (Yap_CVT_Text(&inp, &out PASS_REGS))
mk(MkAtomTerm(out.val.a));
else t = 0L;
else
t = 0L;
RECOVER_H();
}
YAPAtomTerm::YAPAtomTerm(wchar_t *s, size_t len) : YAPTerm() { // build string
BACKUP_H();
@ -74,11 +77,11 @@ YAPAtomTerm::YAPAtomTerm(wchar_t *s, size_t len) : YAPTerm() { // build string
out.max = len;
if (Yap_CVT_Text(&inp, &out PASS_REGS))
mk(MkAtomTerm(out.val.a));
else t = 0L;
else
t = 0L;
RECOVER_H();
}
YAPStringTerm::YAPStringTerm(char *s) { // build string
BACKUP_H();
@ -89,11 +92,11 @@ YAPStringTerm::YAPStringTerm(char *s) { // build string
out.type = YAP_STRING_STRING;
if (Yap_CVT_Text(&inp, &out PASS_REGS))
mk(out.val.t);
else t = 0L;
else
t = 0L;
RECOVER_H();
}
YAPStringTerm::YAPStringTerm(char *s, size_t len) { // build string
BACKUP_H();
@ -107,7 +110,8 @@ YAPStringTerm::YAPStringTerm(char *s, size_t len) { // build string
out.max = len;
if (Yap_CVT_Text(&inp, &out PASS_REGS))
mk(out.val.t);
else t = 0L;
else
t = 0L;
RECOVER_H();
}
@ -122,12 +126,13 @@ YAPStringTerm::YAPStringTerm(wchar_t *s): YAPTerm() { // build string
out.type = YAP_STRING_STRING;
if (Yap_CVT_Text(&inp, &out PASS_REGS))
mk(out.val.t);
else t = 0L;
else
t = 0L;
RECOVER_H();
}
YAPStringTerm::YAPStringTerm(wchar_t *s, size_t len) : YAPTerm() { // build string
YAPStringTerm::YAPStringTerm(wchar_t *s, size_t len)
: YAPTerm() { // build string
BACKUP_H();
CACHE_REGS
@ -140,11 +145,11 @@ YAPStringTerm::YAPStringTerm(wchar_t *s, size_t len) : YAPTerm() { // build stri
out.max = len;
if (Yap_CVT_Text(&inp, &out PASS_REGS))
mk(out.val.t);
else t = 0L;
else
t = 0L;
RECOVER_H();
}
YAPApplTerm::YAPApplTerm(YAPFunctor f, YAPTerm ts[]) : YAPTerm() {
BACKUP_H();
UInt arity = ArityOfFunctor(f.f);
@ -166,9 +171,7 @@ YAPTerm YAPApplTerm::getArg(int arg) {
return to;
}
YAPFunctor YAPApplTerm::getFunctor() {
return YAPFunctor( FunctorOfTerm( gt( )) );
}
YAPFunctor YAPApplTerm::getFunctor() { return YAPFunctor(FunctorOfTerm(gt())); }
YAPPairTerm::YAPPairTerm(YAPTerm th, YAPTerm tl) : YAPTerm() {
CACHE_REGS
@ -299,23 +302,21 @@ const char *YAPTerm::text() {
encoding_t enc = LOCAL_encoding;
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;
}
RECOVER_MACHINE_REGS();
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()
{
@ -337,8 +338,7 @@ YAPTerm::YAPTerm(intptr_t i) {
mk(tn);
}
YAPTerm YAPListTerm::car()
{
YAPTerm YAPListTerm::car() {
Term to = gt();
{ LOG("to=%lx", to); }
if (IsPairTerm(to))
@ -352,7 +352,6 @@ YAPVarTerm::YAPVarTerm() {
mk(MkVarTerm());
}
char *YAPAtom::getName(void) {
if (IsWideAtom(a)) {
// return an UTF-8 version
@ -390,22 +389,11 @@ void YAPQuery::initOpenQ() {
q_cp = CP;
}
int
YAPError::get( )
{
return errNo;
}
int YAPError::get() { return errNo; }
const char *
YAPError::text()
{
return "YAP Error";
}
const char *YAPError::text() { return "YAP Error"; }
void
YAPQuery::initQuery( Term t )
{
void YAPQuery::initQuery(Term t) {
CACHE_REGS
BACKUP_MACHINE_REGS();
arity_t arity = ap->ArityOfPE;
@ -419,9 +407,7 @@ YAPQuery::initQuery( Term t )
RECOVER_MACHINE_REGS();
}
void
YAPQuery::initQuery( YAPTerm ts[], arity_t arity )
{
void YAPQuery::initQuery(YAPTerm ts[], arity_t arity) {
CACHE_REGS
BACKUP_MACHINE_REGS();
@ -430,7 +416,8 @@ YAPQuery::initQuery( YAPTerm ts[], arity_t arity )
for (arity_t i = 0; i < arity; i++) {
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,
Yap_AddressFromSlot(q_g));
goal = YAPTerm(t);
} else {
q_g = 0;
@ -440,48 +427,49 @@ YAPQuery::initQuery( YAPTerm ts[], arity_t arity )
RECOVER_MACHINE_REGS();
}
YAPQuery::YAPQuery(YAPFunctor f, YAPTerm mod, YAPTerm ts[]): YAPPredicate(f, mod)
{
YAPQuery::YAPQuery(YAPFunctor f, YAPTerm mod, YAPTerm ts[])
: YAPPredicate(f, mod) {
/* ignore flags for now */
initQuery(ts, f.arity());
}
YAPQuery::YAPQuery(YAPFunctor f, YAPTerm ts[]): YAPPredicate(f)
{
YAPQuery::YAPQuery(YAPFunctor f, YAPTerm ts[]) : YAPPredicate(f) {
/* ignore flags for now */
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);
}
YAPListTerm YAPQuery::namedVars() {
CACHE_REGS
Term o = vnames.term();
Yap_DebugPlWrite(o); printf("<<<<<<<<<<<<<<<<-------------------------\n");
Yap_DebugPlWrite(o);
printf("<<<<<<<<<<<<<<<<-------------------------\n");
return o; // should be o
}
bool YAPQuery::next()
{
bool YAPQuery::next() {
CACHE_REGS
int result;
Yap_DebugPlWrite(vnames.term()); fprintf(stderr,"++++++++++++++\n");
Yap_DebugPlWrite(vnames.term());
fprintf(stderr, "++++++++++++++\n");
BACKUP_MACHINE_REGS();
if (q_open != 1) return false;
if (q_open != 1)
return false;
if (setjmp(q_env))
return false;
// don't forget, on success these guys must create slots
if (this->q_state == 0) {
fprintf(stderr, "+++++ ap=%p +++++++++\n", ap);
Yap_DebugPlWrite(Yap_GetFromSlot(q_g)); fprintf(stderr,"+++++ ap +++++++++\n");
Yap_DebugPlWrite(Yap_GetFromSlot(q_g));
fprintf(stderr, "+++++ ap +++++++++\n");
result = (bool)YAP_EnterGoal((YAP_PredEntryPtr)ap, q_g, &q_h);
Yap_DebugPlWrite(Yap_GetFromSlot(q_g)); fprintf(stderr,"+++++ ap=%d +++++++++\n", result);
Yap_DebugPlWrite(Yap_GetFromSlot(q_g));
fprintf(stderr, "+++++ ap=%d +++++++++\n", result);
} else {
LOCAL_AllowRestart = q_open;
result = (bool)YAP_RetryGoal(&q_h);
@ -495,20 +483,19 @@ result = (bool)YAP_EnterGoal((YAP_PredEntryPtr)ap, q_g, &q_h);
return result;
}
void YAPQuery::cut()
{
void YAPQuery::cut() {
CACHE_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);
q_open = 0;
LOCAL_execution = this;
RECOVER_MACHINE_REGS();
}
void YAPQuery::close()
{
void YAPQuery::close() {
CACHE_REGS
RECOVER_MACHINE_REGS();
@ -533,24 +520,28 @@ static YAPEngine *curren;
JNIEnv *Yap_jenv;
JNIEXPORT jint JNICALL JNI_OnLoad(JavaVM* vm, void* reserved) {
extern JNIEXPORT jint JNICALL JNI_MySQLOnLoad(JavaVM *vm, void *reserved);
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;
}
Yap_jenv = env;
return JNI_VERSION_1_6;
}
extern char *Yap_AndroidBufp;
char *Yap_AndroidBufp;
static size_t Yap_AndroidMax, Yap_AndroidSz;
extern void (*Yap_DisplayWithJava)(int c);
static void
displayWithJava(int c)
{
void Yap_displayWithJava(int c) {
char *ptr = Yap_AndroidBufp;
if (!ptr)
ptr = Yap_AndroidBufp = (char *)malloc(Yap_AndroidSz);
ptr[Yap_AndroidSz++] = c;
if (Yap_AndroidMax - 1 == Yap_AndroidSz) {
if (Yap_AndroidMax < 32 * 1024) {
@ -568,11 +559,11 @@ displayWithJava(int c)
}
}
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
(JNIEnv *env0, jobject obj, jobject asset_manager)
{
extern "C" void Java_pt_up_fc_dcc_yap_JavaYap_load(JNIEnv *env0, jobject obj,
jobject asset_manager) {
AAssetManager *mgr = AAssetManager_fromJava(Yap_jenv, asset_manager);
if (mgr == NULL) {
LOG("we're doomed, mgr = 0; bip bip bip");
@ -581,25 +572,15 @@ extern "C" void Java_pt_up_fc_dcc_yap_JavaYap_load
}
}
#endif
YAPEngine::YAPEngine( char *savedState,
size_t stackSize,
size_t trailSize,
size_t maxStackSize,
size_t maxTrailSize,
char *libDir,
char *bootFile,
char *goal,
char *topLevel,
bool script,
YAPEngine::YAPEngine(char *savedState, size_t stackSize, size_t trailSize,
size_t maxStackSize, size_t maxTrailSize, char *libDir,
char *bootFile, char *goal, char *topLevel, bool script,
bool fastBoot,
YAPCallback *cb): _callback(0)
{ // a single engine can be active
YAPCallback *cb)
: _callback(0) { // a single engine can be active
#if __ANDROID__
Yap_DisplayWithJava = displayWithJava;
Yap_AndroidBufp = (char *)malloc(Yap_AndroidMax = 4096);
Yap_AndroidBufp[0] = '\0';
Yap_AndroidSz = 0;
@ -618,13 +599,13 @@ YAPEngine::YAPEngine( char *savedState,
init_args.FastBoot = fastBoot;
yerror = YAPError();
delYAPCallback();
if (cb) setYAPCallback(cb);
if (cb)
setYAPCallback(cb);
curren = this;
if (YAP_Init(&init_args) == YAP_BOOT_ERROR)
throw(YAPError(SYSTEM_ERROR_INTERNAL));
}
YAPPredicate::YAPPredicate(YAPAtom at) {
CACHE_REGS
ap = RepPredProp(PredPropByAtom(at.a, Yap_CurrentModule()));
@ -668,25 +649,15 @@ PredEntry *YAPPredicate::getPred( Term &t, Term* &outp ) {
return ap;
}
YAPPrologPredicate::YAPPrologPredicate(YAPAtom name,
arity_t arity,
YAPModule mod,
bool tabled,
bool logical_updates,
bool is_thread_local,
bool sourced,
bool discontiguous,
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;
YAPPrologPredicate::YAPPrologPredicate(
YAPAtom name, arity_t arity, YAPModule mod, bool tabled,
bool logical_updates, bool is_thread_local, bool sourced,
bool discontiguous, 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 (ap->cs.p_code.NOfClauses || tabled)
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
RECOVER_MACHINE_REGS();
Term tt = clause.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 */
Term ntt = clause.gt();
if (LOCAL_ErrorMessage) {
@ -752,7 +725,8 @@ void *YAPPrologPredicate::assertClause( YAPTerm clause, bool last, YAPTerm sourc
return 0;
}
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();
}
return tref;
@ -761,6 +735,4 @@ void *YAPPrologPredicate::assertClause( YAPTerm clause, bool last, YAPTerm sourc
void *YAPPrologPredicate::retractClause(YAPTerm skeleton, bool all) {
return 0;
}
void* YAPPrologPredicate::clause( YAPTerm skeleton, YAPTerm &body ) {
return 0;
}
void *YAPPrologPredicate::clause(YAPTerm skeleton, YAPTerm &body) { return 0; }