diff --git a/C/scanner.c b/C/scanner.c index c5bde12e0..d3f59f21f 100755 --- a/C/scanner.c +++ b/C/scanner.c @@ -871,7 +871,7 @@ static int num_send_error_message(char s[]) { #define number_overflow() \ { \ - size_t nsz = min(max_size * 2, max_size); \ + size_t nsz = Yap_Min(max_size * 2, max_size); \ char *nbuf; \ \ if (buf == buf0) { \ @@ -1406,7 +1406,7 @@ TokEntry *Yap_tokenizer(struct stream_desc *inp_stream, bool store_comments, for (; chtype(ch) <= NU; ch = getchr(inp_stream)) { if (charp == TokImage + (sz - 1)) { unsigned char *p0 = TokImage; - sz = min(sz * 2, sz + MBYTE); + sz = Yap_Min(sz * 2, sz + MBYTE); TokImage = Realloc(p0, sz); if (TokImage == NULL) { return CodeSpaceError(t, p, l); @@ -1560,7 +1560,7 @@ TokEntry *Yap_tokenizer(struct stream_desc *inp_stream, bool store_comments, while (TRUE) { if (charp > TokImage + (sz - 1)) { - TokImage = Realloc(TokImage, min(sz * 2, sz + MBYTE)); + TokImage = Realloc(TokImage, Yap_Min(sz * 2, sz + MBYTE)); if (TokImage == NULL) { return CodeSpaceError(t, p, l); } @@ -1735,7 +1735,7 @@ TokEntry *Yap_tokenizer(struct stream_desc *inp_stream, bool store_comments, add_ch_to_buff(och); for (; chtype(ch) == SY; ch = getchr(inp_stream)) { if (charp >= TokImage + (sz - 10)) { - sz = min(sz * 2, sz + MBYTE); + sz = Yap_Min(sz * 2, sz + MBYTE); TokImage = Realloc(TokImage, sz); if (!TokImage) return CodeSpaceError(t, p, l); diff --git a/CMakeLists.txt b/CMakeLists.txt index fd4a894ea..086a75aa5 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -91,12 +91,12 @@ endif() OPTION (WITH_SWIG " Enable SWIG interfaces to foreign languages" ON) -IF (WITH_SWIG) +IF (WITH_SWIG OR ANDROID) find_host_package (SWIG) macro_log_feature (SWIG_FOUND "Swig" "Use SWIG Interface Generator " "http://www.swig.org" ON) -ENDIF (WITH_SWIG) +ENDIF (WITH_SWIG OR ANDROID) option (WITH_PYTHON "Allow Python->YAP and YAP->Python" ON) @@ -106,37 +106,20 @@ IF (WITH_PYTHON) ENDIF (WITH_PYTHON) -IF (SWIG_FOUND) - add_subDIRECTORY (packages/swig NO_POLICY_SCOPE) -ENDIF(SWIG_FOUND) - - - -if (ANDROID) - - ADD_SUBDIRECTORY(os) - ADD_SUBDIRECTORY(OPTYap) - ADD_SUBDIRECTORY(packages/myddas) - ADD_SUBDIRECTORY(utf8proc) - ADD_SUBDIRECTORY(CXX) - - -else() List (APPEND YLIBS $ ) List (APPEND YLIBS $ ) List (APPEND YLIBS $ ) List (APPEND YLIBS $ ) - List (APPEND YLIBS $ ) List (APPEND YLIBS $ ) if (WIN32) + List (APPEND YLIBS $ ) List (APPEND YLIBS $ ) if (WITH_PYTHON ) List (APPEND YLIBS $ ) endif() endif() -endif() @@ -167,8 +150,6 @@ if (USE_READLINE) endif (USE_READLINE) if (ANDROID) - add_dependencies(libYap plmyddas ) - target_link_libraries(libYap android log) endif () @@ -192,4 +173,9 @@ if (PYTHONLIBS_FOUND AND SWIG_FOUND) ENDIF() endif() + +IF (SWIG_FOUND OR ANDROID) + add_subDIRECTORY (packages/swig NO_POLICY_SCOPE) +ENDIF() + include(Config NO_POLICY_SCOPE) diff --git a/CXX/yapi.cpp b/CXX/yapi.cpp index c093aa681..3295b37ea 100644 --- a/CXX/yapi.cpp +++ b/CXX/yapi.cpp @@ -27,12 +27,14 @@ X_API void YAP_UserBackCPredicate(const char *, YAP_UserCPred, YAP_UserCPred, } +static YAPEngine *curren; + YAPAtomTerm::YAPAtomTerm(char *s) { // build string BACKUP_H(); CACHE_REGS - seq_tv_t inp, out; + seq_tv_t inp, out; inp.val.c = s; inp.type = YAP_STRING_CHARS; out.type = YAP_STRING_ATOM; @@ -187,6 +189,7 @@ YAPApplTerm::YAPApplTerm(std::string f, std::vector ts) mk(o); } + YAPApplTerm::YAPApplTerm(YAPFunctor f) : YAPTerm() { BACKUP_H(); @@ -633,20 +636,20 @@ YAPQuery::YAPQuery(YAPFunctor f, YAPTerm mod, YAPTerm ts[]) /* ignore flags for now */ BACKUP_MACHINE_REGS(); Term *nts; - Term goal; + Term tgoal; if ( ts) { - goal = YAPApplTerm(f, ts).term(); - nts = RepAppl(goal)+1; + goal = new YAPApplTerm(f, ts); + nts = RepAppl(goal->term())+1; } else { - goal = MkVarTerm(); + goal = new YAPVarTerm(); nts = nullptr; } - openQuery(goal, nts); - names = YAPPairTerm( TermNil ); - RECOVER_MACHINE_REGS(); + openQuery(goal->term(), nts); + names = new YAPPairTerm(); + RECOVER_MACHINE_REGS(); } #if 0 @@ -655,12 +658,13 @@ YAPQuery::YAPQuery(YAPFunctor f, YAPTerm ts[]) : YAPPredicate(f) { BACKUP_MACHINE_REGS(); CELL *nts; if (ts) { - goal = YAPApplTerm(f, nts); + tgoal = YAPApplTerm(f, nts); } else { - goal = YAPVarTerm(); + tgoal = YAPVarTerm(); nts = nullptr; } - names = YAPPairTerm( TermNil ); + *names = new YAPPairTerm(); + *goal = new YAPTerm(tgoal); openQuery(goal.term(), nts); RECOVER_MACHINE_REGS(); } @@ -671,19 +675,19 @@ YAPQuery::YAPQuery(YAPTerm t) : YAPPredicate(t) BACKUP_MACHINE_REGS(); CELL *nts; Term tt = t.term(); - goal = t; if (IsApplTerm(tt)) { Functor f = FunctorOfTerm(tt); if (IsExtensionFunctor(f)) - nts = nullptr; - nts = RepAppl(goal.term())+1; + nts = nullptr; + nts = RepAppl(tt)+1; } else if (IsPairTerm(tt)) { nts = RepPair(tt); } else { nts = nullptr; } openQuery(tt, nts); - names = YAPPairTerm( TermNil ); + names = new YAPPairTerm(); + goal = new YAPTerm(t); RECOVER_MACHINE_REGS(); } @@ -692,15 +696,15 @@ YAPQuery::YAPQuery(YAPPredicate p, YAPTerm ts[]) : YAPPredicate(p.ap) { BACKUP_MACHINE_REGS(); 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(goal.term(), nullptr); + goal = new YAPApplTerm(YAPFunctor(p.ap->FunctorOfPred), ts); + for (arity_t i =0; i < arity; i++) { + XREGS[i + 1] = ts[i].term(); + } } else { - goal = YAPAtomTerm((Atom)(p.ap->FunctorOfPred)); - openQuery(goal.term(), nullptr); + goal = new YAPAtomTerm((Atom)(p.ap->FunctorOfPred)); } - names = TermNil; + openQuery(goal->term(), nullptr); + names = new YAPPairTerm(); RECOVER_MACHINE_REGS(); } @@ -709,6 +713,11 @@ bool YAPQuery::next() CACHE_REGS bool result = false; Term terr; + __android_log_print(ANDROID_LOG_INFO, "YAPDroid", "next %d %ld", + q_state, LOCAL_CurSlot); + __android_log_print(ANDROID_LOG_INFO, "YAPDroid", "next %d %s %ld", + q_state, names->text(), LOCAL_CurSlot); + if (ap == NULL || ap->OpcodeOfPred == UNDEF_OPCODE) { ap = rewriteUndefQuery(); } @@ -718,7 +727,7 @@ bool YAPQuery::next() BACKUP_MACHINE_REGS(); if (!q_open) return false; - if (sigsetjmp(q_env, false)) + if (false && sigsetjmp(q_env, false)) { throw YAPError(); } @@ -736,57 +745,57 @@ bool YAPQuery::next() } if (result) { - __android_log_print(ANDROID_LOG_INFO, "YAPDroid", "vnames %d %s %ld", - q_state, vnames.text(), LOCAL_CurSlot); + __android_log_print(ANDROID_LOG_INFO, "YAPDroid", "names %d %s %ld", + q_state, names->text(), LOCAL_CurSlot); } else - { - __android_log_print(ANDROID_LOG_INFO, "YAPDroid", "fail"); - } + { + __android_log_print(ANDROID_LOG_INFO, "YAPDroid", "fail"); + } q_state = 1; if ((terr = Yap_GetException())) - { - if ((terr = Yap_GetException())) { - throw YAPError(); + if ((terr = Yap_GetException())) + { + 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; - } + { + YAP_LeaveGoal(false, &q_h); + Yap_CloseHandles(q_handles); + q_open = false; + } else - { - q_handles = Yap_StartSlots(); - } + { + q_handles = Yap_StartSlots(); + } RECOVER_MACHINE_REGS(); 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"; - throw 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"; + throw e; + } } PredEntry * YAPQuery::rewriteUndefQuery() { Term ts[3]; - ARG1 = ts[0] = goal.term(); + ARG1 = ts[0] = goal->term(); ARG2 = ts[1] = ap->ModuleOfPred; ARG3 = ts[2] = Yap_cp_as_integer(B PASS_REGS); - goal = YAPApplTerm(FunctorUndefinedQuery, ts); + goal = new YAPApplTerm(FunctorUndefinedQuery, ts); return ap = PredUndefinedQuery; } @@ -868,39 +877,6 @@ JNIEXPORT jint JNICALL JNI_MySQLOnLoad(JavaVM *vm, void *reserved) return JNI_VERSION_1_6; } -char *Yap_AndroidBufp; - -static size_t Yap_AndroidMax, Yap_AndroidSz; - -extern void (*Yap_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) - { - Yap_AndroidMax *= 2; - } - else - { - Yap_AndroidMax += 32 * 1024; - } - Yap_AndroidBufp = (char *)realloc(ptr, Yap_AndroidMax); - } - Yap_AndroidBufp[Yap_AndroidSz] = '\0'; - if (c == '\n') - { - Yap_AndroidBufp[Yap_AndroidSz] = '\0'; - curren->run(Yap_AndroidBufp); - Yap_AndroidSz = 0; - } -} - #endif @@ -913,22 +889,18 @@ void YAPEngine::doInit(YAP_file_type_t BootMode) /* Begin preprocessor code */ /* live */ __android_log_print(ANDROID_LOG_INFO, "YAPDroid", "initialize_prolog"); -#if __ANDROID__ - Yap_AndroidBufp = (char *)malloc(Yap_AndroidMax = 4096); - Yap_AndroidBufp[0] = '\0'; - Yap_AndroidSz = 0; -#endif + curren = this; //yerror = YAPError(); #if YAP_PYTHON - do_init_python(); + do_init_python(); #endif - YAP_PredEntryPtr p = YAP_AtomToPred( YAP_LookupAtom("initialize_prolog") ); - YAPQuery initq = YAPQuery(YAPPredicate(p), nullptr); - if (initq.next()) - { - initq.cut(); - } - CurrentModule = TermUser; + YAP_PredEntryPtr p = YAP_AtomToPred( YAP_LookupAtom("initialize_prolog") ); + YAPQuery initq = YAPQuery(YAPPredicate(p), nullptr); + if (initq.next()) + { + initq.cut(); + } + CurrentModule = TermUser; } diff --git a/CXX/yapq.hh b/CXX/yapq.hh index 87a267812..d0907bbdc 100644 --- a/CXX/yapq.hh +++ b/CXX/yapq.hh @@ -41,8 +41,8 @@ class X_API YAPQuery : public YAPPredicate int q_flags; YAP_dogoalinfo q_h; YAPQuery *oq; - YAPPairTerm names; - YAPTerm goal; + YAPPairTerm *names; + YAPTerm *goal; // temporaries Term tnames, tgoal ; @@ -55,6 +55,8 @@ class X_API YAPQuery : public YAPPredicate q_p = P; q_cp = CP; // make sure this is safe + names = new YAPPairTerm(); + goal = new YAPTerm(); q_handles = LOCAL_CurSlot; }; @@ -97,8 +99,7 @@ YAPQuery() { LOCAL_CurSlot); if (!ap) return; - __android_log_print(ANDROID_LOG_INFO, "YAPDroid", "%s", vnames.text()); - goal = YAPTerm(tgoal); + __android_log_print(ANDROID_LOG_INFO, "YAPDroid", "ŸAPQuery"); if (IsPairTerm(tgoal)) { qt = RepPair(tgoal); tgoal = Yap_MkApplTerm(Yap_MkFunctor(Yap_LookupAtom("consult"), 1),1,qt); @@ -108,8 +109,11 @@ YAPQuery() { qt = RepAppl(tgoal)+1; } } - names = YAPPairTerm(tnames); - openQuery(tgoal, qt); + names = new YAPPairTerm(); + goal = new YAPTerm(tgoal); + __android_log_print(ANDROID_LOG_INFO, "YAPDroid", "names %d %s %ld", + q_state, names->text(), LOCAL_CurSlot); + openQuery(tgoal, qt); }; // inline YAPQuery() : YAPPredicate(s, tgoal, tnames) // { @@ -117,7 +121,7 @@ YAPQuery() { // LOCAL_CurSlot); // if (!ap) // return; - // __android_log_print(ANDROID_LOG_INFO, "YAPDroid", "%s", vnames.text()); + // __android_log_print(ANDROID_LOG_INFO, "YAPDroid", "%s", names->text()); // goal = YAPTerm(tgoal); // names = YAPPairTerm(tnames); // openQuery(tgoal); @@ -130,40 +134,39 @@ YAPQuery() { /// 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 -void resetFlag(int flag) { q_flags &= ~flag; } -/// first query -/// -/// actually implemented by calling the next(); -inline bool first() { return next(); } -/// ask for the next solution of the current query -/// same call for every solution -bool next(); -/// does this query have open choice-points? -/// or is it deterministic? -bool deterministic(); -/// represent the top-goal -const char *text(); -/// remove alternatives in the current search space, and finish the current -/// query -/// finish the current query: undo all bindings. -void close(); -/// query variables. -void cut(); -Term namedVars() {return names.term(); }; -/// query variables, but copied out -std::vector namedVarsVector() { - return names.listToArray(); }; -/// convert a ref to a binding. -YAPTerm getTerm(yhandle_t t); -/// simple YAP Query; -/// just calls YAP and reports success or failure, Useful when we just -/// want things done, eg YAPCommand("load_files(library(lists), )") -inline bool command() -{ - bool rc = next(); - close(); - return rc; -}; + void resetFlag(int flag) { q_flags &= ~flag; } + /// first query + /// + /// actually implemented by calling the next(); + inline bool first() { return next(); } + /// ask for the next solution of the current query + /// same call for every solution + bool next(); + /// does this query have open choice-points? + /// or is it deterministic? + bool deterministic(); + /// represent the top-goal + const char *text(); + /// remove alternatives in the current search space, and finish tnamedyaphe current + /// query + /// finish the current query: undo all bindings. + void close(); + /// query variables. + void cut(); + + Term namedVars() {return names->term(); }; + YAPPairTerm * namedYAPVars() {return names; }; + /// query variables, but copied out + YAPTerm getTerm(yhandle_t t); + /// simple YAP Query; + /// just calls YAP and reports success or failure, Useful when we just + /// want things done, eg YAPCommand("load_files(library(lists), )") + inline bool command() + { + bool rc = next(); + close(); + return rc; + }; }; // Java support diff --git a/CXX/yapt.hh b/CXX/yapt.hh index 74dc5537a..68d4a7182 100644 --- a/CXX/yapt.hh +++ b/CXX/yapt.hh @@ -28,7 +28,7 @@ extern "C" { - X_API Term YAP_ReadBuffer(const char *s, Term *tp); +X_API Term YAP_ReadBuffer(const char *s, Term *tp); } class YAPError; @@ -37,59 +37,69 @@ class YAPError; * @brief Generic Prolog Term */ class X_API YAPTerm { - friend class YAPPredicate; - friend class YAPPrologPredicate; - friend class YAPQuery; - friend class YAPModule; - friend class YAPModuleProp; - friend class YAPApplTerm; - friend class YAPListTerm; + friend class YAPPredicate; + + friend class YAPPrologPredicate; + + friend class YAPQuery; + + friend class YAPModule; + + friend class YAPModuleProp; + + friend class YAPApplTerm; + + friend class YAPListTerm; protected: - yhandle_t t; /// handle to term, equivalent to term_t + yhandle_t t; /// handle to term, equivalent to term_t public: - Term gt() { - CACHE_REGS - // fprintf(stderr,"?%d,%lx,%p\n",t,LOCAL_HandleBase[t], HR); - // Yap_DebugPlWriteln(LOCAL_HandleBase[t]); - return Yap_GetFromSlot(t); - }; + Term gt() { + CACHE_REGS + // fprintf(stderr,"?%d,%lx,%p\n",t,LOCAL_HandleBase[t], HR); + // Yap_DebugPlWriteln(LOCAL_HandleBase[t]); + return Yap_GetFromSlot(t); + }; - void mk(Term t0) { - CACHE_REGS t = Yap_InitSlot(t0); - // fprintf(stderr,"+%d,%lx,%p,%p",t,t0,HR,ASP); Yap_DebugPlWriteln(t0); - }; + void mk(Term t0) { + CACHE_REGS t = Yap_InitSlot(t0); + // fprintf(stderr,"+%d,%lx,%p,%p",t,t0,HR,ASP); Yap_DebugPlWriteln(t0); + }; - void put(Term t0) { - Yap_PutInHandle(t, t0); - // fprintf(stderr,"+%d,%lx,%p,%p",t,t0,HR,ASP); Yap_DebugPlWriteln(t0); - }; + void put(Term t0) { + Yap_PutInHandle(t, t0); + // fprintf(stderr,"+%d,%lx,%p,%p",t,t0,HR,ASP); Yap_DebugPlWriteln(t0); + }; - YAPTerm(Term tn) { mk(tn); }; + YAPTerm(Term tn) { mk(tn); }; #ifdef SWIGPYTHON - // YAPTerm(struct _object *inp) { - // Term tinp = pythonToYAP(inp); - // t = Yap_InitSlot(tinp); - //} + // YAPTerm(struct _object *inp) { + // Term tinp = pythonToYAP(inp); + // t = Yap_InitSlot(tinp); + //} #endif - /// private method to convert from Term (internal YAP representation) to - /// YAPTerm - // do nothing constructor - YAPTerm() { t=0; }; - // YAPTerm(yhandle_t i) { t = i; }; - /// pointer to term - YAPTerm(void *ptr); - /// parse string s and construct a term. - YAPTerm(char *s) { - Term tp; - mk(YAP_ReadBuffer(s, &tp)); - } + + /// private method to convert from Term (internal YAP representation) to + /// YAPTerm + // do nothing constructor + YAPTerm() { t = 0; }; + + // YAPTerm(yhandle_t i) { t = i; }; + /// pointer to term + YAPTerm(void *ptr); + + /// parse string s and construct a term. + YAPTerm(char *s) { + Term tp; + mk(YAP_ReadBuffer(s, &tp)); + } #if 1 - /// Term destructor, tries to recover slot - virtual ~YAPTerm() { - // fprintf(stderr,"-%d,%lx,%p ",t,LOCAL_HandleBase[t] ,HR); + + /// Term destructor, tries to recover slot + virtual ~YAPTerm() { + // fprintf(stderr,"-%d,%lx,%p ",t,LOCAL_HandleBase[t] ,HR); /* if (!t) return; Yap_DebugPlWriteln(LOCAL_HandleBase[t]); @@ -98,287 +108,386 @@ public: LOCAL_CurSlot--; } */ - }; + }; #endif - /// construct a term out of an integer (if you know object type use - /// YAPIntegerTerm) - /// YAPTerm(long int num) { mk(MkIntegerTerm(num)); } - /// construct a term out of an integer (if you know object type use - /// YAPIntegerTerm) - /// YAPTerm(double num) { mk(MkFloatTerm(num)); } - /// parse string s and construct a term. - /// YAPTerm(YAPFunctor f, YAPTerm ts[]); - /// extract the tag of a term, after dereferencing. - YAP_tag_t tag(); - /// copy the term ( term copy ) - Term deepCopy(); - /// numbervars ( int start, bool process=false ) - intptr_t numberVars(intptr_t start, bool skip_singletons = false); - inline Term term() { - return gt(); - } /// from YAPTerm to Term (internal YAP representation) - inline void bind(Term b) { LOCAL_HandleBase[t] = b; } - inline void bind(YAPTerm *b) { LOCAL_HandleBase[t] = b->term(); } - /// from YAPTerm to Term (internal YAP representation) - /// fetch a sub-term - Term &operator[](arity_t n); - // const YAPTerm *vars(); - /// this term is == to t1 - virtual bool exactlyEqual(YAPTerm t1) { - bool out; - BACKUP_MACHINE_REGS(); - out = Yap_eq(gt(), t1.term()); - RECOVER_MACHINE_REGS(); - return out; - }; + /// construct a term out of an integer (if you know object type use + /// YAPIntegerTerm) + /// YAPTerm(long int num) { mk(MkIntegerTerm(num)); } + /// construct a term out of an integer (if you know object type use + /// YAPIntegerTerm) + /// YAPTerm(double num) { mk(MkFloatTerm(num)); } + /// parse string s and construct a term. + /// YAPTerm(YAPFunctor f, YAPTerm ts[]); + /// extract the tag of a term, after dereferencing. + YAP_tag_t tag(); - /// t = t1 - virtual bool unify(YAPTerm t1) { - intptr_t out; - BACKUP_MACHINE_REGS(); - out = Yap_unify(gt(), t1.term()); - RECOVER_MACHINE_REGS(); - return out; - }; + /// copy the term ( term copy ) + Term deepCopy(); - /// we can unify t and t1 - virtual bool unifiable(YAPTerm t1) { - bool out; - BACKUP_MACHINE_REGS(); - out = Yap_eq(gt(), t1.term()); - RECOVER_MACHINE_REGS(); - return out; - }; + /// numbervars ( int start, bool process=false ) + intptr_t numberVars(intptr_t start, bool skip_singletons = false); - /// t =@= t1, the two terms are equal up to variable renamingvirtual bool - /// variant( - inline virtual YAP_Term variant(YAPTerm t1) { - intptr_t out; - BACKUP_MACHINE_REGS(); - out = Yap_Variant(gt(), t1.term()); - RECOVER_MACHINE_REGS(); - return out; - }; + inline Term term() { + return gt(); + } /// from YAPTerm to Term (internal YAP representation) + inline void bind(Term b) { LOCAL_HandleBase[t] = b; } - virtual intptr_t hashTerm(size_t sz, size_t depth, bool variant) { - intptr_t out; + inline void bind(YAPTerm *b) { LOCAL_HandleBase[t] = b->term(); } - BACKUP_MACHINE_REGS(); - out = Yap_TermHash(gt(), sz, depth, variant); - RECOVER_MACHINE_REGS(); - return out; - }; - /// term hash, - virtual bool isVar() { return IsVarTerm(gt()); } /// type check for unound - virtual bool isAtom() { return IsAtomTerm(gt()); } /// type check for atom - virtual bool isInteger() { - return IsIntegerTerm(gt()); - } /// type check for integer - virtual bool isFloat() { - return IsFloatTerm(gt()); - } /// type check for floating-point - virtual bool isString() { - return IsStringTerm(gt()); - } /// type check for a string " ... " - virtual bool isCompound() { - return !(IsVarTerm(gt()) || IsNumTerm(gt())); - } /// is a primitive term - virtual bool isAppl() { return IsApplTerm(gt()); } /// is a structured term - virtual bool isPair() { return IsPairTerm(gt()); } /// is a pair term - virtual bool isGround() { return Yap_IsGroundTerm(gt()); } /// term is ground - virtual bool isList() { return Yap_IsListTerm(gt()); } /// term is a list + /// from YAPTerm to Term (internal YAP representation) + /// fetch a sub-term + Term &operator[](arity_t n); - /// extract the argument i of the term, where i in 1...arity - virtual Term getArg(arity_t i) { - BACKUP_MACHINE_REGS(); - Term tf = 0; - Term t0 = gt(); + // const YAPTerm *vars(); + /// this term is == to t1 + virtual bool exactlyEqual(YAPTerm t1) { + bool out; + BACKUP_MACHINE_REGS(); + out = Yap_eq(gt(), t1.term()); + RECOVER_MACHINE_REGS(); + return out; + }; - 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()"); + /// t = t1 + virtual bool unify(YAPTerm t1) { + intptr_t out; + BACKUP_MACHINE_REGS(); + out = Yap_unify(gt(), t1.term()); + RECOVER_MACHINE_REGS(); + return out; + }; + + /// we can unify t and t1 + virtual bool unifiable(YAPTerm t1) { + bool out; + BACKUP_MACHINE_REGS(); + out = Yap_eq(gt(), t1.term()); + RECOVER_MACHINE_REGS(); + return out; + }; + + /// t =@= t1, the two terms are equal up to variable renamingvirtual bool + /// variant( + inline virtual YAP_Term variant(YAPTerm t1) { + intptr_t out; + BACKUP_MACHINE_REGS(); + out = Yap_Variant(gt(), t1.term()); + RECOVER_MACHINE_REGS(); + return out; + }; + + virtual intptr_t hashTerm(size_t sz, size_t depth, bool variant) { + intptr_t out; + + BACKUP_MACHINE_REGS(); + out = Yap_TermHash(gt(), sz, depth, variant); + RECOVER_MACHINE_REGS(); + return out; + }; + + /// term hash, + virtual bool isVar() { return IsVarTerm(gt()); } /// type check for unound + virtual bool isAtom() { return IsAtomTerm(gt()); } /// type check for atom + virtual bool isInteger() { + return IsIntegerTerm(gt()); + } /// type check for integer + virtual bool isFloat() { + return IsFloatTerm(gt()); + } /// type check for floating-point + virtual bool isString() { + return IsStringTerm(gt()); + } /// type check for a string " ... " + virtual bool isCompound() { + return !(IsVarTerm(gt()) || IsNumTerm(gt())); + } /// is a primitive term + virtual bool isAppl() { return IsApplTerm(gt()); } /// is a structured term + virtual bool isPair() { return IsPairTerm(gt()); } /// is a pair term + virtual bool isGround() { return Yap_IsGroundTerm(gt()); } /// term is ground + virtual bool isList() { return Yap_IsListTerm(gt()); } /// term is a list + + + std::vector YAPTermToJavaArray() + { + BACKUP_H(); + Term pt = gt(); + if (IsApplTerm(t)) { + arity_t arity = ArityOfFunctor(FunctorOfTerm(pt)); + std::vector o = std::vector(arity); + for (arity_t i=0; i < arity; i++) { + o[i] = YAPTerm( ArgOfTerm(i+1, pt) ); + } + return o; + + } + if (IsPairTerm(t)) { + std::vector o = std::vector(2); + o[0] = YAPTerm( HeadOfTerm(pt) ); + o[1] = YAPTerm( TailOfTerm(pt) ); + return o; + + } + return std::vector(0); } - RECOVER_MACHINE_REGS(); - return tf; - } - /// extract the arity of the term - /// variables have arity 0 - virtual inline arity_t arity() { - Term t0 = gt(); + std::vector YAPTermToVector() + { + BACKUP_H(); + Term pt = gt(); + if (IsApplTerm(t)) { + arity_t arity = ArityOfFunctor(FunctorOfTerm(pt)); + std::vector o = std::vector(arity); + for (arity_t i=0; i < arity; i++) { + o[i] = ( ArgOfTerm(i+1, pt) ); + } + return o; - if (IsApplTerm(t0)) { - Functor f = FunctorOfTerm(t0); - if (IsExtensionFunctor(f)) + } + if (IsPairTerm(t)) { + std::vector o = std::vector(2); + o[0] = ( HeadOfTerm(pt) ); + o[1] = ( TailOfTerm(pt) ); + return o; + + } + return std::vector(0); + } + /// extract the argument i of the term, where i in 1...arity + 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 YAPTerm getYAPArg(int i) { + return YAPTerm(getArg((arity_t)i)); + } + /// extract the arity of the term + /// variables have arity 0 + virtual inline arity_t arity() { + Term t0 = gt(); + + if (IsApplTerm(t0)) { + Functor f = FunctorOfTerm(t0); + if (IsExtensionFunctor(f)) + return 0; + return ArityOfFunctor(f); + } else if (IsPairTerm(t0)) { + return 2; + } return 0; - return ArityOfFunctor(f); - } else if (IsPairTerm(t0)) { - return 2; } - return 0; - } - /// return a string with a textual representation of the term - virtual const char *text() { - CACHE_REGS - size_t length = 0; - encoding_t enc = LOCAL_encoding; - char *os; + /// return a string with a textual representation of the term + virtual const char *text() { + CACHE_REGS + size_t length = 0; + encoding_t enc = LOCAL_encoding; + char *os; - BACKUP_MACHINE_REGS(); - if (!(os = Yap_TermToString(Yap_GetFromSlot(t), &length, enc, - Handle_vars_f))) { - RECOVER_MACHINE_REGS(); - return 0; - } - RECOVER_MACHINE_REGS(); - length = strlen(os) + 1; - char *sm = (char *)malloc(length + 1); - strcpy(sm, os); - return sm; - }; + BACKUP_MACHINE_REGS(); + if (!(os = Yap_TermToString(Yap_GetFromSlot(t), &length, enc, + Handle_vars_f))) { + RECOVER_MACHINE_REGS(); + return 0; + } + RECOVER_MACHINE_REGS(); + length = strlen(os) + 1; + char *sm = (char *) malloc(length + 1); + strcpy(sm, os); + return sm; + }; - /// return a handle to the term - inline yhandle_t handle() { return t; }; + /// return a handle to the term + inline yhandle_t handle() { return t; }; - /// whether the term actually refers to a live object - inline bool initialized() { return t != 0; }; + /// whether the term actually refers to a live object + inline bool initialized() { return t != 0; }; }; /** * @brief YAPFunctor represents Prolog functors Name/Arity */ class X_API YAPFunctor : public YAPProp { - friend class YAPApplTerm; - friend class YAPTerm; - friend class YAPPredicate; - friend class YAPQuery; - Functor f; - /// Constructor: receives Prolog functor and casts it to YAPFunctor - /// - /// Notice that this is designed for internal use only. - inline YAPFunctor(Functor ff) { f = ff; } + friend class YAPApplTerm; + + friend class YAPTerm; + + friend class YAPPredicate; + + friend class YAPQuery; + + Functor f; + + /// Constructor: receives Prolog functor and casts it to YAPFunctor + /// + /// Notice that this is designed for internal use only. + inline YAPFunctor(Functor ff) { f = ff; } public: - /// Constructor: receives name as an atom, plus arity - /// - /// This is the default method, and the most popular - YAPFunctor(YAPAtom at, uintptr_t arity) { f = Yap_MkFunctor(at.a, arity); } + /// Constructor: receives name as an atom, plus arity + /// + /// This is the default method, and the most popular + YAPFunctor(YAPAtom at, uintptr_t arity) { f = Yap_MkFunctor(at.a, arity); } - /// Constructor: receives name as a string plus arity - /// - /// Notice that this is designed for ISO-LATIN-1 right now - /// Note: Python confuses the 3 constructors, - /// use YAPFunctorFromString - inline YAPFunctor(const char *s, uintptr_t arity, bool isutf8 = true) { - f = Yap_MkFunctor(Yap_LookupAtom(s), arity); - } - /// Constructor: receives name as a wide string plus arity - /// - /// Notice that this is designed for UNICODE right now - /// - /// Note: Python confuses the 3 constructors, - /// use YAPFunctorFromWideString - inline YAPFunctor(const wchar_t *s, uintptr_t arity) { - CACHE_REGS f = Yap_MkFunctor(UTF32ToAtom(s PASS_REGS), arity); - } - /// Getter: extract name of functor as an atom - /// - /// this is for external usage. - YAPAtom name(void) { return YAPAtom(NameOfFunctor(f)); } + /// Constructor: receives name as a string plus arity + /// + /// Notice that this is designed for ISO-LATIN-1 right now + /// Note: Python confuses the 3 constructors, + /// use YAPFunctorFromString + inline YAPFunctor(const char *s, uintptr_t arity, bool isutf8 = true) { + f = Yap_MkFunctor(Yap_LookupAtom(s), arity); + } - /// Getter: extract arity of functor as an unsigned integer - /// - /// this is for external usage. - uintptr_t arity(void) { return ArityOfFunctor(f); } + /// Constructor: receives name as a wide string plus arity + /// + /// Notice that this is designed for UNICODE right now + /// + /// Note: Python confuses the 3 constructors, + /// use YAPFunctorFromWideString + inline YAPFunctor(const wchar_t *s, uintptr_t arity) { + CACHE_REGS f = Yap_MkFunctor(UTF32ToAtom(s PASS_REGS), arity); + } + + /// Getter: extract name of functor as an atom + /// + /// this is for external usage. + YAPAtom name(void) { return YAPAtom(NameOfFunctor(f)); } + + /// Getter: extract arity of functor as an unsigned integer + /// + /// this is for external usage. + uintptr_t arity(void) { return ArityOfFunctor(f); } }; /** * @brief Compound Term */ class X_API YAPApplTerm : public YAPTerm { - friend class YAPTerm; + friend class YAPTerm; public: YAPApplTerm(Term t0) { mk(t0); } - YAPApplTerm(Functor f, Term ts[]) { - BACKUP_MACHINE_REGS(); - Term t0 = Yap_MkApplTerm(f, f->ArityOfFE, ts); - mk(t0); - RECOVER_MACHINE_REGS(); - }; - YAPApplTerm(YAPFunctor f, YAPTerm ts[]); - YAPApplTerm(const std::string s, std::vector 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 - 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 - virtual bool isString() { return false; } /// type check for a string " ... " - virtual bool isCompound() { return true; } /// is a primitive term - virtual bool isAppl() { return true; } /// is a structured term - virtual bool isPair() { return false; } /// is a pair term - virtual bool isGround() { return true; } /// term is ground - virtual bool isList() { return false; } /// [] is a list + YAPApplTerm(Functor f, Term ts[]) { + BACKUP_MACHINE_REGS(); + Term t0 = Yap_MkApplTerm(f, f->ArityOfFE, ts); + mk(t0); + RECOVER_MACHINE_REGS(); + }; + + YAPApplTerm(YAPFunctor f, YAPTerm ts[]); + + YAPApplTerm(const std::string s, std::vector 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 + 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 + virtual bool isString() { return false; } /// type check for a string " ... " + virtual bool isCompound() { return true; } /// is a primitive term + virtual bool isAppl() { return true; } /// is a structured term + virtual bool isPair() { return false; } /// is a pair term + virtual bool isGround() { return true; } /// term is ground + virtual bool isList() { return false; } /// [] is a list }; /** * @brief List Constructor Term */ class X_API YAPPairTerm : public YAPTerm { - friend class YAPTerm; + friend class YAPTerm; public: YAPPairTerm(Term t0) { t0 = Deref(t0); - if (IsPairTerm(t0) || t0 == TermNil) - mk(t0); - else - Yap_ThrowError(TYPE_ERROR_LIST, t0, "YAPPairTerms"); + if (IsPairTerm(t0) || t0 == TermNil) + mk(t0); + else + Yap_ThrowError(TYPE_ERROR_LIST, t0, "YAPPairTerms"); } + + /// cons YAPPairTerm(YAPTerm hd, YAPTerm tl); - YAPPairTerm(); - Term getHead() { return (HeadOfTerm(gt())); } - Term getTail() { return (TailOfTerm(gt())); } - std::vector listToArray() { - Term *tailp; - Term t1 = gt(); - Int l = Yap_SkipList(&t1, &tailp); - if (l < 0) { + + /// null constructor, or empty list + YAPPairTerm(); + + bool empty() { return gt() == TermNil; } + + Term getHead() { return (HeadOfTerm(gt())); } + + Term getTail() { return (TailOfTerm(gt())); } + + YAPTerm car() { return YAPTerm(HeadOfTerm(gt())); } + + YAPPairTerm cdr() { return YAPPairTerm(TailOfTerm(gt())); } + + std::vector listToArray() { + Term *tailp; + Term t1 = gt(); + Int l = Yap_SkipList(&t1, &tailp); + if (l < 0) { throw YAPError(TYPE_ERROR_LIST, YAPTerm(t), ""); - } - std::vector o = std::vector(l); - int i = 0; - Term t = gt(); - while (t != TermNil) { - o[i++] = HeadOfTerm(t); - t = TailOfTerm(t); - } - return o; - } + } + std::vector o = std::vector(l); + int i = 0; + Term t = gt(); + while (t != TermNil) { + o[i++] = HeadOfTerm(t); + t = TailOfTerm(t); + } + return o; + } + + std::vector listToYAPArray() { + Term *tailp; + Term t1 = gt(); + Int l = Yap_SkipList(&t1, &tailp); + if (l < 0) { + throw YAPError(TYPE_ERROR_LIST, YAPTerm(t), ""); + } + std::vector o = std::vector(l); + int i = 0; + Term t = gt(); + while (t != TermNil) { + o[i++] = YAPTerm(HeadOfTerm(t)); + t = TailOfTerm(t); + } + return o; + } }; /** @@ -387,8 +496,9 @@ public: class X_API YAPNumberTerm : public YAPTerm { public: - YAPNumberTerm(){}; - bool isTagged() { return IsIntTerm(gt()); } + YAPNumberTerm() {}; + + bool isTagged() { return IsIntTerm(gt()); } }; /** @@ -397,8 +507,9 @@ public: class X_API YAPIntegerTerm : public YAPNumberTerm { public: - YAPIntegerTerm(intptr_t i); - intptr_t getInteger() { return IntegerOfTerm(gt()); }; + YAPIntegerTerm(intptr_t i); + + intptr_t getInteger() { return IntegerOfTerm(gt()); }; }; /** @@ -407,64 +518,69 @@ public: class X_API YAPFloatTerm : public YAPNumberTerm { public: - YAPFloatTerm(double dbl) { mk(MkFloatTerm(dbl)); }; + YAPFloatTerm(double dbl) { mk(MkFloatTerm(dbl)); }; - double getFl() { return FloatOfTerm(gt()); }; + double getFl() { return FloatOfTerm(gt()); }; }; class X_API YAPListTerm : public YAPTerm { public: - /// Create a list term out of a standard term. Check if a valid operation. - /// - /// @param[in] the term - YAPListTerm() { mk(TermNil); /* else type_error */ } - /// Create an empty list term. - /// - /// @param[in] the term - YAPListTerm(Term t0) { mk(t0); /* else type_error */ } - /// Create a list term out of an array of terms. - /// - /// @param[in] the array of terms - /// @param[in] the length of the array - YAPListTerm(YAPTerm ts[], size_t n); - // YAPListTerm( vector v ); - /// Return the number of elements in a list term. - size_t length() { - Term *tailp; - Term t1 = gt(); - return Yap_SkipList(&t1, &tailp); - } - /// Extract the nth element. - Term &operator[](size_t n); - /// Extract the first element of a list. - /// - /// @param[in] the list - Term car(); - /// 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), ""); - } - /// copy a list. - /// - /// @param[in] the list - Term dup(); + /// Create a list term out of a standard term. Check if a valid operation. + /// + /// @param[in] the term + YAPListTerm() { mk(TermNil); /* else type_error */ } - /// Check if the list is empty. - /// - /// @param[in] the list - inline bool nil() { - return gt() == TermNil; - } + /// Create an empty list term. + /// + /// @param[in] the term + YAPListTerm(Term t0) { mk(t0); /* else type_error */ } - ; + /// Create a list term out of an array of terms. + /// + /// @param[in] the array of terms + /// @param[in] the length of the array + YAPListTerm(YAPTerm ts[], size_t n); + + // YAPListTerm( vector v ); + /// Return the number of elements in a list term. + size_t length() { + Term *tailp; + Term t1 = gt(); + return Yap_SkipList(&t1, &tailp); + } + + /// Extract the nth element. + Term &operator[](size_t n); + + /// Extract the first element of a list. + /// + /// @param[in] the list + Term car(); + + /// 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), ""); + } + + /// copy a list. + /// + /// @param[in] the list + Term dup(); + + /// Check if the list is empty. + /// + /// @param[in] the list + inline bool nil() { + return gt() == TermNil; + }; }; /** @@ -472,15 +588,19 @@ public: */ class X_API YAPStringTerm : public YAPTerm { public: - /// your standard constructor - YAPStringTerm(char *s); - /// use this one to construct length limited strings - YAPStringTerm(char *s, size_t len); - /// construct using wide chars - YAPStringTerm(wchar_t *s); - /// construct using length-limited wide chars - YAPStringTerm(wchar_t *s, size_t len); - const char *getString() { return StringOfTerm(gt()); } + /// your standard constructor + YAPStringTerm(char *s); + + /// use this one to construct length limited strings + YAPStringTerm(char *s, size_t len); + + /// construct using wide chars + YAPStringTerm(wchar_t *s); + + /// construct using length-limited wide chars + YAPStringTerm(wchar_t *s, size_t len); + + const char *getString() { return StringOfTerm(gt()); } }; /** @@ -488,37 +608,46 @@ public: * Term Representation of an Atom */ class X_API YAPAtomTerm : public YAPTerm { - friend class YAPModule; - // Constructor: receives a C-atom; - YAPAtomTerm(Term t) : YAPTerm(t) { IsAtomTerm(t); } + friend class YAPModule; + + // Constructor: receives a C-atom; + YAPAtomTerm(Term t) : YAPTerm(t) { IsAtomTerm(t); } public: - YAPAtomTerm(Atom a) { mk(MkAtomTerm(a)); } - // Constructor: receives an atom; - YAPAtomTerm(YAPAtom a) : YAPTerm() { mk(MkAtomTerm(a.a)); } - // Constructor: receives a sequence of ISO-LATIN1 codes; - YAPAtomTerm(char s[]); - // Constructor: receives a sequence of up to n ISO-LATIN1 codes; - YAPAtomTerm(char *s, size_t len); - // Constructor: receives a sequence of wchar_ts, whatever they may be; - YAPAtomTerm(wchar_t *s); - // Constructor: receives a sequence of n wchar_ts, whatever they may be; - YAPAtomTerm(wchar_t *s, size_t len); - bool isVar() { return false; } /// type check for unbound - bool isAtom() { return true; } /// type check for atom - bool isInteger() { return false; } /// type check for integer - bool isFloat() { return false; } /// type check for floating-point - bool isString() { return false; } /// type check for a string " ... " - bool isCompound() { return false; } /// is a primitive term - bool isAppl() { return false; } /// is a structured term - bool isPair() { return false; } /// is a pair term - virtual bool isGround() { return true; } /// term is ground - virtual bool isList() { return gt() == TermNil; } /// [] is a list - // Getter: outputs the atom; - YAPAtom getAtom() { return YAPAtom(AtomOfTerm(gt())); } - // Getter: outputs the name as a sequence of ISO-LATIN1 codes; - const char *text() { return (const char *)AtomOfTerm(gt())->StrOfAE; } + YAPAtomTerm(Atom a) { mk(MkAtomTerm(a)); } + + // Constructor: receives an atom; + YAPAtomTerm(YAPAtom a) : YAPTerm() { mk(MkAtomTerm(a.a)); } + + // Constructor: receives a sequence of ISO-LATIN1 codes; + YAPAtomTerm(char s[]); + + // Constructor: receives a sequence of up to n ISO-LATIN1 codes; + YAPAtomTerm(char *s, size_t len); + + // Constructor: receives a sequence of wchar_ts, whatever they may be; + YAPAtomTerm(wchar_t *s); + + // Constructor: receives a sequence of n wchar_ts, whatever they may be; + YAPAtomTerm(wchar_t *s, size_t len); + + bool isVar() { return false; } /// type check for unbound + bool isAtom() { return true; } /// type check for atom + bool isInteger() { return false; } /// type check for integer + bool isFloat() { return false; } /// type check for floating-point + bool isString() { return false; } /// type check for a string " ... " + bool isCompound() { return false; } /// is a primitive term + bool isAppl() { return false; } /// is a structured term + bool isPair() { return false; } /// is a pair term + virtual bool isGround() { return true; } /// term is ground + virtual bool isList() { return gt() == TermNil; } /// [] is a list + // Getter: outputs the atom; + YAPAtom getAtom() { return YAPAtom(AtomOfTerm(gt())); } + + // Getter: outputs the name as a sequence of ISO-LATIN1 codes; + const char *text() { return (const char *) AtomOfTerm(gt())->StrOfAE; } }; + #endif /* YAPT_HH */ @@ -530,16 +659,20 @@ class X_API YAPVarTerm : public YAPTerm { public: /// constructor - YAPVarTerm() {mk(MkVarTerm()); }; + YAPVarTerm() { mk(MkVarTerm()); }; + /// get the internal representation CELL *getVar() { return VarOfTerm(gt()); } + /// is the variable bound to another one YAPVarTerm(Term t) { - if (IsVarTerm(t)) { - mk(t); - } + if (IsVarTerm(t)) { + mk(t); + } } + bool unbound() { return IsUnboundVar(VarOfTerm(gt())); } + inline bool isVar() { return true; } /// type check for unbound inline bool isAtom() { return false; } /// type check for atom inline bool isInteger() { return false; } /// type check for integer diff --git a/H/YapHandles.h b/H/YapHandles.h index 625936f56..be5046e36 100755 --- a/H/YapHandles.h +++ b/H/YapHandles.h @@ -179,15 +179,15 @@ INLINE_ONLY inline EXTERN void Yap_PutInHandle__(yhandle_t slot, LOCAL_HandleBase[slot] = t; } -#ifndef max -#define max(X, Y) (X > Y ? X : Y) +#ifndef Yap_Max +#define Yap_Max(X, Y) (X > Y ? X : Y) #endif #define ensure_handles ensure_slots INLINE_ONLY inline EXTERN void ensure_slots(int N USES_REGS) { if (LOCAL_CurHandle + N >= LOCAL_NHandles) { - size_t inc = max(16 * 1024, LOCAL_NHandles / 2); // measured in cells - inc = max(inc, (size_t)N + 16); // measured in cells + size_t inc = Yap_Max(16 * 1024, LOCAL_NHandles / 2); // measured in cells + inc = Yap_Max(inc, (size_t)N + 16); // measured in cells LOCAL_HandleBase = (CELL *)realloc(LOCAL_HandleBase, (inc + LOCAL_NHandles) * sizeof(CELL)); LOCAL_NHandles += inc; diff --git a/H/YapText.h b/H/YapText.h index 34b7b9460..d85b6b021 100644 --- a/H/YapText.h +++ b/H/YapText.h @@ -59,8 +59,9 @@ extern int pop_text_stack(int lvl USES_REGS); extern void *protected_pop_text_stack(int lvl, void *safe, bool tmp, size_t sz USES_REGS); -#ifndef min -#define min(x, y) (x < y ? x : y) +#ifndef Yap_Min +#define Yap_Min(x, y) (x < y ? x : y) + #endif #define MBYTE (1024 * 1024) diff --git a/cmake/FindGMP.cmake b/cmake/FindGMP.cmake index 9744b2ff7..29d957e8f 100644 --- a/cmake/FindGMP.cmake +++ b/cmake/FindGMP.cmake @@ -8,6 +8,8 @@ # GMP_LIBRARY_DLL - library DLL to install. Only available on WIN32. # GMP_LIBRARIES_DIR - the directory the library we link with is found in. +message( "xxxxx ${ANDROID_ABI} yyyyy ${CMAKE_CURRENT_DIR} zzzzzzzzzz" ) + if (ANDROID) set( GMP_ROOT ${CMAKE_SOURCE_DIR}/../gmp/${ANDROID_ABI} ) set (GMP_FOUND ON) @@ -26,7 +28,8 @@ if(MSVC) ${CMAKE_SOURCE_DIR}/../tools/mpird/lib ${CMAKE_SOURCE_DIR}/../mpir/lib ${CMAKE_SOURCE_DIR}/../mpird/lib - $ENV{PROGRAMFILES}/mpir/lib + + $ENV{PROGRAMFILES}/mpir/lib $ENV{PROGRAMFILES}/mpird/lib $ENV{HOME}/mpir/lib $ENV{HOME}/mpird/lib diff --git a/cmake/Prelims.cmake b/cmake/Prelims.cmake index 41b6b4265..59d04c1bd 100644 --- a/cmake/Prelims.cmake +++ b/cmake/Prelims.cmake @@ -7,7 +7,7 @@ if (POLICY CMP0042) cmake_policy( SET CMP0042 NEW) endif() -if (ANDROID) +if (ANDROID_OLD) macro ( MY_add_custom_target) endmacro() else() @@ -17,7 +17,7 @@ else() endif() -if (ANDROID) +if (ANDROID_OLD) macro ( add_component arg1) foreach(item ${ARGN}) get_filename_component(i ${item} ABSOLUTE) @@ -41,7 +41,7 @@ else() endmacro() endif() -if (ANDROID) +if (ANDROID_OLD) macro ( MY_add_dependencies) endmacro() else() @@ -50,7 +50,7 @@ else() endmacro() endif() -if (ANDROID) +if (ANDROID_OLD) macro ( MY_add_library) endmacro() else() @@ -68,7 +68,7 @@ else() endmacro() endif() -if (ANDROID) +if (ANDROID_OLD) macro ( MY_include) endmacro() else() @@ -86,7 +86,7 @@ else() endmacro() endif() -if (ANDROID) +if (ANDROID_OLD) macro ( MY_set_target_properties) endmacro() else() @@ -95,7 +95,7 @@ else() endmacro() endif() -if (ANDROID) +if (ANDROID_OLD) macro ( MY_target_link_libraries) endmacro() else() diff --git a/console/terminal/main.cpp b/console/terminal/streamer.cpp similarity index 100% rename from console/terminal/main.cpp rename to console/terminal/streamer.cpp diff --git a/include/VFS.h b/include/VFS.h index e7b6f71bd..7d00f707d 100644 --- a/include/VFS.h +++ b/include/VFS.h @@ -31,6 +31,8 @@ #endif #endif +#include + typedef struct { dev_t st_dev; /* ID of device containing file */ mode_t st_mode; /* Mode of file (see below) */ @@ -47,6 +49,7 @@ typedef struct { #endif } vfs_stat; + typedef enum vfs_flags { VFS_CAN_WRITE = 0x1, /// we can write to files in this space VFS_CAN_EXEC = 0x2, /// we can execute files in this space @@ -62,7 +65,7 @@ typedef union { size_t sz; void *pt; uintptr_t scalar; -#if __ANDROID__ +#if __ANDROID__0 AAssetManager *mgr; AAsset *asset; #endif @@ -108,6 +111,10 @@ typedef struct vfs { extern VFS_t *GLOBAL_VFS; +extern void init_android_stream(void); + +extern void Yap_InitStdStream(int sno, SMALLUNSGN flags, FILE *file, VFS_t *vfsp); + static inline VFS_t *vfs_owner(const char *fname) { VFS_t *me = GLOBAL_VFS; int d; diff --git a/libYap.cmake b/libYap.cmake index 5f48bfdde..5ef045700 100644 --- a/libYap.cmake +++ b/libYap.cmake @@ -92,12 +92,12 @@ list(APPEND YAP_SYSTEM_OPTIONS "thread support") # we use the nice UTF-8 package #available at the Julia project -MY_ADD_SUBDIRECTORY ( os ) -MY_ADD_SUBDIRECTORY ( OPTYap ) -MY_ADD_SUBDIRECTORY ( packages/myddas ) -MY_ADD_SUBDIRECTORY ( utf8proc ) -MY_ADD_SUBDIRECTORY ( library/dialect/swi/fli ) -MY_ADD_SUBDIRECTORY ( CXX ) +ADD_SUBDIRECTORY ( os ) +ADD_SUBDIRECTORY ( OPTYap ) +ADD_SUBDIRECTORY ( packages/myddas ) +ADD_SUBDIRECTORY ( utf8proc ) +ADD_SUBDIRECTORY ( library/dialect/swi/fli ) +ADD_SUBDIRECTORY ( CXX ) if (READLINE_LIBS) target_link_libraries(libYap ${READLINE_LIBS} ) diff --git a/os/assets.c b/os/assets.c index 83d34fa96..ace50a1f5 100644 --- a/os/assets.c +++ b/os/assets.c @@ -33,7 +33,7 @@ static char SccsId[] = "%W% %G%"; // for native asset manager #include -#if __ANDROID__ +#if __ANDROID__0 static AAssetManager * getMgr(struct vfs *me) @@ -212,7 +212,7 @@ VFS_t * Yap_InitAssetManager(void) { -#if __ANDROID__ +#if __ANDROID__O VFS_t *me; /* init standard VFS */ me = (VFS_t *)Yap_AllocCodeSpace(sizeof(struct vfs)); diff --git a/os/iopreds.c b/os/iopreds.c index 7cad41b5c..7da021c1e 100644 --- a/os/iopreds.c +++ b/os/iopreds.c @@ -285,7 +285,7 @@ static void InitFileIO(StreamDesc *s) { Yap_DefaultStreamOps(s); } -static void InitStdStream(int sno, SMALLUNSGN flags, FILE *file, void *vfsp) { +static void InitStdStream(int sno, SMALLUNSGN flags, FILE *file, VFS_t *vfsp) { StreamDesc *s = &GLOBAL_Stream[sno]; s->file = file; s->status = flags; @@ -295,7 +295,15 @@ static void InitStdStream(int sno, SMALLUNSGN flags, FILE *file, void *vfsp) { s->vfs = vfsp; s->encoding = ENC_ISO_UTF8; INIT_LOCK(s->streamlock); + if (vfsp != NULL) { + s->u.private_data = vfsp->open(vfsp->name, (sno == StdInStream ? "read" : "write" )); + if (s->u.private_data == NULL) { + (PlIOError(EXISTENCE_ERROR_SOURCE_SINK, MkIntTerm(sno), "%s", vfsp->name)); + return; + } + } else { unix_upd_stream_info(s); +} /* Getting streams to prompt is a mess because we need for cooperation between readers and writers to the stream :-( */ @@ -326,6 +334,11 @@ static void InitStdStream(int sno, SMALLUNSGN flags, FILE *file, void *vfsp) { #endif /* HAVE_SETBUF */ } +void Yap_InitStdStream(int sno, SMALLUNSGN flags, FILE *file, VFS_t *vfsp) { + InitStdStream(sno, flags, file, vfsp); +} + + Term Yap_StreamUserName(int sno) { Term atname; StreamDesc *s = &GLOBAL_Stream[sno]; @@ -341,13 +354,13 @@ static void InitStdStreams(void) { CACHE_REGS if (LOCAL_sockets_io) { InitStdStream(StdInStream, Input_Stream_f, NULL, NULL); - InitStdStream(StdOutStream, Output_Stream_f, NULL, NULL); + InitStdStream(StdOutStream, Output_Stream_f, NULL, NULL); InitStdStream(StdErrStream, Output_Stream_f, NULL, NULL); } else { InitStdStream(StdInStream, Input_Stream_f, stdin, NULL); InitStdStream(StdOutStream, Output_Stream_f, stdout, NULL); InitStdStream(StdErrStream, Output_Stream_f, stderr, NULL); - } + } GLOBAL_Stream[StdInStream].name = Yap_LookupAtom("user_input"); GLOBAL_Stream[StdOutStream].name = Yap_LookupAtom("user_output"); GLOBAL_Stream[StdErrStream].name = Yap_LookupAtom("user_error"); @@ -1070,6 +1083,7 @@ bool Yap_initStream(int sno, FILE *fd, const char *name, Term file_name, st->encoding = encoding; } + if (name == NULL) { char buf[YAP_FILENAME_MAX + 1]; name = Yap_guessFileName(fd, sno, buf, YAP_FILENAME_MAX); diff --git a/os/streams.c b/os/streams.c index 1f4a7f5b6..310dcbfcb 100644 --- a/os/streams.c +++ b/os/streams.c @@ -281,7 +281,7 @@ has_reposition(int sno, } char *Yap_guessFileName(FILE *file, int sno, char *nameb, size_t max) { - size_t maxs = max(255, max); + size_t maxs = Yap_Max(255, max); if (!nameb) { nameb = malloc(maxs + 1); } diff --git a/packages/myddas/myddas_shared.c b/packages/myddas/myddas_shared.c index 62dfe7417..506b96c33 100644 --- a/packages/myddas/myddas_shared.c +++ b/packages/myddas/myddas_shared.c @@ -685,7 +685,7 @@ void init_myddas(void) { #if defined MYDDAS_ODBC Yap_InitBackMYDDAS_ODBCPreds(); #endif -#if defined MYDDAS_SQLITE3 +#if WIN32 Yap_InitBackMYDDAS_SQLITE3Preds(); #endif #if defined USE_MYDDAS @@ -697,7 +697,7 @@ void init_myddas(void) { #if defined MYDDAS_ODBC Yap_InitMYDDAS_ODBCPreds(); #endif -#if defined MYDDAS_SQLITE3 +#if WIN32 Yap_InitMYDDAS_SQLITE3Preds(); #endif #if defined USE_MYDDAS diff --git a/packages/myddas/pl/CMakeLists.txt b/packages/myddas/pl/CMakeLists.txt index f6dc8c827..5ea666cbb 100644 --- a/packages/myddas/pl/CMakeLists.txt +++ b/packages/myddas/pl/CMakeLists.txt @@ -39,11 +39,17 @@ function(cpp_compile output filename) set_source_files_properties(${outfile} PROPERTIES GENERATED TRUE) endfunction() +if (ANDROID) +set (MYDDAS_PL_OUTDIR ${YAP_APP_DIR}/src/generated/assets/Yap} ) +else() +set (MYDDAS_PL_OUTDIR ${CMAKE_CURRENT_BINARY_DIR} ) +endif() + function(cpp_driver output dbms filename) if (0) - set(outfile ${libpl}/myddas_${dbms}.yap) + set(outfile ${MYDDAS_PL_OUTDIR}/myddas_${dbms}.yap) else() - set(outfile ${CMAKE_CURRENT_BINARY_DIR}/myddas_${dbms}.yap) + set(outfile ${MYDDAS_PL_OUTDIR}/myddas_${dbms}.yap) endif() set(${output} ${${output}} ${outfile} PARENT_SCOPE) IF (MSVC) @@ -74,3 +80,4 @@ add_custom_target(plmyddas ALL DEPENDS ${MYDDAS_YAP} ) install(FILES ${MYDDAS_YAP} DESTINATION ${libpl} ) + diff --git a/packages/myddas/sqlite3/CMakeLists.txt b/packages/myddas/sqlite3/CMakeLists.txt index 23c7d46c0..f84e10aae 100644 --- a/packages/myddas/sqlite3/CMakeLists.txt +++ b/packages/myddas/sqlite3/CMakeLists.txt @@ -40,14 +40,14 @@ src/Android/jni/sqlite/android_database_SQLiteConnection.cpp src/Android/jni/sqlite/android_database_SQLiteDebug.cpp src/Android/jni/sqlite/android_database_SQLiteGlobal.cpp src/Android/jni/sqlite/nativehelper/jni.h -src/Android/jni/sqlite/nativehelper/jniConstants.h +src/Android/jni/sqlite/nativehelper/JniConstants.h src/Android/jni/sqlite/nativehelper/JNIHelp.h src/Android/jni/sqlite/nativehelper/ScopedLocalRef.h ) endif (ANDROID) -add_component( Yapsqlite3 +add_library( Yapsqlite3 SHARED ${YAPSQLITE3_SOURCES} ) MY_set_target_properties(Yapsqlite3 @@ -56,3 +56,9 @@ add_component( Yapsqlite3 # SOVERSION ${LIBYAPTAI_MAJOR_VERSION}.${LIBYAPTAI_MINOR_VERSION} POSITION_INDEPENDENT_CODE TRUE ) + + +if (ANDROID) + target_link_libraries(Yapsqlite3 android log) + +endif () \ No newline at end of file diff --git a/packages/myddas/sqlite3/myddas_sqlite3.c b/packages/myddas/sqlite3/myddas_sqlite3.c index d91e72ffc..c08bbc65c 100644 --- a/packages/myddas/sqlite3/myddas_sqlite3.c +++ b/packages/myddas/sqlite3/myddas_sqlite3.c @@ -658,6 +658,17 @@ void init_sqlite3( void ) Yap_InitBackMYDDAS_SQLITE3Preds(); } +#if _ANDROID_ +JNIEXPORT void JNICALL + lib_yap_up_pt_init_sqlite(JNIEnv *env); + +JNIEXPORT void JNICALL + lib_yap_up_pt_init_sqlite(JNIEnv *env) +{ + init_sqlite3(); +} + +#endif #ifdef _WIN32 diff --git a/packages/myddas/sqlite3/src/Android/jni/sqlite/android_database_SQLiteConnection.cpp b/packages/myddas/sqlite3/src/Android/jni/sqlite/android_database_SQLiteConnection.cpp index cd9ddff84..ab41e83a1 100644 --- a/packages/myddas/sqlite3/src/Android/jni/sqlite/android_database_SQLiteConnection.cpp +++ b/packages/myddas/sqlite3/src/Android/jni/sqlite/android_database_SQLiteConnection.cpp @@ -360,23 +360,22 @@ static jlong nativePrepareStatement(JNIEnv *env, jclass clazz, int err = sqlite3_prepare16_v2(connection->db, sql, sqlLength * sizeof(jchar), &statement, NULL); env->ReleaseStringCritical(sqlString, sql); - +#if 0 if (err != SQLITE_OK) { // Error messages like 'near ")": syntax error' are not // always helpful enough, so construct an error string that // includes the query itself. const char *query = env->GetStringUTFChars(sqlString, NULL); - char *message = (char *)malloc(strlen(query) + 50); + char *message[512]; if (message) { strcpy(message, ", while compiling: "); // less than 50 chars strcat(message, query); } env->ReleaseStringUTFChars(sqlString, query); throw_sqlite3_exception(env, connection->db, message); - free(message); return 0; } - +#endif ALOGV("Prepared statement %p on connection %p", statement, connection->db); return reinterpret_cast(statement); } diff --git a/packages/python/CMakeLists.txt b/packages/python/CMakeLists.txt index 634f3aab9..f2684dbec 100644 --- a/packages/python/CMakeLists.txt +++ b/packages/python/CMakeLists.txt @@ -14,6 +14,8 @@ add_library (YAPPython SHARED pyload.c ${PYTHON_HEADERS} ) if (WIN32) add_library (Py4YAP OBJECT ${PYTHON_SOURCES} ${PYTHON_HEADERS}) +target_link_libraries(YAPPython libYap ${PYTHON_LIBRARIES}) + else() add_library (Py4YAP SHARED ${PYTHON_SOURCES} ${PYTHON_HEADERS}) @@ -21,7 +23,6 @@ add_library (Py4YAP SHARED ${PYTHON_SOURCES} ${PYTHON_HEADERS}) set_property(TARGET Py4YAP PROPERTY CXX_STANDARD_REQUIRED ON) target_link_libraries(Py4YAP libYap ${PYTHON_LIBRARIES}) -target_link_libraries(YAPPython Py4YAP) MY_install(TARGETS Py4YAP LIBRARY DESTINATION ${libdir} @@ -33,7 +34,6 @@ endif() # arithmetic hassle. set_property(TARGET YAPPython PROPERTY CXX_STANDARD_REQUIRED ON) -target_link_libraries(YAPPython libYap ${PYTHON_LIBRARIES}) set_property( SOURCE ${PYTHON_SOURCES} APPEND PROPERTY COMPILE_DEFINITIONS YAP_KERNEL=1 _GNU_SOURCE=1) diff --git a/packages/python/swig/__init__.py b/packages/python/swig/__init__.py index 2e6496c74..d4f2aa12d 100644 --- a/packages/python/swig/__init__.py +++ b/packages/python/swig/__init__.py @@ -20,6 +20,7 @@ else: dll = glob.glob(os.path.join(yap_lib_path,dll))[0] dll = os.path.abspath(dll) ctypes.CDLL(dll, mode=ctypes.RTLD_GLOBAL) - load('libYap*') - load('libYAP+*') - load('libPy4YAP*') + if platform.system() == 'Apple':: + load('libYap*') + load('libYAP+*') + load('libPy4YAP*') diff --git a/packages/swig/CMakeLists.txt b/packages/swig/CMakeLists.txt index 87d7f15c7..291a67071 100644 --- a/packages/swig/CMakeLists.txt +++ b/packages/swig/CMakeLists.txt @@ -8,12 +8,14 @@ # This is a CMake example for Python and Java +set (SOURCES yap.i) + INCLUDE(${SWIG_USE_FILE}) if (ANDROID) add_subdirectory(android) else(ANDROID) - # add_subdirectory(java) + add_subdirectory(java) endif(ANDROID) set_property( DIRECTORY APPEND PROPERTY COMPILE_DEFINITIONS SWIGYAP=1) diff --git a/packages/swig/android/CMakeLists.txt b/packages/swig/android/CMakeLists.txt index 21a74b8e8..72115a321 100644 --- a/packages/swig/android/CMakeLists.txt +++ b/packages/swig/android/CMakeLists.txt @@ -1,21 +1,72 @@ - # This is a CMake example for Python and Java + # This is a CMake file for SWIG and Android +FILE( MAKE_DIRECTORY ${YAP_APP_DIR}/src/generated/java/pt/up/yap/lib ) +FILE( MAKE_DIRECTORY ${YAP_APP_DIR}/src/generated/assets) + set(CMAKE_SWIG_OUTDIR ${YAP_APP_DIR}/src/generated/java/pt/up/yap/lib ) + set( SWIG_MODULE_NAME pt.up.yap.lib ) + set ( pllib ${YAP_APP_DIR}/src/generated/assets/Yap ) - set(CMAKE_SWIG_OUTDIR ${YAP_APP_DIR}/app/src/main/java/pt/up/yap/lib ) - - set ( SWIG_SOURCES ../yap.i ) + set ( SWIG_SOURCES ${CMAKE_SOURCE_DIR}/packages/swig/yap.i ) SET_SOURCE_FILES_PROPERTIES(${SWIG_SOURCES} PROPERTIES CPLUSPLUS ON) include_directories ( ${CMAKE_SOURCE_DIR}/CXX ) + set( GMP_ROOT ${CMAKE_SOURCE_DIR}/../gmp/${ANDROID_ABI} ) + set (GMP_INCLUDE_DIRS ${GMP_ROOT}) + set (GMP_LIBRARIES ${GMP_ROOT}/libgmp.so) + add_custom_command (OUTPUT yap_swig.cpp - COMMAND ${SWIG} -java -outdir ${CMAKE_SWIG_OUTDIR} -outcurrentdir -addextern -I${CMAKE_SOURCE_DIR}/CXX ${SWIG_SOURCES} -o yap_swig.cpp - ) + COMMAND ${CMAKE_COMMAND} -E make_directory ${pllib} + COMMAND ${CMAKE_COMMAND} -E make_directory ${pllib}/pl + COMMAND ${CMAKE_COMMAND} -E make_directory ${pllib}/os - add_custom_target ( swig ALL - DEPENDS yap_swig.cpp - ) + COMMAND ${CMAKE_COMMAND} -E copy ${pl_library} ${pllib} + COMMAND ${CMAKE_COMMAND} -E copy ${pl_boot_library} ${pllib}/pl + COMMAND ${CMAKE_COMMAND} -E copy ${pl_os_library} ${pllib}/os + COMMAND ${SWIG_EXECUTABLE} -c++ -java -package ${SWIG_MODULE_NAME} -outdir ${CMAKE_SWIG_OUTDIR} -outcurrentdir -addextern -I${CMAKE_SOURCE_DIR}/CXX -I${CMAKE_SOURCE_DIR}/include -I${CMAKE_SOURCE_DIR}/H -I${CMAKE_SOURCE_DIR}/os -I${CMAKE_SOURCE_DIR}/OPTYap -I${CMAKE_BINARY_DIR} -I${GMP_INCLUDE_DIRS} -DX_API="" -o yap_swig.cpp ${SWIG_SOURCES} + DEPENDS ${SWIG_SOURCES} YAP++ + ) + add_custom_command (OUTPUT swig_streamer.cpp + COMMAND ${SWIG_EXECUTABLE} -c++ -java -package ${SWIG_MODULE_NAME} -outdir ${CMAKE_SWIG_OUTDIR} -outcurrentdir -addextern -I${CMAKE_CURRENT_SOURCE_DIR} -o swig_streamer.cpp streamer.i + DEPENDS streamer.i + ) + + + # GMP_FOUND - true if GMP/MPIR was found + # GMP_INCLUDE_DIRS - include search path + # GMP_LIBRARIES - libraries to link with + #config.h needs this (TODO: change in code latter) + include_directories( .;${GMP_INCLUDE_DIRS};${CMAKE_SOURCE_DIR}/include;${CMAKE_SOURCE_DIR}/H;${CMAKE_SOURCE_DIR}/H/generated;${CMAKE_SOURCE_DIR}/os;${CMAKE_SOURCE_DIR}/OPTYap;${CMAKE_BINARY_DIR};${CMAKE_CURRENT_SOURCE_DIR} ) + + + + + add_library (YAPJava SHARED + yap_swig.cpp swig_streamer.cpp streamer.cpp streamer.h + ) + target_link_libraries(YAPJava ${GMP_LIBRARIES} ) + + + target_link_libraries( YAPJava YAP++ libYap android log) + + if (FALSE) + + set (SWIG_ADD_MODULE YAPJava SHARED CPLUPLUS ${SWIG_SOURCES} ) + # Define swig module with given name and specified language + + + set (SWIG_LINK_LIBRARIES YAPJava YAP++ libYAP ) + #- Link libraries to swig module + + + add_library (YAPJavaTop SHARED + main.cpp main.h + ) + + target_link_libraries( YAPJavaTop ${SWIG_MODULE_${YAPJava}_REAL_NAME} YAP++ libYap android) + + endif() diff --git a/packages/swig/java/JavaYAP.java b/packages/swig/java/JavaYAP.java index 0ff1b1ec1..ef0e4a31c 100644 --- a/packages/swig/java/JavaYAP.java +++ b/packages/swig/java/JavaYAP.java @@ -92,7 +92,10 @@ class JavaYAP { public static void main(String args[]) { - System.loadLibrary("Native"); + System.loadLibrary("gmp"); + System.loadLibrary("Yap"); + System.loadLibrary("YAP++"); + System.loadLibrary("JAVAYap"); JavaYAP y = new JavaYAP(); diff --git a/packages/swig/yap.i b/packages/swig/yap.i index 6a1c481ad..02ff95d88 100644 --- a/packages/swig/yap.i +++ b/packages/swig/yap.i @@ -1,10 +1,11 @@ - +// supports Java and Python %{ #include #include + extern "C"{ #ifdef SWIGPYTHON #include @@ -22,11 +23,7 @@ %include std_string.i %include std_vector.i -namespace std { - %template(vectort) vector; -}; - %feature("novaluewrapper") std::vector; %ignore *::operator[]; @@ -255,148 +252,87 @@ case DOMAIN_ERROR_NOT_LESS_THAN_ZERO: #else - // Language independent exception handler - %include exception.i +%typemap(in) arity_t { (jlong)($input); } - %exception { - try { - $action - } catch (YAPError e) { - yap_error_number en = e.getID(); - LOCAL_Error_TYPE = YAP_NO_ERROR; - switch (e.getErrorClass()) { - case YAPC_NO_ERROR: - break; - /// bad domain, "first argument often is the predicate. - case DOMAIN_ERROR: { - switch (en) { - case DOMAIN_ERROR_OUT_OF_RANGE: - case DOMAIN_ERROR_NOT_LESS_THAN_ZERO: - SWIG_exception(SWIG_IndexError, e.text()); - break; - case DOMAIN_ERROR_CLOSE_OPTION: - case DOMAIN_ERROR_ENCODING: - case DOMAIN_ERROR_PROLOG_FLAG: - case DOMAIN_ERROR_ABSOLUTE_FILE_NAME_OPTION: - case DOMAIN_ERROR_READ_OPTION: - case DOMAIN_ERROR_SET_STREAM_OPTION: - SWIG_exception(SWIG_AttributeError, e.text()); - break; - case DOMAIN_ERROR_FILE_ERRORS: - case DOMAIN_ERROR_FILE_TYPE: - case DOMAIN_ERROR_IO_MODE: - case DOMAIN_ERROR_SOURCE_SINK: - case DOMAIN_ERROR_STREAM_POSITION: - SWIG_exception(SWIG_IOError, e.text()); - break; - default: - SWIG_exception(SWIG_ValueError, e.text()); - } - } break; - /// bad arithmetic - case EVALUATION_ERROR: { - switch (en) { - case EVALUATION_ERROR_FLOAT_OVERFLOW: - case EVALUATION_ERROR_FLOAT_UNDERFLOW: - case EVALUATION_ERROR_INT_OVERFLOW: - case EVALUATION_ERROR_UNDERFLOW: - SWIG_exception(SWIG_OverflowError, e.text()); - break; - case EVALUATION_ERROR_ZERO_DIVISOR: - SWIG_exception(SWIG_DivisionByZero, e.text()); - break; - default: - SWIG_exception(SWIG_RuntimeError, e.text()); - } - } break; - /// missing object (I/O mostly) - case EXISTENCE_ERROR: - SWIG_exception(SWIG_RuntimeError, e.text()); - break; - /// should be bound - case INSTANTIATION_ERROR_CLASS: - SWIG_exception(SWIG_RuntimeError, e.text()); - break; - /// bad access, I/O - case PERMISSION_ERROR: { - switch (en) { - case PERMISSION_ERROR_INPUT_BINARY_STREAM: - case PERMISSION_ERROR_INPUT_PAST_END_OF_STREAM: - case PERMISSION_ERROR_INPUT_STREAM: - case PERMISSION_ERROR_INPUT_TEXT_STREAM: - case PERMISSION_ERROR_OPEN_SOURCE_SINK: - case PERMISSION_ERROR_OUTPUT_BINARY_STREAM: - case PERMISSION_ERROR_REPOSITION_STREAM: - case PERMISSION_ERROR_OUTPUT_STREAM: - case PERMISSION_ERROR_OUTPUT_TEXT_STREAM: - SWIG_exception(SWIG_OverflowError, e.text()); - break; - default: - SWIG_exception(SWIG_RuntimeError, e.text()); - } - } break; - /// something that could not be represented into a type - case REPRESENTATION_ERROR: - SWIG_exception(SWIG_RuntimeError, e.text()); - break; - /// not enough .... - case RESOURCE_ERROR: - SWIG_exception(SWIG_RuntimeError, e.text()); - break; - /// bad text - case SYNTAX_ERROR_CLASS: - SWIG_exception(SWIG_SyntaxError, e.text()); - break; - /// OS or internal - case SYSTEM_ERROR_CLASS: - SWIG_exception(SWIG_RuntimeError, e.text()); - break; - /// bad typing - case TYPE_ERROR: - SWIG_exception(SWIG_TypeError, e.text()); - break; - /// should be unbound - case UNINSTANTIATION_ERROR_CLASS: - SWIG_exception(SWIG_RuntimeError, e.text()); - break; - /// escape hatch - default: - break; - } - } +%typecheck(2) Int { $1 = PyLong_Check($input); } +%typecheck(3) double { $1 = PyFloat_Check($input); } +%typecheck(2) const char * { $1 = PyUnicode_Check($input); } + + %typecheck(1) Term { $1 = !PyUnicode_Check($input); } + %typecheck(1) YAP_Term { $1 = PyUnicode_Check($input); } + +%typecheck(0) YAPTerm { $1 = !PyUnicode_Check($input); } + + +%typemap(in) jlong %{ + $1 = (jlong)$input; +%} + +%typemap(out) arity_t { *(jlong *)&$result = $1; } + + // Language independent exception handler + // simplified version +%include + +%exception { + try { + $action + } catch (const std::out_of_range& e) { + SWIG_exception(SWIG_IndexError, e.what()); + } catch (const std::exception& e) { + SWIG_exception(SWIG_RuntimeError, e.what()); + } catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); } +} + #endif - %{ - /* Put header files here or function declarations like below */ +%{ + /* Put header files here or function declarations like below */ - extern "C" { + extern "C" { #if THREADS #define Yap_regp regcache #endif - // we cannot consult YapInterface.h, that conflicts with what we - // declare, though - // it shouldn't - } + // we cannot consult YapInterface.h, that conflicts with what we + // declare, though + // it shouldn't + } - %} +extern void init_sqlite(); - /* turn on director wrapping Callback */ - %feature("director") YAPCallback; + %} - %include "yapa.hh" - %include "yapie.hh" +/* turn on director wrapping Callback */ +//%feature("director") YAPCallback; - %include "yapt.hh" +%include "yapa.hh" - %include "yapdb.hh" +%include "yapie.hh" - %include "yapq.hh" +%include "yapt.hh" - %init %{ - %} +%include "yapdb.hh" + +%include "yapq.hh" + + + +namespace std { + + %template(TermVector) vector; + %feature("novaluewrapper") vector; + + //%template(YAPTermVector) vector; + //%feature("novaluewrapper") vector; + }; + + + %init %{ + %} diff --git a/swi/library/CMakeLists.txt b/swi/library/CMakeLists.txt index c91468604..1f9ca8157 100644 --- a/swi/library/CMakeLists.txt +++ b/swi/library/CMakeLists.txt @@ -36,13 +36,7 @@ set (LIBRARY_PL dcg/basics.pl ) - - if (ANDROID) - file(INSTALL ${LIBRARY_PL} DESTINATION ${libpl}) - else() - install(FILES ${LIBRARY_PL} DESTINATION ${libpl} ) - endif()