From 530d73c47043de7f9dcca1b8cab8b3a6c2854661 Mon Sep 17 00:00:00 2001 From: Vitor Santos Costa Date: Mon, 24 Jul 2017 18:14:57 +0100 Subject: [PATCH 1/6] compilation with 5.1.0 (no testing). --- .../gecode_yap_cc_impl_auto_generated.icc | 27 +++++++++---------- packages/gecode/dev/code-generator.py | 20 +++++++++++--- packages/gecode/gecode5_yap.cc | 14 +++++++++- 3 files changed, 42 insertions(+), 19 deletions(-) diff --git a/packages/gecode/5.1.0/gecode_yap_cc_impl_auto_generated.icc b/packages/gecode/5.1.0/gecode_yap_cc_impl_auto_generated.icc index 7806fddd6..4f831012d 100644 --- a/packages/gecode/5.1.0/gecode_yap_cc_impl_auto_generated.icc +++ b/packages/gecode/5.1.0/gecode_yap_cc_impl_auto_generated.icc @@ -16,6 +16,7 @@ // along with this program. If not, see . //============================================================================= + static YAP_Term gecode_RM_NONE; static YAP_Term gecode_RM_CONSTANT; static YAP_Term gecode_RM_LINEAR; @@ -1397,33 +1398,29 @@ static YAP_Bool gecode_constraint_min_313(void) static YAP_Bool gecode_constraint_when_456(void) { - return YAP_Error("SYSTEN_ERROR", TermNil, "Unsupported"); /* GenericSpace* space = gecode_Space_from_term(YAP_ARG1); BoolVar X2 = gecode_BoolVar_from_term(space,YAP_ARG2); - std::function X3 = gecode_std::function_from_term(YAP_ARG3); + std::function X3 = gecode_StdFunctionSpace_from_term(YAP_ARG3); IntPropLevel X4 = gecode_IntPropLevel_from_term(YAP_ARG4); when(*space,X2,X3,X4); - return TRUE; */ - return false; + return TRUE; } static YAP_Bool gecode_constraint_when_457(void) { - return YAP_Error("SYSTEN_ERROR", TermNil, "Unsupported"); /* - GenericSpace* space = gecode_Space_from_term(YAP_ARG1); BoolVar X2 = gecode_BoolVar_from_term(space,YAP_ARG2); - std::function X3 = gecode_std::function_from_term(YAP_ARG3); - std::function X4 = gecode_std::function_from_term(YAP_ARG4); + std::function X3 = gecode_StdFunctionSpace_from_term(YAP_ARG3); + std::function X4 = gecode_StdFunctionSpace_from_term(YAP_ARG4); when(*space,X2,X3,X4); - return TRUE;*/ + return TRUE; } static YAP_Bool gecode_constraint_cardinality_71(void) { GenericSpace* space = gecode_Space_from_term(YAP_ARG1); SetVarArgs X2 = gecode_SetVarArgs_from_term(space,YAP_ARG2); - int X3 = gecode_int_from_term(YAP_ARG3)289; + int X3 = gecode_int_from_term(YAP_ARG3); int X4 = gecode_int_from_term(YAP_ARG4); cardinality(*space,X2,X3,X4); return TRUE; @@ -2247,7 +2244,7 @@ static YAP_Bool gecode_constraint_when_455(void) { GenericSpace* space = gecode_Space_from_term(YAP_ARG1); BoolVar X2 = gecode_BoolVar_from_term(space,YAP_ARG2); - std::function X3 = gecode_std::function_from_term(YAP_ARG3); + std::function X3 = gecode_StdFunctionSpace_from_term(YAP_ARG3); when(*space,X2,X3); return TRUE; } @@ -2888,11 +2885,10 @@ static YAP_Bool gecode_constraint_channel_74(void) static YAP_Bool gecode_constraint_when_458(void) { - GenericSpace* space = gecode_Space_from_term(YAP_ARG1); BoolVar X2 = gecode_BoolVar_from_term(space,YAP_ARG2); - std::function X3 = gecode_std::function_from_term(YAP_ARG3); - std::function X4 = gecode_std::function_from_term(YAP_ARG4); + std::function X3 = gecode_StdFunctionSpace_from_term(YAP_ARG3); + std::function X4 = gecode_StdFunctionSpace_from_term(YAP_ARG4); IntPropLevel X5 = gecode_IntPropLevel_from_term(YAP_ARG5); when(*space,X2,X3,X4,X5); return TRUE; @@ -3145,7 +3141,7 @@ static YAP_Bool gecode_constraint_binpacking_40(void) static YAP_Bool gecode_constraint_branch_1(void) { GenericSpace* space = gecode_Space_from_term(YAP_ARG1); - std::function X2 = gecode_std::function_from_term(YAP_ARG2); + std::function X2 = gecode_StdFunctionSpace_from_term(YAP_ARG2); branch(*space,X2); return TRUE; } @@ -5174,3 +5170,4 @@ static YAP_Bool gecode_constraint_ite_254(void) ite(*space,X2,X3,X4,X5,X6); return TRUE; } + diff --git a/packages/gecode/dev/code-generator.py b/packages/gecode/dev/code-generator.py index 3e9acc8b1..09efedb79 100755 --- a/packages/gecode/dev/code-generator.py +++ b/packages/gecode/dev/code-generator.py @@ -554,7 +554,11 @@ class YAPEnumImpl(object): print def _generate_from_term(self): - print "static %s gecode_%s_from_term(YAP_Term X)" % (self.TYPE,self.TYPE) + if self.TYPE == "std::function": + t2 = "StdFunctionSpace" + else: + t2 = self.TYPE + print "static %s gecode_%s_from_term(YAP_Term X)" % (self.TYPE,t2) print "{" for x in self.ENUM: print " if (X==gecode_%s) return %s;" % (x,x) @@ -563,11 +567,16 @@ class YAPEnumImpl(object): print def _generate_from_term_forward_decl(self): - print "static %s gecode_%s_from_term(YAP_Term);" % (self.TYPE,self.TYPE) + if self.TYPE == "std::function": + t2 = "StdFunctionSpace" + else: + t2 = self.TYPE + print "static %s gecode_%s_from_term(YAP_Term);" % (self.TYPE,t2) class YAPEnumImplGenerator(object): def generate(self): + generate_space_function(); for c in enum_classes(): class C(c,YAPEnumImpl): pass o = C() @@ -576,6 +585,7 @@ class YAPEnumImplGenerator(object): class YAPEnumForwardGenerator(object): def generate(self): + generate_space_function_forward(); for c in enum_classes(): class C(c,YAPEnumImpl): pass o = C() @@ -642,12 +652,16 @@ class CCDescriptor(object): has_space = True else: extra = "" + t2 = t if t in ("IntVar","BoolVar","SetVar","FloatVar","IntVarArgs","BoolVarArgs","SetVarArgs","FloatVarArgs"): extra = "space," if has_space == False: print " GenericSpace* space = gecode_Space_from_term(%s);" % a has_space = True - print " %s %s = gecode_%s_from_term(%s%s);" % (t,v,t,extra,a) + else: + if t == "std::function": + t2 = "StdFunctionSpace" + print " %s %s = gecode_%s_from_term(%s%s);" % (t,v,t2,extra,a) args.append(v) i += 1 print " %s(%s);" % (self.name, ",".join(args)) diff --git a/packages/gecode/gecode5_yap.cc b/packages/gecode/gecode5_yap.cc index 8238b8f82..8fdf4ddf4 100644 --- a/packages/gecode/gecode5_yap.cc +++ b/packages/gecode/gecode5_yap.cc @@ -186,6 +186,18 @@ static inline BoolAssign& return *(DFA *) YAP_OpaqueObjectFromTerm(t); } + static inline Rnd& + gecode_Rnd_from_term(YAP_Term t) + { + return *(Rnd *) YAP_OpaqueObjectFromTerm(t); + } + + static inline std::function& + gecode_StdFunctionSpace_from_term(YAP_Term t) + { + return *(std::function *) YAP_OpaqueObjectFromTerm(t); + } + static inline FloatNum gecode_FloatNum_from_term(YAP_Term t) { @@ -379,6 +391,7 @@ static YAP_Term gecode_BOOL_VAR_RND; static YAP_Term gecode_FLOAT_VAR_SIZE_MIN; static YAP_Term gecode_FLOAT_VAR_SIZE_MAX; static YAP_Term gecode_FLOAT_VAR_DEGREE_SIZE_MAX; + static YAP_Term gecode_FLOAT_VAR_DEGREE_SIZE_MIN; static inline FloatVarBranch gecode_FloatVarBranch_from_term(YAP_Term t) @@ -386,7 +399,6 @@ static YAP_Term gecode_BOOL_VAR_RND; if (YAP_IsAtomTerm(t)) { if ( t == gecode_FLOAT_VAR_SIZE_MIN) return FLOAT_VAR_SIZE_MIN(); - static YAP_Term gecode_FLOAT_VAR_DEGREE_SIZE_MIN; if ( t == gecode_FLOAT_VAR_SIZE_MAX) return FLOAT_VAR_SIZE_MAX(); if ( t == gecode_FLOAT_VAR_NONE) From 22837d498b4e7ce2ec1eb632de809c3c589bd905 Mon Sep 17 00:00:00 2001 From: Vitor Santos Costa Date: Mon, 24 Jul 2017 18:17:51 +0100 Subject: [PATCH 2/6] improve signal handling. --- C/c_interface.c | 4 ++-- C/signals.c | 14 +++++++------- C/stack.c | 5 ++++- os/readline.c | 25 +++++++++++++------------ os/sig.c | 6 ++++-- 5 files changed, 30 insertions(+), 24 deletions(-) diff --git a/C/c_interface.c b/C/c_interface.c index 5361bbead..c74f91b4e 100755 --- a/C/c_interface.c +++ b/C/c_interface.c @@ -2390,9 +2390,9 @@ X_API YAP_file_type_t YAP_Init(YAP_init_args *yap_init) { #if defined(YAPOR_COPY) || defined(YAPOR_COW) || defined(YAPOR_SBA) Yap_init_yapor_global_local_memory(); #endif /* YAPOR_COPY || YAPOR_COW || YAPOR_SBA */ - // GLOBAL_PrologShouldHandleInterrupts = - // yap_init->PrologShouldHandleInterrupts && if (!yap_init->Embedded) { + GLOBAL_PrologShouldHandleInterrupts = + ~yap_init->PrologCannotHandleInterrupts; Yap_InitSysbits(0); /* init signal handling and time, required by later functions */ GLOBAL_argv = yap_init->Argv; diff --git a/C/signals.c b/C/signals.c index 17b6c8baa..58aca8d47 100755 --- a/C/signals.c +++ b/C/signals.c @@ -28,9 +28,9 @@ static char SccsId[] = "%W% %G%"; #include #include #endif +#include "YapEval.h" #include "YapHeap.h" #include "Yatom.h" -#include "YapEval.h" #include "yapio.h" #ifdef TABLING #include "tab.macros.h" @@ -65,10 +65,8 @@ static yap_signals InteractSIGINT(int ch) { case 'a': /* abort computation */ #if PUSH_REGS -// restore_absmi_regs(&Yap_standard_regs); + // restore_absmi_regs(&Yap_standard_regs); #endif - LOCAL_RestartEnv = malloc( sizeof(sigjmp_buf) ); - siglongjmp(*LOCAL_RestartEnv, 4); return YAP_ABORT_SIGNAL; case 'b': /* continue */ @@ -112,9 +110,11 @@ static yap_signals InteractSIGINT(int ch) { } } -/* - This function talks to the user about a signal. We assume we are in - the context of the main Prolog thread (trivial in Unix, but hard in WIN32) +/** + This function interacts with the user about a signal. We assume we are in + the context of the main Prolog thread (trivial in Unix, but hard in WIN32). + + */ static yap_signals ProcessSIGINT(void) { CACHE_REGS diff --git a/C/stack.c b/C/stack.c index c1bb25b7a..35381c80d 100644 --- a/C/stack.c +++ b/C/stack.c @@ -1155,9 +1155,12 @@ bool Yap_find_prolog_culprit(USES_REGS1) { while (curCP != YESCODE) { curENV = (CELL *)(curENV[E_E]); - if (curENV == NULL) + if (curENV < ASP || curENV >= LCL0) break; pe = EnvPreg(curCP); + if (pe==NULL) { + pe = PredMetaCall; + } if (pe->ModuleOfPred) return set_clause_info(curCP, pe); curCP = (yamop *)(curENV[E_CP]); diff --git a/os/readline.c b/os/readline.c index d96757f9e..5c946d825 100644 --- a/os/readline.c +++ b/os/readline.c @@ -18,7 +18,9 @@ static char SccsId[] = "%W% %G%"; #endif -/* +/** @file readline.c + * + * * This file includes the interface to the readline library, if installed in the *system. * @@ -339,22 +341,22 @@ static bool getLine(int inp) { /* window of vulnerability opened */ LOCAL_PrologMode |= ConsoleGetcMode; if (Yap_DoPrompt(s)) { // no output so far + rl_set_signals(); myrl_line = (unsigned char *)readline(LOCAL_Prompt); - s->stream_getc = ReadlineGetc; - } else { + rl_clear_signals(); +} else { + rl_set_signals(); myrl_line = (unsigned char *)readline(NULL); + rl_clear_signals(); } /* Do it the gnu way */ + LOCAL_PrologMode &= ~ConsoleGetcMode; + if (rl_pending_signal()) { + LOCAL_PrologMode |= InterruptMode; + } if (LOCAL_PrologMode & InterruptMode) { - Yap_external_signal(0, YAP_INT_SIGNAL); - LOCAL_PrologMode &= ~ConsoleGetcMode; - if (LOCAL_PrologMode & AbortMode) { - Yap_Error(ABORT_EVENT, TermNil, ""); - LOCAL_ErrorMessage = "Abort"; - return console_post_process_eof(s); - } + Yap_HandleSIGINT(); } else { - LOCAL_PrologMode &= ~ConsoleGetcMode; LOCAL_newline = true; } strncpy(LOCAL_Prompt, RepAtom(LOCAL_AtPrompt)->StrOfAE, MAX_PROMPT); @@ -437,7 +439,6 @@ int Yap_ReadlineForSIGINT(void) { int ch; StreamDesc *s = &GLOBAL_Stream[StdInStream]; const unsigned char *myrl_line = s->u.irl.buf; - if ((LOCAL_PrologMode & ConsoleGetcMode) && myrl_line != NULL) { ch = myrl_line[0]; free((void *)myrl_line); diff --git a/os/sig.c b/os/sig.c index cbd4c4029..99ceae5f1 100644 --- a/os/sig.c +++ b/os/sig.c @@ -317,8 +317,10 @@ static bool set_fpu_exceptions(Term flag) { static void ReceiveSignal(int s, void *x, void *y) { CACHE_REGS LOCAL_PrologMode |= InterruptMode; - printf("11ooo\n"); - my_signal(s, ReceiveSignal); + if (s == SIGINT && (LOCAL_PrologMode & ConsoleGetcMode)) { + return; + } + my_signal(s, ReceiveSignal); switch (s) { case SIGINT: // always direct SIGINT to console From 023c254d0384b71baa5a3006124f12c946c1a724 Mon Sep 17 00:00:00 2001 From: Vitor Santos Costa Date: Mon, 24 Jul 2017 18:18:56 +0100 Subject: [PATCH 3/6] fix exit --- pl/debug.yap | 16 ++++++++-------- 1 file changed, 8 insertions(+), 8 deletions(-) diff --git a/pl/debug.yap b/pl/debug.yap index 540a63770..610daf279 100644 --- a/pl/debug.yap +++ b/pl/debug.yap @@ -771,14 +771,14 @@ be lost. % set_prolog_flag(debug, OldDeb), % '$skipeol'(0'!), % ' fail. - '$action'(0'<,_,_,_,_,_) :- !, % <'Depth - '$new_deb_depth', - '$skipeol'(0'<), - fail. - '$action'(0'C,_,_,_,_,_) :- - yap_flag(system_options, Opts), +'$action'(0'<,_,_,_,_,_) :- !, % <'Depth + '$new_deb_depth', + '$skipeol'(0'<), + fail. +'$action'(0'C,_,_,_,_,_) :- + yap_flag(system_options, Opts), lists:memberchk( call_tracer, Opts), - !, % <'Depth + !, % <'Depth '$skipeol'(0'C), '__NB_setval__'('$debug_jump',false). '$action'(0'^,_,_,G,_,_) :- !, % ' @@ -791,6 +791,7 @@ be lost. nodebug, abort. '$action'(0'b,_,_,_,_,_) :- !, % 'b break + '$stop_creeping'(_), '$skipeol'(0'b), break, fail. @@ -802,7 +803,6 @@ be lost. '$skipeol'(0'c), '__NB_setval__'('$debug_jump',false). '$action'(0'e,_,_,_,_,_) :- !, % 'e exit - '$skipeol'(0'e), halt. '$action'(0'f,_,CallId,_,_,_) :- !, % 'f fail '$scan_number'(0'f, CallId, GoalId), %'f From 63a1957d8e8adc65fea72d1f9e45bcfda69b5e82 Mon Sep 17 00:00:00 2001 From: Vitor Santos Costa Date: Mon, 24 Jul 2017 18:20:00 +0100 Subject: [PATCH 4/6] documentation. --- C/cmppreds.c | 14 +- C/heapgc.c | 2 +- JIT/HPP/yaam_call_d.h | 609 +++++++++++++------------- docs/Doxyfile.in | 7 +- docs/{ => custom}/pygments.css | 0 docs/{ => custom}/solarized-light.css | 0 docs/md/attscorout.md | 4 +- library/dbusage.yap | 3 +- library/flags.yap | 4 +- library/log2md.yap | 2 +- library/rbtrees.yap | 10 +- packages/myddas/myddas.md | 27 +- pl/attributes.yap | 8 +- pl/boot.yap | 6 +- pl/corout.yap | 2 +- pl/flags.yap | 6 +- 16 files changed, 337 insertions(+), 367 deletions(-) rename docs/{ => custom}/pygments.css (100%) rename docs/{ => custom}/solarized-light.css (100%) diff --git a/C/cmppreds.c b/C/cmppreds.c index faa0970c5..00dbee65b 100644 --- a/C/cmppreds.c +++ b/C/cmppreds.c @@ -540,7 +540,7 @@ Int p_compare(USES_REGS1) { /* compare(?Op,?T1,?T2) */ return Yap_unify_constant(ARG1, MkAtomTerm(p)); } -/** @pred _X_ \== _Y_ is iso +/** @pred X \== Y is iso Terms _X_ and _Y_ are not strictly identical. */ @@ -548,7 +548,7 @@ static Int a_noteq(Term t1, Term t2) { return (compare(t1, t2) != 0); } static Int a_gen_lt(Term t1, Term t2) { return (compare(t1, t2) < 0); } -/** @pred _X_ @=< _Y_ is iso +/** @pred X @=< Y is iso Term _X_ does not follow term _Y_ in the standard order. @@ -556,14 +556,14 @@ Term _X_ does not follow term _Y_ in the standard order. */ static Int a_gen_le(Term t1, Term t2) { return (compare(t1, t2) <= 0); } -/** @pred _X_ @> _Y_ is iso +/** @pred X @> Y is iso Term _X_ does not follow term _Y_ in the standard order */ static Int a_gen_gt(Term t1, Term t2) { return compare(t1, t2) > 0; } -/** @pred _X_ @>= _Y_ is iso +/** @pred X @>= Y is iso Term _X_ does not precede term _Y_ in the standard order. */ @@ -778,7 +778,7 @@ static Int a_gt(Term t1, Term t2) { /* A > B */ } /** - @pred +_X_ >= +_Y_ is iso + @pred +X >= +Y is iso Greater than or equal to arithmetic expressions The value of the expression _X_ is greater than or equal to the @@ -791,7 +791,7 @@ static Int a_ge(Term t1, Term t2) { /* A >= B */ } /** - @pred +_X_ \< +_Y_ is iso + @pred +X < +Y is iso Lesser than arithmetic expressions The value of the expression _X_ is less than the value of expression @@ -806,7 +806,7 @@ static Int a_lt(Term t1, Term t2) { /* A < B */ /** * - @pred _X_ =< + _Y_ + @pred +X =< +Y Lesser than or equal to arithmetic expressions diff --git a/C/heapgc.c b/C/heapgc.c index 68415abbe..e613dad14 100644 --- a/C/heapgc.c +++ b/C/heapgc.c @@ -1658,7 +1658,7 @@ mark_environments(CELL_PTR gc_ENV, size_t size, CELL *pvbmap USES_REGS) } } #endif - mark_external_reference(saved_var PASS_REGS); + mark_external_reference(saved_var PASS_REGS); } bmap <<= 1; currv++; diff --git a/JIT/HPP/yaam_call_d.h b/JIT/HPP/yaam_call_d.h index b81595cb6..604324869 100644 --- a/JIT/HPP/yaam_call_d.h +++ b/JIT/HPP/yaam_call_d.h @@ -1,379 +1,364 @@ -#define EXECUTE_INSTINIT \ - print_instruction((*_PREG), ON_NATIVE); \ - BLOCKADDRESS = (CELL)(*_PREG); \ - register CELL d0; \ - PredEntry *pt0; \ - register CELL *ENV_YREG = (YREG); \ - pt0 = (*_PREG)->u.pp.p; - +#define EXECUTE_INSTINIT \ + print_instruction((*_PREG), ON_NATIVE); \ + BLOCKADDRESS = (CELL)(*_PREG); \ + register CELL d0; \ + PredEntry *pt0; \ + register CELL *ENV_YREG = (YREG); \ + pt0 = (*_PREG)->u.Osbpp.p; + #ifdef LOW_LEVEL_TRACER -#define EXECUTE_LOW_LEVEL_TRACER \ - low_level_trace(enter_pred,pt0,XREGS+1); +#define EXECUTE_LOW_LEVEL_TRACER low_level_trace(enter_pred, pt0, XREGS + 1); #endif -#define EXECUTE_POST_LOW_LEVEL_TRACER \ - CACHE_A1(); \ - ALWAYS_LOOKAHEAD(pt0->OpcodeOfPred); \ - d0 = (CELL)B; - -#define EXECUTE_POST_NOCHECKING \ - (*_PREG) = pt0->CodeOfPred; \ - save_pc(); \ - ENV_YREG[E_CB] = d0; - +#define EXECUTE_POST_LOW_LEVEL_TRACER \ + CACHE_A1(); \ + ALWAYS_LOOKAHEAD(pt0->OpcodeOfPred); \ + d0 = (CELL)B; + +#define EXECUTE_POST_NOCHECKING \ + (*_PREG) = pt0->CodeOfPred; \ + save_pc(); \ + ENV_YREG[E_CB] = d0; + #ifdef DEPTH_LIMIT -#define EXECUTE_DEPTH_MINOR \ - FAILED = 0; \ - if (pt0->ModuleOfPred) { \ - if (DEPTH == MkIntTerm(0)) { \ - YAAM_FAIL; \ - } \ - else { \ - DEPTH = RESET_DEPTH(); \ - } \ - } - -#define EXECUTE_DEPTH_MOFPRED \ - FAILED = 0; \ - DEPTH -= MkIntConstant(2); +#define EXECUTE_DEPTH_MINOR \ + FAILED = 0; \ + if (pt0->ModuleOfPred) { \ + if (DEPTH == MkIntTerm(0)) { \ + YAAM_FAIL; \ + } else { \ + DEPTH = RESET_DEPTH(); \ + } \ + } -#define EXECUTE_DEPTH_END \ - FAILED = 0; +#define EXECUTE_DEPTH_MOFPRED \ + FAILED = 0; \ + DEPTH -= MkIntConstant(2); + +#define EXECUTE_DEPTH_END FAILED = 0; #endif -#define EXECUTE_END_END \ - BLOCK = (CELL)EXECUTE_END_END; \ - if (!FAILED) { \ - ALWAYS_GONext(); \ - } \ +#define EXECUTE_END_END \ + BLOCK = (CELL)EXECUTE_END_END; \ + if (!FAILED) { \ + ALWAYS_GONext(); \ + } + +#define DEXECUTE_INSTINIT \ + print_instruction((*_PREG), ON_NATIVE); \ + BLOCKADDRESS = (CELL)(*_PREG); -#define DEXECUTE_INSTINIT \ - print_instruction((*_PREG), ON_NATIVE); \ - BLOCKADDRESS = (CELL)(*_PREG); \ - #ifdef LOW_LEVEL_TRACER -#define DEXECUTE_LOW_LEVEL_TRACER \ - low_level_trace(enter_pred,(*_PREG)->u.pp.p,XREGS+1); +#define DEXECUTE_LOW_LEVEL_TRACER \ + low_level_trace(enter_pred, (*_PREG)->u.Osbpp.p, XREGS + 1); #endif -#define DEXECUTE_POST_LOW_LEVEL_TRACER \ - CACHE_Y_AS_ENV(YREG); \ - PredEntry *pt0; \ - CACHE_A1(); \ - pt0 = (*_PREG)->u.pp.p; - +#define DEXECUTE_POST_LOW_LEVEL_TRACER \ + CACHE_Y_AS_ENV(YREG); \ + PredEntry *pt0; \ + CACHE_A1(); \ + pt0 = (*_PREG)->u.Osbpp.p; + #ifdef DEPTH_LIMIT -#define DEXECUTE_DEPTH_MINOR \ - FAILED = 0; \ - if (pt0->ModuleOfPred) { \ - if (DEPTH == MkIntTerm(0)) { \ - YAAM_FAIL; \ - } \ - else { \ - DEPTH = RESET_DEPTH(); \ - } \ - } - -#define DEXECUTE_DEPTH_MOFPRED \ - FAILED = 0; \ - DEPTH -= MkIntConstant(2); - -#define DEXECUTE_DEPTH_END \ - FAILED = 0; +#define DEXECUTE_DEPTH_MINOR \ + FAILED = 0; \ + if (pt0->ModuleOfPred) { \ + if (DEPTH == MkIntTerm(0)) { \ + YAAM_FAIL; \ + } else { \ + DEPTH = RESET_DEPTH(); \ + } \ + } + +#define DEXECUTE_DEPTH_MOFPRED \ + FAILED = 0; \ + DEPTH -= MkIntConstant(2); + +#define DEXECUTE_DEPTH_END FAILED = 0; #endif #ifdef FROZEN_STACKS #ifdef YAPOR_SBA -#define DEXECUTE_END_END \ - BLOCK = (CELL)DEXECUTE_END_END; \ - if (!FAILED) { \ - (*_PREG) = pt0->CodeOfPred; \ - save_pc(); \ - (*_CPREG) = (yamop *) ENV_YREG[E_CP]; \ - ENV_YREG = ENV = (CELL *) ENV_YREG[E_E]; \ - choiceptr top_b = PROTECT_FROZEN_B(B); \ - if (ENV_YREG > (CELL *) top_b || ENV_YREG < HR) { \ - ENV_YREG = (CELL *) top_b; \ - } \ - else { \ - ENV_YREG = (CELL *)((CELL)ENV_YREG + ENV_Size((*_CPREG))); \ - } \ - WRITEBACK_Y_AS_ENV(); \ - ENV_YREG[E_CB] = (CELL) B; \ - ALWAYS_GONext(); \ - } \ - ENDCACHE_Y_AS_ENV(); +#define DEXECUTE_END_END \ + BLOCK = (CELL)DEXECUTE_END_END; \ + if (!FAILED) { \ + (*_PREG) = pt0->CodeOfPred; \ + save_pc(); \ + (*_CPREG) = (yamop *)ENV_YREG[E_CP]; \ + ENV_YREG = ENV = (CELL *)ENV_YREG[E_E]; \ + choiceptr top_b = PROTECT_FROZEN_B(B); \ + if (ENV_YREG > (CELL *)top_b || ENV_YREG < HR) { \ + ENV_YREG = (CELL *)top_b; \ + } else { \ + ENV_YREG = (CELL *)((CELL)ENV_YREG + ENV_Size((*_CPREG))); \ + } \ + WRITEBACK_Y_AS_ENV(); \ + ENV_YREG[E_CB] = (CELL)B; \ + ALWAYS_GONext(); \ + } \ + ENDCACHE_Y_AS_ENV(); #else /* YAPOR_SBA */ -#define DEXECUTE_END_END \ - BLOCK = (CELL)DEXECUTE_END_END; \ - if (!FAILED) { \ - (*_PREG) = pt0->CodeOfPred; \ - save_pc(); \ - (*_CPREG) = (yamop *) ENV_YREG[E_CP]; \ - ENV_YREG = ENV = (CELL *) ENV_YREG[E_E]; \ - choiceptr top_b = PROTECT_FROZEN_B(B); \ - if (ENV_YREG > (CELL *) top_b) { \ - ENV_YREG = (CELL *) top_b; \ - } \ - else { \ - ENV_YREG = (CELL *)((CELL)ENV_YREG + ENV_Size((*_CPREG))); \ - } \ - WRITEBACK_Y_AS_ENV(); \ - ENV_YREG[E_CB] = (CELL) B; \ - ALWAYS_GONext(); \ - } \ - ENDCACHE_Y_AS_ENV(); +#define DEXECUTE_END_END \ + BLOCK = (CELL)DEXECUTE_END_END; \ + if (!FAILED) { \ + (*_PREG) = pt0->CodeOfPred; \ + save_pc(); \ + (*_CPREG) = (yamop *)ENV_YREG[E_CP]; \ + ENV_YREG = ENV = (CELL *)ENV_YREG[E_E]; \ + choiceptr top_b = PROTECT_FROZEN_B(B); \ + if (ENV_YREG > (CELL *)top_b) { \ + ENV_YREG = (CELL *)top_b; \ + } else { \ + ENV_YREG = (CELL *)((CELL)ENV_YREG + ENV_Size((*_CPREG))); \ + } \ + WRITEBACK_Y_AS_ENV(); \ + ENV_YREG[E_CB] = (CELL)B; \ + ALWAYS_GONext(); \ + } \ + ENDCACHE_Y_AS_ENV(); #endif /* YAPOR_SBA */ -#else /* FROZEN_STACKS */ -#define DEXECUTE_END_END \ - BLOCK = (CELL)DEXECUTE_END_END; \ - if (!FAILED) { \ - (*_PREG) = pt0->CodeOfPred; \ - save_pc(); \ - (*_CPREG) = (yamop *) ENV_YREG[E_CP]; \ - ENV_YREG = ENV = (CELL *) ENV_YREG[E_E]; \ - if (ENV_YREG > (CELL *)B) { \ - ENV_YREG = (CELL *)B; \ - } \ - else { \ - ENV_YREG = (CELL *) ((CELL) ENV_YREG + ENV_Size((*_CPREG))); \ - } \ - WRITEBACK_Y_AS_ENV(); \ - ENV_YREG[E_CB] = (CELL) B; \ - ALWAYS_GONext(); \ - } \ - ENDCACHE_Y_AS_ENV(); +#else /* FROZEN_STACKS */ +#define DEXECUTE_END_END \ + BLOCK = (CELL)DEXECUTE_END_END; \ + if (!FAILED) { \ + (*_PREG) = pt0->CodeOfPred; \ + save_pc(); \ + (*_CPREG) = (yamop *)ENV_YREG[E_CP]; \ + ENV_YREG = ENV = (CELL *)ENV_YREG[E_E]; \ + if (ENV_YREG > (CELL *)B) { \ + ENV_YREG = (CELL *)B; \ + } else { \ + ENV_YREG = (CELL *)((CELL)ENV_YREG + ENV_Size((*_CPREG))); \ + } \ + WRITEBACK_Y_AS_ENV(); \ + ENV_YREG[E_CB] = (CELL)B; \ + ALWAYS_GONext(); \ + } \ + ENDCACHE_Y_AS_ENV(); #endif /* FROZEN_STACKS */ #ifdef DEPTH_LIMIT -#define FCALL_INST \ - CACHE_Y_AS_ENV(YREG); \ - ENV_YREG[E_CP] = (CELL) (*_CPREG); \ - ENV_YREG[E_E] = (CELL) ENV; \ - ENV_YREG[E_DEPTH] = DEPTH; \ - ENDCACHE_Y_AS_ENV(); +#define FCALL_INST \ + CACHE_Y_AS_ENV(YREG); \ + ENV_YREG[E_CP] = (CELL)(*_CPREG); \ + ENV_YREG[E_E] = (CELL)ENV; \ + ENV_YREG[E_DEPTH] = DEPTH; \ + ENDCACHE_Y_AS_ENV(); #else /* DEPTH_LIMIT */ -#define FCALL_INST \ - CACHE_Y_AS_ENV(YREG); \ - ENV_YREG[E_CP] = (CELL) (*_CPREG); \ - ENV_YREG[E_E] = (CELL) ENV; \ - ENDCACHE_Y_AS_ENV(); +#define FCALL_INST \ + CACHE_Y_AS_ENV(YREG); \ + ENV_YREG[E_CP] = (CELL)(*_CPREG); \ + ENV_YREG[E_E] = (CELL)ENV; \ + ENDCACHE_Y_AS_ENV(); #endif /* DEPTH_LIMIT */ - -#define CALL_INSTINIT \ - print_instruction((*_PREG), ON_NATIVE); \ - BLOCKADDRESS = (CELL)(*_PREG); \ - if (Yap_op_from_opcode((*_PREG)->opc) == _fcall) { \ - FCALL_INST; \ - } - + +#define CALL_INSTINIT \ + print_instruction((*_PREG), ON_NATIVE); \ + BLOCKADDRESS = (CELL)(*_PREG); \ + if (Yap_op_from_opcode((*_PREG)->opc) == _fcall) { \ + FCALL_INST; \ + } + #ifdef LOW_LEVEL_TRACER -#define CALL_LOW_LEVEL_TRACER \ - low_level_trace(enter_pred,(*_PREG)->u.Osbpp.p,XREGS+1); +#define CALL_LOW_LEVEL_TRACER \ + low_level_trace(enter_pred, (*_PREG)->u.Osbpp.p, XREGS + 1); #endif -#define CALL_POST_LOW_LEVEL_TRACER \ - register CELL *ENV_YREG = (YREG); \ - PredEntry *pt; \ - pt = (*_PREG)->u.Osbpp.p; \ - CACHE_A1(); - -#define CALL_POST_NO_CHECKING \ - ENV = ENV_YREG; \ - ENV_YREG = (CELL *) (((char *) ENV_YREG) + (*_PREG)->u.Osbpp.s); \ - (*_CPREG) = NEXTOP((*_PREG), Osbpp); \ - (*_PREG) = pt->CodeOfPred; \ - save_pc(); \ - +#define CALL_POST_LOW_LEVEL_TRACER \ + register CELL *ENV_YREG = (YREG); \ + PredEntry *pt; \ + pt = (*_PREG)->u.Osbpp.p; \ + CACHE_A1(); + +#define CALL_POST_NO_CHECKING \ + ENV = ENV_YREG; \ + ENV_YREG = (CELL *)(((char *)ENV_YREG) + (*_PREG)->u.Osbpp.s); \ + (*_CPREG) = NEXTOP((*_PREG), Osbpp); \ + (*_PREG) = pt->CodeOfPred; \ + save_pc(); + #ifdef DEPTH_LIMIT -#define CALL_DEPTH_MINOR \ - FAILED = 0; \ - if (pt->ModuleOfPred) { \ - if (DEPTH == MkIntTerm(0)){ \ - YAAM_FAIL; \ - } else { \ - DEPTH = RESET_DEPTH(); \ - } \ - } - -#define CALL_DEPTH_MOFPRED \ - FAILED = 0; \ - DEPTH -= MkIntConstant(2); - -#define CALL_DEPTH_END \ - FAILED = 0; +#define CALL_DEPTH_MINOR \ + FAILED = 0; \ + if (pt->ModuleOfPred) { \ + if (DEPTH == MkIntTerm(0)) { \ + YAAM_FAIL; \ + } else { \ + DEPTH = RESET_DEPTH(); \ + } \ + } + +#define CALL_DEPTH_MOFPRED \ + FAILED = 0; \ + DEPTH -= MkIntConstant(2); + +#define CALL_DEPTH_END FAILED = 0; #endif #ifdef YAPOR #ifdef FROZEN_STACKS #ifdef YAPOR_SBA -#define CALL_END_END \ - BLOCK = (CELL)CALL_END_END; \ - if (!FAILED) { \ - { \ - choiceptr top_b = PROTECT_FROZEN_B(B); \ - if (ENV_YREG > (CELL *) top_b || ENV_YREG < HR) { \ - ENV_YREG = (CELL *) top_b; \ - } \ - } \ - WRITEBACK_Y_AS_ENV(); \ - ENV_YREG[E_CB] = (CELL) B; \ - SCH_check_requests(); \ - ALWAYS_GONext(); \ +#define CALL_END_END \ + BLOCK = (CELL)CALL_END_END; \ + if (!FAILED) { \ + { \ + choiceptr top_b = PROTECT_FROZEN_B(B); \ + if (ENV_YREG > (CELL *)top_b || ENV_YREG < HR) { \ + ENV_YREG = (CELL *)top_b; \ + } \ + } \ + WRITEBACK_Y_AS_ENV(); \ + ENV_YREG[E_CB] = (CELL)B; \ + SCH_check_requests(); \ + ALWAYS_GONext(); \ } #else /* YAPOR_SBA */ -#define CALL_END_END \ - BLOCK = (CELL)CALL_END_END; \ - if (!FAILED) { \ - { \ - choiceptr top_b = PROTECT_FROZEN_B(B); \ - if (ENV_YREG > (CELL *) top_b) { \ - ENV_YREG = (CELL *) top_b; \ - } \ - } \ - WRITEBACK_Y_AS_ENV(); \ - ENV_YREG[E_CB] = (CELL) B; \ - SCH_check_requests(); \ - ALWAYS_GONext(); \ +#define CALL_END_END \ + BLOCK = (CELL)CALL_END_END; \ + if (!FAILED) { \ + { \ + choiceptr top_b = PROTECT_FROZEN_B(B); \ + if (ENV_YREG > (CELL *)top_b) { \ + ENV_YREG = (CELL *)top_b; \ + } \ + } \ + WRITEBACK_Y_AS_ENV(); \ + ENV_YREG[E_CB] = (CELL)B; \ + SCH_check_requests(); \ + ALWAYS_GONext(); \ } #endif /* YAPOR_SBA */ -#else /* FROZEN_STACKS */ -#define CALL_END_END \ - BLOCK = (CELL)CALL_END_END; \ - if (!FAILED) { \ - if (ENV_YREG > (CELL *) B) { \ - ENV_YREG = (CELL *) B; \ - } \ - WRITEBACK_Y_AS_ENV(); \ - ENV_YREG[E_CB] = (CELL) B; \ - SCH_check_requests(); \ - ALWAYS_GONext(); \ +#else /* FROZEN_STACKS */ +#define CALL_END_END \ + BLOCK = (CELL)CALL_END_END; \ + if (!FAILED) { \ + if (ENV_YREG > (CELL *)B) { \ + ENV_YREG = (CELL *)B; \ + } \ + WRITEBACK_Y_AS_ENV(); \ + ENV_YREG[E_CB] = (CELL)B; \ + SCH_check_requests(); \ + ALWAYS_GONext(); \ } #endif /* FROZEN_STACKS */ -#else /* YAPOR */ +#else /* YAPOR */ #ifdef FROZEN_STACKS #ifdef YAPOR_SBA -#define CALL_END_END \ - BLOCK = (CELL)CALL_END_END; \ - if (!FAILED) { \ - { \ - choiceptr top_b = PROTECT_FROZEN_B(B); \ - if (ENV_YREG > (CELL *) top_b || ENV_YREG < HR) { \ - ENV_YREG = (CELL *) top_b; \ - } \ - } \ - WRITEBACK_Y_AS_ENV(); \ - ENV_YREG[E_CB] = (CELL) B; \ - ALWAYS_GONext(); \ +#define CALL_END_END \ + BLOCK = (CELL)CALL_END_END; \ + if (!FAILED) { \ + { \ + choiceptr top_b = PROTECT_FROZEN_B(B); \ + if (ENV_YREG > (CELL *)top_b || ENV_YREG < HR) { \ + ENV_YREG = (CELL *)top_b; \ + } \ + } \ + WRITEBACK_Y_AS_ENV(); \ + ENV_YREG[E_CB] = (CELL)B; \ + ALWAYS_GONext(); \ } #else /* YAPOR_SBA */ -#define CALL_END_END \ - BLOCK = (CELL)CALL_END_END; \ - if (!FAILED) { \ - { \ - choiceptr top_b = PROTECT_FROZEN_B(B); \ - if (ENV_YREG > (CELL *) top_b) { \ - ENV_YREG = (CELL *) top_b; \ - } \ - } \ - WRITEBACK_Y_AS_ENV(); \ - ENV_YREG[E_CB] = (CELL) B; \ - ALWAYS_GONext(); \ +#define CALL_END_END \ + BLOCK = (CELL)CALL_END_END; \ + if (!FAILED) { \ + { \ + choiceptr top_b = PROTECT_FROZEN_B(B); \ + if (ENV_YREG > (CELL *)top_b) { \ + ENV_YREG = (CELL *)top_b; \ + } \ + } \ + WRITEBACK_Y_AS_ENV(); \ + ENV_YREG[E_CB] = (CELL)B; \ + ALWAYS_GONext(); \ } #endif /* YAPOR_SBA */ -#else /* FROZEN_STACKS */ -#define CALL_END_END \ - BLOCK = (CELL)CALL_END_END; \ - if (!FAILED) { \ - if (ENV_YREG > (CELL *) B) { \ - ENV_YREG = (CELL *) B; \ - } \ - WRITEBACK_Y_AS_ENV(); \ - ENV_YREG[E_CB] = (CELL) B; \ - ALWAYS_GONext(); \ +#else /* FROZEN_STACKS */ +#define CALL_END_END \ + BLOCK = (CELL)CALL_END_END; \ + if (!FAILED) { \ + if (ENV_YREG > (CELL *)B) { \ + ENV_YREG = (CELL *)B; \ + } \ + WRITEBACK_Y_AS_ENV(); \ + ENV_YREG[E_CB] = (CELL)B; \ + ALWAYS_GONext(); \ } #endif /* FROZEN_STACKS */ #endif /* YAPOR */ -#define PROCCEED_INSTINIT \ - print_instruction((*_PREG), ON_NATIVE); \ - BLOCKADDRESS = (CELL)(*_PREG); \ - CACHE_Y_AS_ENV(YREG); \ - (*_PREG) = (*_CPREG); \ - save_pc(); \ - ENV_YREG = ENV; - +#define PROCCEED_INSTINIT \ + print_instruction((*_PREG), ON_NATIVE); \ + BLOCKADDRESS = (CELL)(*_PREG); \ + CACHE_Y_AS_ENV(YREG); \ + (*_PREG) = (*_CPREG); \ + save_pc(); \ + ENV_YREG = ENV; + #ifdef DEPTH_LIMIT -#define PROCCEED_DEPTH \ - DEPTH = ENV_YREG[E_DEPTH]; +#define PROCCEED_DEPTH DEPTH = ENV_YREG[E_DEPTH]; #endif -#define PROCCEED_END \ - BLOCK = (CELL)PROCCEED_END; \ - WRITEBACK_Y_AS_ENV(); \ - ENDCACHE_Y_AS_ENV(); \ - ALWAYS_GONext(); +#define PROCCEED_END \ + BLOCK = (CELL)PROCCEED_END; \ + WRITEBACK_Y_AS_ENV(); \ + ENDCACHE_Y_AS_ENV(); \ + ALWAYS_GONext(); + +#define ALLOCATE_INSTINIT \ + print_instruction((*_PREG), ON_NATIVE); \ + CACHE_Y_AS_ENV(YREG); \ + (*_PREG) = NEXTOP((*_PREG), e); \ + ENV_YREG[E_CP] = (CELL)(*_CPREG); \ + ENV_YREG[E_E] = (CELL)ENV; -#define ALLOCATE_INSTINIT \ - print_instruction((*_PREG), ON_NATIVE); \ - CACHE_Y_AS_ENV(YREG); \ - (*_PREG) = NEXTOP((*_PREG), e); \ - ENV_YREG[E_CP] = (CELL) (*_CPREG); \ - ENV_YREG[E_E] = (CELL) ENV; - #ifdef DEPTH_LIMIT -#define ALLOCATE_DEPTH \ - ENV_YREG[E_DEPTH] = DEPTH; +#define ALLOCATE_DEPTH ENV_YREG[E_DEPTH] = DEPTH; #endif -#define ALLOCATE_END \ - ENV = ENV_YREG; \ - ENDCACHE_Y_AS_ENV(); \ - GONext(); +#define ALLOCATE_END \ + ENV = ENV_YREG; \ + ENDCACHE_Y_AS_ENV(); \ + GONext(); -#define DEALLOCATE_INSTINIT \ - print_instruction((*_PREG), ON_NATIVE); \ +#define DEALLOCATE_INSTINIT print_instruction((*_PREG), ON_NATIVE); + +#define DEALLOCATE_POST_CHECK \ + CACHE_Y_AS_ENV(YREG); \ + (*_PREG) = NEXTOP((*_PREG), p); \ + (*_SREG) = YREG; \ + (*_CPREG) = (yamop *)ENV_YREG[E_CP]; \ + ENV = ENV_YREG = (CELL *)ENV_YREG[E_E]; -#define DEALLOCATE_POST_CHECK \ - CACHE_Y_AS_ENV(YREG); \ - (*_PREG) = NEXTOP((*_PREG), p); \ - (*_SREG) = YREG; \ - (*_CPREG) = (yamop *) ENV_YREG[E_CP]; \ - ENV = ENV_YREG = (CELL *) ENV_YREG[E_E]; - #ifdef DEPTH_LIMIT -#define DEALLOCATE_DEPTH \ - DEPTH = ENV_YREG[E_DEPTH]; +#define DEALLOCATE_DEPTH DEPTH = ENV_YREG[E_DEPTH]; #endif #ifdef FROZEN_STACKS #ifdef YAPOR_SBA -#define DEALLOCATE_FROZEN \ - choiceptr top_b = PROTECT_FROZEN_B(B); \ - if (ENV_YREG > (CELL *) top_b || ENV_YREG < HR) \ - ENV_YREG = (CELL *) top_b; \ - else \ - ENV_YREG = (CELL *)((CELL) ENV_YREG + ENV_Size(CPREG)); +#define DEALLOCATE_FROZEN \ + choiceptr top_b = PROTECT_FROZEN_B(B); \ + if (ENV_YREG > (CELL *)top_b || ENV_YREG < HR) \ + ENV_YREG = (CELL *)top_b; \ + else \ + ENV_YREG = (CELL *)((CELL)ENV_YREG + ENV_Size(CPREG)); #else /* YAPOR_SBA */ -#define DEALLOCATE_FROZEN \ - choiceptr top_b = PROTECT_FROZEN_B(B); \ - if (ENV_YREG > (CELL *) top_b) \ - ENV_YREG = (CELL *) top_b; \ - else \ - ENV_YREG = (CELL *)((CELL) ENV_YREG + ENV_Size(CPREG)); +#define DEALLOCATE_FROZEN \ + choiceptr top_b = PROTECT_FROZEN_B(B); \ + if (ENV_YREG > (CELL *)top_b) \ + ENV_YREG = (CELL *)top_b; \ + else \ + ENV_YREG = (CELL *)((CELL)ENV_YREG + ENV_Size(CPREG)); #endif /* YAPOR_SBA */ -#else /* FROZEN_STACKS */ -#define DEALLOCATE_FROZEN \ - if (ENV_YREG > (CELL *) B) \ - ENV_YREG = (CELL *) B; \ - else \ - ENV_YREG = (CELL *) ((CELL) ENV_YREG + ENV_Size(CPREG)); +#else /* FROZEN_STACKS */ +#define DEALLOCATE_FROZEN \ + if (ENV_YREG > (CELL *)B) \ + ENV_YREG = (CELL *)B; \ + else \ + ENV_YREG = (CELL *)((CELL)ENV_YREG + ENV_Size(CPREG)); #endif /* FROZEN_STACKS */ - -#define DEALLOCATE_POST_FROZEN \ - WRITEBACK_Y_AS_ENV(); -#define DEALLOCATE_END \ - ENDCACHE_Y_AS_ENV(); \ - GONext(); +#define DEALLOCATE_POST_FROZEN WRITEBACK_Y_AS_ENV(); +#define DEALLOCATE_END \ + ENDCACHE_Y_AS_ENV(); \ + GONext(); diff --git a/docs/Doxyfile.in b/docs/Doxyfile.in index fa459ef21..c3f056c7c 100644 --- a/docs/Doxyfile.in +++ b/docs/Doxyfile.in @@ -1153,9 +1153,10 @@ HTML_STYLESHEET = # list). For an example see the documentation. # This tag requires that the tag GENERATE_HTML is set to YES. -HTML_EXTRA_STYLESHEET = @CMAKE_SOURCE_DIR@/docs/custom/customdoxygen.css \ - @CMAKE_SOURCE_DIR@/docs/custom/pygments.css \ - @CMAKE_SOURCE_DIR@/docs/solarized-light.css +HTML_EXTRA_STYLESHEET = \ + @CMAKE_SOURCE_DIR@/docs/custom/customdoxygen.css \ + @CMAKE_SOURCE_DIR@/docs/custom/pygments.css \ + @CMAKE_SOURCE_DIR@/docs/custom/solarized-light.css \ # The HTML_EXTRA_FILES tag can be used to specify one or more extra images or # other source files which should be copied to the HTML output directory. Note diff --git a/docs/pygments.css b/docs/custom/pygments.css similarity index 100% rename from docs/pygments.css rename to docs/custom/pygments.css diff --git a/docs/solarized-light.css b/docs/custom/solarized-light.css similarity index 100% rename from docs/solarized-light.css rename to docs/custom/solarized-light.css diff --git a/docs/md/attscorout.md b/docs/md/attscorout.md index cfeb32800..6a4444dbf 100644 --- a/docs/md/attscorout.md +++ b/docs/md/attscorout.md @@ -29,7 +29,7 @@ interface. + @ref sicsatts + @ref New_Style_Attribute_Declarations + @ref AttributedVariables_Builtins - + @ref corout + + @ref CohYroutining ### SICStus Style attribute declarations. {#SICS_attributes} @@ -374,7 +374,6 @@ The argument to `wait/1` is a predicate descriptor or a conjunction of these predicates. These predicates will suspend until their first argument is bound. - The following primitives can be used: - freeze/2 @@ -385,6 +384,7 @@ The following primitives can be used: - frozen/2 +See @ref attscorouts for more details. @} diff --git a/library/dbusage.yap b/library/dbusage.yap index a52e73db9..66c21ed43 100644 --- a/library/dbusage.yap +++ b/library/dbusage.yap @@ -26,7 +26,8 @@ `use_module(library(dbusage))` command. */ -/** @pred db_usage +/** @pred db_usage + Give general overview of data-base usage in the system. */ db_usage :- diff --git a/library/flags.yap b/library/flags.yap index 4b3daf33b..048e4bf6a 100644 --- a/library/flags.yap +++ b/library/flags.yap @@ -309,7 +309,7 @@ flag_group_chk(FlagGroup):- flag_type(Type):- flags_type_definition(Type, _, _). -% flags_type_definition(TypeName, TypeHandler, TypeValidator). +%% @pred flags_type_definition(TypeName, TypeHandler, TypeValidator). flags_type_definition(nonvar, nonvar, true). flags_type_definition(atom, atom, true). flags_type_definition(atomic, atomic, true). @@ -586,4 +586,4 @@ defined_flag(FlagName, FlagGroup, FlagType, DefaultValue, Description, Access, H nonvar(FlagName), nonvar(FlagGroup), '$defined_flag$'(FlagName, FlagGroup, FlagType, DefaultValue, Description, Access, Handler). -%% @} +%% @} diff --git a/library/log2md.yap b/library/log2md.yap index 6ce685582..862b265eb 100644 --- a/library/log2md.yap +++ b/library/log2md.yap @@ -147,7 +147,7 @@ open_log(F) :- ). /** - * @pred `<--`( +Tag , :Goal ) + * @pred +Tag <-- :Goal * * @param [in] output goal _Goal_ before and after being evaluated, but only * taking the first solution. The _Tag_ must be an atom or a string. diff --git a/library/rbtrees.yap b/library/rbtrees.yap index 4588309fa..d9c43dc49 100644 --- a/library/rbtrees.yap +++ b/library/rbtrees.yap @@ -150,7 +150,7 @@ min(red(Right,_,_,_), Key, Val) :- min(black(Right,_,_,_), Key, Val) :- min(Right,Key,Val). -%% @pred rb_max(+T, -Key, -Value) is semidet. +%% @pred rb_max( +T, -Key, -Value) is semidet. % % Key is the maximal key in T, and is associated with Val. @@ -612,8 +612,8 @@ pretty_print(black(L,K,_,R),D) :- rb_delete(t(Nil,T), K, t(Nil,NT)) :- delete(T, K, _, NT, _). -%% rb_delete(+T, +Key, -TN). -%% rb_delete(+T, +Key, -Val, -TN). +%% @pred rb_delete(+T, +Key, -TN). +%% @pred rb_delete(+T, +Key, -Val, -TN). % % Delete element with key Key from the tree T, returning the value % Val associated with the key and a new tree TN. @@ -648,7 +648,7 @@ delete(black(L,_,V,R), _, V, OUT, Flag) :- % K == K0, delete_black_node(L,R,OUT,Flag). -%% rb_del_min(+T, -Key, -Val, -TN) +%% @pred rb_del_min(+T, -Key, -Val, -TN) % % Delete the least element from the tree T, returning the key Key, % the value Val associated with the key and a new tree TN. @@ -668,7 +668,7 @@ del_min(black(L,K0,V0,R), K, V, Nil, NT, Flag) :- fixup_left(Flag0,black(NL,K0,V0,R),NT, Flag). -%% rb_del_max(+T, -Key, -Val, -TN) +%% @pred rb_del_max( +T, -Key, -Val, -TN) % % Delete the largest element from the tree T, returning the key % Key, the value Val associated with the key and a new tree TN. diff --git a/packages/myddas/myddas.md b/packages/myddas/myddas.md index f2e2e839b..d35a74118 100644 --- a/packages/myddas/myddas.md +++ b/packages/myddas/myddas.md @@ -1,5 +1,5 @@ -The MYDDAS Data-base interface {#myddas} -=============================== + +## The MYDDAS Data-base interface {#myddas} The MYDDAS database project was developed within a FCT project aiming at the development of a highly efficient deductive database system, based @@ -63,8 +63,8 @@ The MYDDAS Data-base interface {#myddas} Prolog cut operator, which has exactly the same behaviour from predicates defined in the Prolog program source code, or from predicates defined in database as relations. + ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ - Name = 'John Doe', Number = 123456789 ? yes @@ -92,9 +92,6 @@ The MYDDAS Data-base interface {#myddas} @pred db view(+,+,+). - - - @pred db view(+,+). @@ -186,9 +183,6 @@ The MYDDAS Data-base interface {#myddas} @pred db_sql(+,+,?). - - - @pred db_sql(+,?). @@ -284,15 +278,7 @@ The MYDDAS Data-base interface {#myddas} @pred db_get_attributes_types(+,+,?). - - - - @pred db_get_attributes_types(+,?). - - - - - The prototype for this predicate is the following: +otype for this predicate is the following: ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ ?- db_get_attributes_types(Conn,RelationName,ListOfFields). @@ -552,9 +538,6 @@ The MYDDAS Data-base interface {#myddas} this by doing again `db_my_result_set(store_result)`. @pred db_my_sql_mode(+Conn,?SQL_Mode). - - - @pred db_my_sql_mode(?SQL_Mode). @@ -570,4 +553,4 @@ The MYDDAS Data-base interface {#myddas} ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ You can see the available SQL Modes at the MySQL homepage at . - b + \ No newline at end of file diff --git a/pl/attributes.yap b/pl/attributes.yap index fdc6e50f1..155cfc84b 100644 --- a/pl/attributes.yap +++ b/pl/attributes.yap @@ -55,7 +55,7 @@ all_attvars/1, :- dynamic attributed_module/3. -/** @pred get_attr(+ _Var_,+ _Module_,- _Value_) +/** @pred get_attr( + Var,+ Module,- Value) Request the current _value_ for the attribute named _Module_. If _Var_ is not an attributed variable or the named attribute is not @@ -339,7 +339,7 @@ printing and other special purpose operations. */ -/** @pred _Module_:attribute_goal( _-Var_, _-Goal_) +/** @pred Module:attribute_goal( -Var, Goal) User-defined procedure, called to convert the attributes in _Var_ to a _Goal_. Should fail when no interpretation is available. @@ -469,11 +469,11 @@ att_vars([_|LGs], AttVars) :- % make sure we set the suspended goal list to its previous state! % make sure we have installed a SICStus like constraint solver. -/** @pred _Module_:project_attributes(+AttrVars, +Goal) +/** @pred Module:project_attributes( +AttrVars, +Goal) -Given a goal _Goa]l_ with variables _QueryVars_ and list of attributed +Given a goal _Goal_ with variables _QueryVars_ and list of attributed variables _AttrVars_, project all attributes in _AttrVars_ to _QueryVars_. Although projection is constraint system dependent, typically this will involve expressing all constraints in terms of diff --git a/pl/boot.yap b/pl/boot.yap index 1178bce43..11eecb47b 100644 --- a/pl/boot.yap +++ b/pl/boot.yap @@ -41,7 +41,7 @@ should be read as "p( _X_) if q( _X_) or r( _X_)". */ -/** @pred \+ :_P_ is iso +/** @pred \+ 0:P is iso Negation by failure. Goal _P_ is not provable. The execution of this predicate fails if @@ -68,7 +68,7 @@ If _P_ includes cuts, the cuts are defined to be scoped by _P_: they cannot cut */ -/** @pred :_Condition__ -> :_Action_ is iso +/** @pred 0:Condition -> 0:Action is iso @short If _Condition__ has a solution, call _Action_; @@ -119,7 +119,7 @@ arguments. */ -/** @pred :_Condition_ *-> :_Action_ is iso +/** @pred 0:Condition *-> 0:Action is iso This construct implements the so-called soft-cut. The control is defined as follows: diff --git a/pl/corout.yap b/pl/corout.yap index d9f970f40..e0fd90b08 100644 --- a/pl/corout.yap +++ b/pl/corout.yap @@ -41,7 +41,7 @@ /** - * @defgroup corout Implementing Attributed Variables and Co-Routining + * @defgroup attscorouts Implementing Attributed Variables and Co-Routining * * @ingroup attributes * @{ diff --git a/pl/flags.yap b/pl/flags.yap index 7fc5a6982..6ec93294e 100644 --- a/pl/flags.yap +++ b/pl/flags.yap @@ -18,9 +18,9 @@ * @file flagd.ysp * * @defgroup Flags Yap Flags - *n@{} + * @{} * @ingroup builtins - * @}@[ ] + * */ @@ -79,7 +79,7 @@ unknown(_,error). -/** @pred create_prolog_flag(+ _Flag_,+ _Value_,+ _Options_) +/** @pred create_prolog_flag( +Flag, +Value, +Options) Create a new YAP Prolog flag. _Options_ include From 46468803b1e894ce1def596da19a676cbe2e1d49 Mon Sep 17 00:00:00 2001 From: Vitor Santos Costa Date: Tue, 25 Jul 2017 01:09:29 +0100 Subject: [PATCH 5/6] fix warnings. --- packages/python/swig/CMakeLists.txt | 86 ++++++++++++++++------------- packages/python/swig/setup.py.in | 6 +- 2 files changed, 53 insertions(+), 39 deletions(-) diff --git a/packages/python/swig/CMakeLists.txt b/packages/python/swig/CMakeLists.txt index 6bc4ae91b..475f4c800 100644 --- a/packages/python/swig/CMakeLists.txt +++ b/packages/python/swig/CMakeLists.txt @@ -28,72 +28,84 @@ set (SYS_DLLS ${GMP_LIBRARIES} c:/msys64/mingw64/bin/libgmp-10.dll) endif() - # inform we are compiling YAP - # s used in MSYS - # - # - # INSTALL ( TARGETS ${SWIG_MODULE_Py2YAP_REAL_NAME} - # RUNTIME DESTINATION ${PYTHON_MODULE_PATH} - # ARCHIVE DESTINATION ${PYTHON_MODULE_PATH} - # LIBRARY DESTINATION ${PYTHON_MODULE_PATH} - # ) +# inform we are compiling YAP +# s used in MSYS +# +# +# INSTALL ( TARGETS ${SWIG_MODULE_Py2YAP_REAL_NAME} +# RUNTIME DESTINATION ${PYTHON_MODULE_PATH} +# ARCHIVE DESTINATION ${PYTHON_MODULE_PATH} +# LIBRARY DESTINATION ${PYTHON_MODULE_PATH} +# ) - set (python_dlls $ +set (python_dlls ${SYS_DLLS} + $ $ $ $ $ $ $ - ) - if (TARGET real) +) +if (TARGET real) list(APPEND python_dlls $ - ) + ) endif() - if (NOT WIN32) +if (NOT WIN32) list(APPEND python_dlls $ $ - ) - endif() +) +endif() set (PL ${pl_library} ${PROLOG_SOURCES} ) add_custom_target( YAP4PY_SETUP - COMMAND ${CMAKE_COMMAND} -E copy ${CMAKE_SOURCE_DIR}/packages/swig/yap.i ${CMAKE_CURRENT_BINARY_DIR} - COMMAND ${CMAKE_COMMAND} -E copy ${CMAKE_BINARY_DIR}/config.h ${CMAKE_CURRENT_BINARY_DIR} - COMMAND ${CMAKE_COMMAND} -E copy ${PYTHON_SOURCES} ${CMAKE_CURRENT_BINARY_DIR}/yap4py - COMMAND ${CMAKE_COMMAND} -E copy ${python_dlls} ${SYS_DLLS} ${CMAKE_BINARY_DIR}/libYap${CMAKE_SHARED_LIBRARY_SUFFIX} ${CMAKE_BINARY_DIR}/${YAP_STARTUP} ${PYTHON_SOURCES} ${CMAKE_CURRENT_BINARY_DIR}/yap4py - COMMAND ${CMAKE_COMMAND} -E copy ${PL} ${CMAKE_CURRENT_BINARY_DIR}/yap4py/prolog - COMMAND ${CMAKE_COMMAND} -E copy ${pl_boot_library} ${CMAKE_CURRENT_BINARY_DIR}/yap4py/prolog/pl - COMMAND ${CMAKE_COMMAND} -E copy ${pl_os_library} ${CMAKE_CURRENT_BINARY_DIR}/yap4py/prolog/os - DEPENDS YAP4PY_SETUP_DIRS STARTUP ${python_dlls} ${PYTHON_SOURCES} ${PROLOG_SOURCES} ${CMAKE_CURRENT_BINARY_DIR}/setup.py ${SWIG_MODULE_Py2YAP_REAL_NAME} ) + COMMAND ${CMAKE_COMMAND} -E copy ${python_dlls} yap4py + COMMAND ${CMAKE_COMMAND} -E copy ${CMAKE_BINARY_DIR}/libYap${CMAKE_SHARED_LIBRARY_SUFFIX} yap4py + COMMAND ${CMAKE_COMMAND} -E copy ${CMAKE_BINARY_DIR}/${YAP_STARTUP} ${CMAKE_CURRENT_BINARY_DIR}/yap4py +WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR} + DEPENDS YAP4PY_SETUP_PL STARTUP ${python_dlls} libYap ) + +add_custom_target( YAP4PY_SETUP_PL + COMMAND ${CMAKE_COMMAND} -E copy ${PL} yap4py/prolog + COMMAND ${CMAKE_COMMAND} -E copy ${pl_boot_library} yap4py/prolog/pl + COMMAND ${CMAKE_COMMAND} -E copy ${pl_os_library} yap4py/prolog/os +WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR} + DEPENDS ${CMAKE_CURRENT_BINARY_DIR}/yap.i ${PYTHON_SOURCES} ${PL} ${pl_boot_library} ${pl_os_library} ) + +add_custom_target( OUTPUT ${CMAKE_CURRENT_BINARY_DIR}/yap.i +COMMAND ${CMAKE_COMMAND} -E copy_if_different ${CMAKE_SOURCE_DIR}/packages/swig/yap.i yap.i + COMMAND ${CMAKE_COMMAND} -E copy ${PYTHON_SOURCES} yap4py +WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR} + DEPENDS YAP4PY_SETUP_DIRS ${PYTHON_SOURCES} ) add_custom_target( YAP4PY_SETUP_DIRS - COMMAND ${CMAKE_COMMAND} -E make_directory ${CMAKE_CURRENT_BINARY_DIR}/yap4py - COMMAND ${CMAKE_COMMAND} -E make_directory ${CMAKE_CURRENT_BINARY_DIR}/yap4py/prolog - COMMAND ${CMAKE_COMMAND} -E make_directory ${CMAKE_CURRENT_BINARY_DIR}/yap4py/prolog/pl - COMMAND ${CMAKE_COMMAND} -E make_directory ${CMAKE_CURRENT_BINARY_DIR}/yap4py/prolog/os + COMMAND ${CMAKE_COMMAND} -E make_directory yap4py + COMMAND ${CMAKE_COMMAND} -E make_directory yap4py/prolog + COMMAND ${CMAKE_COMMAND} -E make_directory yap4py/prolog/pl + COMMAND ${CMAKE_COMMAND} -E make_directory yap4py/prolog/os +WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR} ) - add_custom_target( YAP4PY ALL - COMMAND ${PYTHON_EXECUTABLE} -m pip uninstall -y YAP4PY + add_custom_target( YAP4PY ALL + COMMAND ${PYTHON_EXECUTABLE} -m pip uninstall -y YAP4PY COMMAND ${SWIG_EXECUTABLE} -python -modern -c++ -py3 -DX_API -I${CMAKE_SOURCE_DIR}/CXX -I${CMAKE_SOURCE_DIR}/include -I${CMAKE_SOURCE_DIR}/H -I${CMAKE_SOURCE_DIR}/H/generated -I${CMAKE_SOURCE_DIR}/OPTYap -I../../.. -o yap_wrap.cpp yap.i COMMAND ${PYTHON_EXECUTABLE} setup.py sdist bdist_wheel - WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR} +WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR} DEPENDS YAP4PY_SETUP) install(CODE "execute_process( - COMMAND ${PYTHON_EXECUTABLE} -m pip install --force --no-index -f packages/python/swig/dist YAP4PY - WORKING_DIRECTORY ${CMAKE_BINARY_DIR})" - DEPENDS Py4YAP ${CMAKE_BINARY_DIR}/${YAP_STARTUP} ${dlls} ) + COMMAND ${PYTHON_EXECUTABLE} -m pip install --force --no-index -f packages/python/swig/dist YAP4PY + WORKING_DIRECTORY ${CMAKE_BINARY_DIR})" + DEPENDS Py4YAP ${CMAKE_BINARY_DIR}/${YAP_STARTUP} ${dlls} ) install(FILES ${PROLOG_SOURCES} DESTINATION ${libpl}) - if (WITH_DOCS AND DOXYGEN_FOUND) + if (WITH_DOCS AND DOXYGEN_FOUND) set(CMAKE_SWIG_FLAGS -DDOXYGEN=${DOXYGEN_FOUND}) @@ -102,8 +114,8 @@ install(FILES ${PROLOG_SOURCES} DESTINATION ${libpl}) COMMAND ${CMAKE_COMMAND} -E make_directory ${CMAKE_BINARY_DIR}/doc COMMAND ${DOXYGEN_EXECUTABLE} ${CMAKE_BINARY_DIR}/Doxyfile.xml WORKING_DIRECTORY ${CMAKE_BINARY_DIR} - DEPENDS ${c_headers};${c_sources};${cpp_sources};${cpp_headers} - ) + DEPENDS ${c_headers};${c_sources};${cpp_sources};${cpp_headers} + ) # generate .i from doxygen .xml add_custom_command(OUTPUT ${CMAKE_CURRENT_BINARY_DIR}/ftdi1_doc.i diff --git a/packages/python/swig/setup.py.in b/packages/python/swig/setup.py.in index 5f1722c28..69c755a77 100644 --- a/packages/python/swig/setup.py.in +++ b/packages/python/swig/setup.py.in @@ -68,6 +68,8 @@ cplus = [''] bpy2yap = [] native_sources = ['yap_wrap.cpp'] here = path.abspath(path.dirname(__file__)) +gmp_dir = path.abspath(path.dirname("${GMP_LIBRARIES}")) +python_libdir = path.abspath(path.dirname("${PYTHON_LIBRARIES}")) # Get the long description from the README file @@ -79,14 +81,14 @@ extensions = [Extension('_yap', native_sources, ('_YAP_NOT_INSTALLED_', '1'), ('YAP_PYTHON', '1'), ('_GNU_SOURCE', '1')], - runtime_library_dirs=['yap4py', '${libdir}', '${bindir}'], + runtime_library_dirs=['yap4py', '${libdir}', '${bindir}', '${gmp_dir}', '${python_libdir}'], swig_opts=['-modern', '-c++', '-py3', '-DX_API', '-I${CMAKE_SOURCE_DIR}/CXX', '-I${CMAKE_SOURCE_DIR}/include', '-I${CMAKE_SOURCE_DIR}/H', '-I${CMAKE_SOURCE_DIR}/H/generated', '-I${CMAKE_SOURCE_DIR}/os', '-I${CMAKE_SOURCE_DIR}/OPTYap', '-I../../..'], library_dirs=['../../..', '../../../CXX', '..', "${dlls}", "${bindir}", '.'], extra_link_args=my_extra_link_args, - libraries=['Yap','${PYTHON_LIBRARIES}','${GMP_LIBRARIES}']+win_libs+local_libs, + libraries=['Yap','gmp']+win_libs+local_libs, include_dirs=['../../..', '${GMP_INCLUDE_DIRS}', '${CMAKE_SOURCE_DIR}/H', From 963752fa9ccd27fb6c615e4e931b40c40093c589 Mon Sep 17 00:00:00 2001 From: Vitor Santos Costa Date: Tue, 25 Jul 2017 01:10:44 +0100 Subject: [PATCH 6/6] Android support, --- C/scanner.c | 8 +- CMakeLists.txt | 30 +- CXX/yapi.cpp | 168 ++-- CXX/yapq.hh | 85 +- CXX/yapt.hh | 869 ++++++++++-------- H/YapHandles.h | 8 +- H/YapText.h | 5 +- cmake/FindGMP.cmake | 5 +- cmake/Prelims.cmake | 14 +- console/terminal/{main.cpp => streamer.cpp} | 0 include/VFS.h | 9 +- libYap.cmake | 12 +- os/assets.c | 4 +- os/iopreds.c | 20 +- os/streams.c | 2 +- packages/myddas/myddas_shared.c | 4 +- packages/myddas/pl/CMakeLists.txt | 11 +- packages/myddas/sqlite3/CMakeLists.txt | 10 +- packages/myddas/sqlite3/myddas_sqlite3.c | 11 + .../android_database_SQLiteConnection.cpp | 7 +- packages/python/CMakeLists.txt | 4 +- packages/python/swig/__init__.py | 7 +- packages/swig/CMakeLists.txt | 4 +- packages/swig/android/CMakeLists.txt | 69 +- packages/swig/java/JavaYAP.java | 5 +- packages/swig/yap.i | 196 ++-- swi/library/CMakeLists.txt | 6 - 27 files changed, 851 insertions(+), 722 deletions(-) rename console/terminal/{main.cpp => streamer.cpp} (100%) 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()