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

Merge branch 'master' of https://github.com/vscosta/yap-6.3

Browse Source
This commit is contained in:
Vitor Santos Costa 2016-09-23 01:38:09 -05:00
commit 94cde0bf18
71 changed files with 5430 additions and 4258 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

22
.gitignore vendored
View File

@ -181,3 +181,25 @@ packages/myddas/DaysInHospital_Y3.csv
packages/myddas/agile.csv packages/myddas/agile.csv
*.pyc *.pyc
*.cmake#
*.tex
*.c#
packages/swig/yap_wrap.cxx
packages/swig/yap_wrap.h
packages/swig/yap_wrap.cpp
packages/swig/yap.py
*.ipynb
packages/python/yap_kernel/x/__init__.py
packages/python/yap_kernel/x/__main__.py
*.gch

4
C/absmi_insts.h
View File

@ -33,10 +33,6 @@
#if BP_FREE #if BP_FREE
P1REG = PCBACKUP; P1REG = PCBACKUP;
#endif #endif
if (LOCAL_Error_TYPE == THROW_EVENT) {
LOCAL_Error_TYPE = YAP_NO_ERROR;
return 1;
}
return 0; return 0;
ENDBOp(); ENDBOp();

85
C/absmi_insts.i
View File

@ -1101,19 +1101,10 @@
#if defined(YAPOR) || defined(THREADS) #if defined(YAPOR) || defined(THREADS)
PP = NULL; PP = NULL;
#endif #endif
if (LOCAL_Error_TYPE == RESOURCE_ERROR_ATTRIBUTED_VARIABLES) {
LOCAL_Error_TYPE = YAP_NO_ERROR;
if (!Yap_growglobal(NULL)) {
Yap_NilError(RESOURCE_ERROR_ATTRIBUTED_VARIABLES, LOCAL_ErrorMessage);
FAIL();
}
} else {
LOCAL_Error_TYPE = YAP_NO_ERROR;
if (!Yap_gc(3, ENV, CP)) { if (!Yap_gc(3, ENV, CP)) {
Yap_NilError(RESOURCE_ERROR_STACK, LOCAL_ErrorMessage); Yap_NilError(RESOURCE_ERROR_STACK, LOCAL_ErrorMessage);
FAIL(); FAIL();
} }
}
#if defined(YAPOR) || defined(THREADS) #if defined(YAPOR) || defined(THREADS)
PELOCK(5,ClauseCodeToLogUpdClause(PREG)->ClPred); PELOCK(5,ClauseCodeToLogUpdClause(PREG)->ClPred);
PP = ClauseCodeToLogUpdClause(PREG)->ClPred; PP = ClauseCodeToLogUpdClause(PREG)->ClPred;
@ -8171,7 +8162,7 @@
setregs(); setregs();
if (d0 == 0L) { if (d0 == 0L) {
saveregs(); saveregs();
Yap_Error(LOCAL_Error_TYPE, LOCAL_Error_Term, LOCAL_ErrorMessage); Yap_PreProcessedError(LOCAL_Error_TYPE, LOCAL_Error_Term, LOCAL_ErrorMessage);
setregs(); setregs();
FAIL(); FAIL();
} }
@ -8216,7 +8207,7 @@
setregs(); setregs();
if (d0 == 0L) { if (d0 == 0L) {
saveregs(); saveregs();
Yap_Error(LOCAL_Error_TYPE, LOCAL_Error_Term, LOCAL_ErrorMessage); Yap_PreprocessedError()
setregs(); setregs();
FAIL(); FAIL();
} }
@ -8257,7 +8248,7 @@
setregs(); setregs();
if (d0 == 0L) { if (d0 == 0L) {
saveregs(); saveregs();
Yap_Error(LOCAL_Error_TYPE, LOCAL_Error_Term, LOCAL_ErrorMessage); Yap_PreprocessedError()
setregs(); setregs();
FAIL(); FAIL();
} }
@ -8305,7 +8296,7 @@
setregs(); setregs();
if (d0 == 0L) { if (d0 == 0L) {
saveregs(); saveregs();
Yap_Error(LOCAL_Error_TYPE, LOCAL_Error_Term, LOCAL_ErrorMessage); Yap_PreprocessedError()
setregs(); setregs();
FAIL(); FAIL();
} }
@ -8349,7 +8340,7 @@
setregs(); setregs();
if (d0 == 0L) { if (d0 == 0L) {
saveregs(); saveregs();
Yap_Error(LOCAL_Error_TYPE, LOCAL_Error_Term, LOCAL_ErrorMessage); Yap_PreprocessedError()
setregs(); setregs();
FAIL(); FAIL();
} }
@ -8394,7 +8385,7 @@
setregs(); setregs();
if (d0 == 0L) { if (d0 == 0L) {
saveregs(); saveregs();
Yap_Error(LOCAL_Error_TYPE, LOCAL_Error_Term, LOCAL_ErrorMessage); Yap_PreprocessedError()
setregs(); setregs();
FAIL(); FAIL();
} }
@ -8435,7 +8426,7 @@
setregs(); setregs();
if (d0 == 0L) { if (d0 == 0L) {
saveregs(); saveregs();
Yap_Error(LOCAL_Error_TYPE, LOCAL_Error_Term, LOCAL_ErrorMessage); Yap_PreprocessedError()
setregs(); setregs();
FAIL(); FAIL();
} }
@ -8483,7 +8474,7 @@
setregs(); setregs();
if (d0 == 0L) { if (d0 == 0L) {
saveregs(); saveregs();
Yap_Error(LOCAL_Error_TYPE, LOCAL_Error_Term, LOCAL_ErrorMessage); Yap_PreprocessedError()
setregs(); setregs();
FAIL(); FAIL();
} }
@ -8527,7 +8518,7 @@
setregs(); setregs();
if (d0 == 0L) { if (d0 == 0L) {
saveregs(); saveregs();
Yap_Error(LOCAL_Error_TYPE, LOCAL_Error_Term, LOCAL_ErrorMessage); Yap_PreprocessedError()
setregs(); setregs();
FAIL(); FAIL();
} }
@ -8572,7 +8563,7 @@
setregs(); setregs();
if (d0 == 0L) { if (d0 == 0L) {
saveregs(); saveregs();
Yap_Error(LOCAL_Error_TYPE, LOCAL_Error_Term, LOCAL_ErrorMessage); Yap_PreprocessedError()
setregs(); setregs();
FAIL(); FAIL();
} }
@ -8613,7 +8604,7 @@
setregs(); setregs();
if (d0 == 0L) { if (d0 == 0L) {
saveregs(); saveregs();
Yap_Error(LOCAL_Error_TYPE, LOCAL_Error_Term, LOCAL_ErrorMessage); Yap_PreprocessedError()
setregs(); setregs();
FAIL(); FAIL();
} }
@ -8661,7 +8652,7 @@
setregs(); setregs();
if (d0 == 0L) { if (d0 == 0L) {
saveregs(); saveregs();
Yap_Error(LOCAL_Error_TYPE, LOCAL_Error_Term, LOCAL_ErrorMessage); Yap_PreprocessedError()
setregs(); setregs();
FAIL(); FAIL();
} }
@ -8712,7 +8703,7 @@
setregs(); setregs();
if (d0 == 0L) { if (d0 == 0L) {
saveregs(); saveregs();
Yap_Error(LOCAL_Error_TYPE, LOCAL_Error_Term, LOCAL_ErrorMessage); Yap_PreprocessedError()
setregs(); setregs();
FAIL(); FAIL();
} }
@ -8757,7 +8748,7 @@
setregs(); setregs();
if (d0 == 0L) { if (d0 == 0L) {
saveregs(); saveregs();
Yap_Error(LOCAL_Error_TYPE, LOCAL_Error_Term, LOCAL_ErrorMessage); Yap_PreprocessedError()
setregs(); setregs();
FAIL(); FAIL();
} }
@ -8800,7 +8791,7 @@
d0 = p_div(MkIntegerTerm(d1),Yap_Eval(d0) PASS_REGS); d0 = p_div(MkIntegerTerm(d1),Yap_Eval(d0) PASS_REGS);
if (d0 == 0L) { if (d0 == 0L) {
saveregs(); saveregs();
Yap_Error(LOCAL_Error_TYPE, LOCAL_Error_Term, LOCAL_ErrorMessage); Yap_PreprocessedError()
setregs(); setregs();
FAIL(); FAIL();
} }
@ -8848,7 +8839,7 @@
setregs(); setregs();
if (d0 == 0L) { if (d0 == 0L) {
saveregs(); saveregs();
Yap_Error(LOCAL_Error_TYPE, LOCAL_Error_Term, LOCAL_ErrorMessage); Yap_PreprocessedError()
setregs(); setregs();
FAIL(); FAIL();
} }
@ -8896,7 +8887,7 @@
setregs(); setregs();
if (d0 == 0L) { if (d0 == 0L) {
saveregs(); saveregs();
Yap_Error(LOCAL_Error_TYPE, LOCAL_Error_Term, LOCAL_ErrorMessage); Yap_PreprocessedError()
setregs(); setregs();
FAIL(); FAIL();
} }
@ -8943,7 +8934,7 @@
setregs(); setregs();
if (d0 == 0L) { if (d0 == 0L) {
saveregs(); saveregs();
Yap_Error(LOCAL_Error_TYPE, LOCAL_Error_Term, LOCAL_ErrorMessage); Yap_PreprocessedError()
setregs(); setregs();
FAIL(); FAIL();
} }
@ -8988,7 +8979,7 @@
setregs(); setregs();
if (d0 == 0L) { if (d0 == 0L) {
saveregs(); saveregs();
Yap_Error(LOCAL_Error_TYPE, LOCAL_Error_Term, LOCAL_ErrorMessage); Yap_PreprocessedError()
setregs(); setregs();
FAIL(); FAIL();
} }
@ -9033,7 +9024,7 @@
setregs(); setregs();
if (d0 == 0L) { if (d0 == 0L) {
saveregs(); saveregs();
Yap_Error(LOCAL_Error_TYPE, LOCAL_Error_Term, LOCAL_ErrorMessage); Yap_PreprocessedError()
setregs(); setregs();
FAIL(); FAIL();
} }
@ -9074,7 +9065,7 @@
setregs(); setregs();
if (d0 == 0L) { if (d0 == 0L) {
saveregs(); saveregs();
Yap_Error(LOCAL_Error_TYPE, LOCAL_Error_Term, LOCAL_ErrorMessage); Yap_PreprocessedError()
setregs(); setregs();
FAIL(); FAIL();
} }
@ -9122,7 +9113,7 @@
setregs(); setregs();
if (d0 == 0L) { if (d0 == 0L) {
saveregs(); saveregs();
Yap_Error(LOCAL_Error_TYPE, LOCAL_Error_Term, LOCAL_ErrorMessage); Yap_PreprocessedError()
setregs(); setregs();
FAIL(); FAIL();
} }
@ -9167,7 +9158,7 @@
setregs(); setregs();
if (d0 == 0L) { if (d0 == 0L) {
saveregs(); saveregs();
Yap_Error(LOCAL_Error_TYPE, LOCAL_Error_Term, LOCAL_ErrorMessage); Yap_PreprocessedError()
setregs(); setregs();
FAIL(); FAIL();
} }
@ -9211,7 +9202,7 @@
d0 = p_or(Yap_Eval(d0), MkIntegerTerm(d1) PASS_REGS); d0 = p_or(Yap_Eval(d0), MkIntegerTerm(d1) PASS_REGS);
if (d0 == 0L) { if (d0 == 0L) {
saveregs(); saveregs();
Yap_Error(LOCAL_Error_TYPE, LOCAL_Error_Term, LOCAL_ErrorMessage); Yap_PreprocessedError()
setregs(); setregs();
FAIL(); FAIL();
} }
@ -9252,7 +9243,7 @@
setregs(); setregs();
if (d0 == 0L) { if (d0 == 0L) {
saveregs(); saveregs();
Yap_Error(LOCAL_Error_TYPE, LOCAL_Error_Term, LOCAL_ErrorMessage); Yap_PreprocessedError()
setregs(); setregs();
FAIL(); FAIL();
} }
@ -9300,7 +9291,7 @@
setregs(); setregs();
if (d0 == 0L) { if (d0 == 0L) {
saveregs(); saveregs();
Yap_Error(LOCAL_Error_TYPE, LOCAL_Error_Term, LOCAL_ErrorMessage); Yap_PreprocessedError()
setregs(); setregs();
FAIL(); FAIL();
} }
@ -9349,7 +9340,7 @@
} }
if (d0 == 0L) { if (d0 == 0L) {
saveregs(); saveregs();
Yap_Error(LOCAL_Error_TYPE, LOCAL_Error_Term, LOCAL_ErrorMessage); Yap_PreprocessedError()
setregs(); setregs();
FAIL(); FAIL();
} }
@ -9395,7 +9386,7 @@
} }
if (d0 == 0L) { if (d0 == 0L) {
saveregs(); saveregs();
Yap_Error(LOCAL_Error_TYPE, LOCAL_Error_Term, LOCAL_ErrorMessage); Yap_PreprocessedError()
setregs(); setregs();
FAIL(); FAIL();
} }
@ -9436,7 +9427,7 @@
} }
if (d0 == 0L) { if (d0 == 0L) {
saveregs(); saveregs();
Yap_Error(LOCAL_Error_TYPE, LOCAL_Error_Term, LOCAL_ErrorMessage); Yap_PreprocessedError()
setregs(); setregs();
FAIL(); FAIL();
} }
@ -9480,7 +9471,7 @@
} }
if (d0 == 0L) { if (d0 == 0L) {
saveregs(); saveregs();
Yap_Error(LOCAL_Error_TYPE, LOCAL_Error_Term, LOCAL_ErrorMessage); Yap_PreprocessedError()
setregs(); setregs();
FAIL(); FAIL();
} }
@ -9529,7 +9520,7 @@
} }
if (d0 == 0L) { if (d0 == 0L) {
saveregs(); saveregs();
Yap_Error(LOCAL_Error_TYPE, LOCAL_Error_Term, LOCAL_ErrorMessage); Yap_PreprocessedError()
setregs(); setregs();
FAIL(); FAIL();
} }
@ -9574,7 +9565,7 @@
} }
if (d0 == 0L) { if (d0 == 0L) {
saveregs(); saveregs();
Yap_Error(LOCAL_Error_TYPE, LOCAL_Error_Term, LOCAL_ErrorMessage); Yap_PreprocessedError()
setregs(); setregs();
FAIL(); FAIL();
} }
@ -9621,7 +9612,7 @@
} }
if (d0 == 0L) { if (d0 == 0L) {
saveregs(); saveregs();
Yap_Error(LOCAL_Error_TYPE, LOCAL_Error_Term, LOCAL_ErrorMessage); Yap_PreprocessedError()
setregs(); setregs();
FAIL(); FAIL();
} }
@ -9665,7 +9656,7 @@
setregs(); setregs();
if (d0 == 0L) { if (d0 == 0L) {
saveregs(); saveregs();
Yap_Error(LOCAL_Error_TYPE, LOCAL_Error_Term, LOCAL_ErrorMessage); Yap_PreprocessedError()
setregs(); setregs();
FAIL(); FAIL();
} }
@ -9708,7 +9699,7 @@
} }
if (d0 == 0L) { if (d0 == 0L) {
saveregs(); saveregs();
Yap_Error(LOCAL_Error_TYPE, LOCAL_Error_Term, LOCAL_ErrorMessage); Yap_PreprocessedError()
setregs(); setregs();
FAIL(); FAIL();
} }
@ -9753,7 +9744,7 @@
BEGP(pt0); BEGP(pt0);
if (d0 == 0L) { if (d0 == 0L) {
saveregs(); saveregs();
Yap_Error(LOCAL_Error_TYPE, LOCAL_Error_Term, LOCAL_ErrorMessage); Yap_PreprocessedError()
setregs(); setregs();
FAIL(); FAIL();
} }
@ -9799,7 +9790,7 @@
setregs(); setregs();
if (d0 == 0L) { if (d0 == 0L) {
saveregs(); saveregs();
Yap_Error(LOCAL_Error_TYPE, LOCAL_Error_Term, LOCAL_ErrorMessage); Yap_PreprocessedError()
setregs(); setregs();
FAIL(); FAIL();
} }
@ -9844,7 +9835,7 @@
} }
if (d0 == 0L) { if (d0 == 0L) {
saveregs(); saveregs();
Yap_Error(LOCAL_Error_TYPE, LOCAL_Error_Term, LOCAL_ErrorMessage); Yap_PreprocessedError()
setregs(); setregs();
FAIL(); FAIL();
} }

4
C/adtdefs.c
View File

@ -16,7 +16,6 @@
*************************************************************************/ *************************************************************************/
#ifdef SCCS #ifdef SCCS
static char SccsId[] = "%W% %G%"; static char SccsId[] = "%W% %G%";
#endif #endif
#define ADTDEFS_C #define ADTDEFS_C
@ -810,6 +809,7 @@ Prop Yap_NewPredPropByFunctor(FunctorEntry *fe, Term cur_mod) {
p->cs.p_code.ExpandCode = EXPAND_OP_CODE; p->cs.p_code.ExpandCode = EXPAND_OP_CODE;
p->TimeStampOfPred = 0L; p->TimeStampOfPred = 0L;
p->LastCallOfPred = LUCALL_ASSERT; p->LastCallOfPred = LUCALL_ASSERT;
p->MetaEntryOfPred = NULL;
if (cur_mod == TermProlog) if (cur_mod == TermProlog)
p->ModuleOfPred = 0L; p->ModuleOfPred = 0L;
else else
@ -892,6 +892,7 @@ Prop Yap_NewThreadPred(PredEntry *ap USES_REGS) {
#if SIZEOF_INT_P == 4 #if SIZEOF_INT_P == 4
p->ExtraPredFlags = 0L; p->ExtraPredFlags = 0L;
#endif #endif
p->MetaEntryOfPred = NULL;
p->src.OwnerFile = ap->src.OwnerFile; p->src.OwnerFile = ap->src.OwnerFile;
p->OpcodeOfPred = FAIL_OPCODE; p->OpcodeOfPred = FAIL_OPCODE;
p->CodeOfPred = p->cs.p_code.TrueCodeOfPred = (yamop *)(&(p->OpcodeOfPred)); p->CodeOfPred = p->cs.p_code.TrueCodeOfPred = (yamop *)(&(p->OpcodeOfPred));
@ -946,6 +947,7 @@ Prop Yap_NewPredPropByAtom(AtomEntry *ae, Term cur_mod) {
p->OpcodeOfPred = UNDEF_OPCODE; p->OpcodeOfPred = UNDEF_OPCODE;
p->cs.p_code.ExpandCode = EXPAND_OP_CODE; p->cs.p_code.ExpandCode = EXPAND_OP_CODE;
p->CodeOfPred = p->cs.p_code.TrueCodeOfPred = (yamop *)(&(p->OpcodeOfPred)); p->CodeOfPred = p->cs.p_code.TrueCodeOfPred = (yamop *)(&(p->OpcodeOfPred));
p->MetaEntryOfPred = NULL;
if (cur_mod == TermProlog) if (cur_mod == TermProlog)
p->ModuleOfPred = 0; p->ModuleOfPred = 0;
else else

9
C/alloc.c
View File

@ -21,10 +21,9 @@ static char SccsId[] = "%W% %G%";
#include "Yap.h" #include "Yap.h"
#include "alloc.h"
#include "YapHeap.h" #include "YapHeap.h"
#include "Yatom.h" #include "Yatom.h"
#include "alloc.h"
#include "yapio.h" #include "yapio.h"
#if HAVE_STRING_H #if HAVE_STRING_H
#include <string.h> #include <string.h>
@ -78,6 +77,8 @@ void *my_malloc(size_t sz) {
p = malloc(sz); p = malloc(sz);
// Yap_DebugPuts(stderr,"gof\n"); // Yap_DebugPuts(stderr,"gof\n");
if (Yap_do_low_level_trace)
fprintf(stderr, "+ %p : %lu\n", p, sz);
if (sz > 500 && write_malloc++ > 0) if (sz > 500 && write_malloc++ > 0)
__android_log_print(ANDROID_LOG_ERROR, "YAPDroid ", "+ %d %p", write_malloc, __android_log_print(ANDROID_LOG_ERROR, "YAPDroid ", "+ %d %p", write_malloc,
p); p);
@ -88,6 +89,8 @@ void *my_realloc(void *ptr, size_t sz) {
void *p; void *p;
p = realloc(ptr, sz); p = realloc(ptr, sz);
if (Yap_do_low_level_trace)
fprintf(stderr, "+ %p -> %p : %lu\n", ptr, p, sz);
// Yap_DebugPuts(stderr,"gof\n"); // Yap_DebugPuts(stderr,"gof\n");
if (sz > 500 && write_malloc++ > 0) if (sz > 500 && write_malloc++ > 0)
__android_log_print(ANDROID_LOG_ERROR, "YAPDroid ", "* %d %p", write_malloc, __android_log_print(ANDROID_LOG_ERROR, "YAPDroid ", "* %d %p", write_malloc,
@ -97,6 +100,8 @@ void *my_realloc(void *ptr, size_t sz) {
void my_free(void *p) { void my_free(void *p) {
// printf("f %p\n",p); // printf("f %p\n",p);
if (Yap_do_low_level_trace)
fprintf(stderr, "+ %p\n", p);
if (write_malloc && write_malloc++ > 0) if (write_malloc && write_malloc++ > 0)
__android_log_print(ANDROID_LOG_ERROR, "YAPDroid ", "- %d %p", write_malloc, __android_log_print(ANDROID_LOG_ERROR, "YAPDroid ", "- %d %p", write_malloc,
p); p);

1296
C/amasm.c
View File

File diff suppressed because it is too large Load Diff

161
C/args.c
View File

@ -2,8 +2,6 @@
#include "Yap.h" #include "Yap.h"
#include "Yatom.h" #include "Yatom.h"
/** /**
* Scan a list of arguments and output results to a pre-processed vector. * Scan a list of arguments and output results to a pre-processed vector.
* *
@ -13,11 +11,9 @@
* @return all arguments, some of them set, some of them not. * @return all arguments, some of them set, some of them not.
*/ */
static xarg * static xarg *matchKey(Atom key, xarg *e0, int n, const param_t *def) {
matchKey(Atom key, xarg *e0, int n, const param_t *def)
{
int i; int i;
for (i=0; i< n; i++) { for (i = 0; i < n; i++) {
if (!strcmp((char *)def->name, (char *)RepAtom(key)->StrOfAE)) { if (!strcmp((char *)def->name, (char *)RepAtom(key)->StrOfAE)) {
return e0; return e0;
} }
@ -31,11 +27,9 @@ matchKey(Atom key, xarg *e0, int n, const param_t *def)
* Returns the index of an argument key, or -1 if not found. * Returns the index of an argument key, or -1 if not found.
* *
*/ */
int int Yap_ArgKey(Atom key, const param_t *def, int n) {
Yap_ArgKey(Atom key, const param_t *def, int n)
{
int i; int i;
for (i=0; i< n; i++) { for (i = 0; i < n; i++) {
if (!strcmp((char *)def->name, (char *)RepAtom(key)->StrOfAE)) { if (!strcmp((char *)def->name, (char *)RepAtom(key)->StrOfAE)) {
return i; return i;
} }
@ -46,105 +40,95 @@ Yap_ArgKey(Atom key, const param_t *def, int n)
#define failed(e, t, a) failed__(e, t, a PASS_REGS) #define failed(e, t, a) failed__(e, t, a PASS_REGS)
static xarg * static xarg *failed__(yap_error_number e, Term t, xarg *a USES_REGS) {
failed__( yap_error_number e, Term t, xarg *a USES_REGS) free(a);
{
free( a );
LOCAL_Error_TYPE = e;
LOCAL_Error_Term = t;
return NULL; return NULL;
} }
xarg *Yap_ArgListToVector(Term listl, const param_t *def, int n) {
xarg *
Yap_ArgListToVector (Term listl, const param_t *def, int n)
{
CACHE_REGS CACHE_REGS
listl = Deref(listl); listl = Deref(listl);
xarg *a = calloc( n , sizeof(xarg) ); xarg *a = calloc(n, sizeof(xarg));
LOCAL_Error_TYPE = YAP_NO_ERROR;
if (IsApplTerm(listl) && FunctorOfTerm(listl) == FunctorModule) if (IsApplTerm(listl) && FunctorOfTerm(listl) == FunctorModule)
listl = ArgOfTerm(2,listl); listl = ArgOfTerm(2, listl);
if (!IsPairTerm(listl) && listl != TermNil) { if (!IsPairTerm(listl) && listl != TermNil) {
if (IsVarTerm(listl) ) { if (IsVarTerm(listl)) {
return failed( INSTANTIATION_ERROR, listl, a); return failed(INSTANTIATION_ERROR, listl, a);
} }
if (IsAtomTerm(listl) ) { if (IsAtomTerm(listl)) {
xarg *na = matchKey( AtomOfTerm(listl), a, n, def); xarg *na = matchKey(AtomOfTerm(listl), a, n, def);
if (!na) { if (!na) {
return failed( TYPE_ERROR_LIST, listl, a ); return failed(TYPE_ERROR_LIST, listl, a);
} }
} else if (IsApplTerm(listl)) { } else if (IsApplTerm(listl)) {
Functor f = FunctorOfTerm( listl ); Functor f = FunctorOfTerm(listl);
if (IsExtensionFunctor(f)) { if (IsExtensionFunctor(f)) {
return failed( TYPE_ERROR_LIST, listl, a); return failed(TYPE_ERROR_LIST, listl, a);
} }
arity_t arity = ArityOfFunctor( f ); arity_t arity = ArityOfFunctor(f);
if (arity != 1) { if (arity != 1) {
return failed( TYPE_ERROR_LIST, listl, a); return failed(TYPE_ERROR_LIST, listl, a);
} }
xarg *na = matchKey( NameOfFunctor( f ), a, n, def); xarg *na = matchKey(NameOfFunctor(f), a, n, def);
if (!na) { if (!na) {
return failed( TYPE_ERROR_LIST, listl, a); return failed(TYPE_ERROR_LIST, listl, a);
} }
na->used = true; na->used = true;
na->tvalue = ArgOfTerm(1,listl); na->tvalue = ArgOfTerm(1, listl);
return a; return a;
} else { } else {
return failed( TYPE_ERROR_LIST, listl, a); return failed(TYPE_ERROR_LIST, listl, a);
} }
listl = MkPairTerm( listl, TermNil ); listl = MkPairTerm(listl, TermNil);
} }
while (IsPairTerm(listl)) { while (IsPairTerm(listl)) {
Term hd = HeadOfTerm( listl ); Term hd = HeadOfTerm(listl);
listl = TailOfTerm( listl ); listl = TailOfTerm(listl);
if (IsVarTerm(hd) || IsVarTerm(listl)) { if (IsVarTerm(hd) || IsVarTerm(listl)) {
if (IsVarTerm(hd)) { if (IsVarTerm(hd)) {
return failed( INSTANTIATION_ERROR, hd, a); return failed(INSTANTIATION_ERROR, hd, a);
} else { } else {
return failed( INSTANTIATION_ERROR, listl, a); return failed(INSTANTIATION_ERROR, listl, a);
} }
} }
if (IsAtomTerm(hd)) { if (IsAtomTerm(hd)) {
xarg *na = matchKey( AtomOfTerm( hd ), a, n, def); xarg *na = matchKey(AtomOfTerm(hd), a, n, def);
if (!na) if (!na)
return failed( DOMAIN_ERROR_GENERIC_ARGUMENT, hd, a); return failed(DOMAIN_ERROR_GENERIC_ARGUMENT, hd, a);
na->used = true; na->used = true;
na->tvalue = TermNil; na->tvalue = TermNil;
continue; continue;
} else if (IsApplTerm( hd )) { } else if (IsApplTerm(hd)) {
Functor f = FunctorOfTerm( hd ); Functor f = FunctorOfTerm(hd);
if (IsExtensionFunctor(f)) { if (IsExtensionFunctor(f)) {
return failed( TYPE_ERROR_PARAMETER, hd, a); return failed(TYPE_ERROR_PARAMETER, hd, a);
} }
arity_t arity = ArityOfFunctor( f ); arity_t arity = ArityOfFunctor(f);
if (arity != 1) { if (arity != 1) {
return failed( DOMAIN_ERROR_OUT_OF_RANGE, hd, a); return failed(DOMAIN_ERROR_OUT_OF_RANGE, hd, a);
} }
xarg *na = matchKey( NameOfFunctor( f ), a, n, def); xarg *na = matchKey(NameOfFunctor(f), a, n, def);
if (!na) { if (!na) {
return failed( DOMAIN_ERROR_GENERIC_ARGUMENT, hd, a); return failed(DOMAIN_ERROR_GENERIC_ARGUMENT, hd, a);
} }
na->used = true; na->used = true;
na->tvalue = ArgOfTerm(1, hd); na->tvalue = ArgOfTerm(1, hd);
} else { } else {
return failed( TYPE_ERROR_PARAMETER, hd, a); return failed(TYPE_ERROR_PARAMETER, hd, a);
} }
} }
if (IsVarTerm(listl)) { if (IsVarTerm(listl)) {
return failed( INSTANTIATION_ERROR, listl, a); return failed(INSTANTIATION_ERROR, listl, a);
} else if (listl != TermNil) { } else if (listl != TermNil) {
return failed( TYPE_ERROR_LIST, listl, a); return failed(TYPE_ERROR_LIST, listl, a);
} }
return a; return a;
} }
static xarg * static xarg *matchKey2(Atom key, xarg *e0, int n, const param2_t *def) {
matchKey2(Atom key, xarg *e0, int n, const param2_t *def)
{
int i; int i;
for (i=0; i< n; i++) { for (i = 0; i < n; i++) {
if (!strcmp((char*)def->name, (char*)RepAtom(key)->StrOfAE)) { if (!strcmp((char *)def->name, (char *)RepAtom(key)->StrOfAE)) {
return e0; return e0;
} }
def++; def++;
@ -153,82 +137,79 @@ matchKey2(Atom key, xarg *e0, int n, const param2_t *def)
return NULL; return NULL;
} }
/// Yap_ArgList2ToVector is much the same as before, /// Yap_ArgList2ToVector is much the same as before,
/// but assumes parameters also have something called a /// but assumes parameters also have something called a
/// scope /// scope
xarg * xarg *Yap_ArgList2ToVector(Term listl, const param2_t *def, int n) {
Yap_ArgList2ToVector (Term listl, const param2_t *def, int n)
{
CACHE_REGS CACHE_REGS
xarg *a = calloc( n , sizeof(xarg) ); xarg *a = calloc(n, sizeof(xarg));
if (!IsPairTerm(listl) && listl != TermNil) { if (!IsPairTerm(listl) && listl != TermNil) {
if (IsVarTerm(listl) ) { if (IsVarTerm(listl)) {
return failed( INSTANTIATION_ERROR, listl, a); return failed(INSTANTIATION_ERROR, listl, a);
} }
if (IsAtomTerm(listl) ) { if (IsAtomTerm(listl)) {
xarg *na = matchKey2( AtomOfTerm(listl), a, n, def); xarg *na = matchKey2(AtomOfTerm(listl), a, n, def);
if (!na) { if (!na) {
return failed( DOMAIN_ERROR_GENERIC_ARGUMENT, listl, a); return failed(DOMAIN_ERROR_GENERIC_ARGUMENT, listl, a);
} }
} }
if (IsApplTerm(listl)) { if (IsApplTerm(listl)) {
Functor f = FunctorOfTerm( listl ); Functor f = FunctorOfTerm(listl);
if (IsExtensionFunctor(f)) { if (IsExtensionFunctor(f)) {
return failed( TYPE_ERROR_PARAMETER, listl, a); return failed(TYPE_ERROR_PARAMETER, listl, a);
} }
arity_t arity = ArityOfFunctor( f ); arity_t arity = ArityOfFunctor(f);
if (arity != 1) { if (arity != 1) {
return failed( TYPE_ERROR_LIST, listl, a); return failed(TYPE_ERROR_LIST, listl, a);
} }
xarg *na = matchKey2( NameOfFunctor( f ), a, n, def); xarg *na = matchKey2(NameOfFunctor(f), a, n, def);
if (!na) { if (!na) {
return failed( DOMAIN_ERROR_GENERIC_ARGUMENT, listl, a); return failed(DOMAIN_ERROR_GENERIC_ARGUMENT, listl, a);
} }
} else { } else {
return failed( TYPE_ERROR_LIST, listl, a); return failed(TYPE_ERROR_LIST, listl, a);
} }
listl = MkPairTerm( listl, TermNil ); listl = MkPairTerm(listl, TermNil);
} }
while (IsPairTerm(listl)) { while (IsPairTerm(listl)) {
Term hd = HeadOfTerm( listl ); Term hd = HeadOfTerm(listl);
if (IsVarTerm(hd)) { if (IsVarTerm(hd)) {
return failed( INSTANTIATION_ERROR, hd, a); return failed(INSTANTIATION_ERROR, hd, a);
} }
if (IsAtomTerm(hd)) { if (IsAtomTerm(hd)) {
xarg *na = matchKey2( AtomOfTerm( hd ), a, n, def); xarg *na = matchKey2(AtomOfTerm(hd), a, n, def);
if (!na) { if (!na) {
return failed( DOMAIN_ERROR_GENERIC_ARGUMENT, hd, a); return failed(DOMAIN_ERROR_GENERIC_ARGUMENT, hd, a);
} }
na->used = true; na->used = true;
na->tvalue = TermNil; na->tvalue = TermNil;
continue; continue;
} else if (IsApplTerm( hd )) { } else if (IsApplTerm(hd)) {
Functor f = FunctorOfTerm( hd ); Functor f = FunctorOfTerm(hd);
if (IsExtensionFunctor(f)) { if (IsExtensionFunctor(f)) {
return failed( TYPE_ERROR_PARAMETER, hd, a); return failed(TYPE_ERROR_PARAMETER, hd, a);
} }
arity_t arity = ArityOfFunctor( f ); arity_t arity = ArityOfFunctor(f);
if (arity != 1) { if (arity != 1) {
return failed( DOMAIN_ERROR_GENERIC_ARGUMENT, hd, a); return failed(DOMAIN_ERROR_GENERIC_ARGUMENT, hd, a);
} }
xarg *na = matchKey2( NameOfFunctor( f ), a, n, def); xarg *na = matchKey2(NameOfFunctor(f), a, n, def);
if (na) { if (na) {
na->used = 1; na->used = 1;
na->tvalue = ArgOfTerm(1, hd); na->tvalue = ArgOfTerm(1, hd);
} else { } else {
return failed( DOMAIN_ERROR_GENERIC_ARGUMENT, hd, a); return failed(DOMAIN_ERROR_GENERIC_ARGUMENT, hd, a);
} }
} else { } else {
return failed( INSTANTIATION_ERROR, hd, a); return failed(INSTANTIATION_ERROR, hd, a);
} }
listl = TailOfTerm(listl); listl = TailOfTerm(listl);
} }
if (IsVarTerm(listl)) { if (IsVarTerm(listl)) {
return failed( INSTANTIATION_ERROR, listl, a); return failed(INSTANTIATION_ERROR, listl, a);
} }
if (TermNil != listl) { if (TermNil != listl) {
return failed( TYPE_ERROR_LIST, listl, a); return failed(TYPE_ERROR_LIST, listl, a);
} }
return a; return a;
} }

72
C/arrays.c
View File

@ -234,22 +234,23 @@ static Int CloseMmappedArray(StaticArrayEntry *pp, void *area USES_REGS) {
} }
if (ptr == NULL) { if (ptr == NULL) {
#if !defined(USE_SYSTEM_MALLOC) #if !defined(USE_SYSTEM_MALLOC)
Yap_Error(SYSTEM_ERROR_INTERNAL, ARG1, Yap_FullError(SYSTEM_ERROR_INTERNAL, ARG1,
"close_mmapped_array (array chain incoherent)", strerror(errno)); "close_mmapped_array (array chain incoherent)",
strerror(errno));
#endif #endif
return FALSE; return FALSE;
} }
if (munmap(ptr->start, ptr->size) == -1) { if (munmap(ptr->start, ptr->size) == -1) {
Yap_Error(SYSTEM_ERROR_INTERNAL, ARG1, "close_mmapped_array (munmap: %s)", Yap_FullError(SYSTEM_ERROR_INTERNAL, ARG1,
strerror(errno)); "close_mmapped_array (munmap: %s)", strerror(errno));
return (FALSE); return (FALSE);
} }
optr->next = ptr->next; optr->next = ptr->next;
pp->ValueOfVE.ints = NULL; pp->ValueOfVE.ints = NULL;
pp->ArrayEArity = 0; pp->ArrayEArity = 0;
if (close(ptr->fd) < 0) { if (close(ptr->fd) < 0) {
Yap_Error(SYSTEM_ERROR_INTERNAL, ARG1, "close_mmapped_array (close: %s)", Yap_FullError(SYSTEM_ERROR_OPERATING_SYSTEM, ARG1,
strerror(errno)); "close_mmapped_array (close: %s)", strerror(errno));
return (FALSE); return (FALSE);
} }
Yap_FreeAtomSpace((char *)ptr); Yap_FreeAtomSpace((char *)ptr);
@ -271,30 +272,31 @@ static void ResizeMmappedArray(StaticArrayEntry *pp, Int dim,
and last we initialize again and last we initialize again
*/ */
if (munmap(ptr->start, ptr->size) == -1) { if (munmap(ptr->start, ptr->size) == -1) {
Yap_Error(SYSTEM_ERROR_INTERNAL, ARG1, "resize_mmapped_array (munmap: %s)", Yap_FullError(SYSTEM_ERROR_OPERATING_SYSTEM, ARG1,
strerror(errno)); "resize_mmapped_array (munmap: %s)", strerror(errno));
return; return;
} }
total_size = (ptr->size / ptr->items) * dim; total_size = (ptr->size / ptr->items) * dim;
if (ftruncate(ptr->fd, total_size) < 0) { if (ftruncate(ptr->fd, total_size) < 0) {
Yap_Error(SYSTEM_ERROR_INTERNAL, ARG1, Yap_FullError(SYSTEM_ERROR_OPERATING_SYSTEM, ARG1,
"resize_mmapped_array (ftruncate: %s)", strerror(errno)); "resize_mmapped_array (ftruncate: %s)", strerror(errno));
return; return;
} }
if (lseek(ptr->fd, total_size - 1, SEEK_SET) < 0) { if (lseek(ptr->fd, total_size - 1, SEEK_SET) < 0) {
Yap_Error(SYSTEM_ERROR_INTERNAL, ARG1, "resize_mmapped_array (lseek: %s)", Yap_Error(SYSTEM_ERROR_OPERATING_SYSTEM, ARG1,
strerror(errno)); "resize_mmapped_array (lseek: %s)", strerror(errno));
return; return;
} }
if (write(ptr->fd, "", 1) < 0) { if (write(ptr->fd, "", 1) < 0) {
Yap_Error(SYSTEM_ERROR_INTERNAL, ARG1, "resize_mmapped_array (write: %s)", Yap_FullError(SYSTEM_ERROR_OPERATING_SYSTEM, ARG1,
strerror(errno)); "resize_mmapped_array (write: %s)", strerror(errno));
return; return;
} }
if ((ptr->start = (void *)mmap(0, (size_t)total_size, PROT_READ | PROT_WRITE, if ((ptr->start = (void *)mmap(0, (size_t)total_size, PROT_READ | PROT_WRITE,
MAP_SHARED, ptr->fd, 0)) == (void *)-1) { MAP_SHARED, ptr->fd, 0)) == (void *)-1) {
Yap_Error(SYSTEM_ERROR_INTERNAL, ARG1, "resize_mmapped_array (mmap: %s)", Yap_FullError(SYSTEM_ERROR_OPERATING_SYSTEM, ARG1,
strerror(errno)); "resize_mmapped_array (mmap: %s)", ___LINE__, __FUNCTION__,
-__FILE__, strerror(errno));
return; return;
} }
ptr->size = total_size; ptr->size = total_size;
@ -309,25 +311,15 @@ static Term GetTermFromArray(DBTerm *ref USES_REGS) {
Term TRef; Term TRef;
while ((TRef = Yap_FetchTermFromDB(ref)) == 0L) { while ((TRef = Yap_FetchTermFromDB(ref)) == 0L) {
if (LOCAL_Error_TYPE == RESOURCE_ERROR_ATTRIBUTED_VARIABLES) {
LOCAL_Error_TYPE = YAP_NO_ERROR;
if (!Yap_growglobal(NULL)) {
Yap_Error(RESOURCE_ERROR_ATTRIBUTED_VARIABLES, TermNil,
LOCAL_ErrorMessage);
return TermNil;
}
} else {
LOCAL_Error_TYPE = YAP_NO_ERROR;
if (!Yap_gcl(LOCAL_Error_Size, 3, ENV, Yap_gcP())) { if (!Yap_gcl(LOCAL_Error_Size, 3, ENV, Yap_gcP())) {
Yap_Error(RESOURCE_ERROR_STACK, TermNil, LOCAL_ErrorMessage); Yap_Error(RESOURCE_ERROR_STACK, TermNil, LOCAL_ErrorMessage);
return TermNil; return 0;
}
} }
} }
return TRef; return TRef;
} else { } else {
P = (yamop *)FAILCODE; Yap_Error(DOMAIN_ERROR_NOT_ZERO, ARG1, "Null reference.");
return TermNil; return 0;
} }
} }
@ -355,8 +347,8 @@ static Term GetNBTerm(live_term *ar, Int indx USES_REGS) {
livet = termt; livet = termt;
} else { } else {
DBTerm *ref = (DBTerm *)RepAppl(termt); DBTerm *ref = (DBTerm *)RepAppl(termt);
if ((livet = GetTermFromArray(ref PASS_REGS)) == TermNil) { if ((livet = GetTermFromArray(ref PASS_REGS)) == 0) {
return TermNil; return 0;
} }
} }
YapBind(&(ar[indx].tlive), livet); YapBind(&(ar[indx].tlive), livet);
@ -391,10 +383,13 @@ static Term AccessNamedArray(Atom a, Int indx USES_REGS) {
if (ArrayIsDynamic(pp)) { if (ArrayIsDynamic(pp)) {
Term out; Term out;
READ_LOCK(pp->ArRWLock); READ_LOCK(pp->ArRWLock);
if (IsVarTerm(pp->ValueOfVE) || pp->ArrayEArity <= indx || indx < 0) { if (IsVarTerm(pp->ValueOfVE)) {
READ_UNLOCK(pp->ArRWLock); READ_UNLOCK(pp->ArRWLock);
P = (yamop *)FAILCODE; Yap_Error(INSTANTIATION_ERROR, ARG1, "unbound static array", indx);
return (MkAtomTerm(AtomFoundVar)); }
if (pp->ArrayEArity <= indx || indx < 0) {
READ_UNLOCK(pp->ArRWLock);
Yap_Error(DOMAIN_ERROR_ARRAY_OVERFLOW, ARG1, "bad index %ld", indx);
} }
out = RepAppl(pp->ValueOfVE)[indx + 1]; out = RepAppl(pp->ValueOfVE)[indx + 1];
READ_UNLOCK(pp->ArRWLock); READ_UNLOCK(pp->ArRWLock);
@ -404,11 +399,7 @@ static Term AccessNamedArray(Atom a, Int indx USES_REGS) {
READ_LOCK(ptr->ArRWLock); READ_LOCK(ptr->ArRWLock);
if (pp->ArrayEArity <= indx || indx < 0) { if (pp->ArrayEArity <= indx || indx < 0) {
/* Yap_Error(DOMAIN_ERROR_ARRAY_OVERFLOW, MkIntegerTerm(indx), Yap_Error(DOMAIN_ERROR_ARRAY_OVERFLOW, ARG1, "bad index %ld", indx);
* "access_array");*/
READ_UNLOCK(ptr->ArRWLock);
P = (yamop *)FAILCODE;
return (MkAtomTerm(AtomFoundVar));
} }
switch (ptr->ArrayType) { switch (ptr->ArrayType) {
@ -489,9 +480,9 @@ static Term AccessNamedArray(Atom a, Int indx USES_REGS) {
case array_of_nb_terms: { case array_of_nb_terms: {
/* The object is now in use */ /* The object is now in use */
Term out = GetNBTerm(ptr->ValueOfVE.lterms, indx PASS_REGS); Term out = GetNBTerm(ptr->ValueOfVE.lterms, indx PASS_REGS);
READ_UNLOCK(ptr->ArRWLock); READ_UNLOCK(ptr->ArRWLock);
return out; if (out == 0)
return TermNil;
} }
case array_of_terms: { case array_of_terms: {
/* The object is now in use */ /* The object is now in use */
@ -1655,7 +1646,6 @@ static Int array_references(USES_REGS1) {
/** @pred update_array(+ _Name_, + _Index_, ? _Value_) /** @pred update_array(+ _Name_, + _Index_, ? _Value_)
Attribute value _Value_ to _Name_[ _Index_]. Type Attribute value _Value_ to _Name_[ _Index_]. Type
restrictions must be respected for static arrays. This operation is restrictions must be respected for static arrays. This operation is
available for dynamic arrays if `MULTI_ASSIGNMENT_VARIABLES` is available for dynamic arrays if `MULTI_ASSIGNMENT_VARIABLES` is

7
C/atomic.c
View File

@ -704,13 +704,6 @@ restart_aux:
cut_fail(); cut_fail();
} }
#define CastToAtom(x) CastToAtom__(x PASS_REGS)
static Term CastToAtom__(Term t USES_REGS) {
if (IsAtomTerm(t))
return t;
return MkAtomTerm(Yap_AtomicToAtom(t PASS_REGS));
}
#define CastToNumeric(x) CastToNumeric__(x PASS_REGS) #define CastToNumeric(x) CastToNumeric__(x PASS_REGS)

6
C/c_interface.c
View File

@ -1623,7 +1623,7 @@ static int run_emulator(USES_REGS1) {
return out; return out;
} }
X_API bool YAP_EnterGoal(PredEntry *pe, yhandle_t ptr, YAP_dogoalinfo *dgi) { X_API bool YAP_EnterGoal(PredEntry *pe, CELL *ptr, YAP_dogoalinfo *dgi) {
CACHE_REGS CACHE_REGS
bool out; bool out;
@ -1634,7 +1634,7 @@ X_API bool YAP_EnterGoal(PredEntry *pe, yhandle_t ptr, YAP_dogoalinfo *dgi) {
dgi->CurSlot = LOCAL_CurSlot; dgi->CurSlot = LOCAL_CurSlot;
// ensure our current ENV receives current P. // ensure our current ENV receives current P.
Yap_PrepGoal(pe->ArityOfPE, Yap_AddressFromSlot(ptr), B PASS_REGS); Yap_PrepGoal(pe->ArityOfPE, nullptr, B PASS_REGS);
P = pe->CodeOfPred; P = pe->CodeOfPred;
// __android_log_print(ANDROID_LOG_INFO, "YAP ", "ap=%p %d %x %x args=%x,%x // __android_log_print(ANDROID_LOG_INFO, "YAP ", "ap=%p %d %x %x args=%x,%x
// slot=%d", pe, pe->CodeOfPred->opc, FAILCODE, Deref(ARG1), Deref(ARG2), // slot=%d", pe, pe->CodeOfPred->opc, FAILCODE, Deref(ARG1), Deref(ARG2),
@ -1679,7 +1679,7 @@ X_API bool YAP_RetryGoal(YAP_dogoalinfo *dgi) {
return out; return out;
} }
X_API bool YAP_LeaveGoal(int backtrack, YAP_dogoalinfo *dgi) { X_API bool YAP_LeaveGoal(bool backtrack, YAP_dogoalinfo *dgi) {
CACHE_REGS CACHE_REGS
choiceptr myB; choiceptr myB;

21
C/dbase.c
View File

@ -1408,7 +1408,7 @@ static DBRef CreateDBStruct(Term Tm, DBProp p, int InFlag, int *pstat,
DBRef *TmpRefBase = (DBRef *)LOCAL_TrailTop; DBRef *TmpRefBase = (DBRef *)LOCAL_TrailTop;
CELL *CodeAbs; /* how much code did we find */ CELL *CodeAbs; /* how much code did we find */
int vars_found = FALSE; int vars_found = FALSE;
yap_error_number oerr = LOCAL_Error_TYPE;
LOCAL_Error_TYPE = YAP_NO_ERROR; LOCAL_Error_TYPE = YAP_NO_ERROR;
if (p == NULL) { if (p == NULL) {
@ -1418,6 +1418,7 @@ static DBRef CreateDBStruct(Term Tm, DBProp p, int InFlag, int *pstat,
#endif #endif
DBRef out = (DBRef)CreateDBTermForVar(extra_size, dbg); DBRef out = (DBRef)CreateDBTermForVar(extra_size, dbg);
*pstat = TRUE; *pstat = TRUE;
LOCAL_Error_TYPE = oerr;
return out; return out;
#ifdef COROUTINING #ifdef COROUTINING
} }
@ -1425,6 +1426,7 @@ static DBRef CreateDBStruct(Term Tm, DBProp p, int InFlag, int *pstat,
} else if (IsAtomOrIntTerm(Tm)) { } else if (IsAtomOrIntTerm(Tm)) {
DBRef out = (DBRef)CreateDBTermForAtom(Tm, extra_size, dbg); DBRef out = (DBRef)CreateDBTermForAtom(Tm, extra_size, dbg);
*pstat = FALSE; *pstat = FALSE;
LOCAL_Error_TYPE = oerr;
return out; return out;
} }
} else { } else {
@ -1434,8 +1436,10 @@ static DBRef CreateDBStruct(Term Tm, DBProp p, int InFlag, int *pstat,
#endif #endif
) { ) {
*pstat = TRUE; *pstat = TRUE;
LOCAL_Error_TYPE = oerr;
return CreateDBRefForVar(Tm, p, InFlag, dbg); return CreateDBRefForVar(Tm, p, InFlag, dbg);
} else if (IsAtomOrIntTerm(Tm)) { } else if (IsAtomOrIntTerm(Tm)) {
LOCAL_Error_TYPE = oerr;
return CreateDBRefForAtom(Tm, p, InFlag, dbg); return CreateDBRefForAtom(Tm, p, InFlag, dbg);
} }
} }
@ -1463,6 +1467,7 @@ static DBRef CreateDBStruct(Term Tm, DBProp p, int InFlag, int *pstat,
LOCAL_Error_Size = (UInt)(extra_size + sizeof(ppt0)); LOCAL_Error_Size = (UInt)(extra_size + sizeof(ppt0));
LOCAL_Error_TYPE = RESOURCE_ERROR_AUXILIARY_STACK; LOCAL_Error_TYPE = RESOURCE_ERROR_AUXILIARY_STACK;
Yap_ReleasePreAllocCodeSpace((ADDR)pp0); Yap_ReleasePreAllocCodeSpace((ADDR)pp0);
LOCAL_Error_TYPE = oerr;
return NULL; return NULL;
} }
ntp0 = ppt0->Contents; ntp0 = ppt0->Contents;
@ -1470,6 +1475,8 @@ static DBRef CreateDBStruct(Term Tm, DBProp p, int InFlag, int *pstat,
LOCAL_Error_Size = 0; LOCAL_Error_Size = 0;
LOCAL_Error_TYPE = RESOURCE_ERROR_TRAIL; LOCAL_Error_TYPE = RESOURCE_ERROR_TRAIL;
Yap_ReleasePreAllocCodeSpace((ADDR)pp0); Yap_ReleasePreAllocCodeSpace((ADDR)pp0);
LOCAL_Error_TYPE = oerr;
return NULL; return NULL;
} }
dbg->lr = dbg->LinkAr = (link_entry *)TR; dbg->lr = dbg->LinkAr = (link_entry *)TR;
@ -1481,6 +1488,7 @@ static DBRef CreateDBStruct(Term Tm, DBProp p, int InFlag, int *pstat,
&attachments, &vars_found, dbg); &attachments, &vars_found, dbg);
if (ntp == NULL) { if (ntp == NULL) {
Yap_ReleasePreAllocCodeSpace((ADDR)pp0); Yap_ReleasePreAllocCodeSpace((ADDR)pp0);
LOCAL_Error_TYPE = oerr;
return NULL; return NULL;
} }
} else } else
@ -1495,6 +1503,7 @@ static DBRef CreateDBStruct(Term Tm, DBProp p, int InFlag, int *pstat,
&vars_found, dbg); &vars_found, dbg);
if (ntp == NULL) { if (ntp == NULL) {
Yap_ReleasePreAllocCodeSpace((ADDR)pp0); Yap_ReleasePreAllocCodeSpace((ADDR)pp0);
LOCAL_Error_TYPE = oerr;
return NULL; return NULL;
} }
} else { } else {
@ -1535,6 +1544,7 @@ static DBRef CreateDBStruct(Term Tm, DBProp p, int InFlag, int *pstat,
&vars_found, dbg); &vars_found, dbg);
if (ntp == NULL) { if (ntp == NULL) {
Yap_ReleasePreAllocCodeSpace((ADDR)pp0); Yap_ReleasePreAllocCodeSpace((ADDR)pp0);
LOCAL_Error_TYPE = oerr;
return NULL; return NULL;
} }
} }
@ -1542,6 +1552,7 @@ static DBRef CreateDBStruct(Term Tm, DBProp p, int InFlag, int *pstat,
CodeAbs = (CELL *)((CELL)ntp - (CELL)ntp0); CodeAbs = (CELL *)((CELL)ntp - (CELL)ntp0);
if (LOCAL_Error_TYPE) { if (LOCAL_Error_TYPE) {
Yap_ReleasePreAllocCodeSpace((ADDR)pp0); Yap_ReleasePreAllocCodeSpace((ADDR)pp0);
LOCAL_Error_TYPE = oerr;
return NULL; /* Error Situation */ return NULL; /* Error Situation */
} }
NOfCells = ntp - ntp0; /* End Of Code Info */ NOfCells = ntp - ntp0; /* End Of Code Info */
@ -1560,11 +1571,13 @@ static DBRef CreateDBStruct(Term Tm, DBProp p, int InFlag, int *pstat,
LOCAL_Error_Size = (UInt)DBLength(CodeAbs); LOCAL_Error_Size = (UInt)DBLength(CodeAbs);
LOCAL_Error_TYPE = RESOURCE_ERROR_AUXILIARY_STACK; LOCAL_Error_TYPE = RESOURCE_ERROR_AUXILIARY_STACK;
Yap_ReleasePreAllocCodeSpace((ADDR)pp0); Yap_ReleasePreAllocCodeSpace((ADDR)pp0);
LOCAL_Error_TYPE = oerr;
return NULL; return NULL;
} }
if ((InFlag & MkIfNot) && if ((InFlag & MkIfNot) &&
(dbg->found_one = check_if_wvars(p->First, NOfCells, ntp0))) { (dbg->found_one = check_if_wvars(p->First, NOfCells, ntp0))) {
Yap_ReleasePreAllocCodeSpace((ADDR)pp0); Yap_ReleasePreAllocCodeSpace((ADDR)pp0);
LOCAL_Error_TYPE = oerr;
return dbg->found_one; return dbg->found_one;
} }
} else { } else {
@ -1572,6 +1585,7 @@ static DBRef CreateDBStruct(Term Tm, DBProp p, int InFlag, int *pstat,
if ((InFlag & MkIfNot) && if ((InFlag & MkIfNot) &&
(dbg->found_one = check_if_nvars(p->First, NOfCells, ntp0, dbg))) { (dbg->found_one = check_if_nvars(p->First, NOfCells, ntp0, dbg))) {
Yap_ReleasePreAllocCodeSpace((ADDR)pp0); Yap_ReleasePreAllocCodeSpace((ADDR)pp0);
LOCAL_Error_TYPE = oerr;
return dbg->found_one; return dbg->found_one;
} }
} }
@ -1581,6 +1595,7 @@ static DBRef CreateDBStruct(Term Tm, DBProp p, int InFlag, int *pstat,
LOCAL_Error_Size = (UInt)DBLength(CodeAbs); LOCAL_Error_Size = (UInt)DBLength(CodeAbs);
LOCAL_Error_TYPE = RESOURCE_ERROR_AUXILIARY_STACK; LOCAL_Error_TYPE = RESOURCE_ERROR_AUXILIARY_STACK;
Yap_ReleasePreAllocCodeSpace((ADDR)pp0); Yap_ReleasePreAllocCodeSpace((ADDR)pp0);
LOCAL_Error_TYPE = oerr;
return NULL; return NULL;
} }
flag |= DBWithRefs; flag |= DBWithRefs;
@ -1588,6 +1603,7 @@ static DBRef CreateDBStruct(Term Tm, DBProp p, int InFlag, int *pstat,
#if SIZEOF_LINK_ENTRY == 2 #if SIZEOF_LINK_ENTRY == 2
if (Unsigned(CodeAbs) >= 0x40000) { if (Unsigned(CodeAbs) >= 0x40000) {
Yap_ReleasePreAllocCodeSpace((ADDR)pp0); Yap_ReleasePreAllocCodeSpace((ADDR)pp0);
LOCAL_Error_TYPE = oerr;
return generate_dberror_msg(SYSTEM_ERROR_INTERNAL, 0, return generate_dberror_msg(SYSTEM_ERROR_INTERNAL, 0,
"trying to store term larger than 256KB"); "trying to store term larger than 256KB");
} }
@ -1598,6 +1614,7 @@ static DBRef CreateDBStruct(Term Tm, DBProp p, int InFlag, int *pstat,
ppt = (DBTerm *)(ptr + extra_size); ppt = (DBTerm *)(ptr + extra_size);
if (ptr == NULL) { if (ptr == NULL) {
Yap_ReleasePreAllocCodeSpace((ADDR)pp0); Yap_ReleasePreAllocCodeSpace((ADDR)pp0);
LOCAL_Error_TYPE = oerr;
return generate_dberror_msg(RESOURCE_ERROR_HEAP, sz, return generate_dberror_msg(RESOURCE_ERROR_HEAP, sz,
"heap crashed against stacks"); "heap crashed against stacks");
} }
@ -1609,6 +1626,7 @@ static DBRef CreateDBStruct(Term Tm, DBProp p, int InFlag, int *pstat,
pp = AllocDBSpace(sz); pp = AllocDBSpace(sz);
if (pp == NULL) { if (pp == NULL) {
Yap_ReleasePreAllocCodeSpace((ADDR)pp0); Yap_ReleasePreAllocCodeSpace((ADDR)pp0);
LOCAL_Error_TYPE = oerr;
return generate_dberror_msg(RESOURCE_ERROR_HEAP, sz, return generate_dberror_msg(RESOURCE_ERROR_HEAP, sz,
"heap crashed against stacks"); "heap crashed against stacks");
} }
@ -1682,6 +1700,7 @@ static DBRef CreateDBStruct(Term Tm, DBProp p, int InFlag, int *pstat,
ppt->DBRefs = NULL; ppt->DBRefs = NULL;
} }
Yap_ReleasePreAllocCodeSpace((ADDR)pp0); Yap_ReleasePreAllocCodeSpace((ADDR)pp0);
LOCAL_Error_TYPE = oerr;
return pp; return pp;
} }
} }

198
C/errors.c
View File

@ -11,7 +11,7 @@
* File: errors.c * * File: errors.c *
* Last Rev: * * Last Rev: *
* Mods: * * Mods: *
* Comments: Yap'S error handlers * * Comments: Yap's error handlers *
* * * *
*************************************************************************/ *************************************************************************/
@ -32,7 +32,6 @@
#endif #endif
#include "Foreign.h" #include "Foreign.h"
bool Yap_Warning(const char *s, ...) { bool Yap_Warning(const char *s, ...) {
CACHE_REGS CACHE_REGS
va_list ap; va_list ap;
@ -62,8 +61,7 @@ bool Yap_Warning(const char *s, ...) {
} else } else
return false; return false;
va_end(ap); va_end(ap);
if (pred->OpcodeOfPred == UNDEF_OPCODE|| if (pred->OpcodeOfPred == UNDEF_OPCODE || pred->OpcodeOfPred == FAIL_OPCODE) {
pred->OpcodeOfPred == FAIL_OPCODE) {
fprintf(stderr, "warning message: %s\n", tmpbuf); fprintf(stderr, "warning message: %s\n", tmpbuf);
LOCAL_DoingUndefp = false; LOCAL_DoingUndefp = false;
LOCAL_within_print_message = false; LOCAL_within_print_message = false;
@ -75,12 +73,27 @@ bool Yap_Warning(const char *s, ...) {
rc = Yap_execute_pred(pred, ts, true PASS_REGS); rc = Yap_execute_pred(pred, ts, true PASS_REGS);
return rc; return rc;
} }
void Yap_InitError(yap_error_number e, Term t, const char *msg) {
if (LOCAL_ActiveError.status) {
Yap_exit(1);
}
LOCAL_ActiveError.errorNo = e;
LOCAL_ActiveError.errorFile = NULL;
LOCAL_ActiveError.errorFunction = NULL;
LOCAL_ActiveError.errorLine = 0;
if (msg) {
LOCAL_Error_Size = strlen(msg);
strcpy(LOCAL_ActiveError.errorComment, msg);
} else {
LOCAL_Error_Size = 0;
}
}
bool Yap_PrintWarning(Term twarning) { bool Yap_PrintWarning(Term twarning) {
CACHE_REGS CACHE_REGS
PredEntry *pred = RepPredProp(PredPropByFunc( PredEntry *pred = RepPredProp(PredPropByFunc(
FunctorPrintMessage, PROLOG_MODULE)); // PROCEDURE_print_message2; FunctorPrintMessage, PROLOG_MODULE)); // PROCEDURE_print_message2;
Term cmod = ( CurrentModule == PROLOG_MODULE ? TermProlog : CurrentModule ); Term cmod = (CurrentModule == PROLOG_MODULE ? TermProlog : CurrentModule);
bool rc; bool rc;
Term ts[2]; Term ts[2];
@ -91,9 +104,7 @@ bool Yap_PrintWarning(Term twarning) {
} }
LOCAL_DoingUndefp = true; LOCAL_DoingUndefp = true;
LOCAL_within_print_message = true; LOCAL_within_print_message = true;
if (pred->OpcodeOfPred == UNDEF_OPCODE || if (pred->OpcodeOfPred == UNDEF_OPCODE || pred->OpcodeOfPred == FAIL_OPCODE) {
pred->OpcodeOfPred == FAIL_OPCODE
) {
fprintf(stderr, "warning message:\n"); fprintf(stderr, "warning message:\n");
Yap_DebugPlWrite(twarning); Yap_DebugPlWrite(twarning);
fprintf(stderr, "\n"); fprintf(stderr, "\n");
@ -112,12 +123,12 @@ bool Yap_PrintWarning(Term twarning) {
return rc; return rc;
} }
bool Yap_HandleError__(const char *file, const char *function, int lineno, const char *s, ...) { bool Yap_HandleError__(const char *file, const char *function, int lineno,
const char *s, ...) {
CACHE_REGS CACHE_REGS
yap_error_number err = LOCAL_Error_TYPE; yap_error_number err = LOCAL_Error_TYPE;
const char *serr; const char *serr;
LOCAL_Error_TYPE = YAP_NO_ERROR;
if (LOCAL_ErrorMessage) { if (LOCAL_ErrorMessage) {
serr = LOCAL_ErrorMessage; serr = LOCAL_ErrorMessage;
} else { } else {
@ -136,7 +147,8 @@ bool Yap_HandleError__(const char *file, const char *function, int lineno, const
} }
if (!Yap_ExpandPreAllocCodeSpace(0, NULL, TRUE)) { if (!Yap_ExpandPreAllocCodeSpace(0, NULL, TRUE)) {
/* crash in flames */ /* crash in flames */
Yap_Error__(file, function, lineno, RESOURCE_ERROR_AUXILIARY_STACK, ARG1, serr); Yap_Error__(file, function, lineno, RESOURCE_ERROR_AUXILIARY_STACK, ARG1,
serr);
return false; return false;
} }
return true; return true;
@ -156,7 +168,6 @@ int Yap_SWIHandleError(const char *s, ...) {
yap_error_number err = LOCAL_Error_TYPE; yap_error_number err = LOCAL_Error_TYPE;
char *serr; char *serr;
LOCAL_Error_TYPE = YAP_NO_ERROR;
if (LOCAL_ErrorMessage) { if (LOCAL_ErrorMessage) {
serr = LOCAL_ErrorMessage; serr = LOCAL_ErrorMessage;
} else { } else {
@ -210,11 +221,10 @@ static void error_exit_yap(int value) {
void *callstack[256]; void *callstack[256];
int i; int i;
int frames = backtrace(callstack, 256); int frames = backtrace(callstack, 256);
char** strs = backtrace_symbols(callstack, frames); char **strs = backtrace_symbols(callstack, frames);
fprintf(stderr, "Execution stack:\n"); fprintf(stderr, "Execution stack:\n");
for (i = 0; i < frames; ++i) { for (i = 0; i < frames; ++i) {
fprintf(stderr, " %s\n", strs[i]); fprintf(stderr, " %s\n", strs[i]);
} }
free(strs); free(strs);
#endif #endif
@ -257,6 +267,7 @@ static char tmpbuf[YAP_BUF_SIZE];
#define END_ERROR_CLASSES() \ #define END_ERROR_CLASSES() \
} \ } \
return TermNil; \
} }
#define BEGIN_ERRORS() \ #define BEGIN_ERRORS() \
@ -281,7 +292,7 @@ static char tmpbuf[YAP_BUF_SIZE];
return mkerrorct(B, ts); return mkerrorct(B, ts);
#define END_ERRORS() \ #define END_ERRORS() \
} \ } return TermNil; \
} }
#include "YapErrors.h" #include "YapErrors.h"
@ -336,15 +347,23 @@ yamop *Yap_Error__(const char *file, const char *function, int lineno,
tmpbuf); tmpbuf);
Yap_RestartYap(1); Yap_RestartYap(1);
} }
LOCAL_ActiveError.errorNo = type;
LOCAL_ActiveError.errorAsText = Yap_LookupAtom(Yap_errorName( type ));
LOCAL_ActiveError.errorClass = Yap_errorClass( type);
LOCAL_ActiveError.classAsText = Yap_LookupAtom(Yap_errorClassName( LOCAL_ActiveError.errorClass ));
LOCAL_ActiveError.errorLine = lineno;
LOCAL_ActiveError.errorFunction = function;
LOCAL_ActiveError.errorFile = file;
Yap_find_prolog_culprit(PASS_REGS1);
LOCAL_PrologMode |= InErrorMode; LOCAL_PrologMode |= InErrorMode;
LOCAL_Error_TYPE = YAP_NO_ERROR;
Yap_ClearExs(); Yap_ClearExs();
if (where == 0L) { if (where == 0L) {
where = TermNil; where = TermNil;
} }
// first, obtain current location // first, obtain current location
// sprintf(LOCAL_FileNameBuf, "%s:%d in C-function %s ", file, lineno, function); // sprintf(LOCAL_FileNameBuf, "%s:%d in C-function %s ", file, lineno,
// tf = MkAtomTerm(Yap_LookupAtom(LOCAL_FileNameBuf)); // function);
// tf = MkAtomTerm(Yap_LookupAtom(LOCAL_FileNameBuf));
#if DEBUG_STRICT #if DEBUG_STRICT
if (Yap_heap_regs && !(LOCAL_PrologMode & BootMode)) if (Yap_heap_regs && !(LOCAL_PrologMode & BootMode))
fprintf(stderr, "***** Processing Error %d (%lx,%x) %s***\n", type, fprintf(stderr, "***** Processing Error %d (%lx,%x) %s***\n", type,
@ -416,14 +435,15 @@ yamop *Yap_Error__(const char *file, const char *function, int lineno,
if (LOCAL_PrologMode & BootMode) { if (LOCAL_PrologMode & BootMode) {
/* crash in flames! */ /* crash in flames! */
fprintf(stderr, "%s:%d:0 YAP Fatal Error %d in function %s:\n %s exiting....\n", file, lineno, type, function, s); fprintf(stderr,
"%s:%d:0 YAP Fatal Error %d in function %s:\n %s exiting....\n",
file, lineno, type, function, s);
error_exit_yap(1); error_exit_yap(1);
} }
#ifdef DEBUG #ifdef DEBUG
// DumpActiveGoals( USES_REGS1 ); // DumpActiveGoals( USES_REGS1 );
#endif /* DEBUG */ #endif /* DEBUG */
if (!IsVarTerm(where) && if (!IsVarTerm(where) && IsApplTerm(where) &&
IsApplTerm(where) &&
FunctorOfTerm(where) == FunctorError) { FunctorOfTerm(where) == FunctorError) {
error_t = where; error_t = where;
P = (yamop *)FAILCODE; P = (yamop *)FAILCODE;
@ -446,7 +466,7 @@ yamop *Yap_Error__(const char *file, const char *function, int lineno,
void *callstack[256]; void *callstack[256];
int i; int i;
int frames = backtrace(callstack, 256); int frames = backtrace(callstack, 256);
char** strs = backtrace_symbols(callstack, frames); char **strs = backtrace_symbols(callstack, frames);
fprintf(stderr, "Execution stack:\n"); fprintf(stderr, "Execution stack:\n");
for (i = 0; i < frames; ++i) { for (i = 0; i < frames; ++i) {
fprintf(stderr, " %s\n", strs[i]); fprintf(stderr, " %s\n", strs[i]);
@ -501,9 +521,6 @@ yamop *Yap_Error__(const char *file, const char *function, int lineno,
ts[2] = where; ts[2] = where;
nt[0] = mkerrort(type, ts + 2); nt[0] = mkerrort(type, ts + 2);
} }
} }
LOCAL_PrologMode &= ~InErrorMode; LOCAL_PrologMode &= ~InErrorMode;
if (type != ABORT_EVENT) { if (type != ABORT_EVENT) {
@ -511,12 +528,12 @@ yamop *Yap_Error__(const char *file, const char *function, int lineno,
/* This is used by some complex procedures to detect there was an error */ /* This is used by some complex procedures to detect there was an error */
if (IsAtomTerm(nt[0])) { if (IsAtomTerm(nt[0])) {
strncpy(LOCAL_ErrorSay, (char *) RepAtom(AtomOfTerm(nt[0]))->StrOfAE, strncpy(LOCAL_ErrorSay, (char *)RepAtom(AtomOfTerm(nt[0]))->StrOfAE,
MAX_ERROR_MSG_SIZE); MAX_ERROR_MSG_SIZE);
LOCAL_ErrorMessage = LOCAL_ErrorSay; LOCAL_ErrorMessage = LOCAL_ErrorSay;
} else { } else {
strncpy(LOCAL_ErrorSay, strncpy(LOCAL_ErrorSay,
(char *) RepAtom(NameOfFunctor(FunctorOfTerm(nt[0])))->StrOfAE, (char *)RepAtom(NameOfFunctor(FunctorOfTerm(nt[0])))->StrOfAE,
MAX_ERROR_MSG_SIZE); MAX_ERROR_MSG_SIZE);
LOCAL_ErrorMessage = LOCAL_ErrorSay; LOCAL_ErrorMessage = LOCAL_ErrorSay;
} }
@ -540,12 +557,12 @@ yamop *Yap_Error__(const char *file, const char *function, int lineno,
MkPairTerm(MkPairTerm(MkAtomTerm(Yap_LookupAtom("c")), t3), nt[1]); MkPairTerm(MkPairTerm(MkAtomTerm(Yap_LookupAtom("c")), t3), nt[1]);
} }
if ((location = Yap_pc_location(P, B, ENV)) != TermNil) { if ((location = Yap_pc_location(P, B, ENV)) != TermNil) {
nt[1] = MkPairTerm(MkPairTerm(MkAtomTerm(Yap_LookupAtom("p")), location), nt[1] = MkPairTerm(
nt[1]); MkPairTerm(MkAtomTerm(Yap_LookupAtom("p")), location), nt[1]);
} }
if ((location = Yap_env_location(CP, B, ENV, 0)) != TermNil) { if ((location = Yap_env_location(CP, B, ENV, 0)) != TermNil) {
nt[1] = MkPairTerm(MkPairTerm(MkAtomTerm(Yap_LookupAtom("e")), location), nt[1] = MkPairTerm(
nt[1]); MkPairTerm(MkAtomTerm(Yap_LookupAtom("e")), location), nt[1]);
} }
} }
} }
@ -553,7 +570,7 @@ yamop *Yap_Error__(const char *file, const char *function, int lineno,
LOCAL_Signals = 0; LOCAL_Signals = 0;
CalculateStackGap(PASS_REGS1); CalculateStackGap(PASS_REGS1);
#if DEBUG #if DEBUG
// DumpActiveGoals( PASS_REGS1 ); // DumpActiveGoals( PASS_REGS1 );
#endif #endif
/* wait if we we are in user code, /* wait if we we are in user code,
it's up to her to decide */ it's up to her to decide */
@ -568,16 +585,13 @@ yamop *Yap_Error__(const char *file, const char *function, int lineno,
Yap_JumpToEnv(error_t); Yap_JumpToEnv(error_t);
P = (yamop *)FAILCODE; P = (yamop *)FAILCODE;
LOCAL_PrologMode &= ~InErrorMode; LOCAL_PrologMode &= ~InErrorMode;
return P; return P;
} }
static Int static Int is_boolean(USES_REGS1) {
is_boolean( USES_REGS1 )
{
Term t = Deref(ARG1); Term t = Deref(ARG1);
//Term Context = Deref(ARG2)Yap_Error(INSTANTIATION_ERROR, t, NULL);; // Term Context = Deref(ARG2)Yap_Error(INSTANTIATION_ERROR, t, NULL);;
if (IsVarTerm(t)) { if (IsVarTerm(t)) {
Yap_Error(INSTANTIATION_ERROR, t, NULL); Yap_Error(INSTANTIATION_ERROR, t, NULL);
return false; return false;
@ -585,25 +599,19 @@ is_boolean( USES_REGS1 )
return t == TermTrue || t == TermFalse; return t == TermTrue || t == TermFalse;
} }
static Int static Int is_atom(USES_REGS1) {
is_atom( USES_REGS1 )
{
Term t = Deref(ARG1); Term t = Deref(ARG1);
//Term Context = Deref(ARG2)Yap_Error(INSTANTIATION_ERROR, t, NULL);; // Term Context = Deref(ARG2)Yap_Error(INSTANTIATION_ERROR, t, NULL);;
if (IsVarTerm(t)) { if (IsVarTerm(t)) {
Yap_Error(INSTANTIATION_ERROR, t, NULL); Yap_Error(INSTANTIATION_ERROR, t, NULL);
return false; return false;
} }
return IsAtomTerm( t ); return IsAtomTerm(t);
} }
static Int is_callable(USES_REGS1) {
static Int
is_callable( USES_REGS1 )
{
Term G = Deref(ARG1); Term G = Deref(ARG1);
//Term Context = Deref(ARG2); // Term Context = Deref(ARG2);
while (true) { while (true) {
if (IsVarTerm(G)) { if (IsVarTerm(G)) {
Yap_Error(INSTANTIATION_ERROR, G, NULL); Yap_Error(INSTANTIATION_ERROR, G, NULL);
@ -615,7 +623,7 @@ is_callable( USES_REGS1 )
Yap_Error(TYPE_ERROR_CALLABLE, G, NULL); Yap_Error(TYPE_ERROR_CALLABLE, G, NULL);
} }
if (f == FunctorModule) { if (f == FunctorModule) {
Term tm = ArgOfTerm( 1, G); Term tm = ArgOfTerm(1, G);
if (IsVarTerm(tm)) { if (IsVarTerm(tm)) {
Yap_Error(INSTANTIATION_ERROR, G, NULL); Yap_Error(INSTANTIATION_ERROR, G, NULL);
return false; return false;
@ -624,7 +632,7 @@ is_callable( USES_REGS1 )
Yap_Error(TYPE_ERROR_CALLABLE, G, NULL); Yap_Error(TYPE_ERROR_CALLABLE, G, NULL);
return false; return false;
} }
G = ArgOfTerm( 2, G ); G = ArgOfTerm(2, G);
} else { } else {
return true; return true;
} }
@ -638,11 +646,9 @@ is_callable( USES_REGS1 )
return false; return false;
} }
static Int static Int is_predicate_indicator(USES_REGS1) {
is_predicate_indicator( USES_REGS1 )
{
Term G = Deref(ARG1); Term G = Deref(ARG1);
//Term Context = Deref(ARG2); // Term Context = Deref(ARG2);
Term mod = CurrentModule; Term mod = CurrentModule;
G = Yap_YapStripModule(G, &mod); G = Yap_YapStripModule(G, &mod);
@ -667,13 +673,85 @@ is_predicate_indicator( USES_REGS1 )
return false; return false;
} }
static Int close_error(USES_REGS1) {
LOCAL_Error_TYPE = YAP_NO_ERROR;
return true;
}
void #undef BEGIN_ERROR_CLASSES
Yap_InitErrorPreds( void ) #undef ECLASS
{ #undef END_ERROR_CLASSES
#undef BEGIN_ERRORS
#undef E0
#undef E
#undef E2
#undef END_ERRORS
#define BEGIN_ERROR_CLASSES() typedef enum aux_class {
#define ECLASS(CL, A, B) CL##__,
#define END_ERROR_CLASSES() \
} \
aux_class_t;
#define BEGIN_ERRORS()
#define E0(X, Y)
#define E(X, Y, Z)
#define E2(X, Y, Z, W)
#define END_ERRORS()
#include <YapErrors.h>
#undef BEGIN_ERROR_CLASSES
#undef ECLASS
#undef END_ERROR_CLASSES
#undef BEGIN_ERRORS
#undef E0
#undef E
#undef E2
#undef END_ERRORS
#define BEGIN_ERROR_CLASSES() static const char *c_error_class_name[] = {
#define ECLASS(CL, A, B) A,
#define END_ERROR_CLASSES() \
NULL \
}
typedef struct c_error_info {
int class;
const char *name;
} c_error_t;
#define BEGIN_ERRORS() static struct c_error_info c_error_list[] = {
#define E0(X, Y) {Y##__, ""},
#define E(X, Y, Z) {Y##__, Z},
#define E2(X, Y, Z, W) {Y##__, Z " " W},
#define END_ERRORS() \
{ YAPC_NO_ERROR, "" } \
} \
;
#include <YapErrors.h>
yap_error_class_number Yap_errorClass(yap_error_number e) {
return c_error_list[e].class;
}
const char *Yap_errorName(yap_error_number e) { return c_error_list[e].name; }
const char *Yap_errorClassName(yap_error_class_number e) {
return c_error_class_name[e];
}
void Yap_InitErrorPreds(void) {
CACHE_REGS CACHE_REGS
Yap_InitCPred("$close_error", 0, close_error, HiddenPredFlag);
Yap_InitCPred("is_boolean", 2, is_boolean, TestPredFlag); Yap_InitCPred("is_boolean", 2, is_boolean, TestPredFlag);
Yap_InitCPred("is_callable", 2, is_callable, TestPredFlag); Yap_InitCPred("is_callable", 2, is_callable, TestPredFlag);
Yap_InitCPred("is_atom", 2, is_atom, TestPredFlag); Yap_InitCPred("is_atom", 2, is_atom, TestPredFlag);
Yap_InitCPred("is_predicate_indicator", 2, is_predicate_indicator, TestPredFlag); Yap_InitCPred("is_predicate_indicator", 2, is_predicate_indicator,
TestPredFlag);
} }

116
C/exec.c
View File

@ -209,6 +209,66 @@ static Int save_env_b(USES_REGS1) {
return true; return true;
} }
/** Look for a predicate with same functor as t,
create a new one of it cannot find it.
*/
static PredEntry *new_pred(Term t, Term tmod, char *pname) {
Term t0 = t;
restart:
if (IsVarTerm(t)) {
Yap_Error(INSTANTIATION_ERROR, t0, pname);
return NULL;
} else if (IsAtomTerm(t)) {
return RepPredProp(PredPropByAtom(AtomOfTerm(t), tmod));
} else if (IsIntegerTerm(t) && tmod == IDB_MODULE) {
return Yap_FindLUIntKey(IntegerOfTerm(t));
} else if (IsApplTerm(t)) {
Functor fun = FunctorOfTerm(t);
if (IsExtensionFunctor(fun)) {
Yap_Error(TYPE_ERROR_CALLABLE, Yap_PredicateIndicator(t, tmod), pname);
return NULL;
}
if (fun == FunctorModule) {
Term tmod = ArgOfTerm(1, t);
if (IsVarTerm(tmod)) {
Yap_Error(INSTANTIATION_ERROR, t0, pname);
return NULL;
}
if (!IsAtomTerm(tmod)) {
Yap_Error(TYPE_ERROR_ATOM, t0, pname);
return NULL;
}
t = ArgOfTerm(2, t);
goto restart;
}
return RepPredProp(PredPropByFunc(fun, tmod));
} else
return NULL;
}
static bool CommaCall(Term t, Term mod) {
PredEntry *pen;
arity_t i;
if (IsVarTerm(t) || (pen = new_pred(t, mod, "_,_")))
return false;
for (i = 0; i < pen->ArityOfPE; i++) {
YENV[-EnvSizeInCells - i] = XREGS[i + 1];
}
YENV[E_CB] = (CELL)B;
YENV[E_CP] = (CELL)P;
YENV[E_E] = (CELL)ENV;
YENV[E_DEPTH] = DEPTH;
ASP = YENV - (EnvSizeInCells + i);
ENV = YENV;
YENV = ASP;
if ((P = pen->MetaEntryOfPred) == NULL) {
P = Yap_InitCommaContinuation(pen);
}
return P == NULL;
}
inline static bool do_execute(Term t, Term mod USES_REGS) { inline static bool do_execute(Term t, Term mod USES_REGS) {
Term t0 = t; Term t0 = t;
t = Yap_YapStripModule(t, &mod); t = Yap_YapStripModule(t, &mod);
@ -220,14 +280,28 @@ inline static bool do_execute(Term t, Term mod USES_REGS) {
} }
if (IsVarTerm(t) || IsVarTerm(mod)) { if (IsVarTerm(t) || IsVarTerm(mod)) {
return CallError(INSTANTIATION_ERROR, t0, mod PASS_REGS); return CallError(INSTANTIATION_ERROR, t0, mod PASS_REGS);
} else if (IsApplTerm(t)) { }
if (IsApplTerm(t)) {
register Functor f = FunctorOfTerm(t); register Functor f = FunctorOfTerm(t);
register CELL *pt; register CELL *pt;
PredEntry *pen; PredEntry *pen;
unsigned int i, arity; unsigned int i, arity;
f = FunctorOfTerm(t); f = FunctorOfTerm(t);
if (IsExtensionFunctor(f)) { if (f == FunctorComma && false) {
Term t2 = ArgOfTerm(2, t);
if (IsVarTerm(t2))
return CallMetaCall(t, mod PASS_REGS);
if (!CommaCall(t2, mod))
return CallMetaCall(t, mod PASS_REGS);
Term t1 = ArgOfTerm(1, t);
t = t1;
pen = new_pred(t, mod, "_,_");
if (pen == NULL || (arity = pen->ArityOfPE) == 0) {
return do_execute(t, mod);
}
} else if (IsExtensionFunctor(f)) {
return CallError(TYPE_ERROR_CALLABLE, t, mod PASS_REGS); return CallError(TYPE_ERROR_CALLABLE, t, mod PASS_REGS);
} }
arity = ArityOfFunctor(f); arity = ArityOfFunctor(f);
@ -237,9 +311,6 @@ inline static bool do_execute(Term t, Term mod USES_REGS) {
pen = RepPredProp(PredPropByFunc(f, mod)); pen = RepPredProp(PredPropByFunc(f, mod));
/* You thought we would be over by now */ /* You thought we would be over by now */
/* but no meta calls require special preprocessing */ /* but no meta calls require special preprocessing */
if (pen->PredFlags & MetaPredFlag) {
return CallMetaCall(t, mod PASS_REGS);
}
/* now let us do what we wanted to do from the beginning !! */ /* now let us do what we wanted to do from the beginning !! */
/* I cannot use the standard macro here because /* I cannot use the standard macro here because
otherwise I would dereference the argument and otherwise I would dereference the argument and
@ -249,7 +320,7 @@ inline static bool do_execute(Term t, Term mod USES_REGS) {
#if YAPOR_SBA #if YAPOR_SBA
Term d0 = *pt++; Term d0 = *pt++;
if (d0 == 0) if (d0 == 0)
` XREGS[i] = (CELL)(pt - 1); XREGS[i] = (CELL)(pt - 1);
else else
XREGS[i] = d0; XREGS[i] = d0;
#else #else
@ -257,8 +328,9 @@ inline static bool do_execute(Term t, Term mod USES_REGS) {
XREGS[i] = *pt++; XREGS[i] = *pt++;
#endif #endif
} }
return (CallPredicate(pen, B, pen->CodeOfPred PASS_REGS)); return CallPredicate(pen, B, pen->CodeOfPred PASS_REGS);
} else if (IsAtomTerm(t)) { }
if (IsAtomTerm(t)) {
PredEntry *pe; PredEntry *pe;
Atom a = AtomOfTerm(t); Atom a = AtomOfTerm(t);
@ -271,12 +343,8 @@ inline static bool do_execute(Term t, Term mod USES_REGS) {
/* call may not define new system predicates!! */ /* call may not define new system predicates!! */
pe = RepPredProp(PredPropByAtom(a, mod)); pe = RepPredProp(PredPropByAtom(a, mod));
return (CallPredicate(pe, B, pe->CodeOfPred PASS_REGS)); return (CallPredicate(pe, B, pe->CodeOfPred PASS_REGS));
} else if (IsIntTerm(t)) {
return CallError(TYPE_ERROR_CALLABLE, t, mod PASS_REGS);
} else {
/* Is Pair Term */
return (CallMetaCall(t, mod PASS_REGS));
} }
return CallMetaCall(t, mod PASS_REGS);
} }
static Term copy_execn_to_heap(Functor f, CELL *pt, unsigned int n, static Term copy_execn_to_heap(Functor f, CELL *pt, unsigned int n,
@ -1133,6 +1201,7 @@ static Int execute0(USES_REGS1) { /* '$execute0'(Goal,Mod) */
if (Yap_has_a_signal() && !LOCAL_InterruptsDisabled) { if (Yap_has_a_signal() && !LOCAL_InterruptsDisabled) {
return EnterCreepMode(t, mod PASS_REGS); return EnterCreepMode(t, mod PASS_REGS);
} }
t = Yap_YapStripModule(t, &mod);
restart_exec: restart_exec:
if (IsVarTerm(t)) { if (IsVarTerm(t)) {
Yap_Error(INSTANTIATION_ERROR, ARG3, "call/1"); Yap_Error(INSTANTIATION_ERROR, ARG3, "call/1");
@ -1407,7 +1476,7 @@ static bool exec_absmi(bool top, yap_reset_t reset_mode USES_REGS) {
return out; return out;
} }
void Yap_PrepGoal(UInt arity, CELL *pt, choiceptr saved_b USES_REGS) { void Yap_PrepGoal(arity_t arity, CELL *pt, choiceptr saved_b USES_REGS) {
/* create an initial pseudo environment so that when garbage /* create an initial pseudo environment so that when garbage
collection is going up in the environment chain it doesn't get collection is going up in the environment chain it doesn't get
confused */ confused */
@ -1526,7 +1595,7 @@ void Yap_fail_all(choiceptr bb USES_REGS) {
P = saved_p; P = saved_p;
} }
bool Yap_execute_pred( PredEntry *ppe, CELL *pt, bool pass_ex USES_REGS) { bool Yap_execute_pred(PredEntry *ppe, CELL *pt, bool pass_ex USES_REGS) {
yamop *saved_p, *saved_cp; yamop *saved_p, *saved_cp;
yamop *CodeAdr; yamop *CodeAdr;
bool out; bool out;
@ -2004,13 +2073,28 @@ static Int jump_env(USES_REGS1) {
if (IsVarTerm(t)) { if (IsVarTerm(t)) {
Yap_Error(INSTANTIATION_ERROR, t, "throw ball must be bound"); Yap_Error(INSTANTIATION_ERROR, t, "throw ball must be bound");
return false; return false;
} else if (IsApplTerm(t) && FunctorOfTerm(t) == FunctorError) {
Term t2;
Yap_find_prolog_culprit(PASS_REGS1);
LOCAL_Error_TYPE = ERROR_EVENT;
t = ArgOfTerm(1, t);
if (IsApplTerm(t) && IsAtomTerm((t2 = ArgOfTerm(1,t)))) {
LOCAL_ActiveError.errorAsText = AtomOfTerm(t2);
LOCAL_ActiveError.classAsText = NameOfFunctor(t);
} else if (IsAtomTerm(t)) {
LOCAL_ActiveError.errorAsText = AtomOfTerm(t);
LOCAL_ActiveError.classAsText = NULL;
} }
} else {
LOCAL_Error_TYPE = THROW_EVENT;
}
LOCAL_ActiveError.prologPredName = NULL;
Yap_PutException(t); Yap_PutException(t);
bool out = JumpToEnv(PASS_REGS1); bool out = JumpToEnv(PASS_REGS1);
if (B != NULL && P == FAILCODE && B->cp_ap == NOCODE && if (B != NULL && P == FAILCODE && B->cp_ap == NOCODE &&
LCL0 - (CELL *)B > LOCAL_CBorder) { LCL0 - (CELL *)B > LOCAL_CBorder) {
// we're failing up to the top layer // we're failing up to the top layer
LOCAL_Error_TYPE = THROW_EVENT;
} }
return out; return out;
} }

2
C/fli_absmi_insts.h
View File

@ -134,7 +134,7 @@
CPredicate f = PREG->y_u.pp.p->cs.f_code; CPredicate f = PREG->y_u.pp.p->cs.f_code;
yamop *oldPREG = PREG; yamop *oldPREG = PREG;
saveregs(); saveregs();
d0 = (f)(PASS_REGS1); d0 = f(PASS_REGS1);
setregs(); setregs();
#ifdef SHADOW_S #ifdef SHADOW_S
SREG = Yap_REGS.S_; SREG = Yap_REGS.S_;

1
C/load_foreign.c
View File

@ -49,7 +49,6 @@ p_load_foreign( USES_REGS1 )
Int returncode = FALSE; Int returncode = FALSE;
yhandle_t CurSlot = Yap_StartSlots(); yhandle_t CurSlot = Yap_StartSlots();
strcpy(LOCAL_ErrorSay,"Invalid arguments");
// Yap_DebugPlWrite(ARG1); printf("%s\n", " \n"); // Yap_DebugPlWrite(ARG1); printf("%s\n", " \n");
//Yap_DebugPlWrite(ARG2); printf("%s\n", " \n"); //Yap_DebugPlWrite(ARG2); printf("%s\n", " \n");
//ap_DebugPlWrite(ARG3); printf("%s\n", " \n"); //ap_DebugPlWrite(ARG3); printf("%s\n", " \n");

2
C/meta_absmi_insts.h
View File

@ -23,7 +23,7 @@
/* original goal */ /* original goal */
d0 = ENV_YREG[-EnvSizeInCells-1]; d0 = ENV_YREG[-EnvSizeInCells-1];
/* predicate we had used */ /* predicate we had used */
pen = RepPredProp((Prop)IntegerOfTerm(ENV_YREG[-EnvSizeInCells-2])); pen = RepPredProp(AddressOfTerm(ENV_YREG[-EnvSizeInCells-2]));
/* current module at the time */ /* current module at the time */
mod = ENV_YREG[-EnvSizeInCells-3]; mod = ENV_YREG[-EnvSizeInCells-3];
/* set YREG */ /* set YREG */

184
C/stack.c
View File

@ -30,10 +30,10 @@
#include "Yap.h" #include "Yap.h"
#include "clause.h" #include "clause.h"
#include "yapio.h"
#include "iopreds.h"
#include "eval.h" #include "eval.h"
#include "iopreds.h"
#include "tracer.h" #include "tracer.h"
#include "yapio.h"
#ifdef YAPOR #ifdef YAPOR
#include "or.macros.h" #include "or.macros.h"
#endif /* YAPOR */ #endif /* YAPOR */
@ -507,8 +507,7 @@ static Int find_code_in_clause(PredEntry *pp, yamop *codeptr, void **startp,
if (cl == NULL) if (cl == NULL)
return 0; return 0;
if (IN_BLOCK(codeptr, cl, cl->ClSize)) { if (IN_BLOCK(codeptr, cl, cl->ClSize)) {
if if (startp)
(startp)
*startp = (CODEADDR)cl; *startp = (CODEADDR)cl;
if (endp) if (endp)
*endp = (CODEADDR)cl + cl->ClSize; *endp = (CODEADDR)cl + cl->ClSize;
@ -528,8 +527,7 @@ static Term clause_loc(void *clcode, PredEntry *pp) {
CACHE_REGS CACHE_REGS
if (pp->PredFlags & LogUpdatePredFlag) { if (pp->PredFlags & LogUpdatePredFlag) {
LogUpdClause *cl = ClauseCodeToLogUpdClause(clcode); LogUpdClause *cl = clcode;
cl = ClauseCodeToLogUpdClause(clcode);
if (cl->ClFlags & FactMask) { if (cl->ClFlags & FactMask) {
return MkIntegerTerm(cl->lusl.ClLine); return MkIntegerTerm(cl->lusl.ClLine);
@ -537,25 +535,25 @@ static Term clause_loc(void *clcode, PredEntry *pp) {
return MkIntegerTerm(cl->lusl.ClSource->ag.line_number); return MkIntegerTerm(cl->lusl.ClSource->ag.line_number);
} }
} else if (pp->PredFlags & DynamicPredFlag) { } else if (pp->PredFlags & DynamicPredFlag) {
DynamicClause *cl; // DynamicClause *cl;
cl = ClauseCodeToDynamicClause(clcode); // cl = ClauseCodeToDynamicClause(clcode);
return TermNil; return MkIntTerm(0);
} else if (pp->PredFlags & MegaClausePredFlag) { } else if (pp->PredFlags & MegaClausePredFlag) {
MegaClause *mcl = ClauseCodeToMegaClause(pp->cs.p_code.FirstClause); MegaClause *mcl = ClauseCodeToMegaClause(pp->cs.p_code.FirstClause);
return MkIntTerm(mcl->ClLine); return MkIntTerm(mcl->ClLine);
} else { } else {
StaticClause *cl; StaticClause *cl;
cl = ClauseCodeToStaticClause(clcode); cl = clcode;
if (cl->ClFlags & FactMask) { if (cl->ClFlags & FactMask) {
return MkIntTerm(cl->usc.ClLine); return MkIntTerm(cl->usc.ClLine);
} else if (cl->ClFlags & SrcMask) { } else if (cl->ClFlags & SrcMask) {
return MkIntTerm(cl->usc.ClSource->ag.line_number); return MkIntTerm(cl->usc.ClSource->ag.line_number);
} else } else
return TermNil; return MkIntTerm(0);
} }
return TermNil; return MkIntTerm(0);
} }
static int cl_code_in_pred(PredEntry *pp, yamop *codeptr, void **startp, static int cl_code_in_pred(PredEntry *pp, yamop *codeptr, void **startp,
@ -1007,10 +1005,9 @@ static Term all_cps(choiceptr b_ptr USES_REGS) {
bp[1] = AbsPair(HR); bp[1] = AbsPair(HR);
} }
b_ptr = b_ptr->cp_b; b_ptr = b_ptr->cp_b;
if (!IsVarTerm((CELL)b_ptr) || if (!IsVarTerm((CELL)b_ptr) || (CELL *)b_ptr < HR || (CELL *)b_ptr > LCL0) {
(CELL*)b_ptr < HR || // Yap_Error(SYSTEM_ERROR_INTERNAL, TermNil, "choice-point chain
(CELL*)b_ptr > LCL0) { // corrupted at %p!!!\n", b_ptr);
//Yap_Error(SYSTEM_ERROR_INTERNAL, TermNil, "choice-point chain corrupted at %p!!!\n", b_ptr);
break; break;
} }
} }
@ -1040,7 +1037,7 @@ static Int p_all_envs(USES_REGS1) {
return Yap_unify(ARG1, t); return Yap_unify(ARG1, t);
} }
Term clause_info(yamop *codeptr, PredEntry *pp) { static Term clause_info(yamop *codeptr, PredEntry *pp) {
CACHE_REGS CACHE_REGS
Term ts[2]; Term ts[2];
void *begin; void *begin;
@ -1055,24 +1052,72 @@ Term clause_info(yamop *codeptr, PredEntry *pp) {
ts[0] = MkAtomTerm(pp->src.OwnerFile); ts[0] = MkAtomTerm(pp->src.OwnerFile);
Term t1 = Yap_MkApplTerm(FunctorModule, 2, ts); Term t1 = Yap_MkApplTerm(FunctorModule, 2, ts);
if (find_code_in_clause(pp, codeptr, &begin, NULL) <= 0 || if ((find_code_in_clause(pp, codeptr, &begin, NULL)) <= 0) {
((ts[0] = clause_loc(begin, pp) == TermNil))) {
ts[0] = clause_loc(pp->cs.p_code.FirstClause, pp); ts[0] = clause_loc(pp->cs.p_code.FirstClause, pp);
ts[1] = clause_loc(pp->cs.p_code.LastClause, pp); ts[1] = clause_loc(pp->cs.p_code.LastClause, pp);
if (ts[0] == ts[1] && ts[1] != TermNil) { if (ts[0] == ts[1] && ts[1] != TermNil) {
} else if (ts[1] == TermNil && ts[0] != TermNil) } else if (ts[1] == TermNil && ts[0] != MkIntTerm(0))
ts[0] = Yap_MkApplTerm(FunctorMinus, 2, ts); ts[0] = Yap_MkApplTerm(FunctorMinus, 2, ts);
} }
ts[1] = t1; ts[1] = t1;
return Yap_MkApplTerm(FunctorModule, 2, ts); return Yap_MkApplTerm(FunctorModule, 2, ts);
} }
bool set_clause_info(yamop *codeptr, PredEntry *pp) {
CACHE_REGS
Term ts[2];
void *begin;
if (pp->ArityOfPE == 0) {
LOCAL_ActiveError.prologPredName = (Atom)pp->FunctorOfPred;
LOCAL_ActiveError.prologPredArity = 0;
} else {
LOCAL_ActiveError.prologPredName = NameOfFunctor(pp->FunctorOfPred);
LOCAL_ActiveError.prologPredArity = pp->ArityOfPE;
}
LOCAL_ActiveError.prologPredModule =
(pp->ModuleOfPred ? pp->ModuleOfPred : TermProlog);
LOCAL_ActiveError.prologPredFile = pp->src.OwnerFile;
if (codeptr->opc == UNDEF_OPCODE) {
LOCAL_ActiveError.prologPredFirstLine = 0;
LOCAL_ActiveError.prologPredLine = 0;
LOCAL_ActiveError.prologPredLastLine = 0;
return true;
} else if (pp->cs.p_code.NOfClauses) {
if ((LOCAL_ActiveError.prologPredCl =
find_code_in_clause(pp, codeptr, &begin, NULL)) <= 0) {
LOCAL_ActiveError.prologPredLine = 0;
} else {
LOCAL_ActiveError.prologPredLine = IntegerOfTerm(clause_loc(begin, pp));
}
if (pp->PredFlags & LogUpdatePredFlag) {
LOCAL_ActiveError.prologPredFirstLine = IntegerOfTerm(
ts[0] = clause_loc(
ClauseCodeToLogUpdClause(pp->cs.p_code.FirstClause), pp));
LOCAL_ActiveError.prologPredLastLine = IntegerOfTerm(
ts[1] = clause_loc(ClauseCodeToLogUpdClause(pp->cs.p_code.LastClause),
pp));
} else {
LOCAL_ActiveError.prologPredFirstLine = IntegerOfTerm(
ts[0] = clause_loc(
ClauseCodeToStaticClause(pp->cs.p_code.FirstClause), pp));
LOCAL_ActiveError.prologPredLastLine = IntegerOfTerm(
ts[1] = clause_loc(ClauseCodeToStaticClause(pp->cs.p_code.LastClause),
pp));
}
return true;
} else {
return false;
}
}
static Term error_culprit(bool internal USES_REGS) { static Term error_culprit(bool internal USES_REGS) {
PredEntry *pe; PredEntry *pe;
// case number 1: Yap_Error called from built-in. // case number 1: Yap_Error called from built-in.
void *startp, *endp;
// case number 1: Yap_Error called from built-in.
pe = ClauseInfoForCode(P, &startp, &endp PASS_REGS);
if (internal) { if (internal) {
pe = EnvPreg(CP);
if (pe->PredFlags & HiddenPredFlag)
return clause_info(P, pe); return clause_info(P, pe);
} else { } else {
CELL *curENV = ENV; CELL *curENV = ENV;
@ -1081,7 +1126,7 @@ static Term error_culprit(bool internal USES_REGS) {
while (curCP != YESCODE) { while (curCP != YESCODE) {
if (pe->ModuleOfPred) if (pe->ModuleOfPred)
return clause_info(P, pe); return clause_info(curCP, pe);
curENV = (CELL *)(curENV[E_E]); curENV = (CELL *)(curENV[E_E]);
curCP = (yamop *)(curENV[E_CP]); curCP = (yamop *)(curENV[E_CP]);
pe = EnvPreg(curCP); pe = EnvPreg(curCP);
@ -1090,6 +1135,31 @@ static Term error_culprit(bool internal USES_REGS) {
return TermNil; return TermNil;
} }
bool Yap_find_prolog_culprit(USES_REGS1) {
PredEntry *pe;
void *startp, *endp;
// case number 1: Yap_Error called from built-in.
pe = ClauseInfoForCode(P, &startp, &endp PASS_REGS);
if (pe && (CurrentModule == 0 || !(pe->PredFlags & HiddenPredFlag))) {
return set_clause_info(P, pe);
} else {
CELL *curENV = ENV;
yamop *curCP = CP;
PredEntry *pe = EnvPreg(curCP);
while (curCP != YESCODE) {
curENV = (CELL *)(curENV[E_E]);
if (curENV == NULL)
break;
pe = EnvPreg(curCP);
if (pe->ModuleOfPred)
return set_clause_info(curCP, pe);
curCP = (yamop *)(curENV[E_CP]);
}
}
return TermNil;
}
static Term all_calls(bool internal USES_REGS) { static Term all_calls(bool internal USES_REGS) {
Term ts[6]; Term ts[6];
Functor f = Yap_MkFunctor(AtomLocalSp, 6); Functor f = Yap_MkFunctor(AtomLocalSp, 6);
@ -1671,8 +1741,7 @@ void Yap_dump_stack(void) {
} }
#endif #endif
#endif #endif
Yap_detect_bug_location(P, FIND_PRED_FROM_ANYWHERE Yap_detect_bug_location(P, FIND_PRED_FROM_ANYWHERE, 256);
, 256);
fprintf(stderr, "%%\n%% PC: %s\n", (char *)HR); fprintf(stderr, "%%\n%% PC: %s\n", (char *)HR);
Yap_detect_bug_location(CP, FIND_PRED_FROM_ANYWHERE, 256); Yap_detect_bug_location(CP, FIND_PRED_FROM_ANYWHERE, 256);
fprintf(stderr, "%% Continuation: %s\n", (char *)HR); fprintf(stderr, "%% Continuation: %s\n", (char *)HR);
@ -1777,8 +1846,9 @@ void DumpActiveGoals(USES_REGS1) {
if (mod == PROLOG_MODULE) if (mod == PROLOG_MODULE)
mod = TermProlog; mod = TermProlog;
Term t = Yap_MkNewApplTerm(f, pe->ArityOfPE); Term t = Yap_MkNewApplTerm(f, pe->ArityOfPE);
Yap_plwrite(Yap_PredicateIndicator(t,mod),GLOBAL_Stream+2, 0, 0, GLOBAL_MaxPriority); Yap_plwrite(Yap_PredicateIndicator(t, mod), GLOBAL_Stream + 2, 0, 0,
fputc( '\n', stderr ); GLOBAL_MaxPriority);
fputc('\n', stderr);
} else { } else {
UNLOCK(pe->PELock); UNLOCK(pe->PELock);
} }
@ -1806,67 +1876,72 @@ void DumpActiveGoals(USES_REGS1) {
else else
mod = TermProlog; mod = TermProlog;
if (mod != TermProlog && mod != MkAtomTerm(AtomUser)) { if (mod != TermProlog && mod != MkAtomTerm(AtomUser)) {
Yap_plwrite(mod,GLOBAL_Stream+2, 0, 0, GLOBAL_MaxPriority); Yap_plwrite(mod, GLOBAL_Stream + 2, 0, 0, GLOBAL_MaxPriority);
fputc( ':', stderr ); fputc(':', stderr);
} }
if (mod == IDB_MODULE) { if (mod == IDB_MODULE) {
if (pe->PredFlags & NumberDBPredFlag) { if (pe->PredFlags & NumberDBPredFlag) {
Int id = pe->src.IndxId; Int id = pe->src.IndxId;
Yap_plwrite(MkIntegerTerm(id),GLOBAL_Stream+2, 0, 0, GLOBAL_MaxPriority); Yap_plwrite(MkIntegerTerm(id), GLOBAL_Stream + 2, 0, 0,
GLOBAL_MaxPriority);
} else if (pe->PredFlags & AtomDBPredFlag) { } else if (pe->PredFlags & AtomDBPredFlag) {
Atom At = (Atom)pe->FunctorOfPred; Atom At = (Atom)pe->FunctorOfPred;
Yap_plwrite(MkAtomTerm(At),GLOBAL_Stream+2, 0, 0, GLOBAL_MaxPriority); Yap_plwrite(MkAtomTerm(At), GLOBAL_Stream + 2, 0, 0,
GLOBAL_MaxPriority);
} else { } else {
Functor f = pe->FunctorOfPred; Functor f = pe->FunctorOfPred;
Atom At = NameOfFunctor(f); Atom At = NameOfFunctor(f);
arity_t arity = ArityOfFunctor(f); arity_t arity = ArityOfFunctor(f);
int i; int i;
Yap_plwrite(MkAtomTerm(At),GLOBAL_Stream+2, 0, 0, GLOBAL_MaxPriority); Yap_plwrite(MkAtomTerm(At), GLOBAL_Stream + 2, 0, 0,
fputc( '(', stderr ); GLOBAL_MaxPriority);
fputc('(', stderr);
for (i = 0; i < arity; i++) { for (i = 0; i < arity; i++) {
if (i > 0) if (i > 0)
fputc( ',', stderr ); fputc(',', stderr);
fputc( '_', stderr ); fputc('_', stderr);
} }
fputc( ')', stderr ); fputc(')', stderr);
} }
fputc( '(', stderr ); fputc('(', stderr);
Yap_plwrite(b_ptr->cp_a2,GLOBAL_Stream+2, 0, 0, GLOBAL_MaxPriority); Yap_plwrite(b_ptr->cp_a2, GLOBAL_Stream + 2, 0, 0, GLOBAL_MaxPriority);
fputc( ')', stderr ); fputc(')', stderr);
} else if (pe->ArityOfPE == 0) { } else if (pe->ArityOfPE == 0) {
Yap_plwrite(MkAtomTerm((Atom)f),GLOBAL_Stream+2, 0, 0, GLOBAL_MaxPriority); Yap_plwrite(MkAtomTerm((Atom)f), GLOBAL_Stream + 2, 0, 0,
GLOBAL_MaxPriority);
} else { } else {
Int i = 0, arity = pe->ArityOfPE; Int i = 0, arity = pe->ArityOfPE;
if (opnum == _or_last || opnum == _or_else) { if (opnum == _or_last || opnum == _or_else) {
Yap_plwrite(MkAtomTerm(NameOfFunctor(f)),GLOBAL_Stream+2, 0, 0, GLOBAL_MaxPriority); Yap_plwrite(MkAtomTerm(NameOfFunctor(f)), GLOBAL_Stream + 2, 0, 0,
fputc( '(', stderr ); GLOBAL_MaxPriority);
fputc('(', stderr);
for (i = 0; i < arity; i++) { for (i = 0; i < arity; i++) {
if (i > 0) if (i > 0)
fputc( ',', stderr ); fputc(',', stderr);
fputc( '_', stderr ); fputc('_', stderr);
} }
fputs(") :- ... ( _ ; _ ", stderr); fputs(") :- ... ( _ ; _ ", stderr);
} else { } else {
Term *args = &(b_ptr->cp_a1); Term *args = &(b_ptr->cp_a1);
Yap_plwrite(MkAtomTerm(NameOfFunctor(f)),GLOBAL_Stream+2, 0, 0, GLOBAL_MaxPriority); Yap_plwrite(MkAtomTerm(NameOfFunctor(f)), GLOBAL_Stream + 2, 0, 0,
fputc( '(', stderr ); GLOBAL_MaxPriority);
fputc('(', stderr);
for (i = 0; i < arity; i++) { for (i = 0; i < arity; i++) {
if (i > 0) if (i > 0)
fputc( ',', stderr ); fputc(',', stderr);
Yap_plwrite(args[i],GLOBAL_Stream+2, 0, 0, GLOBAL_MaxPriority); Yap_plwrite(args[i], GLOBAL_Stream + 2, 0, 0, GLOBAL_MaxPriority);
} }
} }
fputc( ')', stderr ); fputc(')', stderr);
} }
fputc( '\n', stderr ); fputc('\n', stderr);
} }
b_ptr = b_ptr->cp_b; b_ptr = b_ptr->cp_b;
} }
} }
void Yap_detect_bug_location(yamop *yap_pc, int where_from, void Yap_detect_bug_location(yamop *yap_pc, int where_from, int psize) {
int psize) {
Atom pred_name; Atom pred_name;
UInt pred_arity; UInt pred_arity;
Term pred_module; Term pred_module;
@ -1874,7 +1949,7 @@ void Yap_detect_bug_location(yamop *yap_pc, int where_from,
if ((cl = Yap_PredForCode(yap_pc, where_from, &pred_name, &pred_arity, if ((cl = Yap_PredForCode(yap_pc, where_from, &pred_name, &pred_arity,
&pred_module)) == 0) { &pred_module)) == 0) {
/* system predicate */ /* system predicate */
fprintf(stderr, "%s", "meta-call"); fprintf(stderr, "%s", "meta-call");
} else if (pred_module == 0) { } else if (pred_module == 0) {
fprintf(stderr, "in prolog:%s/%lu", RepAtom(pred_name)->StrOfAE, fprintf(stderr, "in prolog:%s/%lu", RepAtom(pred_name)->StrOfAE,
@ -1975,8 +2050,7 @@ Term Yap_env_location(yamop *cp, choiceptr b_ptr, CELL *env, Int ignore_first) {
return TermNil; return TermNil;
if (ignore_first <= 0 && pe if (ignore_first <= 0 && pe
// pe->ModuleOfPred != PROLOG_MODULE &&s // pe->ModuleOfPred != PROLOG_MODULE &&s
&& && !(pe->PredFlags & HiddenPredFlag)) {
!(pe->PredFlags & HiddenPredFlag)) {
return build_bug_location(cp, pe); return build_bug_location(cp, pe);
} else { } else {
if (NULL && b_ptr && b_ptr->cp_env < env) { if (NULL && b_ptr && b_ptr->cp_env < env) {

186
C/text.c
View File

@ -39,23 +39,26 @@ void *buf__, *cur__;
#define init_alloc(I) \ #define init_alloc(I) \
void *ov__ = TR, *ocur__ = LOCAL_ScannerStack; \ void *ov__ = TR, *ocur__ = LOCAL_ScannerStack; \
if (!LOCAL_ScannerStack) LOCAL_ScannerStack = (char *)TR if (!LOCAL_ScannerStack) \
LOCAL_ScannerStack = (char *)TR
#define mark_stack() \ #define mark_stack() \
void *otr__ = TR; void * ost__ = LOCAL_ScannerStack; TR =(tr_fr_ptr)LOCAL_ScannerStack void *otr__ = TR; \
void *ost__ = LOCAL_ScannerStack; \
TR = (tr_fr_ptr)LOCAL_ScannerStack
#define restore_stack() \ #define restore_stack() \
TR = otr__; LOCAL_ScannerStack = ost__ TR = otr__; \
LOCAL_ScannerStack = ost__
#define export_buf(s) {} #define export_buf(s) \
{}
#define unprotect_stack(s) \
TR = ov__, LOCAL_ScannerStack = ocur__
//LOCAL_ScannerStack = ov__, TR = ot__
#define unprotect_stack(s) TR = ov__, LOCAL_ScannerStack = ocur__
// LOCAL_ScannerStack = ov__, TR = ot__
static bool alloc_ovfl(size_t sz) { static bool alloc_ovfl(size_t sz) {
return (char *) +(sz + 4096) > (char *) LOCAL_TrailTop; return (char *)+(sz + 4096) > (char *)LOCAL_TrailTop;
} }
static void *Malloc(size_t sz USES_REGS) { static void *Malloc(size_t sz USES_REGS) {
@ -63,13 +66,13 @@ static void *Malloc(size_t sz USES_REGS) {
if (alloc_ovfl(sz)) if (alloc_ovfl(sz))
return NULL; return NULL;
void *o = LOCAL_ScannerStack; void *o = LOCAL_ScannerStack;
LOCAL_ScannerStack = (void *) ((char *) LOCAL_ScannerStack + sz); LOCAL_ScannerStack = (void *)((char *)LOCAL_ScannerStack + sz);
return o; return o;
} }
static size_t MaxTmp(USES_REGS1) { static size_t MaxTmp(USES_REGS1) {
if (LOCAL_ScannerStack) { if (LOCAL_ScannerStack) {
return (char *) LOCAL_TrailTop - (char *) LOCAL_ScannerStack; return (char *)LOCAL_TrailTop - (char *)LOCAL_ScannerStack;
} }
return 0; return 0;
} }
@ -194,8 +197,7 @@ static Int SkipListCodes(unsigned char **bufp, Term *l, Term **tailp,
return length; return length;
} }
static unsigned char *latin2utf8(seq_tv_t *inp, size_t static unsigned char *latin2utf8(seq_tv_t *inp, size_t *lengp) {
*lengp) {
unsigned char *b0 = inp->val.uc; unsigned char *b0 = inp->val.uc;
size_t sz = *lengp = strlen(inp->val.c); size_t sz = *lengp = strlen(inp->val.c);
sz *= 2; sz *= 2;
@ -214,7 +216,6 @@ static unsigned char *latin2utf8(seq_tv_t *inp, size_t
return buf; return buf;
} }
static unsigned char *wchar2utf8(seq_tv_t *inp, size_t *lengp) { static unsigned char *wchar2utf8(seq_tv_t *inp, size_t *lengp) {
*lengp = wcslen(inp->val.w); *lengp = wcslen(inp->val.w);
size_t sz = *lengp * 4; size_t sz = *lengp * 4;
@ -306,15 +307,12 @@ unsigned char *Yap_readText(seq_tv_t *inp, size_t *lengp) {
if (!(inp->type & YAP_STRING_TERM)) { if (!(inp->type & YAP_STRING_TERM)) {
if (IsVarTerm(inp->val.t)) { if (IsVarTerm(inp->val.t)) {
LOCAL_Error_TYPE = INSTANTIATION_ERROR; LOCAL_Error_TYPE = INSTANTIATION_ERROR;
} else if (!IsAtomTerm(inp->val.t) && } else if (!IsAtomTerm(inp->val.t) && inp->type == YAP_STRING_ATOM) {
inp->type == YAP_STRING_ATOM) {
LOCAL_Error_TYPE = TYPE_ERROR_ATOM; LOCAL_Error_TYPE = TYPE_ERROR_ATOM;
} else if (!IsStringTerm(inp->val.t) && } else if (!IsStringTerm(inp->val.t) && inp->type == YAP_STRING_STRING) {
inp->type == YAP_STRING_STRING) {
LOCAL_Error_TYPE = TYPE_ERROR_STRING; LOCAL_Error_TYPE = TYPE_ERROR_STRING;
} else if (!IsPairOrNilTerm(inp->val.t) && !IsStringTerm(inp->val.t) && } else if (!IsPairOrNilTerm(inp->val.t) && !IsStringTerm(inp->val.t) &&
inp->type == inp->type == (YAP_STRING_ATOMS_CODES | YAP_STRING_STRING)) {
(YAP_STRING_ATOMS_CODES | YAP_STRING_STRING)) {
LOCAL_Error_TYPE = TYPE_ERROR_LIST; LOCAL_Error_TYPE = TYPE_ERROR_LIST;
} else if (!IsNumTerm(inp->val.t) && } else if (!IsNumTerm(inp->val.t) &&
(inp->type & (YAP_STRING_INT | YAP_STRING_FLOAT | (inp->type & (YAP_STRING_INT | YAP_STRING_FLOAT |
@ -329,7 +327,7 @@ unsigned char *Yap_readText(seq_tv_t *inp, size_t *lengp) {
if (IsAtomTerm(inp->val.t) && inp->type & YAP_STRING_ATOM) { if (IsAtomTerm(inp->val.t) && inp->type & YAP_STRING_ATOM) {
// this is a term, extract to a buffer, and representation is wide // this is a term, extract to a buffer, and representation is wide
//Yap_DebugPlWriteln(inp->val.t); // Yap_DebugPlWriteln(inp->val.t);
Atom at = AtomOfTerm(inp->val.t); Atom at = AtomOfTerm(inp->val.t);
if (IsWideAtom(at)) { if (IsWideAtom(at)) {
inp->val.w = at->WStrOfAE; inp->val.w = at->WStrOfAE;
@ -341,35 +339,35 @@ unsigned char *Yap_readText(seq_tv_t *inp, size_t *lengp) {
} }
if (IsStringTerm(inp->val.t) && inp->type & YAP_STRING_STRING) { if (IsStringTerm(inp->val.t) && inp->type & YAP_STRING_STRING) {
// this is a term, extract to a buffer, and representation is wide // this is a term, extract to a buffer, and representation is wide
//Yap_DebugPlWriteln(inp->val.t); // Yap_DebugPlWriteln(inp->val.t);
return UStringOfTerm(inp->val.t); return (unsigned char *)UStringOfTerm(inp->val.t);
} }
if (((inp->type & (YAP_STRING_CODES | YAP_STRING_ATOMS)) == if (((inp->type & (YAP_STRING_CODES | YAP_STRING_ATOMS)) ==
(YAP_STRING_CODES | YAP_STRING_ATOMS)) && IsPairOrNilTerm(inp->val.t)) { (YAP_STRING_CODES | YAP_STRING_ATOMS)) &&
//Yap_DebugPlWriteln(inp->val.t); IsPairOrNilTerm(inp->val.t)) {
// Yap_DebugPlWriteln(inp->val.t);
return inp->val.uc = return inp->val.uc =
Yap_ListToBuffer(s0, inp->val.t, inp, &wide, lengp Yap_ListToBuffer(s0, inp->val.t, inp, &wide, lengp PASS_REGS);
PASS_REGS);
// this is a term, extract to a sfer, and representation is wide // this is a term, extract to a sfer, and representation is wide
} }
if (inp->type & YAP_STRING_CODES && IsPairOrNilTerm(inp->val.t)) { if (inp->type & YAP_STRING_CODES && IsPairOrNilTerm(inp->val.t)) {
//Yap_DebugPlWriteln(inp->val.t); // Yap_DebugPlWriteln(inp->val.t);
return inp->val.uc = Yap_ListOfCodesToBuffer(s0, inp->val.t, inp, &wide, return inp->val.uc = Yap_ListOfCodesToBuffer(s0, inp->val.t, inp, &wide,
lengp PASS_REGS); lengp PASS_REGS);
// this is a term, extract to a sfer, and representation is wide // this is a term, extract to a sfer, and representation is wide
} }
if (inp->type & YAP_STRING_ATOMS && IsPairOrNilTerm(inp->val.t)) { if (inp->type & YAP_STRING_ATOMS && IsPairOrNilTerm(inp->val.t)) {
//Yap_DebugPlWriteln(inp->val.t); // Yap_DebugPlWriteln(inp->val.t);
return inp->val.uc = Yap_ListOfAtomsToBuffer(s0, inp->val.t, inp, &wide, return inp->val.uc = Yap_ListOfAtomsToBuffer(s0, inp->val.t, inp, &wide,
lengp PASS_REGS); lengp PASS_REGS);
// this is a term, extract to a buffer, and representation is wide // this is a term, extract to a buffer, and representation is wide
} }
if (inp->type & YAP_STRING_INT && IsIntegerTerm(inp->val.t)) { if (inp->type & YAP_STRING_INT && IsIntegerTerm(inp->val.t)) {
// ASCII, so both LATIN1 and UTF-8 // ASCII, so both LATIN1 and UTF-8
//Yap_DebugPlWriteln(inp->val.t); // Yap_DebugPlWriteln(inp->val.t);
char *s; char *s;
if (s0) if (s0)
s = (char *) s0; s = (char *)s0;
else else
s = Malloc(0); s = Malloc(0);
AUX_ERROR(inp->val.t, MaxTmp(PASS_REGS1), s, char); AUX_ERROR(inp->val.t, MaxTmp(PASS_REGS1), s, char);
@ -379,13 +377,13 @@ unsigned char *Yap_readText(seq_tv_t *inp, size_t *lengp) {
} }
*lengp = strlen(s); *lengp = strlen(s);
Malloc(*lengp); Malloc(*lengp);
return inp->val.uc = (unsigned char *) s; return inp->val.uc = (unsigned char *)s;
} }
if (inp->type & YAP_STRING_FLOAT && IsFloatTerm(inp->val.t)) { if (inp->type & YAP_STRING_FLOAT && IsFloatTerm(inp->val.t)) {
char *s; char *s;
//Yap_DebugPlWriteln(inp->val.t); // Yap_DebugPlWriteln(inp->val.t);
if (s0) if (s0)
s = (char *) s0; s = (char *)s0;
else else
s = Malloc(0); s = Malloc(0);
AUX_ERROR(inp->val.t, MaxTmp(PASS_REGS1), s, char); AUX_ERROR(inp->val.t, MaxTmp(PASS_REGS1), s, char);
@ -394,32 +392,31 @@ unsigned char *Yap_readText(seq_tv_t *inp, size_t *lengp) {
} }
*lengp = strlen(s); *lengp = strlen(s);
Malloc(*lengp); Malloc(*lengp);
return inp->val.uc = (unsigned char *) s; return inp->val.uc = (unsigned char *)s;
} }
#if USE_GMP #if USE_GMP
if (inp->type & YAP_STRING_BIG && IsBigIntTerm(inp->val.t)) { if (inp->type & YAP_STRING_BIG && IsBigIntTerm(inp->val.t)) {
//Yap_DebugPlWriteln(inp->val.t); // Yap_DebugPlWriteln(inp->val.t);
char *s; char *s;
if (s0) if (s0)
s = 0; s = 0;
else else
s = Malloc(0); s = Malloc(0);
if (!Yap_mpz_to_string(Yap_BigIntOfTerm(inp->val.t), s, MaxTmp() - 1, if (!Yap_mpz_to_string(Yap_BigIntOfTerm(inp->val.t), s, MaxTmp() - 1, 10)) {
10)) {
AUX_ERROR(inp->val.t, MaxTmp(PASS_REGS1), s, char); AUX_ERROR(inp->val.t, MaxTmp(PASS_REGS1), s, char);
} }
*lengp = strlen(s); *lengp = strlen(s);
Malloc(*lengp); Malloc(*lengp);
return inp->val.uc = (unsigned char *) s; return inp->val.uc = (unsigned char *)s;
} }
#endif #endif
if (inp->type & YAP_STRING_TERM) { if (inp->type & YAP_STRING_TERM) {
//Yap_DebugPlWriteln(inp->val.t); // Yap_DebugPlWriteln(inp->val.t);
char *s = (char *) Yap_TermToString(inp->val.t, lengp, ENC_ISO_UTF8, 0); char *s = (char *)Yap_TermToString(inp->val.t, lengp, ENC_ISO_UTF8, 0);
return inp->val.uc = (unsigned char *) s; return inp->val.uc = (unsigned char *)s;
} }
if (inp->type & YAP_STRING_CHARS) { if (inp->type & YAP_STRING_CHARS) {
//printf("%s\n",inp->val.c); // printf("%s\n",inp->val.c);
if (inp->enc == ENC_ISO_UTF8) { if (inp->enc == ENC_ISO_UTF8) {
if (lengp) if (lengp)
*lengp = strlen_utf8(inp->val.uc); *lengp = strlen_utf8(inp->val.uc);
@ -433,7 +430,7 @@ unsigned char *Yap_readText(seq_tv_t *inp, size_t *lengp) {
} }
} }
if (inp->type & YAP_STRING_WCHARS) { if (inp->type & YAP_STRING_WCHARS) {
//printf("%S\n",inp->val.w); // printf("%S\n",inp->val.w);
return wchar2utf8(inp, lengp); return wchar2utf8(inp, lengp);
} }
return NULL; return NULL;
@ -460,14 +457,15 @@ static Term write_strings(unsigned char *s0, seq_tv_t *out,
utf8proc_int32_t chr; utf8proc_int32_t chr;
int off; int off;
off = get_utf8(cp, -1, &chr); off = get_utf8(cp, -1, &chr);
if (off > 0) cp += off; if (off > 0)
cp += off;
else { else {
//Yap_Error(TYPE_ERROR_TEXT, t, NULL); // Yap_Error(TYPE_ERROR_TEXT, t, NULL);
cp++; cp++;
} }
off = put_utf8(buf, chr); off = put_utf8(buf, chr);
if (off > 0) buf += off; if (off > 0)
buf += off;
} }
if (max >= min) if (max >= min)
*buf++ = '\0'; *buf++ = '\0';
@ -496,7 +494,7 @@ static Term write_atoms(void *s0, seq_tv_t *out, size_t leng USES_REGS) {
max = out->max; max = out->max;
} }
unsigned char *s = s0, *lim = s + strnlen((char *) s, max); unsigned char *s = s0, *lim = s + strnlen((char *)s, max);
unsigned char *cp = s; unsigned char *cp = s;
wchar_t w[2]; wchar_t w[2];
w[1] = '\0'; w[1] = '\0';
@ -544,7 +542,7 @@ static Term write_codes(void *s0, seq_tv_t *out, size_t leng USES_REGS) {
max = out->max; max = out->max;
} }
unsigned char *s = s0, *lim = s + strlen((char *) s); unsigned char *s = s0, *lim = s + strlen((char *)s);
unsigned char *cp = s; unsigned char *cp = s;
wchar_t w[2]; wchar_t w[2];
w[1] = '\0'; w[1] = '\0';
@ -582,9 +580,10 @@ static Atom write_atom(void *s0, seq_tv_t *out, size_t leng USES_REGS) {
{ {
unsigned char *s = s0; unsigned char *s = s0;
utf8proc_int32_t chr; utf8proc_int32_t chr;
while (*s && get_utf8(s, -1, &chr) == 1) s++; while (*s && get_utf8(s, -1, &chr) == 1)
s++;
if (*s == '\0') if (*s == '\0')
return out->val.a = Yap_LookupAtom((char *) s0); return out->val.a = Yap_LookupAtom((char *)s0);
s = s0; s = s0;
size_t l = strlen(s0); size_t l = strlen(s0);
wchar_t *wbuf = Malloc(sizeof(wchar_t) * ((l + 1))), *wptr = wbuf; wchar_t *wbuf = Malloc(sizeof(wchar_t) * ((l + 1))), *wptr = wbuf;
@ -612,15 +611,15 @@ static Atom write_atom(void *s0, seq_tv_t *out, size_t leng USES_REGS) {
size_t write_buffer(unsigned char *s0, seq_tv_t *out, size_t leng USES_REGS) { size_t write_buffer(unsigned char *s0, seq_tv_t *out, size_t leng USES_REGS) {
size_t min = 0, max = leng, room_end; size_t min = 0, max = leng, room_end;
if (out->enc == ENC_ISO_UTF8) { if (out->enc == ENC_ISO_UTF8) {
room_end = strlen((char *) s0) + 1; room_end = strlen((char *)s0) + 1;
if (out->val.uc == NULL) { if (out->val.uc == NULL) {
out->val.uc = malloc(room_end); out->val.uc = malloc(room_end < 16 ? 16 : room_end);
} }
if (out->val.uc != s0) { if (out->val.uc != s0) {
strcpy(out->val.c, (char *) s0); strcpy(out->val.c, (char *)s0);
} }
} else if (out->enc == ENC_ISO_LATIN1) { } else if (out->enc == ENC_ISO_LATIN1) {
room_end = strlen((char *) s0) + 1; room_end = strlen((char *)s0) + 1;
unsigned char *s = s0; unsigned char *s = s0;
unsigned char *cp = s; unsigned char *cp = s;
unsigned char *buf = out->val.uc; unsigned char *buf = out->val.uc;
@ -647,7 +646,7 @@ size_t write_buffer(unsigned char *s0, seq_tv_t *out, size_t leng USES_REGS) {
} }
room_end = buf - out->val.uc; room_end = buf - out->val.uc;
} else if (out->enc == ENC_WCHAR) { } else if (out->enc == ENC_WCHAR) {
unsigned char *s = s0, *lim = s + (max = strnlen((char *) s0, max)); unsigned char *s = s0, *lim = s + (max = strnlen((char *)s0, max));
unsigned char *cp = s; unsigned char *cp = s;
wchar_t *buf0, *buf; wchar_t *buf0, *buf;
@ -682,11 +681,10 @@ static size_t write_length(const unsigned char *s0, seq_tv_t *out,
return leng; return leng;
} }
static Term write_number(unsigned char *s, seq_tv_t *out, int size static Term write_number(unsigned char *s, seq_tv_t *out, int size USES_REGS) {
USES_REGS) {
Term t; Term t;
mark_stack(); mark_stack();
t = Yap_StringToNumberTerm((char *) s, &out->enc); t = Yap_StringToNumberTerm((char *)s, &out->enc);
restore_stack(); restore_stack();
return t; return t;
} }
@ -695,8 +693,7 @@ static Term string_to_term(void *s, seq_tv_t *out, size_t leng USES_REGS) {
Term o; Term o;
mark_stack(); mark_stack();
o = out->val.t = o = out->val.t =
Yap_StringToTerm(s, strlen(s) + 1, &out->enc, Yap_StringToTerm(s, strlen(s) + 1, &out->enc, GLOBAL_MaxPriority, NULL);
GLOBAL_MaxPriority, NULL);
restore_stack(); restore_stack();
return o; return o;
} }
@ -707,12 +704,9 @@ bool write_Text(unsigned char *inp, seq_tv_t *out, size_t leng USES_REGS) {
if ((out->val.t = string_to_term(inp, out, leng PASS_REGS)) != 0L) if ((out->val.t = string_to_term(inp, out, leng PASS_REGS)) != 0L)
return out->val.t != 0; return out->val.t != 0;
} }
if (out->type & if (out->type & (YAP_STRING_INT | YAP_STRING_FLOAT | YAP_STRING_BIG)) {
(YAP_STRING_INT | YAP_STRING_FLOAT | YAP_STRING_BIG)) { if ((out->val.t = write_number(inp, out, leng PASS_REGS)) != 0L) {
if ( // Yap_DebugPlWriteln(out->val.t);
(out->val.t = write_number(inp, out, leng PASS_REGS)) !=
0L) {
//Yap_DebugPlWriteln(out->val.t);
return true; return true;
} }
@ -721,12 +715,11 @@ bool write_Text(unsigned char *inp, seq_tv_t *out, size_t leng USES_REGS) {
return false; return false;
} }
if (out->type & (YAP_STRING_ATOM)) { if (out->type & (YAP_STRING_ATOM)) {
if ( if (write_atom(inp, out, leng PASS_REGS) != NIL) {
write_atom(inp, out, leng PASS_REGS) != NIL) {
Atom at = out->val.a; Atom at = out->val.a;
if (at && ( out->type & YAP_STRING_OUTPUT_TERM)) if (at && (out->type & YAP_STRING_OUTPUT_TERM))
out->val.t = MkAtomTerm(at); out->val.t = MkAtomTerm(at);
//Yap_DebugPlWriteln(out->val.t); // Yap_DebugPlWriteln(out->val.t);
return at != NIL; return at != NIL;
} }
} }
@ -734,40 +727,39 @@ bool write_Text(unsigned char *inp, seq_tv_t *out, size_t leng USES_REGS) {
switch (out->type & YAP_TYPE_MASK) { switch (out->type & YAP_TYPE_MASK) {
case YAP_STRING_CHARS: { case YAP_STRING_CHARS: {
size_t room = write_buffer(inp, out, leng PASS_REGS); size_t room = write_buffer(inp, out, leng PASS_REGS);
//printf("%s\n", out->val.c); // printf("%s\n", out->val.c);
return ((Int) room > 0); return ((Int)room > 0);
} }
case YAP_STRING_WCHARS: { case YAP_STRING_WCHARS: {
size_t room = write_buffer(inp, out, leng PASS_REGS); size_t room = write_buffer(inp, out, leng PASS_REGS);
//printf("%S\n", out->val.w); // printf("%S\n", out->val.w);
return ((Int) room > 0); return ((Int)room > 0);
} }
case YAP_STRING_STRING: case YAP_STRING_STRING:
out->val.t = write_strings(inp, out, leng PASS_REGS); out->val.t = write_strings(inp, out, leng PASS_REGS);
//Yap_DebugPlWriteln(out->val.t); // Yap_DebugPlWriteln(out->val.t);
return out->val.t != 0; return out->val.t != 0;
case YAP_STRING_ATOMS: case YAP_STRING_ATOMS:
out->val.t = write_atoms(inp, out, leng PASS_REGS); out->val.t = write_atoms(inp, out, leng PASS_REGS);
//Yap_DebugPlWriteln(out->val.t); // Yap_DebugPlWriteln(out->val.t);
return out->val.t != 0; return out->val.t != 0;
case YAP_STRING_CODES: case YAP_STRING_CODES:
out->val.t = write_codes(inp, out, leng PASS_REGS); out->val.t = write_codes(inp, out, leng PASS_REGS);
//Yap_DebugPlWriteln(out->val.t); // Yap_DebugPlWriteln(out->val.t);
return out->val.t != 0; return out->val.t != 0;
case YAP_STRING_LENGTH: case YAP_STRING_LENGTH:
out->val.l = write_length(inp, out, leng PASS_REGS); out->val.l = write_length(inp, out, leng PASS_REGS);
//printf("s\n",out->val.l); // printf("s\n",out->val.l);
return out->val.l != (size_t) (-1); return out->val.l != (size_t)(-1);
case YAP_STRING_ATOM: case YAP_STRING_ATOM:
out->val.a = write_atom(inp, out, leng PASS_REGS); out->val.a = write_atom(inp, out, leng PASS_REGS);
//Yap_DebugPlWriteln(out->val.t); // Yap_DebugPlWriteln(out->val.t);
return out->val.a != NULL; return out->val.a != NULL;
case YAP_STRING_INT | YAP_STRING_FLOAT | YAP_STRING_BIG: case YAP_STRING_INT | YAP_STRING_FLOAT | YAP_STRING_BIG:
out->val.t = write_number(inp, out, leng PASS_REGS); out->val.t = write_number(inp, out, leng PASS_REGS);
//Yap_DebugPlWriteln(out->val.t); // Yap_DebugPlWriteln(out->val.t);
return out->val.t != 0; return out->val.t != 0;
default: { default: {}
}
} }
return false; return false;
} }
@ -812,7 +804,7 @@ bool Yap_CVT_Text(seq_tv_t *inp, seq_tv_t *out USES_REGS) {
else if (inp->type & YAP_STRING_WCHARS) fprintf(stderr,"S %S\n", inp->val else if (inp->type & YAP_STRING_WCHARS) fprintf(stderr,"S %S\n", inp->val
.w); .w);
else fprintf(stderr,"s %s\n", inp->val.c); else fprintf(stderr,"s %s\n", inp->val.c);
*/ */
buf = Yap_readText(inp, &leng PASS_REGS); buf = Yap_readText(inp, &leng PASS_REGS);
if (out->type & (YAP_STRING_NCHARS | YAP_STRING_TRUNC)) { if (out->type & (YAP_STRING_NCHARS | YAP_STRING_TRUNC)) {
if (out->max < leng) { if (out->max < leng) {
@ -884,13 +876,14 @@ static unsigned char *concat(int n, unsigned char *sv[] USES_REGS) {
int i; int i;
for (i = 0; i < n; i++) { for (i = 0; i < n; i++) {
room += strlen((char *) sv[i]); room += strlen((char *)sv[i]);
} }
buf = Malloc(room + 1); buf = Malloc(room + 1);
buf0 = (unsigned char *) buf; buf0 = (unsigned char *)buf;
for (i = 0; i < n; i++) { for (i = 0; i < n; i++) {
buf = strcpy(buf, (char *) sv[i]); char *s = (char *)sv[i];
buf += strlen( sv[i] ); buf = strcpy(buf, s);
buf += strlen(s);
} }
return buf0; return buf0;
} }
@ -983,8 +976,7 @@ bool Yap_Splice_Text(int n, size_t cuts[], seq_tv_t *inp,
return false; return false;
} }
l0 = l - l1; l0 = l - l1;
if (cmp_Text(skip_utf8((const unsigned char *) buf, l0), buf1, if (cmp_Text(skip_utf8((const unsigned char *)buf, l0), buf1, l1) !=
l1) !=
0) { 0) {
unprotect_stack(NULL); unprotect_stack(NULL);
return false; return false;
@ -1095,11 +1087,10 @@ const char *Yap_PredIndicatorToUTF8String(PredEntry *ap) {
if (ap->ModuleOfPred == IDB_MODULE) { if (ap->ModuleOfPred == IDB_MODULE) {
if (ap->PredFlags & NumberDBPredFlag) { if (ap->PredFlags & NumberDBPredFlag) {
Int key = ap->src.IndxId; Int key = ap->src.IndxId;
snprintf(s, smax - s, "%" snprintf(s, smax - s, "%" PRIdPTR, key);
PRIdPTR, key);
return LOCAL_FileNameBuf; return LOCAL_FileNameBuf;
} else if (ap->PredFlags & AtomDBPredFlag) { } else if (ap->PredFlags & AtomDBPredFlag) {
at = (Atom) (ap->FunctorOfPred); at = (Atom)(ap->FunctorOfPred);
if (!Yap_AtomToUTF8Text(at, s)) if (!Yap_AtomToUTF8Text(at, s))
return NULL; return NULL;
} else { } else {
@ -1112,15 +1103,14 @@ const char *Yap_PredIndicatorToUTF8String(PredEntry *ap) {
if (arity) { if (arity) {
at = NameOfFunctor(ap->FunctorOfPred); at = NameOfFunctor(ap->FunctorOfPred);
} else { } else {
at = (Atom) (ap->FunctorOfPred); at = (Atom)(ap->FunctorOfPred);
} }
} }
if (!Yap_AtomToUTF8Text(at, s)) { if (!Yap_AtomToUTF8Text(at, s)) {
return NULL; return NULL;
} }
s += strlen(s); s += strlen(s);
snprintf(s, smax - s, "/%" snprintf(s, smax - s, "/%" PRIdPTR, arity);
PRIdPTR, arity);
return s0; return s0;
} }

112
C/tracer.c
View File

@ -20,45 +20,63 @@
#ifdef LOW_LEVEL_TRACER #ifdef LOW_LEVEL_TRACER
#include "YapHeap.h" #include "YapHeap.h"
#include "YapText.h"
#include "Yatom.h" #include "Yatom.h"
#include "attvar.h" #include "attvar.h"
#include "clause.h" #include "clause.h"
#include "tracer.h"
#include "iopreds.h" #include "iopreds.h"
#include "tracer.h"
#include "yapio.h"
static void send_tracer_message(char *start, char *name, Int arity, char *mname, static char *send_tracer_message(char *start, char *name, Int arity,
CELL *args) { char *mname, CELL *args, char *s, char *top) {
if (name == NULL) { if (name == NULL) {
#ifdef YAPOR #ifdef YAPOR
fprintf(stderr, "(%d)%s", worker_id, start); s += snprintf(s, top - s, "(%d)%s", worker_id, start);
#else #else
fprintf(stderr, "%s", start); s += snprintf(s, top - s, "%s", start);
#endif #endif
} else { } else {
int i; int i;
if (arity) { if (arity) {
if (args) if (args)
fprintf(stderr, "%s %s:%s(", start, mname, name); s += snprintf(s, top - s, "%s %s:%s(", start, mname, name);
else else
fprintf(stderr, "%s %s:%s/%lu", start, mname, name, s += snprintf(s, top - s, "%s %s:%s/%lu", start, mname, name,
(unsigned long int)arity); (unsigned long int)arity);
} else { } else {
fprintf(stderr, "%s %s:%s", start, mname, name); s += snprintf(s, top - s, "%s %s:%s", start, mname, name);
} }
if (args) { if (args) {
for (i = 0; i < arity; i++) { for (i = 0; i < arity; i++) {
if (i > 0) size_t length = top - (s + 4);
fprintf(stderr, ","); if ((ssize_t)length < 16) {
Yap_plwrite(args[i], NULL, 15, Handle_vars_f | AttVar_Portray_f, s[0] = '\0';
GLOBAL_MaxPriority); return s;
}
if (i > 0) {
*s++ = ',';
}
const char *sn = Yap_TermToString(args[i], NULL, LOCAL_encoding,
Quote_illegal_f | Handle_vars_f);
size_t sz;
if (sn != s) {
if (sn == NULL) {
sn = "<* error *>";
}
strlcpy(s, sn, top - (s + 3));
}
sz = strlen(s);
s += sz;
} }
if (arity) { if (arity) {
fprintf(stderr, ")"); *s++ = ')';
} }
} }
} }
fprintf(stderr, "\n"); s[0] = '\0';
return s;
} }
#if defined(__GNUC__) #if defined(__GNUC__)
@ -140,22 +158,18 @@ check_area(void)
// PredEntry *old_p[10000]; // PredEntry *old_p[10000];
// Term old_x1[10000], old_x2[10000], old_x3[10000]; // Term old_x1[10000], old_x2[10000], old_x3[10000];
//static CELL oldv = 0; // static CELL oldv = 0;
void low_level_trace(yap_low_level_port port, PredEntry *pred, CELL *args) { void low_level_trace__(yap_low_level_port port, PredEntry *pred, CELL *args) {
CACHE_REGS CACHE_REGS
char *s; char *s;
char *mname; char *mname;
Int arity; Int arity;
/* extern int gc_calls; */ /* extern int gc_calls; */
vsc_count++; vsc_count++;
// if (HR < ASP ) return; // if (HR < ASP ) return;
// fif (vsc_count == 12534) jmp_deb( 2 ); // fif (vsc_count == 12534) jmp_deb( 2 );
#if __ANDROID__ char buf[512], *top = buf + 511, *b = buf;
if (vsc_count == 1)
freopen("log", "w", stderr);
#endif
// if (!worker_id) return; // if (!worker_id) return;
LOCK(Yap_low_level_trace_lock); LOCK(Yap_low_level_trace_lock);
@ -165,10 +179,10 @@ void low_level_trace(yap_low_level_port port, PredEntry *pred, CELL *args) {
LOCAL_ThreadHandle.thread_inst_count++; LOCAL_ThreadHandle.thread_inst_count++;
#endif #endif
#ifdef COMMENTED #ifdef COMMENTED
fprintf(stderr, "in %p\n"); b = snprintf(b, top - b, "in %p\n");
CELL *gc_ENV = ENV; CELL *gc_ENV = ENV;
while (gc_ENV != NULL) { /* no more environments */ while (gc_ENV != NULL) { /* no more environments */
fprintf(stderr, "%ld\n", LCL0 - gc_ENV); b = snprintf(b, top - b, "%ld\n", LCL0 - gc_ENV);
gc_ENV = (CELL *)gc_ENV[E_E]; /* link to prev gc_ENV = (CELL *)gc_ENV[E_E]; /* link to prev
* environment */ * environment */
} }
@ -176,7 +190,8 @@ void low_level_trace(yap_low_level_port port, PredEntry *pred, CELL *args) {
{ {
choiceptr b_p = B; choiceptr b_p = B;
while (b_p) { while (b_p) {
fprintf(stderr, "%p %ld\n", b_p, Yap_op_from_opcode(b_p->cp_ap->opc)); b = snprintf(b, top - b, "%p %ld\n", b_p,
Yap_op_from_opcode(b_p->cp_ap->opc));
b_p = b_p->cp_b; b_p = b_p->cp_b;
} }
} }
@ -193,7 +208,7 @@ void low_level_trace(yap_low_level_port port, PredEntry *pred, CELL *args) {
if (vsc_count % 1LL == 0) { if (vsc_count % 1LL == 0) {
UInt sz = Yap_regp->H0_[17]; UInt sz = Yap_regp->H0_[17];
UInt end = sizeof(MP_INT) / sizeof(CELL) + sz + 1; UInt end = sizeof(MP_INT) / sizeof(CELL) + sz + 1;
fprintf(stderr, "VAL %lld %d %x/%x\n", vsc_count, sz, H0[16], b = snprintf(b, top - b, "VAL %lld %d %x/%x\n", vsc_count, sz, H0[16],
H0[16 + end]); H0[16 + end]);
} }
} else } else
@ -306,10 +321,10 @@ void low_level_trace(yap_low_level_port port, PredEntry *pred, CELL *args) {
printf("\n"); printf("\n");
} }
#endif #endif
fprintf(stderr, "%lld %ld ", vsc_count, LCL0 - (CELL *)B); b += snprintf(b, top - b, "%lld %ld ", vsc_count, LCL0 - (CELL *)B);
fprintf(stderr, "%ld ", LCL0 - (CELL *)Yap_REGS.CUT_C_TOP); b += snprintf(b, top - b, "%ld ", LCL0 - (CELL *)Yap_REGS.CUT_C_TOP);
#if defined(THREADS) || defined(YAPOR) #if defined(THREADS) || defined(YAPOR)
fprintf(stderr, "(%d)", worker_id); b += snprintf(b, top - b, "(%d)", worker_id);
#endif #endif
/* check_trail_consistency(); */ /* check_trail_consistency(); */
if (pred == NULL) { if (pred == NULL) {
@ -335,41 +350,42 @@ void low_level_trace(yap_low_level_port port, PredEntry *pred, CELL *args) {
} }
/* if ((pred->ModuleOfPred == 0) && (s[0] == '$')) /* if ((pred->ModuleOfPred == 0) && (s[0] == '$'))
return; */ return; */
send_tracer_message("CALL: ", s, arity, mname, args); b = send_tracer_message("CALL: ", s, arity, mname, args, b, top);
break; break;
case try_or: case try_or:
send_tracer_message("TRY_OR ", NULL, 0, NULL, args); b = send_tracer_message("TRY_OR ", NULL, 0, NULL, args, b, top);
break; break;
case retry_or: case retry_or:
send_tracer_message("FAIL ", NULL, 0, NULL, args); b = send_tracer_message("FAIL ", NULL, 0, NULL, args, b, top);
send_tracer_message("RETRY_OR ", NULL, 0, NULL, args); b = send_tracer_message("RETRY_OR ", NULL, 0, NULL, args, b, top);
break; break;
case retry_table_generator: case retry_table_generator:
send_tracer_message("FAIL ", NULL, 0, NULL, args); b = send_tracer_message("FAIL ", NULL, 0, NULL, args, b, top);
mname = (char *)RepAtom(AtomOfTerm(Yap_Module_Name(pred)))->StrOfAE; mname = (char *)RepAtom(AtomOfTerm(Yap_Module_Name(pred)))->StrOfAE;
arity = pred->ArityOfPE; arity = pred->ArityOfPE;
if (arity == 0) if (arity == 0)
s = (char *)RepAtom((Atom)pred->FunctorOfPred)->StrOfAE; s = (char *)RepAtom((Atom)pred->FunctorOfPred)->StrOfAE;
else else
s = (char *)RepAtom(NameOfFunctor((pred->FunctorOfPred)))->StrOfAE; s = (char *)RepAtom(NameOfFunctor((pred->FunctorOfPred)))->StrOfAE;
send_tracer_message("RETRY GENERATOR: ", s, arity, mname, args); b = send_tracer_message("RETRY GENERATOR: ", s, arity, mname, args, b, top);
break; break;
case retry_table_consumer: case retry_table_consumer:
send_tracer_message("FAIL ", NULL, 0, NULL, args); b = send_tracer_message("FAIL ", NULL, 0, NULL, args, b, top);
mname = (char *)RepAtom(AtomOfTerm(Yap_Module_Name(pred)))->StrOfAE; mname = (char *)RepAtom(AtomOfTerm(Yap_Module_Name(pred)))->StrOfAE;
arity = pred->ArityOfPE; arity = pred->ArityOfPE;
if (arity == 0) { if (arity == 0) {
s = (char *)RepAtom((Atom)pred->FunctorOfPred)->StrOfAE; s = (char *)RepAtom((Atom)pred->FunctorOfPred)->StrOfAE;
send_tracer_message("RETRY CONSUMER: ", s, 0, mname, NULL); b = send_tracer_message("RETRY CONSUMER: ", s, 0, mname, NULL, b, top);
} else { } else {
s = (char *)RepAtom(NameOfFunctor((pred->FunctorOfPred)))->StrOfAE; s = (char *)RepAtom(NameOfFunctor((pred->FunctorOfPred)))->StrOfAE;
send_tracer_message("RETRY CONSUMER: ", s, pred->ArityOfPE, mname, NULL); b = send_tracer_message("RETRY CONSUMER: ", s, pred->ArityOfPE, mname,
NULL, b, top);
} }
break; break;
case retry_table_loader: case retry_table_loader:
send_tracer_message("FAIL ", NULL, 0, NULL, args); b = send_tracer_message("FAIL ", NULL, 0, NULL, args, b, top);
if (pred == UndefCode) { if (pred == UndefCode) {
send_tracer_message("RETRY LOADER ", NULL, 0, NULL, NULL); b = send_tracer_message("RETRY LOADER ", NULL, 0, NULL, NULL, b, top);
} else { } else {
mname = (char *)RepAtom(AtomOfTerm(Yap_Module_Name(pred)))->StrOfAE; mname = (char *)RepAtom(AtomOfTerm(Yap_Module_Name(pred)))->StrOfAE;
arity = pred->ArityOfPE; arity = pred->ArityOfPE;
@ -377,11 +393,11 @@ void low_level_trace(yap_low_level_port port, PredEntry *pred, CELL *args) {
s = (char *)RepAtom((Atom)pred->FunctorOfPred)->StrOfAE; s = (char *)RepAtom((Atom)pred->FunctorOfPred)->StrOfAE;
else else
s = (char *)RepAtom(NameOfFunctor((pred->FunctorOfPred)))->StrOfAE; s = (char *)RepAtom(NameOfFunctor((pred->FunctorOfPred)))->StrOfAE;
send_tracer_message("RETRY LOADER: ", s, 0, mname, NULL); b = send_tracer_message("RETRY LOADER: ", s, 0, mname, NULL, b, top);
} }
break; break;
case retry_pred: case retry_pred:
send_tracer_message("FAIL ", NULL, 0, NULL, args); b = send_tracer_message("FAIL ", NULL, 0, NULL, args, b, top);
if (pred != NULL) { if (pred != NULL) {
mname = (char *)RepAtom(AtomOfTerm(Yap_Module_Name(pred)))->StrOfAE; mname = (char *)RepAtom(AtomOfTerm(Yap_Module_Name(pred)))->StrOfAE;
arity = pred->ArityOfPE; arity = pred->ArityOfPE;
@ -393,12 +409,18 @@ void low_level_trace(yap_low_level_port port, PredEntry *pred, CELL *args) {
} else { } else {
s = (char *)RepAtom(NameOfFunctor((pred->FunctorOfPred)))->StrOfAE; s = (char *)RepAtom(NameOfFunctor((pred->FunctorOfPred)))->StrOfAE;
} }
send_tracer_message("RETRY: ", s, arity, mname, args); b = send_tracer_message("RETRY: ", s, arity, mname, args, b, top);
} }
break; break;
} }
fflush(NULL);
UNLOCK(Yap_low_level_trace_lock); UNLOCK(Yap_low_level_trace_lock);
#if __ANDROID__
__android_log_print(ANDROID_LOG_DEBUG, "YAPDroid", "%s\n", buf);
#else
*b++ = '\n';
*b++ = '\0';
fputs(buf, stderr);
#endif
} }
void toggle_low_level_trace(void) { void toggle_low_level_trace(void) {

26
CMakeLists.txt
View File

@ -18,8 +18,6 @@ set(
"${CMAKE_SOURCE_DIR}" "${CMAKE_SOURCE_DIR}"
"${CMAKE_SOURCE_DIR}/cmake") "${CMAKE_SOURCE_DIR}/cmake")
set(LIBYAP_SOURCES ../../externalNativeBuild/swig/yapj.cpp)
include(CheckIncludeFiles) include(CheckIncludeFiles)
include(CheckLibraryExists) include(CheckLibraryExists)
include(CheckSymbolExists) include(CheckSymbolExists)
@ -29,6 +27,7 @@ include(MacroOptionalAddSubdirectory)
include(MacroOptionalFindPackage) include(MacroOptionalFindPackage)
include(MacroLogFeature) include(MacroLogFeature)
include(FindPackageHandleStandardArgs) include(FindPackageHandleStandardArgs)
include (GNUInstallDirs)
# Creates and names a library, sets it as either STATIC # Creates and names a library, sets it as either STATIC
# or SHARED, and provides the relative paths to its source code. # or SHARED, and provides the relative paths to its source code.
# You can define multiple libraries, and CMake builds it for you. # You can define multiple libraries, and CMake builds it for you.
@ -61,7 +60,26 @@ if (MYSQL_POSTGRES)
if (ANDROID) if (ANDROID)
set(ALL_SOURCES ../../externalNativeBuild/swig/yapj.cpp) #
# SWIG_FOUND - set to true if SWIG is found
# SWIG_DIR - t he directory where swig is installed
# SWIG_EXECUTABLE - the path to the swig executable
# SWIG_VERSION - the version number of the swig executable
#
#
set (SWIG_SOURCES ${CMAKE_SOURCE_DIR}/packages/swig/yap.i)
set (SWIG_CXX ${CMAKE_BINARY_DIR}/yap_swig.cpp)
find_host_package (SWIG)
macro_log_feature (SWIG_FOUND "Swig"
"Use SWIG Language Interface "
"http://www.swig.org" ON)
add_custom_command (OUTPUT ${SWIG_CXX}
COMMAND ${SWIG_EXECUTABLE} -c++ -java -package pt.up.yap.lib -outdir ${CMAKE_LIBRARY_OUTPUT_DIRECTORY}/../../../../../src/generated/java -I${CMAKE_SOURCE_DIR}/CXX -o ${SWIG_CXX}
${SWIG_SOURCES}
)
ADD_SUBDIRECTORY(os) ADD_SUBDIRECTORY(os)
ADD_SUBDIRECTORY(OPTYap) ADD_SUBDIRECTORY(OPTYap)
@ -96,6 +114,7 @@ add_library( # Sets the name of the library.
SHARED SHARED
${ENGINE_SOURCES} ${ENGINE_SOURCES}
${SWIG_CXX}
${C_INTERFACE_SOURCES} ${C_INTERFACE_SOURCES}
${STATIC_SOURCES} ${STATIC_SOURCES}
${ALL_SOURCES} ${ALL_SOURCES}
@ -112,6 +131,7 @@ endif (USE_READLINE)
if (ANDROID) if (ANDROID)
add_dependencies(libYap plmyddas)
target_link_libraries(libYap android log) target_link_libraries(libYap android log)

185
CXX/yapdb.hh
View File

@ -1,5 +1,4 @@
#ifndef _YAPDB_H #ifndef _YAPDB_H
#define _YAPDB_H #define _YAPDB_H
@ -35,13 +34,14 @@ class YAPModule;
*/ */
class YAPModule : protected YAPAtomTerm { class YAPModule : protected YAPAtomTerm {
friend class YAPPredicate; friend class YAPPredicate;
YAPModule( Term t ): YAPAtomTerm( t ) {}; YAPModule(Term t) : YAPAtomTerm(t){};
Term t() { return gt(); } Term t() { return gt(); }
Term curModule() {CACHE_REGS return Yap_CurrentModule(); } Term curModule() { CACHE_REGS return Yap_CurrentModule(); }
public: public:
~YAPModule( ) {}; ~YAPModule(){};
YAPModule( ): YAPAtomTerm( curModule() ) {}; YAPModule() : YAPAtomTerm(curModule()){};
YAPModule( YAPAtom t ): YAPAtomTerm( t ) {}; YAPModule(YAPAtom t) : YAPAtomTerm(t){};
}; };
/** /**
@ -49,144 +49,142 @@ public:
* A YAPModuleProp controls access to a module property. * A YAPModuleProp controls access to a module property.
* *
*/ */
class YAPModuleProp: public YAPProp { class YAPModuleProp : public YAPProp {
friend class YAPPredicate; friend class YAPPredicate;
ModEntry *m; ModEntry *m;
YAPModuleProp(ModEntry *mod) {m = mod;}; YAPModuleProp(ModEntry *mod) { m = mod; };
YAPModuleProp(Term tmod) { m = Yap_GetModuleEntry(tmod); }; YAPModuleProp(Term tmod) { m = Yap_GetModuleEntry(tmod); };
public: public:
YAPModuleProp() { CACHE_REGS m = Yap_GetModuleEntry(Yap_CurrentModule()); }; YAPModuleProp() { CACHE_REGS m = Yap_GetModuleEntry(Yap_CurrentModule()); };
YAPModuleProp(YAPModule tmod) ; YAPModuleProp(YAPModule tmod);
virtual YAPModule module() { return YAPModule(m->AtomOfME); }; virtual YAPModule module() { return YAPModule(m->AtomOfME); };
}; };
/** /**
* @brief YAPFunctor represents Prolog functors Name/Arity * @brief YAPFunctor represents Prolog functors Name/Arity
*/ */
class YAPFunctor: public YAPProp { class YAPFunctor : public YAPProp {
friend class YAPApplTerm; friend class YAPApplTerm;
friend class YAPTerm;
friend class YAPPredicate; friend class YAPPredicate;
friend class YAPQuery;
Functor f; Functor f;
/// Constructor: receives Prolog functor and casts it to YAPFunctor /// Constructor: receives Prolog functor and casts it to YAPFunctor
/// ///
/// Notice that this is designed for internal use only. /// Notice that this is designed for internal use only.
inline YAPFunctor( Functor ff) { f = ff; } inline YAPFunctor(Functor ff) { f = ff; }
public:
public:
/// Constructor: receives name as an atom, plus arity /// Constructor: receives name as an atom, plus arity
/// ///
/// This is the default method, and the most popular /// This is the default method, and the most popular
YAPFunctor( YAPAtom at, uintptr_t arity) { f = Yap_MkFunctor( at.a, arity ); } YAPFunctor(YAPAtom at, uintptr_t arity) { f = Yap_MkFunctor(at.a, arity); }
/// Constructor: receives name as a string plus arity /// Constructor: receives name as a string plus arity
/// ///
/// Notice that this is designed for ISO-LATIN-1 right now /// Notice that this is designed for ISO-LATIN-1 right now
/// Note: Python confuses the 3 constructors, /// Note: Python confuses the 3 constructors,
/// use YAPFunctorFromString /// use YAPFunctorFromString
inline YAPFunctor( const char * s, uintptr_t arity, bool isutf8=true) inline YAPFunctor(const char *s, uintptr_t arity, bool isutf8 = true) {
{ f = Yap_MkFunctor( f = Yap_MkFunctor(Yap_LookupAtom(s), arity);
Yap_LookupAtom( s ), arity ); } }
/// Constructor: receives name as a wide string plus arity /// Constructor: receives name as a wide string plus arity
/// ///
/// Notice that this is designed for UNICODE right now /// Notice that this is designed for UNICODE right now
/// ///
/// Note: Python confuses the 3 constructors, /// Note: Python confuses the 3 constructors,
/// use YAPFunctorFromWideString /// use YAPFunctorFromWideString
inline YAPFunctor( const wchar_t * s, uintptr_t arity) { inline YAPFunctor(const wchar_t *s, uintptr_t arity) {
f = Yap_MkFunctor( f = Yap_MkFunctor(Yap_LookupWideAtom(s), arity);
Yap_LookupWideAtom( s ), arity ) ; } }
~YAPFunctor( ) { }; ~YAPFunctor(){};
/// Getter: extract name of functor as an atom /// Getter: extract name of functor as an atom
/// ///
/// this is for external usage. /// this is for external usage.
YAPAtom name(void) { YAPAtom name(void) { return YAPAtom(NameOfFunctor(f)); }
return YAPAtom( NameOfFunctor( f ) );
}
/// Getter: extract arity of functor as an unsigned integer /// Getter: extract arity of functor as an unsigned integer
/// ///
/// this is for external usage. /// this is for external usage.
uintptr_t arity(void) { uintptr_t arity(void) { return ArityOfFunctor(f); }
return ArityOfFunctor( f ); };
}
};
/** /**
* @brief Predicates * @brief Predicates
* *
* This class interfaces with PredEntry in Yatom. * This class interfaces with PredEntry in Yatom.
*/ */
class YAPPredicate: public YAPModuleProp { class YAPPredicate : public YAPModuleProp {
friend class YAPQuery; friend class YAPQuery;
friend class YAPEngine;
protected: protected:
PredEntry *ap; PredEntry *ap;
/// auxiliary routine to find a predicate in the current module. /// auxiliary routine to find a predicate in the current module.
PredEntry *getPred( Term &t, Term* &outp ) ; PredEntry *getPred(Term &t, Term *&outp);
PredEntry *asPred() { return ap; };
/// String constructor for predicates /// String constructor for predicates
/// ///
/// It also communicates the array of arguments t[] /// It also communicates the array of arguments t[]
/// and the array of variables /// and the array of variables
/// back to yapquery /// back to yapquery
YAPPredicate(const char *s0, Term &out, Term &names ) { YAPPredicate(const char *s0, Term &out, Term &names) {
CACHE_REGS CACHE_REGS
BACKUP_MACHINE_REGS(); BACKUP_MACHINE_REGS();
Term *outp; Term *modp = NULL;;
out = Yap_StringToTerm(s0, strlen(s0)+1, &LOCAL_encoding, 1200, &names ) ; out = Yap_StringToTerm(s0, strlen(s0) + 1, &LOCAL_encoding, 1200, &names);
//extern char *s0; // extern char *s0;
//fprintf(stderr,"ap=%p arity=%d text=%s", ap, ap->ArityOfPE, s); // fprintf(stderr,"ap=%p arity=%d text=%s", ap, ap->ArityOfPE, s);
// Yap_DebugPlWrite(out); // Yap_DebugPlWrite(out);
// delete [] ns; // delete [] ns;
if (out == 0L) if (out == 0L)
throw YAPError(SYNTAX_ERROR); throw YAPError();
ap = getPred( out, outp); ap = getPred(out, modp);
RECOVER_MACHINE_REGS(); RECOVER_MACHINE_REGS();
} }
/// Term constructor for predicates /// Term constructor for predicates
/// ///
/// It is just a call to getPred /// It is just a call to getPred
inline YAPPredicate(Term t) { inline YAPPredicate(Term t) {
CELL * v = NULL; CELL *v = NULL;
ap = getPred( t , v ); ap = getPred(t, v);
} }
/// Cast constructor for predicates, /// Cast constructor for predicates,
/// if we have the implementation data. /// if we have the implementation data.
/// ///
inline YAPPredicate(PredEntry *pe) { inline YAPPredicate(PredEntry *pe) { ap = pe; }
ap = pe;
}
public: public:
~YAPPredicate() {}; ~YAPPredicate(){};
/// Functor constructor for predicates /// Functor constructor for predicates
/// ///
/// Asssumes that we use the current module. /// Asssumes that we use the current module.
YAPPredicate(YAPFunctor f) { YAPPredicate(YAPFunctor f) {
CACHE_REGS CACHE_REGS
ap = RepPredProp(PredPropByFunc(f.f,Yap_CurrentModule())); ap = RepPredProp(PredPropByFunc(f.f, Yap_CurrentModule()));
}; };
/// Functor constructor for predicates, is given a specific module. /// Functor constructor for predicates, is given a specific module.
/// ///
inline YAPPredicate(YAPFunctor f, YAPTerm mod) { inline YAPPredicate(YAPFunctor f, YAPTerm mod) {
ap = RepPredProp(PredPropByFunc(f.f,mod.t)); ap = RepPredProp(PredPropByFunc(f.f, mod.t));
} }
/// Name/arity constructor for predicates. /// Name/arity constructor for predicates.
/// ///
inline YAPPredicate(YAPAtom at, YAPTerm mod) { inline YAPPredicate(YAPAtom at, YAPTerm mod) {
ap = RepPredProp(PredPropByAtom(at.a,mod.t)); ap = RepPredProp(PredPropByAtom(at.a, mod.t));
} }
/// Name/0 constructor for predicates. /// Name/0 constructor for predicates.
/// ///
YAPPredicate(YAPAtom at); YAPPredicate(YAPAtom at);
@ -196,9 +194,9 @@ public:
inline YAPPredicate(YAPAtom at, uintptr_t arity, YAPModule mod) { inline YAPPredicate(YAPAtom at, uintptr_t arity, YAPModule mod) {
if (arity) { if (arity) {
Functor f = Yap_MkFunctor(at.a, arity); Functor f = Yap_MkFunctor(at.a, arity);
ap = RepPredProp(PredPropByFunc(f,mod.t())); ap = RepPredProp(PredPropByFunc(f, mod.t()));
} else { } else {
ap = RepPredProp(PredPropByAtom(at.a,mod.t())); ap = RepPredProp(PredPropByAtom(at.a, mod.t()));
} }
} }
@ -206,7 +204,6 @@ public:
/// ///
YAPPredicate(YAPAtom at, uintptr_t arity); YAPPredicate(YAPAtom at, uintptr_t arity);
/// module of a predicate /// module of a predicate
/// ///
/// notice that modules are currently treated as atoms, this should change. /// notice that modules are currently treated as atoms, this should change.
@ -220,7 +217,8 @@ public:
/// name of predicate /// name of predicate
/// ///
/// notice that we return the atom, not a string. /// notice that we return the atom, not a string.
YAPAtom name() { if (ap->ArityOfPE) YAPAtom name() {
if (ap->ArityOfPE)
return YAPAtom((Atom)ap->FunctorOfPred); return YAPAtom((Atom)ap->FunctorOfPred);
else else
return YAPAtom(NameOfFunctor(ap->FunctorOfPred)); return YAPAtom(NameOfFunctor(ap->FunctorOfPred));
@ -237,28 +235,20 @@ public:
* *
* This class interfaces with Predicates Implemented in Prolog. * This class interfaces with Predicates Implemented in Prolog.
*/ */
class YAPPrologPredicate: public YAPPredicate { class YAPPrologPredicate : public YAPPredicate {
public: public:
YAPPrologPredicate(YAPAtom name, YAPPrologPredicate(YAPAtom name, uintptr_t arity,
uintptr_t arity, YAPModule module = YAPModule(), bool tabled = false,
YAPModule module = YAPModule(), bool logical_updates = false, bool local = false,
bool tabled = false, bool sourced = true, bool discontiguous = false,
bool logical_updates = false, bool multiFile = false, bool hidden = false,
bool local = false, bool untraceable = false, bool unspyable = false,
bool sourced = true, bool meta = false, bool sync = false,
bool discontiguous = false, bool quasi_quotable = false, size_t mega_clause = 0);
bool multiFile = false, void *assertClause(YAPTerm clause, bool last = true,
bool hidden = false, YAPTerm source = YAPTerm(TermNil));
bool untraceable = false, void *retractClause(YAPTerm skeleton, bool all = false);
bool unspyable = false, void *clause(YAPTerm skeleton, YAPTerm &body);
bool meta = false,
bool sync = false,
bool quasi_quotable = false,
size_t mega_clause = 0
);
void *assertClause( YAPTerm clause, bool last=true, YAPTerm source= YAPTerm(TermNil));
void *retractClause( YAPTerm skeleton, bool all=false);
void *clause( YAPTerm skeleton, YAPTerm &body );
}; };
/** /**
@ -266,52 +256,35 @@ public:
* *
* This class interfaces with Predicates Implemented in Prolog. * This class interfaces with Predicates Implemented in Prolog.
*/ */
class YAPFLIP: public YAPPredicate { class YAPFLIP : public YAPPredicate {
public: public:
YAPFLIP(CPredicate call, YAPFLIP(CPredicate call, YAPAtom name, uintptr_t arity,
YAPAtom name, YAPModule module = YAPModule(), CPredicate retry = 0,
uintptr_t arity, CPredicate cut = 0, size_t extra = 0, bool test = false)
YAPModule module = YAPModule(), : YAPPredicate(name, arity, module) {
CPredicate retry = 0,
CPredicate cut = 0,
size_t extra = 0,
bool test = false
) : YAPPredicate( name, arity, module) {
if (retry) { if (retry) {
Yap_InitCPredBackCut(name.getName(), arity, extra, call, retry, cut, UserCPredFlag); Yap_InitCPredBackCut(name.getName(), arity, extra, call, retry, cut,
UserCPredFlag);
} else { } else {
if (test) { if (test) {
YAP_UserCPredicate (name.getName(), YAP_UserCPredicate(name.getName(), call, arity);
call, arity);
} else { } else {
YAP_UserCPredicate (name.getName(), YAP_UserCPredicate(name.getName(), call, arity);
call, arity);
} }
} }
}; };
YAPFLIP(const char *name, YAPFLIP(const char *name, uintptr_t arity, YAPModule module = YAPModule(),
uintptr_t arity, bool backtrackable = false)
YAPModule module = YAPModule(), : YAPPredicate(YAPAtom(name), arity, module) {
bool backtrackable = false
) : YAPPredicate( YAPAtom(name), arity, module) {
if (backtrackable) { if (backtrackable) {
Yap_InitCPredBackCut(name, arity, 0, 0, 0, 0, UserCPredFlag); Yap_InitCPredBackCut(name, arity, 0, 0, 0, 0, UserCPredFlag);
} else { } else {
YAP_UserCPredicate (name, YAP_UserCPredicate(name, 0, arity);
0, arity);
} }
}; };
bool addCall(CPredicate call) { bool addCall(CPredicate call) { return Yap_AddCallToFli(ap, call); }
return Yap_AddCallToFli( ap, call ); bool addRetry(CPredicate call) { return Yap_AddRetryToFli(ap, call); }
} bool addCut(CPredicate call) { return Yap_AddCutToFli(ap, call); }
bool addRetry(CPredicate call) {
return Yap_AddRetryToFli( ap, call );
}
bool addCut(CPredicate call) {
return Yap_AddCutToFli( ap, call );
}
}; };
#endif #endif

242
CXX/yapi.cpp
View File

@ -1,6 +1,7 @@
#define YAP_CPP_INTERFACE 1 #define YAP_CPP_INTERFACE 1
#include <string>
#include "yapi.hh" #include "yapi.hh"
extern "C" { extern "C" {
@ -161,6 +162,17 @@ YAPApplTerm::YAPApplTerm(YAPFunctor f, YAPTerm ts[]) : YAPTerm() {
RECOVER_H(); RECOVER_H();
} }
YAPApplTerm::YAPApplTerm(const char *f, std::vector<YAPTerm> ts) : YAPTerm() {
BACKUP_H();
arity_t arity = ts.size();
std::vector<Term> tt(arity);
for (arity_t i = 0; i < arity; i++)
tt[i] = ts[i].term();
Functor ff = Yap_MkFunctor(Yap_LookupAtom(f), arity);
t = Yap_MkApplTerm(ff, arity, &tt[0]);
RECOVER_H();
}
YAPApplTerm::YAPApplTerm(YAPFunctor f) : YAPTerm() { YAPApplTerm::YAPApplTerm(YAPFunctor f) : YAPTerm() {
BACKUP_H(); BACKUP_H();
arity_t arity = ArityOfFunctor(f.f); arity_t arity = ArityOfFunctor(f.f);
@ -170,8 +182,6 @@ YAPApplTerm::YAPApplTerm(YAPFunctor f) : YAPTerm() {
YAPFunctor YAPApplTerm::getFunctor() { return YAPFunctor(FunctorOfTerm(gt())); } YAPFunctor YAPApplTerm::getFunctor() { return YAPFunctor(FunctorOfTerm(gt())); }
static YAPTerm tmp;
YAPTerm &YAPTerm::operator[](arity_t i) { YAPTerm &YAPTerm::operator[](arity_t i) {
BACKUP_MACHINE_REGS(); BACKUP_MACHINE_REGS();
Term t0 = gt(); Term t0 = gt();
@ -359,7 +369,7 @@ const char *YAPTerm::text() {
if (!(os = Yap_TermToString(Yap_GetFromSlot(t), &length, enc, if (!(os = Yap_TermToString(Yap_GetFromSlot(t), &length, enc,
Handle_vars_f))) { Handle_vars_f))) {
RECOVER_MACHINE_REGS(); RECOVER_MACHINE_REGS();
return nullptr; return 0;
} }
RECOVER_MACHINE_REGS(); RECOVER_MACHINE_REGS();
return os; return os;
@ -392,8 +402,36 @@ YAPTerm YAPListTerm::car() {
Term to = gt(); Term to = gt();
if (IsPairTerm(to)) if (IsPairTerm(to))
return YAPTerm(HeadOfTerm(to)); return YAPTerm(HeadOfTerm(to));
else else {
throw YAPError(TYPE_ERROR_LIST); Yap_Error(TYPE_ERROR_LIST, to, "");
throw YAPError();
}
}
YAPTerm::YAPTerm(YAPFunctor f, YAPTerm ts[]) {
CACHE_REGS
BACKUP_H();
Functor fun = f.f;
arity_t arity = ArityOfFunctor(fun);
while (HR + arity > ASP - 1024) {
RECOVER_H();
if (!Yap_dogc(0, NULL PASS_REGS)) {
t = TermNil;
}
BACKUP_H();
}
if (fun == FunctorDot) {
t = AbsPair(HR);
HR[0] = ts[0].term();
HR[1] = ts[1].term();
} else {
t = AbsAppl(HR);
*HR++ = (CELL)fun;
for (arity_t i = 0; i < arity; i++) {
HR[i] = ts[i].term();
}
RECOVER_H();
}
} }
YAPListTerm::YAPListTerm(YAPTerm ts[], arity_t n) { YAPListTerm::YAPListTerm(YAPTerm ts[], arity_t n) {
@ -445,8 +483,21 @@ const char *YAPAtom::getName(void) {
} }
} }
void YAPQuery::initOpenQ() { void YAPQuery::openQuery() {
CACHE_REGS CACHE_REGS
arity_t arity = ap->ArityOfPE;
if (arity) {
Term *ts;
Term t = goal.term();
if (IsPairTerm(t)) {
ts = RepPair(t);
} else {
ts = RepAppl(t) + 1;
}
for (arity_t i = 0; i < arity; i++) {
XREGS[i + 1] = ts[i];
}
}
// oq = LOCAL_execution; // oq = LOCAL_execution;
// LOCAL_execution = this; // LOCAL_execution = this;
q_open = true; q_open = true;
@ -459,69 +510,73 @@ void YAPQuery::initOpenQ() {
q_handles = Yap_StartSlots(); q_handles = Yap_StartSlots();
} }
int YAPError::get() { return errNo; } bool YAPEngine::call(YAPPredicate ap, YAPTerm ts[]) {
const char *YAPError::text() { return "YAP Error"; }
void YAPQuery::initQuery(Term t) {
CACHE_REGS CACHE_REGS
BACKUP_MACHINE_REGS(); BACKUP_MACHINE_REGS();
arity_t arity = ap->ArityOfPE; arity_t arity = ap.getArity();
goal = YAPTerm(t); bool result;
if (arity) { YAP_dogoalinfo q;
q_g = Yap_InitSlots(arity, RepAppl(t) + 1); Term terr;
jmp_buf q_env;
std::vector<Term> vt(arity);
for (arity_t i = 0; i < arity; i++)
vt[i] = ts[i].term();
q.CurSlot = Yap_StartSlots();
q.p = P;
q.cp = CP;
// make sure this is safe
if (setjmp(q_env)) {
if ((terr = Yap_PeekException())) {
YAP_LeaveGoal(false, &q);
Yap_CloseHandles(q.CurSlot);
throw YAPError();
}
return false;
}
// don't forget, on success these guys may create slots
__android_log_print(ANDROID_LOG_INFO, "YAPDroid", "exec ");
result = (bool)YAP_EnterGoal(ap.asPred(), &vt[0], &q);
if ((terr = Yap_GetException())) {
YAP_LeaveGoal(false, &q);
throw YAPError();
}
__android_log_print(ANDROID_LOG_INFO, "YAPDroid", "out %d", result);
if (!result) {
YAP_LeaveGoal(false, &q);
} else { } else {
q_g = 0; YAP_LeaveGoal(FALSE, &q);
} }
q_pe = ap;
initOpenQ();
RECOVER_MACHINE_REGS();
}
void YAPQuery::initQuery(YAPAtom at) {
CACHE_REGS
BACKUP_MACHINE_REGS();
PredEntry *ap = RepPredProp(PredPropByAtom(at.a, Yap_CurrentModule()));
goal = YAPAtomTerm(at);
q_g = 0;
q_pe = ap;
initOpenQ();
RECOVER_MACHINE_REGS();
}
void YAPQuery::initQuery(YAPTerm ts[], arity_t arity) {
CACHE_REGS
BACKUP_MACHINE_REGS();
if (arity) {
q_g = Yap_NewSlots(arity);
for (arity_t i = 0; i < arity; i++) {
Yap_PutInSlot(q_g + i, ts[i].term());
}
Term t = Yap_MkApplTerm(ap->FunctorOfPred, ap->ArityOfPE,
Yap_AddressFromSlot(q_g));
goal = YAPTerm(t);
} else {
q_g = 0;
goal = YAPTerm(MkAtomTerm((Atom)ap->FunctorOfPred));
}
initOpenQ();
RECOVER_MACHINE_REGS(); RECOVER_MACHINE_REGS();
return result;
} }
YAPQuery::YAPQuery(YAPFunctor f, YAPTerm mod, YAPTerm ts[]) YAPQuery::YAPQuery(YAPFunctor f, YAPTerm mod, YAPTerm ts[])
: YAPPredicate(f, mod) { : YAPPredicate(f, mod) {
/* ignore flags for now */ /* ignore flags for now */
initQuery(ts, f.arity()); BACKUP_MACHINE_REGS();
goal = YAPTerm(f, ts);
vnames = YAPListTerm();
openQuery();
RECOVER_MACHINE_REGS();
} }
YAPQuery::YAPQuery(YAPFunctor f, YAPTerm ts[]) : YAPPredicate(f) { YAPQuery::YAPQuery(YAPFunctor f, YAPTerm ts[]) : YAPPredicate(f) {
/* ignore flags for now */ /* ignore flags for now */
initQuery(ts, f.arity()); BACKUP_MACHINE_REGS();
goal = YAPTerm(f, ts);
vnames = YAPListTerm();
openQuery();
RECOVER_MACHINE_REGS();
} }
YAPQuery::YAPQuery(YAPPredicate p, YAPTerm ts[]) : YAPPredicate(p.ap) { YAPQuery::YAPQuery(YAPPredicate p, YAPTerm ts[]) : YAPPredicate(p.ap) {
initQuery(ts, p.ap->ArityOfPE); BACKUP_MACHINE_REGS();
goal = YAPTerm(YAPFunctor(ap->FunctorOfPred), ts);
vnames = YAPListTerm();
openQuery();
RECOVER_MACHINE_REGS();
} }
YAPListTerm YAPQuery::namedVars() { YAPListTerm YAPQuery::namedVars() {
@ -541,38 +596,45 @@ YAPListTerm YAPQuery::namedVarsCopy() {
bool YAPQuery::next() { bool YAPQuery::next() {
CACHE_REGS CACHE_REGS
bool result; bool result;
Term terr;
BACKUP_MACHINE_REGS(); BACKUP_MACHINE_REGS();
if (!q_open) if (!q_open)
return false; return false;
if (setjmp(q_env)) { if (setjmp(q_env)) {
if ((terr = Yap_GetException())) {
YAP_LeaveGoal(false, &q_h);
Yap_CloseHandles(q_handles);
throw YAPError();
}
return false; return false;
} }
// don't forget, on success these guys may create slots // don't forget, on success these guys may create slots
__android_log_print(ANDROID_LOG_INFO, "YAPDroid", "exec "); __android_log_print(ANDROID_LOG_INFO, "YAPDroid", "exec ");
if (q_state == 0) { if (q_state == 0) {
result = (bool)YAP_EnterGoal((YAP_PredEntryPtr)ap, q_g, &q_h); result = (bool)YAP_EnterGoal(ap, nullptr, &q_h);
} else { } else {
LOCAL_AllowRestart = q_open; LOCAL_AllowRestart = q_open;
result = (bool)YAP_RetryGoal(&q_h); result = (bool)YAP_RetryGoal(&q_h);
} }
{ if (result) {
if (result)
__android_log_print(ANDROID_LOG_INFO, "YAPDroid", "vnames %d %s %d", __android_log_print(ANDROID_LOG_INFO, "YAPDroid", "vnames %d %s %d",
q_state, vnames.text(), LOCAL_CurSlot); q_state, vnames.text(), LOCAL_CurSlot);
else } else {
__android_log_print(ANDROID_LOG_INFO, "YAPDroid", "fail"); __android_log_print(ANDROID_LOG_INFO, "YAPDroid", "fail");
} }
q_state = 1; q_state = 1;
if (Yap_GetException()) { if ((terr = Yap_GetException())) {
return false; YAP_LeaveGoal(false, &q_h);
Yap_CloseHandles(q_handles);
throw YAPError();
} }
__android_log_print(ANDROID_LOG_INFO, "YAPDroid", "out %d", result); __android_log_print(ANDROID_LOG_INFO, "YAPDroid", "out %d", result);
if (!result) { if (!result) {
YAP_LeaveGoal(FALSE, &q_h); YAP_LeaveGoal(false, &q_h);
Yap_CloseHandles(q_handles);
q_open = false; q_open = false;
} else { } else {
q_handles = Yap_StartSlots(); q_handles = Yap_StartSlots();
@ -612,12 +674,13 @@ void YAPQuery::close() {
RECOVER_MACHINE_REGS(); RECOVER_MACHINE_REGS();
Yap_ResetException(worker_id); Yap_ResetException(worker_id);
/* need to implement backtracking here */ /* need to implement backtracking here */
if (q_open != 1 || q_state == 0) { if (q_open != true || q_state == 0) {
RECOVER_MACHINE_REGS(); RECOVER_MACHINE_REGS();
return; return;
} }
YAP_LeaveGoal(FALSE, &q_h); YAP_LeaveGoal(FALSE, &q_h);
q_open = 0; q_open = 0;
Yap_CloseHandles(q_handles);
// LOCAL_execution = this; // LOCAL_execution = this;
RECOVER_MACHINE_REGS(); RECOVER_MACHINE_REGS();
} }
@ -674,7 +737,7 @@ void Yap_displayWithJava(int c) {
void YAPEngine::doInit(YAP_file_type_t BootMode) { void YAPEngine::doInit(YAP_file_type_t BootMode) {
if ((BootMode = YAP_Init(&init_args)) == YAP_FOUND_BOOT_ERROR) { if ((BootMode = YAP_Init(&init_args)) == YAP_FOUND_BOOT_ERROR) {
throw(YAPError(SYSTEM_ERROR_INTERNAL)); throw YAPError();
} }
/* Begin preprocessor code */ /* Begin preprocessor code */
/* live */ /* live */
@ -767,7 +830,11 @@ PredEntry *YAPPredicate::getPred(Term &t, Term *&outp) {
Term m = Yap_CurrentModule(); Term m = Yap_CurrentModule();
t = Yap_StripModule(t, &m); t = Yap_StripModule(t, &m);
if (IsVarTerm(t) || IsNumTerm(t)) { if (IsVarTerm(t) || IsNumTerm(t)) {
throw YAPError(TYPE_ERROR_NUMBER); if (IsVarTerm(t))
Yap_Error(INSTANTIATION_ERROR, t, 0);
else if (IsNumTerm(t))
Yap_Error(TYPE_ERROR_CALLABLE, t, 0);
throw YAPError();
} }
if (IsAtomTerm(t)) { if (IsAtomTerm(t)) {
ap = RepPredProp(PredPropByAtom(AtomOfTerm(t), m)); ap = RepPredProp(PredPropByAtom(AtomOfTerm(t), m));
@ -782,7 +849,9 @@ PredEntry *YAPPredicate::getPred(Term &t, Term *&outp) {
} }
Functor f = FunctorOfTerm(t); Functor f = FunctorOfTerm(t);
if (IsExtensionFunctor(f)) { if (IsExtensionFunctor(f)) {
throw YAPError(TYPE_ERROR_NUMBER); Yap_Error(TYPE_ERROR_CALLABLE, t, 0);
;
throw YAPError();
} else { } else {
ap = RepPredProp(PredPropByFunc(f, m)); ap = RepPredProp(PredPropByFunc(f, m));
outp = RepAppl(t) + 1; outp = RepAppl(t) + 1;
@ -877,3 +946,48 @@ void *YAPPrologPredicate::retractClause(YAPTerm skeleton, bool all) {
return 0; return 0;
} }
void *YAPPrologPredicate::clause(YAPTerm skeleton, YAPTerm &body) { return 0; } void *YAPPrologPredicate::clause(YAPTerm skeleton, YAPTerm &body) { return 0; }
const char *YAPError::text() {
char buf[256];
std::string s = "";
if (LOCAL_ActiveError.errorFunction) {
s += LOCAL_ActiveError.errorFile;
s += ":";
sprintf(buf, "%ld", (long int)LOCAL_ActiveError.errorLine);
s += buf;
s += ":0 in C-code";
}
if (LOCAL_ActiveError.prologPredLine) {
s += "\n" ;
s+= LOCAL_ActiveError.prologPredFile->StrOfAE ;
s+= ":" ;
sprintf(buf, "%ld", (long int)LOCAL_ActiveError.prologPredLine);
s+= buf; // std::to_string(LOCAL_ActiveError.prologPredLine) ;
// YAPIntegerTerm(LOCAL_ActiveError.prologPredLine).text();
s+= ":0 " ;
s+= LOCAL_ActiveError.prologPredModule ;
s+= ":" ;
s+= (LOCAL_ActiveError.prologPredName)->StrOfAE ;
s+= "/" ;
sprintf(buf, "%ld", (long int)LOCAL_ActiveError.prologPredArity);
s+= // std::to_string(LOCAL_ActiveError.prologPredArity);
buf;
}
s += " error ";
if (LOCAL_ActiveError.classAsText != nullptr)
s += LOCAL_ActiveError.classAsText->StrOfAE;
s += ".";
s += LOCAL_ActiveError.errorAsText->StrOfAE;
s += ".\n";
if (LOCAL_ActiveError.errorTerm) {
Term t = Yap_PopTermFromDB(LOCAL_ActiveError.errorTerm);
if (t) {
s += "error term is: ";
s += YAPTerm(t).text();
s += "\n";
}
}
printf("%s\n", s.c_str());
return s.c_str();
}

20
CXX/yapi.hh
View File

@ -3,7 +3,7 @@
#define YAP_CPP_INTERFACE 1 #define YAP_CPP_INTERFACE 1
#include <gmpxx.h> #include <gmpxx.h>
#include <vector>
//! @{ //! @{
/** /**
@ -73,8 +73,7 @@ X_API bool init_python(void);
extern PyObject *py_Main; extern PyObject *py_Main;
extern inline PyObject *AtomToPy( const char *s) extern inline PyObject *AtomToPy(const char *s) {
{
if (strcmp(s, "true") == 0) if (strcmp(s, "true") == 0)
return Py_True; return Py_True;
if (strcmp(s, "false") == 0) if (strcmp(s, "false") == 0)
@ -97,17 +96,18 @@ extern inline PyObject *AtomToPy( const char *s)
X_API void YAP_UserCPredicate(const char *, YAP_UserCPred, YAP_Arity arity); X_API void YAP_UserCPredicate(const char *, YAP_UserCPred, YAP_Arity arity);
/* void UserCPredicateWithArgs(const char *name, int *fn(), unsigned int arity) */ /* void UserCPredicateWithArgs(const char *name, int *fn(), unsigned int arity)
X_API void YAP_UserCPredicateWithArgs(const char *, YAP_UserCPred, YAP_Arity, YAP_Term); */
X_API void YAP_UserCPredicateWithArgs(const char *, YAP_UserCPred, YAP_Arity,
YAP_Term);
/* void UserBackCPredicate(const char *name, int *init(), int *cont(), int /* void UserBackCPredicate(const char *name, int *init(), int *cont(), int
arity, int extra) */ arity, int extra) */
X_API void YAP_UserBackCPredicate(const char *, YAP_UserCPred, YAP_UserCPred, YAP_Arity, YAP_Arity); X_API void YAP_UserBackCPredicate(const char *, YAP_UserCPred, YAP_UserCPred,
YAP_Arity, YAP_Arity);
X_API Term Yap_StringToTerm(const char *s, size_t len, encoding_t *encp, int prio, Term *bindings_p);
X_API Term Yap_StringToTerm(const char *s, size_t len, encoding_t *encp,
int prio, Term *bindings_p);
} }
class YAPEngine; class YAPEngine;

30
CXX/yapie.hh
View File

@ -1,11 +1,33 @@
#ifndef YAPIE_HH
#define YAPIE_HH
class YAPPPredicate;
class YAPTerm;
/// take information on a Prolog error:
class YAPError { class YAPError {
int errNo; std::string name, errorClass, info;
int swigcode;
public: public:
YAPError() { errNo = YAP_NO_ERROR; }; /// error handling when receiving the error term
YAPError(int err) { errNo = err; }; YAPError(){};
int get(); /// we just know the error number
/// exact error ID
yap_error_number getID() { return LOCAL_ActiveError.errorNo; };
/// class of error
yap_error_class_number getErrorClass() {
return Yap_errorClass(LOCAL_ActiveError.errorNo);
};
/// where in the code things happened;
const char *getFile() { return LOCAL_ActiveError.errorFile; };
/// predicate things happened;
Int getLine() { return LOCAL_ActiveError.errorLine; };
/// the term that caused the bug
// YAPTerm getCulprit(LOCAL_ActiveError.errorFile){};
/// text describing the Error
const char *text(); const char *text();
}; };
#endif

34
CXX/yapq.hh
View File

@ -17,7 +17,6 @@ class YAPQuery : public YAPPredicate {
bool q_open; bool q_open;
int q_state; int q_state;
yhandle_t q_g, q_handles; yhandle_t q_g, q_handles;
struct pred_entry *q_pe;
struct yami *q_p, *q_cp; struct yami *q_p, *q_cp;
jmp_buf q_env; jmp_buf q_env;
int q_flags; int q_flags;
@ -25,13 +24,10 @@ class YAPQuery : public YAPPredicate {
YAPQuery *oq; YAPQuery *oq;
YAPListTerm vnames; YAPListTerm vnames;
YAPTerm goal; YAPTerm goal;
Term names; // temporaries
Term t; Term tgoal, names;
void initOpenQ(); void openQuery();
void initQuery(Term t);
void initQuery(YAPAtom at);
void initQuery(YAPTerm ts[], arity_t arity);
public: public:
/// main constructor, uses a predicate and an array of terms /// main constructor, uses a predicate and an array of terms
@ -56,21 +52,24 @@ public:
/// It is given a string, calls the parser and obtains a Prolog term that /// It is given a string, calls the parser and obtains a Prolog term that
/// should be a callable /// should be a callable
/// goal. /// goal.
inline YAPQuery(const char *s) : YAPPredicate(s, t, names) { inline YAPQuery(const char *s): YAPPredicate(s, tgoal, names) {
BACKUP_H();
__android_log_print(ANDROID_LOG_INFO, "YAPDroid", "got game %d", __android_log_print(ANDROID_LOG_INFO, "YAPDroid", "got game %d",
LOCAL_CurSlot); LOCAL_CurSlot);
goal = YAPTerm(tgoal);
vnames = YAPListTerm(names); vnames = YAPListTerm(names);
__android_log_print(ANDROID_LOG_INFO, "YAPDroid", "%s", vnames.text()); __android_log_print(ANDROID_LOG_INFO, "YAPDroid", "%s", vnames.text());
initQuery(t); openQuery();
RECOVER_H();
}; };
/// string constructor with just an atom /// string constructor with just an atom
/// ///
/// It is given an atom, and a Prolog term that should be a callable /// It is given an atom, and a Prolog term that should be a callable
/// goal, say `main`, `init`, `live`. /// goal, say `main`, `init`, `live`.
inline YAPQuery(YAPAtom goal) : YAPPredicate(goal) { inline YAPQuery(YAPAtom g) : YAPPredicate( g ) {
vnames = YAPListTerm(TermNil); goal = YAPAtomTerm( g );
initQuery(goal); vnames = YAPListTerm(names);
openQuery();
}; };
/// set flags for query execution, currently only for exception handling /// set flags for query execution, currently only for exception handling
@ -164,8 +163,13 @@ public:
if (_callback) if (_callback)
_callback->run(s); _callback->run(s);
} }
/// stop yap
void close() {
Yap_exit(0);
}
/// execute the callback with a text argument. /// execute the callback with a text argument.
YAPError hasError() { return yerror.get(); } bool hasError() { return LOCAL_Error_TYPE != YAP_NO_ERROR; }
/// build a query on the engine /// build a query on the engine
YAPQuery *query(const char *s) { return new YAPQuery(s); }; YAPQuery *query(const char *s) { return new YAPQuery(s); };
/// current module for the engine /// current module for the engine
@ -173,6 +177,8 @@ public:
/// given a handle, fetch a term from the engine /// given a handle, fetch a term from the engine
inline YAPTerm getTerm(yhandle_t h) { return YAPTerm(h); } inline YAPTerm getTerm(yhandle_t h) { return YAPTerm(h); }
/// current directory for the engine /// current directory for the engine
bool call(YAPPredicate ap, YAPTerm ts[]);
const char *currentDir() { const char *currentDir() {
char dir[1024]; char dir[1024];
std::string s = Yap_getcwd(dir, 1024 - 1); std::string s = Yap_getcwd(dir, 1024 - 1);

17
CXX/yapt.hh
View File

@ -4,6 +4,7 @@
extern "C" Term YAP_ReadBuffer(const char *s, Term *tp); extern "C" Term YAP_ReadBuffer(const char *s, Term *tp);
class YAPError;
/** /**
* @brief Generic Prolog Term * @brief Generic Prolog Term
*/ */
@ -27,8 +28,8 @@ public:
} /// private method to convert from Term (internal YAP representation) to } /// private method to convert from Term (internal YAP representation) to
/// YAPTerm /// YAPTerm
// do nothing constructor // do nothing constructor
YAPTerm() { t = 0; } YAPTerm() { mk(MkVarTerm()); }
YAPTerm(yhandle_t i) { t= i; }; YAPTerm(yhandle_t i) { t = i; };
/// pointer to term /// pointer to term
YAPTerm(void *ptr); YAPTerm(void *ptr);
/// parse string s and construct a term. /// parse string s and construct a term.
@ -36,6 +37,8 @@ public:
Term tp; Term tp;
mk(YAP_ReadBuffer(s, &tp)); mk(YAP_ReadBuffer(s, &tp));
} }
/// parse string s and construct a term.
YAPTerm(YAPFunctor f, YAPTerm ts[]);
/// extract the tag of a term, after dereferencing. /// extract the tag of a term, after dereferencing.
YAP_tag_t tag(); YAP_tag_t tag();
/// copy the term ( term copy ) /// copy the term ( term copy )
@ -76,7 +79,7 @@ public:
virtual bool isList() { return Yap_IsListTerm(gt()); } /// term is a list virtual bool isList() { return Yap_IsListTerm(gt()); } /// term is a list
/// extract the argument i of the term, where i in 1...arity /// extract the argument i of the term, where i in 1...arity
inline YAPTerm getArg(arity_t i) { virtual YAPTerm getArg(arity_t i) {
BACKUP_MACHINE_REGS(); BACKUP_MACHINE_REGS();
Term t0 = gt(); Term t0 = gt();
YAPTerm tf; YAPTerm tf;
@ -155,9 +158,10 @@ class YAPApplTerm : public YAPTerm {
public: public:
~YAPApplTerm() {} ~YAPApplTerm() {}
YAPApplTerm(YAPFunctor f, YAPTerm ts[]); YAPApplTerm(YAPFunctor f, YAPTerm ts[]);
YAPApplTerm(const char *s, std::vector<YAPTerm> ts);
YAPApplTerm(YAPFunctor f); YAPApplTerm(YAPFunctor f);
YAPFunctor getFunctor(); YAPFunctor getFunctor();
inline YAPTerm getArg(arity_t i) { YAPTerm getArg(arity_t i) {
BACKUP_MACHINE_REGS(); BACKUP_MACHINE_REGS();
Term t0 = gt(); Term t0 = gt();
YAPTerm tf; YAPTerm tf;
@ -254,7 +258,8 @@ public:
else if (to == TermNil) else if (to == TermNil)
return YAPListTerm(); return YAPListTerm();
/* error */ /* error */
throw YAPError(TYPE_ERROR_LIST); Yap_Error(TYPE_ERROR_LIST, t, 0);
throw YAPError();
} }
/// copy a list. /// copy a list.
/// ///
@ -303,7 +308,7 @@ public:
// Constructor: receives an atom; // Constructor: receives an atom;
YAPAtomTerm(YAPAtom a) : YAPTerm() { mk(MkAtomTerm(a.a)); } YAPAtomTerm(YAPAtom a) : YAPTerm() { mk(MkAtomTerm(a.a)); }
// Constructor: receives a sequence of ISO-LATIN1 codes; // Constructor: receives a sequence of ISO-LATIN1 codes;
YAPAtomTerm(char *s); YAPAtomTerm(char s[]);
// Constructor: receives a sequence of up to n ISO-LATIN1 codes; // Constructor: receives a sequence of up to n ISO-LATIN1 codes;
YAPAtomTerm(char *s, size_t len); YAPAtomTerm(char *s, size_t len);
// Constructor: receives a sequence of wchar_ts, whatever they may be; // Constructor: receives a sequence of wchar_ts, whatever they may be;

16
H/LOCALS
View File

@ -86,8 +86,6 @@ char* ScannerStack =NULL
struct scanner_extra_alloc* ScannerExtraBlocks =NULL struct scanner_extra_alloc* ScannerExtraBlocks =NULL
/// worker control information /// worker control information
/// pointer to an exception term, from throw
struct DB_TERM* BallTerm =NULL RestoreBallTerm(wid)
/// stack limit after which the stack is managed by C-code. /// stack limit after which the stack is managed by C-code.
Int CBorder =0 Int CBorder =0
@ -198,12 +196,12 @@ ADDR TrailBase void
ADDR TrailTop void ADDR TrailTop void
char* ErrorMessage void char* ErrorMessage void
Term Error_Term void Term Error_Term void
yap_error_number Error_TYPE void
const char* Error_File void /** error handling info, designed to be easy to pass to the foreign world */
const char* Error_Function void struct yap_error_descriptor ActiveError void
int Error_Lineno void /// pointer to an exception term, from throw
size_t Error_Size void struct DB_TERM* BallTerm =NULL
char ErrorSay[MAX_ERROR_MSG_SIZE] void
jmp_buf IOBotch void jmp_buf IOBotch void
TokEntry* tokptr void TokEntry* tokptr void
TokEntry* toktide void TokEntry* toktide void
@ -307,7 +305,7 @@ UInt exo_arg =0
struct scan_atoms* search_atoms void struct scan_atoms* search_atoms void
struct pred_entry* SearchPreds void struct pred_entry* SearchPreds void
// Slots /// Slots Status
yhandle_t CurSlot =0 yhandle_t CurSlot =0
yhandle_t FrozenHandles =0 yhandle_t FrozenHandles =0
yhandle_t NSlots =0 yhandle_t NSlots =0

11
H/Yap.h
View File

@ -236,7 +236,8 @@ INLINE_ONLY inline EXTERN size_t strnlen(const char *s, size_t maxlen) {
#if !defined(IN_SECOND_QUADRANT) #if !defined(IN_SECOND_QUADRANT)
#if defined(__linux__) || defined(__FreeBSD__) || defined(__NetBSD__) || \ #if defined(__linux__) || defined(__FreeBSD__) || defined(__NetBSD__) || \
defined(mips) || defined(__mips64) || defined(__aarch64__) || (__DragonFly__) defined(mips) || defined(__mips64) || defined(__aarch64__) || \
(__DragonFly__)
#if defined(YAPOR) && defined(__alpha) #if defined(YAPOR) && defined(__alpha)
#define MMAP_ADDR 0x40000000 #define MMAP_ADDR 0x40000000
@ -253,17 +254,15 @@ INLINE_ONLY inline EXTERN size_t strnlen(const char *s, size_t maxlen) {
#endif /* YAPOR && __alpha */ #endif /* YAPOR && __alpha */
#elif __svr4__ || defined(__SVR4) #elif __svr4__ || defined(__SVR4)
#define MMAP_ADDR 0x02000000 #define MMAP_ADDR 0x02000000
#endif /* __linux__ || __FreeBSD__ || __NetBSD__ || mips || __mips64 || __APPLE__ || \ #endif /* __linux__ || __FreeBSD__ || __NetBSD__ || mips || __mips64 || \
__APPLE__ || \
__DragonFly__ */ __DragonFly__ */
#endif /* !IN_SECOND_QUADRANT */ #endif /* !IN_SECOND_QUADRANT */
/* #define RANDOMIZE_START_ADDRESS 1 */ /* #define RANDOMIZE_START_ADDRESS 1 */
extern size_t Yap_page_size; extern size_t Yap_page_size;
#ifdef USE_SYSTEM_MALLOC #ifdef USE_SYSTEM_MALLOC
#define HEAP_INIT_BASE 0L #define HEAP_INIT_BASE 0L
#define AtomBase NULL #define AtomBase NULL
@ -463,8 +462,6 @@ extern ADDR Yap_HeapBase;
/* This is ok for Linux, should be ok for everyone */ /* This is ok for Linux, should be ok for everyone */
#define YAP_FILENAME_MAX 1024 #define YAP_FILENAME_MAX 1024
#define MAX_ERROR_MSG_SIZE YAP_FILENAME_MAX
/************************************************************************************************* /*************************************************************************************************
Debugging Support Debugging Support
*************************************************************************************************/ *************************************************************************************************/

25
H/YapFlags.h
View File

@ -117,9 +117,9 @@ INLINE_ONLY inline EXTERN Term aro(Term inp) {
// INLINE_ONLY inline EXTERN Term booleanFlag( Term inp ); // INLINE_ONLY inline EXTERN Term booleanFlag( Term inp );
static inline Term booleanFlag(Term inp) { static inline Term booleanFlag(Term inp) {
if (inp == TermTrue || inp == TermOn ) if (inp == TermTrue || inp == TermOn)
return TermTrue; return TermTrue;
if ( inp == TermFalse || inp == TermOff) if (inp == TermFalse || inp == TermOff)
return TermFalse; return TermFalse;
if (IsVarTerm(inp)) { if (IsVarTerm(inp)) {
Yap_Error(INSTANTIATION_ERROR, inp, "set_prolog_flag %s", Yap_Error(INSTANTIATION_ERROR, inp, "set_prolog_flag %s",
@ -154,15 +154,13 @@ static Term synerr(Term inp) {
static inline Term filler(Term inp) { return inp; } static inline Term filler(Term inp) { return inp; }
static inline Term list_filler(Term inp) { static inline Term list_filler(Term inp) {
if (IsVarTerm(inp) || if (IsVarTerm(inp) || IsPairTerm(inp) || inp == TermNil)
IsPairTerm(inp) ||
inp == TermNil)
return inp; return inp;
Yap_Error(TYPE_ERROR_LIST, inp, Yap_Error(TYPE_ERROR_LIST, inp, "set_prolog_flag in {codes,string}");
"set_prolog_flag in {codes,string}");
return TermZERO; } return TermZERO;
}
static Term bqs(Term inp) { static Term bqs(Term inp) {
if (inp == TermCodes || inp == TermString || inp == TermSymbolChar) if (inp == TermCodes || inp == TermString || inp == TermSymbolChar)
@ -191,7 +189,9 @@ static inline Term isatom(Term inp) {
return TermZERO; return TermZERO;
} }
static inline Term options(Term inp) { return Yap_IsGroundTerm(inp) ? inp : TermZERO; } static inline Term options(Term inp) {
return Yap_IsGroundTerm(inp) ? inp : TermZERO;
}
// INLINE_ONLY inline EXTERN Term ok( Term inp ); // INLINE_ONLY inline EXTERN Term ok( Term inp );
@ -347,8 +347,7 @@ static inline Term getBackQuotesFlag(void) {
return GLOBAL_Flags[BACKQUOTED_STRING_FLAG].at; return GLOBAL_Flags[BACKQUOTED_STRING_FLAG].at;
} }
static inline Term static inline Term indexingMode(void) { return GLOBAL_Flags[INDEX_FLAG].at; }
indexingMode(void) { return GLOBAL_Flags[INDEX_FLAG].at; }
static inline const char *floatFormat(void) { static inline const char *floatFormat(void) {
return RepAtom(AtomOfTerm(GLOBAL_Flags[FLOAT_FORMAT_FLAG].at))->rep.uStrOfAE; return RepAtom(AtomOfTerm(GLOBAL_Flags[FLOAT_FORMAT_FLAG].at))->rep.uStrOfAE;
@ -358,9 +357,7 @@ static inline size_t indexingDepth(void) {
return IntOfTerm(GLOBAL_Flags[INDEX_SUB_TERM_SEARCH_DEPTH_FLAG].at); return IntOfTerm(GLOBAL_Flags[INDEX_SUB_TERM_SEARCH_DEPTH_FLAG].at);
} }
static inline Term gcTrace(void) { static inline Term gcTrace(void) { return GLOBAL_Flags[GC_TRACE_FLAG].at; }
return GLOBAL_Flags[GC_TRACE_FLAG].at;
}
Term Yap_UnknownFlag(Term mod); Term Yap_UnknownFlag(Term mod);

39
H/YapText.h
View File

@ -181,7 +181,6 @@ inline static utf8proc_ssize_t strlen_utf8(const utf8proc_uint8_t *pt) {
} else { } else {
pt++; pt++;
} }
} }
return rc; return rc;
} }
@ -365,7 +364,7 @@ static inline seq_type_t mod_to_type(Term mod USES_REGS) {
// see pl-incl.h // see pl-incl.h
unsigned int flags = Yap_GetModuleEntry(mod)->flags; unsigned int flags = Yap_GetModuleEntry(mod)->flags;
if (flags & DBLQ_ATOM) { if (flags & DBLQ_ATOM) {
return YAP_STRING_ATOM|YAP_STRING_OUTPUT_TERM; return YAP_STRING_ATOM | YAP_STRING_OUTPUT_TERM;
} else if (flags & DBLQ_STRING) { } else if (flags & DBLQ_STRING) {
return YAP_STRING_STRING; return YAP_STRING_STRING;
} else if (flags & DBLQ_CHARS) { } else if (flags & DBLQ_CHARS) {
@ -380,7 +379,7 @@ static inline seq_type_t mod_to_bqtype(Term mod USES_REGS) {
// see pl-incl.h // see pl-incl.h
unsigned int flags = Yap_GetModuleEntry(mod)->flags; unsigned int flags = Yap_GetModuleEntry(mod)->flags;
if (flags & BCKQ_ATOM) { if (flags & BCKQ_ATOM) {
return YAP_STRING_ATOM|YAP_STRING_OUTPUT_TERM; return YAP_STRING_ATOM | YAP_STRING_OUTPUT_TERM;
} else if (flags & BCKQ_STRING) { } else if (flags & BCKQ_STRING) {
return YAP_STRING_STRING; return YAP_STRING_STRING;
} else if (flags & BCKQ_CHARS) { } else if (flags & BCKQ_CHARS) {
@ -391,8 +390,7 @@ static inline seq_type_t mod_to_bqtype(Term mod USES_REGS) {
// the routines // the routines
extern unsigned char *Yap_readText(seq_tv_t *inp, size_t *lengp extern unsigned char *Yap_readText(seq_tv_t *inp, size_t *lengp USES_REGS);
USES_REGS);
extern bool write_Text(unsigned char *inp, seq_tv_t *out, extern bool write_Text(unsigned char *inp, seq_tv_t *out,
size_t leng USES_REGS); size_t leng USES_REGS);
extern bool Yap_CVT_Text(seq_tv_t *inp, seq_tv_t *out USES_REGS); extern bool Yap_CVT_Text(seq_tv_t *inp, seq_tv_t *out USES_REGS);
@ -738,7 +736,6 @@ static inline Atom Yap_UTF8ToAtom(const unsigned char *s USES_REGS) {
return out.val.a; return out.val.a;
} }
static inline Term Yap_CharsToDiffListOfCodes(const char *s, Term tail, static inline Term Yap_CharsToDiffListOfCodes(const char *s, Term tail,
encoding_t enc USES_REGS) { encoding_t enc USES_REGS) {
seq_tv_t inp, out; seq_tv_t inp, out;
@ -930,7 +927,7 @@ static inline Term Yap_ListToAtomic(Term t0 USES_REGS) {
inp.type = YAP_STRING_STRING | YAP_STRING_ATOMS_CODES | YAP_STRING_TERM; inp.type = YAP_STRING_STRING | YAP_STRING_ATOMS_CODES | YAP_STRING_TERM;
out.val.uc = NULL; out.val.uc = NULL;
out.type = YAP_STRING_ATOM | YAP_STRING_INT | YAP_STRING_FLOAT | out.type = YAP_STRING_ATOM | YAP_STRING_INT | YAP_STRING_FLOAT |
YAP_STRING_BIG |YAP_STRING_OUTPUT_TERM; YAP_STRING_BIG | YAP_STRING_OUTPUT_TERM;
if (!Yap_CVT_Text(&inp, &out PASS_REGS)) if (!Yap_CVT_Text(&inp, &out PASS_REGS))
return 0L; return 0L;
return out.val.t; return out.val.t;
@ -1083,7 +1080,6 @@ static inline Term Yap_NCharsToTBQ(const char *s, size_t len, encoding_t enc,
inp.type = YAP_STRING_CHARS | YAP_STRING_NCHARS; inp.type = YAP_STRING_CHARS | YAP_STRING_NCHARS;
inp.enc = enc; inp.enc = enc;
out.type = mod_to_bqtype(mod PASS_REGS); out.type = mod_to_bqtype(mod PASS_REGS);
out.max = len; out.max = len;
if (!Yap_CVT_Text(&inp, &out PASS_REGS)) if (!Yap_CVT_Text(&inp, &out PASS_REGS))
@ -1215,8 +1211,8 @@ static inline size_t Yap_StringToAtomic(Term t0 USES_REGS) {
seq_tv_t inp, out; seq_tv_t inp, out;
inp.val.t = t0; inp.val.t = t0;
inp.type = YAP_STRING_STRING; inp.type = YAP_STRING_STRING;
out.type = YAP_STRING_ATOM | YAP_STRING_INT | YAP_STRING_FLOAT | out.type =
YAP_STRING_BIG ; YAP_STRING_ATOM | YAP_STRING_INT | YAP_STRING_FLOAT | YAP_STRING_BIG;
out.val.uc = NULL; out.val.uc = NULL;
if (!Yap_CVT_Text(&inp, &out PASS_REGS)) if (!Yap_CVT_Text(&inp, &out PASS_REGS))
return 0L; return 0L;
@ -1322,6 +1318,17 @@ static inline Term Yap_TextToString(Term t0 USES_REGS) {
return out.val.t; return out.val.t;
} }
static inline void Yap_OverwriteUTF8BufferToLowCase(void *buf USES_REGS) {
unsigned char *s = (unsigned char *)buf;
while (*s) {
// assumes the two code have always the same size;
utf8proc_int32_t chr;
get_utf8(s, -1, &chr);
chr = utf8proc_tolower(chr);
s += put_utf8(s, chr);
}
}
static inline const unsigned char *Yap_TextToUTF8Buffer(Term t0 USES_REGS) { static inline const unsigned char *Yap_TextToUTF8Buffer(Term t0 USES_REGS) {
seq_tv_t inp, out; seq_tv_t inp, out;
@ -1456,8 +1463,7 @@ static inline Atom Yap_SubtractHeadAtom(Term t1, Term th USES_REGS) {
outv[0].val.t = th; outv[0].val.t = th;
outv[1].type = YAP_STRING_ATOM; outv[1].type = YAP_STRING_ATOM;
outv[1].val.t = 0; outv[1].val.t = 0;
if (!Yap_Splice_Text(2, (size_t *)NULL, &inp, if (!Yap_Splice_Text(2, (size_t *)NULL, &inp, outv PASS_REGS))
outv PASS_REGS))
return (Atom)NULL; return (Atom)NULL;
return outv[1].val.a; return outv[1].val.a;
} }
@ -1470,8 +1476,7 @@ static inline Atom Yap_SubtractTailAtom(Term t1, Term th USES_REGS) {
outv[0].val.t = 0; outv[0].val.t = 0;
outv[1].type = YAP_STRING_ATOM; outv[1].type = YAP_STRING_ATOM;
outv[1].val.t = th; outv[1].val.t = th;
if (!Yap_Splice_Text(2, (size_t *)NULL, &inp, if (!Yap_Splice_Text(2, (size_t *)NULL, &inp, outv PASS_REGS))
outv PASS_REGS))
return (Atom)NULL; return (Atom)NULL;
return outv[0].val.a; return outv[0].val.a;
} }
@ -1501,8 +1506,7 @@ static inline Term Yap_SubtractHeadString(Term t1, Term th USES_REGS) {
outv[0].val.t = th; outv[0].val.t = th;
outv[1].type = YAP_STRING_STRING; outv[1].type = YAP_STRING_STRING;
outv[1].val.t = 0; outv[1].val.t = 0;
if (!Yap_Splice_Text(2, (size_t *)NULL, &inp, if (!Yap_Splice_Text(2, (size_t *)NULL, &inp, outv PASS_REGS))
outv PASS_REGS))
return 0L; return 0L;
return outv[1].val.t; return outv[1].val.t;
} }
@ -1515,8 +1519,7 @@ static inline Term Yap_SubtractTailString(Term t1, Term th USES_REGS) {
outv[0].val.t = 0; outv[0].val.t = 0;
outv[1].type = YAP_STRING_STRING; outv[1].type = YAP_STRING_STRING;
outv[1].val.t = th; outv[1].val.t = th;
if (!Yap_Splice_Text(2, (size_t *)NULL, &inp, if (!Yap_Splice_Text(2, (size_t *)NULL, &inp, outv PASS_REGS))
outv PASS_REGS))
return 0L; return 0L;
return outv[0].val.t; return outv[0].val.t;
} }

1
H/Yatom.h
View File

@ -620,6 +620,7 @@ typedef struct pred_entry {
#ifdef BEAM #ifdef BEAM
struct Predicates *beamTable; struct Predicates *beamTable;
#endif #endif
struct yami *MetaEntryOfPred; /* allow direct access from meta-calls */
Term ModuleOfPred; /* module for this definition */ Term ModuleOfPred; /* module for this definition */
UInt TimeStampOfPred; UInt TimeStampOfPred;
timestamp_type LastCallOfPred; timestamp_type LastCallOfPred;

1
H/clause.h
View File

@ -278,6 +278,7 @@ typedef struct dbterm_list {
wamreg Yap_emit_x(CELL); wamreg Yap_emit_x(CELL);
COUNT Yap_compile_cmp_flags(PredEntry *); COUNT Yap_compile_cmp_flags(PredEntry *);
void Yap_InitComma(void); void Yap_InitComma(void);
yamop *Yap_InitCommaContinuation(PredEntry *);
/* cdmgr.c */ /* cdmgr.c */
void Yap_IPred(PredEntry *, UInt, yamop *); void Yap_IPred(PredEntry *, UInt, yamop *);

2
H/generated/dhstruct.h
View File

@ -48,7 +48,7 @@
#define HeapLim Yap_heap_regs->HeapLim_ #define HeapLim Yap_heap_regs->HeapLim_
#define FreeBlocks Yap_heap_regs->FreeBlocks_ #define FreeBlocks Yap_heap_regs->FreeBlocks_
#if defined(YAPOR) || defined(THREADS) #if defined(YAPOR) || defined(THREADS)
#define fFreeBlocksLock Yap_heap_regs->FreeBlocksLock_ #define FreeBlocksLock Yap_heap_regs->FreeBlocksLock_
#define HeapUsedLock Yap_heap_regs->HeapUsedLock_ #define HeapUsedLock Yap_heap_regs->HeapUsedLock_
#define HeapTopLock Yap_heap_regs->HeapTopLock_ #define HeapTopLock Yap_heap_regs->HeapTopLock_
#define HeapTopOwner Yap_heap_regs->HeapTopOwner_ #define HeapTopOwner Yap_heap_regs->HeapTopOwner_

21
H/generated/dlocals.h
View File

@ -133,9 +133,6 @@
#define REMOTE_ScannerExtraBlocks(wid) REMOTE(wid)->ScannerExtraBlocks_ #define REMOTE_ScannerExtraBlocks(wid) REMOTE(wid)->ScannerExtraBlocks_
#define LOCAL_BallTerm LOCAL->BallTerm_
#define REMOTE_BallTerm(wid) REMOTE(wid)->BallTerm_
#define LOCAL_CBorder LOCAL->CBorder_ #define LOCAL_CBorder LOCAL->CBorder_
#define REMOTE_CBorder(wid) REMOTE(wid)->CBorder_ #define REMOTE_CBorder(wid) REMOTE(wid)->CBorder_
@ -295,18 +292,12 @@
#define REMOTE_ErrorMessage(wid) REMOTE(wid)->ErrorMessage_ #define REMOTE_ErrorMessage(wid) REMOTE(wid)->ErrorMessage_
#define LOCAL_Error_Term LOCAL->Error_Term_ #define LOCAL_Error_Term LOCAL->Error_Term_
#define REMOTE_Error_Term(wid) REMOTE(wid)->Error_Term_ #define REMOTE_Error_Term(wid) REMOTE(wid)->Error_Term_
#define LOCAL_Error_TYPE LOCAL->Error_TYPE_
#define REMOTE_Error_TYPE(wid) REMOTE(wid)->Error_TYPE_ #define LOCAL_ActiveError LOCAL->ActiveError_
#define LOCAL_Error_File LOCAL->Error_File_ #define REMOTE_ActiveError(wid) REMOTE(wid)->ActiveError_
#define REMOTE_Error_File(wid) REMOTE(wid)->Error_File_
#define LOCAL_Error_Function LOCAL->Error_Function_ #define LOCAL_BallTerm LOCAL->BallTerm_
#define REMOTE_Error_Function(wid) REMOTE(wid)->Error_Function_ #define REMOTE_BallTerm(wid) REMOTE(wid)->BallTerm_
#define LOCAL_Error_Lineno LOCAL->Error_Lineno_
#define REMOTE_Error_Lineno(wid) REMOTE(wid)->Error_Lineno_
#define LOCAL_Error_Size LOCAL->Error_Size_
#define REMOTE_Error_Size(wid) REMOTE(wid)->Error_Size_
#define LOCAL_ErrorSay LOCAL->ErrorSay_
#define REMOTE_ErrorSay(wid) REMOTE(wid)->ErrorSay_
#define LOCAL_IOBotch LOCAL->IOBotch_ #define LOCAL_IOBotch LOCAL->IOBotch_
#define REMOTE_IOBotch(wid) REMOTE(wid)->IOBotch_ #define REMOTE_IOBotch(wid) REMOTE(wid)->IOBotch_
#define LOCAL_tokptr LOCAL->tokptr_ #define LOCAL_tokptr LOCAL->tokptr_

208
H/generated/hlocals.h
View File

@ -1,22 +1,23 @@
/* This file, hlocals.h, was generated automatically by "yap -L misc/buildlocalglobal" /* This file, hlocals.h, was generated automatically by "yap -L
misc/buildlocalglobal"
please do not update, update H/LOCALS instead */ please do not update, update H/LOCALS instead */
// Stuff that must be considered local to a thread or worker // Stuff that must be considered local to a thread or worker
typedef struct worker_local { typedef struct worker_local {
// Streams // Streams
int c_input_stream_; int c_input_stream_;
int c_output_stream_; int c_output_stream_;
int c_error_stream_; int c_error_stream_;
bool sockets_io_; bool sockets_io_;
bool within_print_message_; bool within_print_message_;
// //
// Used by the prompts to check if they are after a newline, and then a // Used by the prompts to check if they are after a newline, and then a
// prompt should be output, or if we are in the middle of a line. // prompt should be output, or if we are in the middle of a line.
// //
bool newline_; bool newline_;
Atom AtPrompt_; Atom AtPrompt_;
char Prompt_[MAX_PROMPT+1]; char Prompt_[MAX_PROMPT + 1];
encoding_t encoding_; encoding_t encoding_;
bool quasi_quotations_; bool quasi_quotations_;
UInt default_priority_; UInt default_priority_;
@ -24,13 +25,13 @@ typedef struct worker_local {
UInt max_depth_; UInt max_depth_;
UInt max_list_; UInt max_list_;
UInt max_write_args_; UInt max_write_args_;
// Restore info // Restore info
CELL* OldASP_; CELL *OldASP_;
CELL* OldLCL0_; CELL *OldLCL0_;
tr_fr_ptr OldTR_; tr_fr_ptr OldTR_;
CELL* OldGlobalBase_; CELL *OldGlobalBase_;
CELL* OldH_; CELL *OldH_;
CELL* OldH0_; CELL *OldH0_;
ADDR OldTrailBase_; ADDR OldTrailBase_;
ADDR OldTrailTop_; ADDR OldTrailTop_;
ADDR OldHeapBase_; ADDR OldHeapBase_;
@ -39,53 +40,51 @@ typedef struct worker_local {
Int GDiff_; Int GDiff_;
Int HDiff_; Int HDiff_;
Int GDiff0_; Int GDiff0_;
CELL* GSplit_; CELL *GSplit_;
Int LDiff_; Int LDiff_;
Int TrDiff_; Int TrDiff_;
Int XDiff_; Int XDiff_;
Int DelayDiff_; Int DelayDiff_;
Int BaseDiff_; Int BaseDiff_;
// Reduction counters // Reduction counters
YAP_ULONG_LONG ReductionsCounter_; YAP_ULONG_LONG ReductionsCounter_;
YAP_ULONG_LONG PredEntriesCounter_; YAP_ULONG_LONG PredEntriesCounter_;
YAP_ULONG_LONG RetriesCounter_; YAP_ULONG_LONG RetriesCounter_;
int ReductionsCounterOn_; int ReductionsCounterOn_;
int PredEntriesCounterOn_; int PredEntriesCounterOn_;
int RetriesCounterOn_; int RetriesCounterOn_;
// support for consulting files // support for consulting files
/* current consult stack */ /* current consult stack */
union CONSULT_OBJ* ConsultSp_; union CONSULT_OBJ *ConsultSp_;
/* current maximum number of cells in consult stack */ /* current maximum number of cells in consult stack */
UInt ConsultCapacity_; UInt ConsultCapacity_;
/* top of consult stack */ /* top of consult stack */
union CONSULT_OBJ* ConsultBase_; union CONSULT_OBJ *ConsultBase_;
/* low-water mark for consult */ /* low-water mark for consult */
union CONSULT_OBJ* ConsultLow_; union CONSULT_OBJ *ConsultLow_;
Term VarNames_; Term VarNames_;
Atom SourceFileName_; Atom SourceFileName_;
UInt SourceFileLineno_; UInt SourceFileLineno_;
//global variables // global variables
Term GlobalArena_; Term GlobalArena_;
UInt GlobalArenaOverflows_; UInt GlobalArenaOverflows_;
Int ArenaOverflows_; Int ArenaOverflows_;
Int DepthArenas_; Int DepthArenas_;
int ArithError_; int ArithError_;
struct pred_entry* LastAssertedPred_; struct pred_entry *LastAssertedPred_;
struct pred_entry* TmpPred_; struct pred_entry *TmpPred_;
char* ScannerStack_; char *ScannerStack_;
struct scanner_extra_alloc* ScannerExtraBlocks_; struct scanner_extra_alloc *ScannerExtraBlocks_;
/// worker control information /// worker control information
/// pointer to an exception term, from throw /// stack limit after which the stack is managed by C-code.
struct DB_TERM* BallTerm_;
/// stack limit after which the stack is managed by C-code.
Int CBorder_; Int CBorder_;
/// max number of signals (uint64_t) /// max number of signals (uint64_t)
UInt MaxActiveSignals_; UInt MaxActiveSignals_;
/// actual life signals /// actual life signals
uint64_t Signals_; uint64_t Signals_;
/// indexing help data? /// indexing help data?
UInt IPredArity_; UInt IPredArity_;
yamop* ProfEnd_; yamop *ProfEnd_;
int DoingUndefp_; int DoingUndefp_;
Int StartCharCount_; Int StartCharCount_;
Int StartLineCount_; Int StartLineCount_;
@ -95,7 +94,7 @@ typedef struct worker_local {
Term WokenGoals_; Term WokenGoals_;
Term AttsMutableList_; Term AttsMutableList_;
#endif #endif
// gc_stuff // gc_stuff
Term GcGeneration_; Term GcGeneration_;
Term GcPhase_; Term GcPhase_;
UInt GcCurrentPhase_; UInt GcCurrentPhase_;
@ -104,50 +103,51 @@ typedef struct worker_local {
YAP_ULONG_LONG TotGcRecovered_; YAP_ULONG_LONG TotGcRecovered_;
Int LastGcTime_; Int LastGcTime_;
Int LastSSTime_; Int LastSSTime_;
CELL* OpenArray_; CELL *OpenArray_;
/* in a single gc */ /* in a single gc */
Int total_marked_; Int total_marked_;
Int total_oldies_; Int total_oldies_;
struct choicept* current_B_; struct choicept *current_B_;
CELL* prev_HB_; CELL *prev_HB_;
CELL* HGEN_; CELL *HGEN_;
CELL** iptop_; CELL **iptop_;
#if defined(GC_NO_TAGS) #if defined(GC_NO_TAGS)
char* bp_; char *bp_;
#endif #endif
tr_fr_ptr sTR_; tr_fr_ptr sTR_;
tr_fr_ptr sTR0_; tr_fr_ptr sTR0_;
tr_fr_ptr new_TR_; tr_fr_ptr new_TR_;
struct gc_mark_continuation* cont_top0_; struct gc_mark_continuation *cont_top0_;
struct gc_mark_continuation* cont_top_; struct gc_mark_continuation *cont_top_;
int discard_trail_entries_; int discard_trail_entries_;
gc_ma_hash_entry gc_ma_hash_table_[GC_MAVARS_HASH_SIZE]; gc_ma_hash_entry gc_ma_hash_table_[GC_MAVARS_HASH_SIZE];
gc_ma_hash_entry* gc_ma_h_top_; gc_ma_hash_entry *gc_ma_h_top_;
gc_ma_hash_entry* gc_ma_h_list_; gc_ma_hash_entry *gc_ma_h_list_;
UInt gc_timestamp_; UInt gc_timestamp_;
ADDR db_vec_; ADDR db_vec_;
ADDR db_vec0_; ADDR db_vec0_;
struct RB_red_blk_node* db_root_; struct RB_red_blk_node *db_root_;
struct RB_red_blk_node* db_nil_; struct RB_red_blk_node *db_nil_;
sigjmp_buf gc_restore_; sigjmp_buf gc_restore_;
CELL* extra_gc_cells_; CELL *extra_gc_cells_;
CELL* extra_gc_cells_base_; CELL *extra_gc_cells_base_;
CELL* extra_gc_cells_top_; CELL *extra_gc_cells_top_;
UInt extra_gc_cells_size_; UInt extra_gc_cells_size_;
struct array_entry* DynamicArrays_; struct array_entry *DynamicArrays_;
struct static_array_entry* StaticArrays_; struct static_array_entry *StaticArrays_;
struct global_entry* GlobalVariables_; struct global_entry *GlobalVariables_;
int AllowRestart_; int AllowRestart_;
// Thread Local Area for Fast Storage of Intermediate Compiled Code // Thread Local Area for Fast Storage of Intermediate Compiled Code
struct mem_blk* CMemFirstBlock_; struct mem_blk *CMemFirstBlock_;
UInt CMemFirstBlockSz_; UInt CMemFirstBlockSz_;
// Variable used by the compiler to store number of permanent vars in a clause // Variable used by the compiler to store number of permanent vars in a clause
int nperm_; int nperm_;
// Thread Local Area for Labels // Thread Local Area for Labels
Int* LabelFirstArray_; Int *LabelFirstArray_;
UInt LabelFirstArraySz_; UInt LabelFirstArraySz_;
// Thread Local Area for SWI-Prolog emulation routines. // Thread Local Area for SWI-Prolog emulation routines.
// struct PL_local_data* PL_local_data_p =Yap_InitThreadIO(wid) // struct PL_local_data* PL_local_data_p
// =Yap_InitThreadIO(wid)
#ifdef THREADS #ifdef THREADS
struct thandle ThreadHandle_; struct thandle ThreadHandle_;
#endif /* THREADS */ #endif /* THREADS */
@ -156,59 +156,57 @@ typedef struct worker_local {
UInt TabMode_; UInt TabMode_;
#endif /* YAPOR || TABLING */ #endif /* YAPOR || TABLING */
int InterruptsDisabled_; int InterruptsDisabled_;
struct open_query_struct* execution_; struct open_query_struct *execution_;
#if LOW_LEVEL_TRACER #if LOW_LEVEL_TRACER
Int total_choicepoints_; Int total_choicepoints_;
#endif #endif
int consult_level_; int consult_level_;
// Variables related to memory allocation // Variables related to memory allocation
ADDR LocalBase_; ADDR LocalBase_;
ADDR GlobalBase_; ADDR GlobalBase_;
ADDR TrailBase_; ADDR TrailBase_;
ADDR TrailTop_; ADDR TrailTop_;
char* ErrorMessage_; char *ErrorMessage_;
Term Error_Term_; Term Error_Term_;
yap_error_number Error_TYPE_; /** error handling info, designed to be easy to pass to the foreign world */
const char* Error_File_; struct yap_error_descriptor ActiveError_;
const char* Error_Function_; /// pointer to an exception term, from throw
int Error_Lineno_; struct DB_TERM *BallTerm_;
size_t Error_Size_;
char ErrorSay_[MAX_ERROR_MSG_SIZE];
jmp_buf IOBotch_; jmp_buf IOBotch_;
TokEntry* tokptr_; TokEntry *tokptr_;
TokEntry* toktide_; TokEntry *toktide_;
VarEntry* VarTable_; VarEntry *VarTable_;
VarEntry* AnonVarTable_; VarEntry *AnonVarTable_;
Term Comments_; Term Comments_;
CELL* CommentsTail_; CELL *CommentsTail_;
CELL* CommentsNextChar_; CELL *CommentsNextChar_;
wchar_t* CommentsBuff_; wchar_t *CommentsBuff_;
size_t CommentsBuffPos_; size_t CommentsBuffPos_;
size_t CommentsBuffLim_; size_t CommentsBuffLim_;
sigjmp_buf RestartEnv_; sigjmp_buf RestartEnv_;
char FileNameBuf_[YAP_FILENAME_MAX]; char FileNameBuf_[YAP_FILENAME_MAX + 1];
char FileNameBuf2_[YAP_FILENAME_MAX]; char FileNameBuf2_[YAP_FILENAME_MAX + 1];
// Prolog State // Prolog State
UInt BreakLevel_; UInt BreakLevel_;
Int PrologMode_; Int PrologMode_;
int CritLocks_; int CritLocks_;
// Prolog execution and state flags // Prolog execution and state flags
union flagTerm* Flags_; union flagTerm *Flags_;
UInt flagCount_; UInt flagCount_;
//analyst.c // analyst.c
/* used to find out how many instructions of each kind are executed */ /* used to find out how many instructions of each kind are executed */
#ifdef ANALYST #ifdef ANALYST
YAP_ULONG_LONG opcount_[_std_top+1]; YAP_ULONG_LONG opcount_[_std_top + 1];
YAP_ULONG_LONG 2opcount[_std_top+1][_std_top+1]_; YAP_ULONG_LONG 2opcount [_std_top + 1][_std_top + 1] _;
#endif /* ANALYST */ #endif /* ANALYST */
//dbase.c // dbase.c
struct db_globs* s_dbg_; struct db_globs *s_dbg_;
//eval.c // eval.c
yap_error_number matherror_; yap_error_number matherror_;
Term mathtt_; Term mathtt_;
char* mathstring_; char *mathstring_;
yap_error_number CurrentError_; yap_error_number CurrentError_;
//grow.c // grow.c
int heap_overflows_; int heap_overflows_;
Int total_heap_overflow_time_; Int total_heap_overflow_time_;
int stack_overflows_; int stack_overflows_;
@ -219,15 +217,15 @@ const char* Error_Function_;
Int total_trail_overflow_time_; Int total_trail_overflow_time_;
int atom_table_overflows_; int atom_table_overflows_;
Int total_atom_table_overflow_time_; Int total_atom_table_overflow_time_;
//load_dyld // load_dyld
#ifdef LOAD_DYLD #ifdef LOAD_DYLD
int dl_errno_; int dl_errno_;
#endif #endif
//tracer.c // tracer.c
#ifdef LOW_LEVEL_TRACER #ifdef LOW_LEVEL_TRACER
int do_trace_primitives_; int do_trace_primitives_;
#endif #endif
//quick loader // quick loader
struct export_atom_hash_entry_struct *ExportAtomHashChain_; struct export_atom_hash_entry_struct *ExportAtomHashChain_;
UInt ExportAtomHashTableSize_; UInt ExportAtomHashTableSize_;
UInt ExportAtomHashTableNum_; UInt ExportAtomHashTableNum_;
@ -255,25 +253,25 @@ const char* Error_Function_;
UInt ImportDBRefHashTableSize_; UInt ImportDBRefHashTableSize_;
UInt ImportDBRefHashTableNum_; UInt ImportDBRefHashTableNum_;
yamop *ImportFAILCODE_; yamop *ImportFAILCODE_;
// exo indexing // exo indexing
UInt ibnds_[256]; UInt ibnds_[256];
struct index_t* exo_it_; struct index_t *exo_it_;
CELL* exo_base_; CELL *exo_base_;
UInt exo_arity_; UInt exo_arity_;
UInt exo_arg_; UInt exo_arg_;
// atom completion // atom completion
struct scan_atoms* search_atoms_; struct scan_atoms *search_atoms_;
struct pred_entry* SearchPreds_; struct pred_entry *SearchPreds_;
// Slots /// Slots Status
yhandle_t CurSlot_; yhandle_t CurSlot_;
yhandle_t FrozenHandles_; yhandle_t FrozenHandles_;
yhandle_t NSlots_; yhandle_t NSlots_;
CELL* SlotBase_; CELL *SlotBase_;
// Mutexes // Mutexes
struct swi_mutex* Mutexes_; struct swi_mutex *Mutexes_;
Term SourceModule_; Term SourceModule_;
Term Including_; Term Including_;
size_t MAX_SIZE_; size_t MAX_SIZE_;
/* last call to walltime. */ /* last call to walltime. */
uint64_t LastWTime_; uint64_t LastWTime_;
} w_local; } w_local;

6
H/generated/ilocals.h
View File

@ -76,8 +76,6 @@ static void InitWorker(int wid) {
REMOTE_ScannerExtraBlocks(wid) = NULL; REMOTE_ScannerExtraBlocks(wid) = NULL;
REMOTE_BallTerm(wid) = NULL;
REMOTE_CBorder(wid) = 0; REMOTE_CBorder(wid) = 0;
REMOTE_MaxActiveSignals(wid) = 64L; REMOTE_MaxActiveSignals(wid) = 64L;
@ -171,9 +169,7 @@ static void InitWorker(int wid) {
REMOTE_BallTerm(wid) = NULL;

4
H/generated/rlocals.h
View File

@ -76,8 +76,6 @@ static void RestoreWorker(int wid USES_REGS) {
RestoreBallTerm(wid);
@ -192,8 +190,6 @@ static void RestoreWorker(int wid USES_REGS) {

19
H/rheap.h
View File

@ -934,28 +934,29 @@ static void RestoreForeignCode__(USES_REGS1) {
} }
} }
static void RestoreBallTerm(int wid) {
CACHE_REGS
if (LOCAL_BallTerm) {
LOCAL_BallTerm = DBTermAdjust(LOCAL_BallTerm);
RestoreDBTerm(LOCAL_BallTerm, false, 1 PASS_REGS);
}
}
static void RestoreYapRecords__(USES_REGS1) { static void RestoreYapRecords__(USES_REGS1) {
struct record_list *ptr; struct record_list *ptr;
RestoreBallTerm(worker_id);
Yap_Records = DBRecordAdjust(Yap_Records); Yap_Records = DBRecordAdjust(Yap_Records);
ptr = Yap_Records; ptr = Yap_Records;
while (ptr) { while (ptr) {
ptr->next_rec = DBRecordAdjust(ptr->next_rec); ptr->next_rec = DBRecordAdjust(ptr->next_rec);
ptr->prev_rec = DBRecordAdjust(ptr->prev_rec); ptr->prev_rec = DBRecordAdjust(ptr->prev_rec);
ptr->dbrecord = DBTermAdjust(ptr->dbrecord); ptr->dbrecord = DBTermAdjust(ptr->dbrecord);
RestoreDBTerm(ptr->dbrecord, false,0 PASS_REGS); RestoreDBTerm(ptr->dbrecord, false, 0 PASS_REGS);
ptr = ptr->next_rec; ptr = ptr->next_rec;
} }
} }
static void RestoreBallTerm(int wid) {
CACHE_REGS
if (LOCAL_BallTerm) {
LOCAL_BallTerm = DBTermAdjust(LOCAL_BallTerm);
RestoreDBTerm(LOCAL_BallTerm, false,1 PASS_REGS);
}
}
#if defined(THREADS) || defined(YAPOR) #if defined(THREADS) || defined(YAPOR)
#include "rglobals.h" #include "rglobals.h"
#endif #endif

15
H/tracer.h
View File

@ -27,10 +27,19 @@ typedef enum {
retry_table_loader retry_table_loader
} yap_low_level_port; } yap_low_level_port;
void low_level_trace(yap_low_level_port, PredEntry *, CELL *); #ifdef saveregs
#define low_level_trace(Port, pred, args) \
{ \
saveregs(); \
low_level_trace__(Port, pred, args); \
setregs(); \
}
#else
#define low_level_trace(Port, pred, args) low_level_trace__(Port, pred, args)
#endif
void low_level_trace__(yap_low_level_port, PredEntry *, CELL *);
void Yap_InitLowLevelTrace(void); void Yap_InitLowLevelTrace(void);
void toggle_low_level_trace(void); void toggle_low_level_trace(void);
#endif #endif

75
Prelims.cmake
View File

@ -9,11 +9,11 @@ endif()
if (ANDROID) if (ANDROID)
macro ( MY_add_custom_target) macro ( MY_add_custom_target)
endmacro() endmacro()
else() else()
macro ( MY_add_custom_target ) macro ( MY_add_custom_target )
add_custom_target (${ARGN}) add_custom_target (${ARGN})
endmacro() endmacro()
endif() endif()
@ -22,86 +22,86 @@ if (ANDROID)
foreach(item ${ARGN}) foreach(item ${ARGN})
get_filename_component(i ${item} ABSOLUTE) get_filename_component(i ${item} ABSOLUTE)
set( ALL_SOURCES ${ALL_SOURCES} ${i} ) set( ALL_SOURCES ${ALL_SOURCES} ${i} )
endforeach() endforeach()
set( ALL_SOURCES ${ALL_SOURCES} PARENT_SCOPE ) set( ALL_SOURCES ${ALL_SOURCES} PARENT_SCOPE )
endmacro() endmacro()
macro ( add_external arg1) macro ( add_external arg1)
foreach(item ${ARGN}) foreach(item ${ARGN})
get_filename_component(i ${item} ABSOLUTE) get_filename_component(i ${item} ABSOLUTE)
set( ALL_SOURCES ${ALL_SOURCES} ${i} ) set( ALL_SOURCES ${ALL_SOURCES} ${i} )
endforeach() endforeach()
set( ALL_SOURCES ${ALL_SOURCES} PARENT_SCOPE ) set( ALL_SOURCES ${ALL_SOURCES} PARENT_SCOPE )
endmacro() endmacro()
else() else()
macro ( add_component arg1 ) macro ( add_component arg1 )
add_library ( ${arg1} OBJECT ${ARGN}) add_library ( ${arg1} OBJECT ${ARGN})
endmacro() endmacro()
macro ( add_external arg1 ) macro ( add_external arg1 )
add_library ( ${arg1} SHARED ${ARGN}) add_library ( ${arg1} SHARED ${ARGN})
endmacro() endmacro()
endif() endif()
if (ANDROID) if (ANDROID)
macro ( MY_add_dependencies) macro ( MY_add_dependencies)
endmacro() endmacro()
else() else()
macro ( MY_add_dependencies ) macro ( MY_add_dependencies )
add_dependencies (${ARGN}) add_dependencies (${ARGN})
endmacro() endmacro()
endif() endif()
if (ANDROID) if (ANDROID)
macro ( MY_add_library) macro ( MY_add_library)
endmacro() endmacro()
else() else()
macro ( MY_add_library ) macro ( MY_add_library )
add_library (${ARGN}) add_library (${ARGN})
endmacro() endmacro()
endif() endif()
if (ANDROID) if (ANDROID)
macro ( MY_add_subdirectory) macro ( MY_add_subdirectory)
endmacro() endmacro()
else() else()
macro ( MY_add_subdirectory ) macro ( MY_add_subdirectory )
add_subdirectory (${ARGN}) add_subdirectory (${ARGN})
endmacro() endmacro()
endif() endif()
if (ANDROID) if (ANDROID)
macro ( MY_include) macro ( MY_include)
endmacro() endmacro()
else() else()
macro ( MY_include ) macro ( MY_include )
include (${ARGN}) include (${ARGN})
endmacro() endmacro()
endif() endif()
if (ANDROID) if (ANDROID)
macro ( MY_install) macro ( MY_install)
endmacro() endmacro()
else() else()
macro ( MY_install ) macro ( MY_install )
install (${ARGN}) install (${ARGN})
endmacro() endmacro()
endif() endif()
if (ANDROID) if (ANDROID)
macro ( MY_set_target_properties) macro ( MY_set_target_properties)
endmacro() endmacro()
else() else()
macro ( MY_set_target_properties ) macro ( MY_set_target_properties )
set_target_properties (${ARGN}) set_target_properties (${ARGN})
endmacro() endmacro()
endif() endif()
if (ANDROID) if (ANDROID)
macro ( MY_target_link_libraries) macro ( MY_target_link_libraries)
endmacro() endmacro()
else() else()
macro ( MY_target_link_libraries ) macro ( MY_target_link_libraries )
target_link_libraries (${ARGN}) target_link_libraries (${ARGN})
endmacro() endmacro()
endif() endif()
@ -131,41 +131,32 @@ disallow_intree_builds()
# set(CMAKE_BUILD_TYPE Debug) # set(CMAKE_BUILD_TYPE Debug)
if (APPLE) if (APPLE)
set (MACOSX_RPATH ON) set (MACOSX_RPATH ON)
endif (APPLE ) endif (APPLE )
if(POLICY CMP0042) if(POLICY CMP0042)
cmake_policy(SET CMP0042 NEW) cmake_policy(SET CMP0042 NEW)
endif(POLICY CMP0042) endif(POLICY CMP0042)
if(POLICY CMP0043) if(POLICY CMP0043)
cmake_policy(SET CMP0043 NEW) cmake_policy(SET CMP0043 NEW)
endif(POLICY CMP0043) endif(POLICY CMP0043)
if (ANDROID)
set (prefix ${CMAKE_SOURCE_DIR}/../app/src/main)
set ( exec_prefix "${prefix}")
set ( libdir "${exec_prefix}/jni/${ANDROID_ABI}")
set ( dlls "${libdir}")
set ( includedir "${prefix}/assets/include")
set ( datarootdir "${prefix}/assets/share")
set ( libpl "${prefix}/assets/share/Yap")
set ( datadir "${datarootdir}")
set ( mandir "${datarootdir}/man")
set ( bindir "${exec_prefix}/bin")
set ( docdir "${exec_prefix}/assets/share/doc/yap")
else()
set ( prefix "${CMAKE_INSTALL_PREFIX}") set ( prefix "${CMAKE_INSTALL_PREFIX}")
set ( exec_prefix "${prefix}") set ( exec_prefix "${prefix}")
set ( libdir "${exec_prefix}/lib") set ( libdir "${exec_prefix}/lib")
set ( dlls "${exec_prefix}/lib/Yap") set ( dlls "${exec_prefix}/lib/Yap")
set ( includedir "${prefix}/include") set ( includedir "${prefix}/include")
set ( datarootdir "${prefix}/share") set ( datarootdir "${prefix}/share")
set ( libpl "${prefix}/share/Yap") if (ANDROID)
set ( libpl "${CMAKE_LIBRARY_OUTPUT_DIRECTORY}/../../../../../build/generated/assets/Yap")
else()
set ( libpl "${datarootdir}/Yap")
endif()
set ( datadir "${datarootdir}") set ( datadir "${datarootdir}")
set ( mandir "${datarootdir}/man") set ( mandir "${datarootdir}/man")
set ( bindir "${exec_prefix}/bin") set ( bindir "${exec_prefix}/bin")
set ( docdir "${exec_prefix}/share/doc/Yap") set ( docdir "${exec_prefix}/doc/Yap")
endif()
set(YAP_ROOTDIR ${prefix}) set(YAP_ROOTDIR ${prefix})

1
cmake/Config.cmake
View File

@ -345,6 +345,7 @@ check_function_exists(strcasestr HAVE_STRCASESTR)
check_function_exists(strchr HAVE_STRCHR) check_function_exists(strchr HAVE_STRCHR)
check_function_exists(strerror HAVE_STRERROR) check_function_exists(strerror HAVE_STRERROR)
check_function_exists(stricmp HAVE_STRICMP) check_function_exists(stricmp HAVE_STRICMP)
check_function_exists(strlcpy HAVE_STRLCPY)
check_function_exists(strlwr HAVE_STRLWR) check_function_exists(strlwr HAVE_STRLWR)
check_function_exists(strncasecmp HAVE_STRNCASECMP) check_function_exists(strncasecmp HAVE_STRNCASECMP)
check_function_exists(strncat HAVE_STRNCAT) check_function_exists(strncat HAVE_STRNCAT)

3
config.h.cmake
View File

@ -2011,6 +2011,9 @@ calls it, or to nothing if 'inline' is not supported under any name. */
#endif #endif
#endif #endif
#ifndef HAVE_STRLCPY
#define strlcpy(X,Y,Z) strcpy(X,Y)
#endif
//#define DEBUG_MALLOC 1 //#define DEBUG_MALLOC 1
#if DEBUG_MALLOC #if DEBUG_MALLOC

92
include/YapError.h
View File

@ -36,33 +36,40 @@
#include "YapErrors.h" #include "YapErrors.h"
struct yami *Yap_Error__(const char *file, const char *function, int lineno, yap_error_number err,YAP_Term wheret, ...); #define MAX_ERROR_MSG_SIZE 10
#define Yap_NilError( id, ...) Yap_Error__(__FILE__, __FUNCTION__, __LINE__, id, TermNil, __VA_ARGS__) struct yami *Yap_Error__(const char *file, const char *function, int lineno,
yap_error_number err, YAP_Term wheret, ...);
#define Yap_Error( id, inp, ...) Yap_Error__(__FILE__, __FUNCTION__, __LINE__, id, inp, __VA_ARGS__) #define Yap_NilError(id, ...) \
Yap_Error__(__FILE__, __FUNCTION__, __LINE__, id, TermNil, __VA_ARGS__)
#define Yap_Error(id, inp, ...) \
Yap_Error__(__FILE__, __FUNCTION__, __LINE__, id, inp, __VA_ARGS__)
#ifdef YAP_TERM_H #ifdef YAP_TERM_H
/** /**
* make sure next argument is a bound instance of type * make sure next argument is a bound instance of type
* atom. * atom.
*/ */
#define Yap_ensure_atom( T0, TF ) { if ( (TF = Yap_ensure_atom__(__FILE__, __FUNCTION__, __LINE__, T0 ) == 0L ) return false; } #define Yap_ensure_atom(T0, TF) \
{ if ( (TF = Yap_ensure_atom__(__FILE__, __FUNCTION__, __LINE__, T0 ) == 0L ) return false; \
}
INLINE_ONLY extern inline Term INLINE_ONLY extern inline Term Yap_ensure_atom__(const char *fu, const char *fi,
Yap_ensure_atom__( const char *fu, const char *fi, int line, Term in ) int line, Term in) {
{
Term t = Deref(in); Term t = Deref(in);
//Term Context = Deref(ARG2); // Term Context = Deref(ARG2);
if (!IsVarTerm(t) && IsAtomTerm(t)) if (!IsVarTerm(t) && IsAtomTerm(t))
return t; return t;
if (IsVarTerm(t)) { if (IsVarTerm(t)) {
Yap_Error__(fu, fi, line, INSTANTIATION_ERROR, t, NULL); Yap_Error__(fu, fi, line, INSTANTIATION_ERROR, t, NULL);
} else { } else {
if ( IsAtomTerm(t) ) return t ; if (IsAtomTerm(t))
return t;
Yap_Error__(fu, fi, line, TYPE_ERROR_ATOM, t, NULL); Yap_Error__(fu, fi, line, TYPE_ERROR_ATOM, t, NULL);
return 0L; return 0L;
} }
#endif #endif
@ -138,4 +145,69 @@ Yap_ensure_atom__( const char *fu, const char *fi, int line, Term in )
goto LAB; \ goto LAB; \
} }
/**
* Error stages since it was initially processed.
*
* Notice that some of the stages may be active simultaneouly.
*/
typedef enum yap_error_status {
/// where we like to be
YAP_NO_ERROR_STATUS = 0x0,
/// Prolog discovered the problem
YAP_ERROR_INITIATED_IN_PROLOG = 0x1,
/// The problem was found before the system can cope
YAP_ERROR_INITIATED_IN_BOOT = 0x2,
/// C-helper like must_ found out the problem
YAP_ERROR_INITIATED_IN_HELPER = 0x4,
/// C-builtin crashed
YAP_ERROR_INITIATED_IN_SYSTEM_C = 0x8,
/// user code crashed
YAP_ERROR_INITIATED_IN_USER_C = 0x10,
/// ok, we put a throw to be dispatched
YAP_THROW_THROWN = 0x20,
/// someone caught it
YAP_THROW_CAUGHT = 0x40,
/// error became an exception (usually SWIG bridge)
YAP_ERROR_EXPORTED_TO_CXX = 0x80,
/// handle error in Prolog
YAP_ERROR_BEING_PROCESSED_IN_PROLOG = 0x100
/// go back t
} yap_error_stage_t;
/// all we need to know about an error/throw
typedef struct yap_error_descriptor {
enum yap_error_status status;
yap_error_class_number errorClass;
YAP_Atom errorAsText;
YAP_Atom classAsText;
yap_error_number errorNo;
YAP_Int errorLine;
const char *errorFunction;
const char *errorFile;
YAP_Int prologPredCl;
YAP_UInt prologPredLine;
YAP_UInt prologPredFirstLine;
YAP_UInt prologPredLastLine;
YAP_Atom prologPredName;
YAP_UInt prologPredArity;
YAP_Term prologPredModule;
YAP_Atom prologPredFile;
struct DB_TERM *errorTerm;
char errorComment[MAX_ERROR_MSG_SIZE];
size_t errorMsgLen;
} yap_error_descriptor_t;
/// compatibility with existing code..
#define LOCAL_Error_TYPE LOCAL_ActiveError.errorNo
#define LOCAL_Error_File LOCAL_ActiveError.errorFile
#define LOCAL_Error_Function LOCAL_ActiveError.errorFunction
#define LOCAL_Error_Lineno LOCAL_ActiveError.errorLine
#define LOCAL_Error_Size LOCAL_ActiveError.errorMsgLen
#define LOCAL_ErrorSay LOCAL_ActiveError.errorComment
extern bool Yap_find_prolog_culprit();
extern yap_error_class_number Yap_errorClass(yap_error_number e);
extern const char *Yap_errorName(yap_error_number e);
extern const char *Yap_errorClassName(yap_error_class_number e);
#endif #endif

4
include/YapErrors.h
View File

@ -1,7 +1,6 @@
/// ///
/// @file YapErrors.h /// @file YapErrors.h
/// /// /// @adddtogroup YapError
/// @adddtogroup YapError
/// ///
/// The file YapErrors.h contains a list with all the error classes known /// The file YapErrors.h contains a list with all the error classes known
/// internally to the YAP system. /// internally to the YAP system.
@ -149,6 +148,7 @@ E(SYSTEM_ERROR_JIT_NOT_AVAILABLE, SYSTEM_ERROR_CLASS, "jit_not_available")
E(SYSTEM_ERROR_OPERATING_SYSTEM, SYSTEM_ERROR_CLASS, "operating_system_error") E(SYSTEM_ERROR_OPERATING_SYSTEM, SYSTEM_ERROR_CLASS, "operating_system_error")
E(SYSTEM_ERROR_SAVED_STATE, SYSTEM_ERROR_CLASS, "saved_state_error") E(SYSTEM_ERROR_SAVED_STATE, SYSTEM_ERROR_CLASS, "saved_state_error")
E(ERROR_EVENT, EVENT, "error")
E(ABORT_EVENT, EVENT, "abort") E(ABORT_EVENT, EVENT, "abort")
E(THROW_EVENT, EVENT, "throw") E(THROW_EVENT, EVENT, "throw")
E(CALL_COUNTER_UNDERFLOW_EVENT, EVENT, "call_counter_underflow") E(CALL_COUNTER_UNDERFLOW_EVENT, EVENT, "call_counter_underflow")

4
include/YapInterface.h
View File

@ -1896,14 +1896,14 @@ extern X_API YAP_PredEntryPtr YAP_FunctorToPredInModule(YAP_Functor,
extern X_API YAP_PredEntryPtr YAP_AtomToPredInModule(YAP_Atom, YAP_Module); extern X_API YAP_PredEntryPtr YAP_AtomToPredInModule(YAP_Atom, YAP_Module);
/* int YAP_EnterGoal(void) */ /* int YAP_EnterGoal(void) */
extern X_API YAP_Bool YAP_EnterGoal(YAP_PredEntryPtr, YAP_handle_t, extern X_API YAP_Bool YAP_EnterGoal(YAP_PredEntryPtr, YAP_Term *,
YAP_dogoalinfo *); YAP_dogoalinfo *);
/* int YAP_RetryGoal(void) */ /* int YAP_RetryGoal(void) */
extern X_API YAP_Bool YAP_RetryGoal(YAP_dogoalinfo *); extern X_API YAP_Bool YAP_RetryGoal(YAP_dogoalinfo *);
/* int YAP_LeaveGoal(void) */ /* int YAP_LeaveGoal(void) */
extern X_API YAP_Bool YAP_LeaveGoal(int, YAP_dogoalinfo *); extern X_API YAP_Bool YAP_LeaveGoal(bool, YAP_dogoalinfo *);
/* int YAP_GoalHasException(YAP_Term *) */ /* int YAP_GoalHasException(YAP_Term *) */
extern X_API YAP_Bool YAP_GoalHasException(YAP_Term *); extern X_API YAP_Bool YAP_GoalHasException(YAP_Term *);

5
library/CMakeLists.txt
View File

@ -72,8 +72,11 @@ MY_add_subdirectory(rltree)
MY_add_subdirectory(system) MY_add_subdirectory(system)
MY_add_subdirectory(tries) MY_add_subdirectory(tries)
MY_add_subdirectory(ytest) MY_add_subdirectory(ytest)
MY_add_custom_target (library SOURCES ${LIBRARY_PL} ) # WORKING_DIRECTORY ${CMAKE_BINARY_DIR} ) if (ANDROID)
file(INSTALL ${LIBRARY_PL} DESTINATION ${libpl})
else()
install(FILES ${LIBRARY_PL} install(FILES ${LIBRARY_PL}
DESTINATION ${libpl} DESTINATION ${libpl}
) )
endif()

17
library/dialect/swi/fli/swi.c
View File

@ -32,11 +32,14 @@ Moyle. All rights reserved.
#include <Yatom.h> #include <Yatom.h>
#include <eval.h> #include <eval.h>
#include "swi.h"
#include <YapHeap.h> #include <YapHeap.h>
#include <YapHandles.h>
#include <YapText.h> #include <YapText.h>
#include <yapio.h> #include <yapio.h>
#include "swi.h"
#if HAVE_MATH_H #if HAVE_MATH_H
#include <math.h> #include <math.h>
#endif #endif
@ -255,7 +258,7 @@ X_API int PL_unify_chars(term_t l, int flags, size_t length, const char *s) {
if (flags & REP_UTF8) { if (flags & REP_UTF8) {
inp.val.c0 = s; inp.val.c0 = s;
inp.type = YAP_STRING_CHARS|ENC_ISO_LATIN1; inp.type = YAP_STRING_CHARS | ENC_ISO_LATIN1;
if (length != (size_t)-1) { if (length != (size_t)-1) {
inp.type |= YAP_STRING_NCHARS; inp.type |= YAP_STRING_NCHARS;
} }
@ -1977,7 +1980,8 @@ X_API int PL_is_pair(term_t ts) {
X_API int PL_skip_list(term_t list, term_t tail, size_t *len) { X_API int PL_skip_list(term_t list, term_t tail, size_t *len) {
CACHE_REGS CACHE_REGS
Term *l = Yap_AddressFromSlot(list); Term t0 = Yap_GetFromSlot(list);
Term *l = &t0;
Term *t; Term *t;
intptr_t length; intptr_t length;
@ -2413,14 +2417,15 @@ X_API int PL_next_solution(qid_t qi) {
return 0; return 0;
// don't forget, on success these guys must create slots // don't forget, on success these guys must create slots
if (qi->q_state == 0) { if (qi->q_state == 0) {
result = YAP_EnterGoal((YAP_PredEntryPtr)qi->q_pe, qi->q_g, &qi->q_h); result = YAP_EnterGoal((YAP_PredEntryPtr)qi->q_pe,
Yap_GetPtrFromHandle(qi->q_g), &qi->q_h);
} else { } else {
LOCAL_AllowRestart = qi->q_open; LOCAL_AllowRestart = qi->q_open;
result = YAP_RetryGoal(&qi->q_h); result = YAP_RetryGoal(&qi->q_h);
} }
qi->q_state = 1; qi->q_state = 1;
if (result == 0) { if (result == 0) {
YAP_LeaveGoal(FALSE, &qi->q_h); YAP_LeaveGoal(false, &qi->q_h);
qi->q_open = 0; qi->q_open = 0;
} }
return result; return result;
@ -2431,7 +2436,7 @@ X_API void PL_cut_query(qid_t qi) {
if (qi->q_open != 1 || qi->q_state == 0) if (qi->q_open != 1 || qi->q_state == 0)
return; return;
YAP_LeaveGoal(FALSE, &qi->q_h); YAP_LeaveGoal(false, &qi->q_h);
qi->q_open = 0; qi->q_open = 0;
LOCAL_execution = qi->oq; LOCAL_execution = qi->oq;
Yap_FreeCodeSpace((char *)qi); Yap_FreeCodeSpace((char *)qi);

6
os/CMakeLists.txt
View File

@ -58,9 +58,12 @@ set (YAPOS_HEADERS
chartypes.yap chartypes.yap
) )
if (ANDROID)
file(INSTALL ${YAPOS_PL_SOURCES} DESTINATION ${libpl}/os)
else()
install (FILES ${YAPOS_PL_SOURCES} install (FILES ${YAPOS_PL_SOURCES}
DESTINATION ${libpl}/os ) DESTINATION ${libpl}/os )
endif()
include(CheckFunctionExists) include(CheckFunctionExists)
@ -118,4 +121,3 @@ endif (READLINE_FOUND)
set( READLINE_LIBS ${READLINE_LIBRARIES} PARENT_SCOPE) set( READLINE_LIBS ${READLINE_LIBRARIES} PARENT_SCOPE)
endif (WITH_READLINE) endif (WITH_READLINE)

6
os/encoding.h
View File

@ -19,6 +19,8 @@
#define ENCODING_H 1 #define ENCODING_H 1
#include "YapError.h"
typedef enum { typedef enum {
ENC_OCTET = 0, /// binary files ENC_OCTET = 0, /// binary files
ENC_ISO_LATIN1 = 1, /// US+West Europe ENC_ISO_LATIN1 = 1, /// US+West Europe
@ -186,9 +188,7 @@ static inline encoding_t enc_id(const char *s, encoding_t enc_bom) {
if (enc_bom != ENC_OCTET) if (enc_bom != ENC_OCTET)
return enc_bom; return enc_bom;
return Yap_DefaultEncoding(); return Yap_DefaultEncoding();
} } else {
else {
Yap_Error(DOMAIN_ERROR_OUT_OF_RANGE, MkAtomTerm(Yap_LookupAtom(s)), "bad encoding %s", s);
return Yap_DefaultEncoding(); return Yap_DefaultEncoding();
} }
} }

216
os/files.c
View File

@ -32,33 +32,31 @@ static char SccsId[] = "%W% %G%";
#define SYSTEM_STAT stat #define SYSTEM_STAT stat
#endif #endif
bool Yap_GetFileName(Term t, char *buf, size_t len, encoding_t enc) {
while (IsApplTerm(t) && FunctorOfTerm(t) == FunctorSlash) {
if (!Yap_GetFileName(ArgOfTerm(1, t), buf, len, enc))
return false;
size_t szl = strlen(buf);
buf += szl;
*buf++ = '/';
t = ArgOfTerm(2, t);
len -= (szl + 1);
}
return Yap_TextTermToText(t, buf, len, enc);
}
static Int file_name_extension(USES_REGS1) { static Int file_name_extension(USES_REGS1) {
Term t1 = Deref(ARG1); Term t1 = Deref(ARG1);
Term t2 = Deref(ARG2); Term t2 = Deref(ARG2);
Term t3 = Deref(ARG3); Term t3 = Deref(ARG3);
bool use_string = false; char f[YAP_FILENAME_MAX + 1];
loop: #if __APPLE__ || _WIN32
bool lowcase = true;
#endif
if (!IsVarTerm((t3))) { if (!IsVarTerm((t3))) {
const char *f; char *f2;
if (IsAtomTerm(t3)) { if (!Yap_GetFileName(t3, f, YAP_FILENAME_MAX, ENC_ISO_UTF8)) {
f = AtomName(AtomOfTerm(t3));
} else if (IsStringTerm(t3)) {
f = StringOfTerm(t3);
use_string = true;
} else if (IsApplTerm(t3) && FunctorOfTerm(t3) == FunctorSlash) {
// descend a compound term of the form a/b.
Term tn1 = MkVarTerm(), tf1;
Term ts[2];
ts[0] = ArgOfTerm(1, t3);
ts[1] = tn1;
tf1 = Yap_MkApplTerm(FunctorSlash, 2, ts);
if (!Yap_unify(ARG1, tf1)) {
return false;
}
t3 = ArgOfTerm(2, t3);
goto loop;
} else {
Yap_Error(TYPE_ERROR_ATOMIC, t3, "file_name_extension/3");
return false; return false;
} }
char *pts = strrchr(f, '/'); char *pts = strrchr(f, '/');
@ -68,106 +66,69 @@ loop:
pts = pts1; pts = pts1;
#endif #endif
char *ss = strrchr(f, '.'); char *ss = strrchr(f, '.');
if (pts > ss) if (pts > ss) {
ss = NULL; ss = f + strlen(f);
if (use_string) { } else if (ss == NULL) {
char *tmp; ss = "";
if (!ss) {
return Yap_unify(ARG1, ARG3) && Yap_unify(ARG2, MkStringTerm(""));
}
tmp = malloc((ss - f) + 1);
int i;
for (i=0;i < (ss - f); i++) tmp[i] = ss[i];
tmp[i] = '\0';
if (!Yap_unify(ARG1, MkStringTerm(tmp))) {
free(tmp);
return false;
}
free(tmp);
// without and with dot
if (!Yap_unify(ARG2, MkStringTerm(ss + 1)))
return Yap_unify(ARG2, MkStringTerm(ss));
return true;
} else { } else {
char *tmp; ss++;
if (!ss) {
return Yap_unify(ARG1, ARG3) &&
Yap_unify(ARG2, MkAtomTerm(Yap_LookupAtom("")));
} }
tmp = malloc((ss - f) + 1);
int i;
for (i=0;i < (ss - f); i++) tmp[i] = ss[i];
tmp[i] = '\0';
if (!Yap_unify(ARG1, MkAtomTerm(Yap_LookupAtom(tmp)))) {
if (tmp != f)
free(tmp);
return false;
}
if (tmp != f)
free(tmp);
// without and with dot
if (!Yap_unify(ARG2, MkAtomTerm(Yap_LookupAtom(ss + 1))))
return Yap_unify(ARG2, MkAtomTerm(Yap_LookupAtom(ss)));
return true;
}
} else {
char s[MAXPATHLEN + 1];
const char *f1, *f2;
loop1:
if (IsVarTerm(t1)) {
Yap_Error(INSTANTIATION_ERROR, t1, "access");
return FALSE;
} else if (IsAtomTerm(t1)) {
f1 = AtomName(AtomOfTerm(t1));
} else if (IsStringTerm(t1)) {
f1 = StringOfTerm(t1);
use_string = true;
} else if (IsApplTerm(t1) && FunctorOfTerm(t1) == FunctorSlash) {
// descend a compound term of the form a/b.
Term tn1 = MkVarTerm(), tf1;
Term ts[2];
ts[0] = ArgOfTerm(1, t1);
ts[1] = tn1;
tf1 = Yap_MkApplTerm(FunctorSlash, 2, ts);
if (!Yap_unify(ARG3, tf1)) {
return false;
}
t1 = ArgOfTerm(2, t1);
goto loop1;
} else {
Yap_Error(TYPE_ERROR_ATOMIC, t1, "file_name_extension/3");
return false;
}
if (IsVarTerm(t2)) { if (IsVarTerm(t2)) {
Yap_Error(INSTANTIATION_ERROR, t2, "access"); Term t = Yap_MkTextTerm(ss, ENC_ISO_UTF8, t3);
return FALSE; Yap_unify(t2, t);
} else if (IsAtomTerm(t2)) {
f2 = AtomName(AtomOfTerm(t2));
} else if (IsStringTerm(t1)) {
f2 = StringOfTerm(t2);
use_string = true;
} else { } else {
Yap_Error(TYPE_ERROR_ATOMIC, t2, "file_name_extension/3"); f2 = ss + (strlen(ss) + 1);
if (!Yap_TextTermToText(t2, f2, YAP_FILENAME_MAX - 1 - (f2 - f),
ENC_ISO_UTF8))
return false;
#if __APPLE__ || _WIN32
Yap_OverwriteUTF8BufferToLowCase(f2);
lowcase = true;
#endif
if (strcmp(f2, ss) != 0 && (ss > f && strcmp(f2, ss - 1) != 0)) {
return false; return false;
} }
if (f2[0] == '.') {
strncpy(s, f1, MAXPATHLEN);
strncat(s, f2, MAXPATHLEN);
if (use_string)
return Yap_unify_constant(ARG3, MkStringTerm(s));
else
return Yap_unify_constant(ARG3, MkAtomTerm(Yap_LookupAtom(s)));
} else {
strncpy(s, f1, MAXPATHLEN);
strncat(s, ".", MAXPATHLEN);
strncat(s, f2, MAXPATHLEN);
if (use_string)
return Yap_unify_constant(ARG3, MkStringTerm(s));
else
return Yap_unify_constant(ARG3, MkAtomTerm(Yap_LookupAtom(s)));
} }
if (f[0] && ss[0] && ss[0] != '.') {
ss[-1] = '\0';
}
if (IsVarTerm(t1)) {
Term t = Yap_MkTextTerm(f, ENC_ISO_UTF8, t3);
Yap_unify(t1, t);
} else {
char f1[YAP_FILENAME_MAX + 1];
#if __APPLE || _WIN32
Yap_OverwriteUTF8BufferToLowCase(f);
#endif
if (!Yap_GetFileName(t2, f1, YAP_FILENAME_MAX, ENC_ISO_UTF8))
return false;
#if __APPLE__ || _WIN32
if (!lowcase)
Yap_OverwriteUTF8BufferToLowCase(f2);
#endif
if (strcmp(f1, f) != 0) {
return false;
}
}
return true;
} else {
char *f2;
if (!Yap_TextTermToText(t1, f, YAP_FILENAME_MAX - 2, ENC_ISO_UTF8)) {
return false;
}
f2 = f + strlen(f);
if (!Yap_TextTermToText(t2, f2, YAP_FILENAME_MAX - 2 - (f2 - f),
ENC_ISO_UTF8)) {
return false;
}
if (f2[0] != '.') {
memmove(f2 + 1, f2, strlen(f2) + 1);
f2[0] = '.';
}
Term t = Yap_MkTextTerm(f, ENC_ISO_UTF8, t1);
if (!t)
return false;
return Yap_unify(t, t3);
} }
} }
@ -345,6 +306,29 @@ static Int file_size(USES_REGS1) {
return false; return false;
} }
static Int lines_in_file(USES_REGS1) {
Int sno = Yap_CheckStream(ARG1, (Input_Stream_f | Output_Stream_f),
"lines_in_file/2");
if (sno < 0)
return (FALSE);
if (GLOBAL_Stream[sno].status & Seekable_Stream_f &&
!(GLOBAL_Stream[sno].status &
(InMemory_Stream_f | Socket_Stream_f | Pipe_Stream_f))) {
FILE *f = GLOBAL_Stream[sno].file;
size_t count = 0;
int ch;
#if __ANDROID__
#define getw getc
#endif
while ((ch = getw(f)) >= 0) {
if (ch == '\n')
count++;
}
return Yap_unify(ARG3, MkIntegerTerm(count));
}
return false;
}
static Int access_file(USES_REGS1) { static Int access_file(USES_REGS1) {
Term tname = Deref(ARG1); Term tname = Deref(ARG1);
Term tmode = Deref(ARG2); Term tmode = Deref(ARG2);
@ -657,6 +641,8 @@ void Yap_InitFiles(void) {
SafePredFlag); SafePredFlag);
Yap_InitCPred("same_file", 2, same_file, SafePredFlag | SyncPredFlag); Yap_InitCPred("same_file", 2, same_file, SafePredFlag | SyncPredFlag);
Yap_InitCPred("$access_file", 2, access_file, SafePredFlag | SyncPredFlag); Yap_InitCPred("$access_file", 2, access_file, SafePredFlag | SyncPredFlag);
Yap_InitCPred("$lines_in_file", 2, lines_in_file,
SafePredFlag | SyncPredFlag);
Yap_InitCPred("access", 1, access_path, SafePredFlag | SyncPredFlag); Yap_InitCPred("access", 1, access_path, SafePredFlag | SyncPredFlag);
Yap_InitCPred("exists_directory", 1, exists_directory, Yap_InitCPred("exists_directory", 1, exists_directory,
SafePredFlag | SyncPredFlag); SafePredFlag | SyncPredFlag);

7
os/mem.c
View File

@ -204,7 +204,7 @@ int Yap_open_buf_write_stream(encoding_t enc, memBufSource src) {
if (sno < 0) if (sno < 0)
return -1; return -1;
st = GLOBAL_Stream + sno; st = GLOBAL_Stream + sno;
st->status = Output_Stream_f | InMemory_Stream_f|FreeOnClose_Stream_f; st->status = Output_Stream_f | InMemory_Stream_f | FreeOnClose_Stream_f;
st->linepos = 0; st->linepos = 0;
st->charcount = 0; st->charcount = 0;
st->linecount = 1; st->linecount = 1;
@ -267,8 +267,8 @@ char *Yap_MemExportStreamPtr(int sno) {
#if MAY_WRITE #if MAY_WRITE
char *s; char *s;
if (fflush(GLOBAL_Stream[sno].file) == 0) { if (fflush(GLOBAL_Stream[sno].file) == 0) {
fseek(GLOBAL_Stream[sno].file, 0, SEEK_END);
s = GLOBAL_Stream[sno].nbuf; s = GLOBAL_Stream[sno].nbuf;
// s[fseek(GLOBAL_Stream[sno].file, 0, SEEK_END)] = '\0';
return s; return s;
} }
return NULL; return NULL;
@ -282,8 +282,7 @@ char *Yap_MemExportStreamPtr(int sno) {
static Int peek_mem_write_stream( static Int peek_mem_write_stream(
USES_REGS1) { /* '$peek_mem_write_stream'(+GLOBAL_Stream,?S0,?S) */ USES_REGS1) { /* '$peek_mem_write_stream'(+GLOBAL_Stream,?S0,?S) */
Int sno = Int sno =
Yap_CheckStream(ARG1, (Output_Stream_f | Yap_CheckStream(ARG1, (Output_Stream_f | InMemory_Stream_f), "close/2");
InMemory_Stream_f), "close/2");
Int i; Int i;
Term tf = ARG2; Term tf = ARG2;
CELL *HI; CELL *HI;

422
packages/cplint/approx/simplecuddLPADs/ProblogBDD.c
View File

@ -192,8 +192,10 @@ Multivalued variables are translated to binary variables by means of a log
encodimg encodimg
*/ */
#include "simplecudd.h" #include "simplecudd.h"
#if HAVE_UNISTD_H
#include <unistd.h>
#endif
#include <signal.h> #include <signal.h>
#include <time.h> #include <time.h>
@ -226,13 +228,11 @@ typedef struct _extmanager {
namedvars varmap; namedvars varmap;
} extmanager; } extmanager;
double ProbBool(extmanager MyManager, DdNode *node, int bits, int nBit,
double ProbBool(extmanager MyManager, DdNode *node, int bits, int nBit,int posBVar,variable v, int comp); int posBVar, variable v, int comp);
double Prob(extmanager MyManager, DdNode *node, int comp); double Prob(extmanager MyManager, DdNode *node, int comp);
int correctPosition(int index,variable v,int posBVar); int correctPosition(int index, variable v, int posBVar);
double ret_prob(extmanager MyManager, DdNode * bdd); double ret_prob(extmanager MyManager, DdNode *bdd);
int argtype(const char *arg); int argtype(const char *arg);
void printhelp(int argc, char **arg); void printhelp(int argc, char **arg);
@ -247,13 +247,14 @@ double sigmoid(double x, double slope);
void myexpand(extmanager MyManager, DdNode *Current); void myexpand(extmanager MyManager, DdNode *Current);
double CalcProbability(extmanager MyManager, DdNode *Current); double CalcProbability(extmanager MyManager, DdNode *Current);
double CalcProbabilitySigmoid(extmanager MyManager, DdNode *Current); double CalcProbabilitySigmoid(extmanager MyManager, DdNode *Current);
gradientpair CalcGradient(extmanager MyManager, DdNode *Current, int TargetVar, char *TargetPattern); gradientpair CalcGradient(extmanager MyManager, DdNode *Current, int TargetVar,
char *TargetPattern);
int patterncalculated(char *pattern, extmanager MyManager, int loc); int patterncalculated(char *pattern, extmanager MyManager, int loc);
char * extractpattern(char *thestr); char *extractpattern(char *thestr);
int main(int argc, char **arg) { int main(int argc, char **arg) {
clock_t start, endc, endt; clock_t start, endc, endt;
double elapsedc,elapsedt; double elapsedc, elapsedt;
extmanager MyManager; extmanager MyManager;
DdNode *bdd; DdNode *bdd;
@ -268,7 +269,8 @@ int main(int argc, char **arg) {
if (params.errorcnt > 0) { if (params.errorcnt > 0) {
printhelp(argc, arg); printhelp(argc, arg);
for (i = 0; i < params.errorcnt; i++) { for (i = 0; i < params.errorcnt; i++) {
fprintf(stderr, "Error: not known or error at parameter %s.\n", arg[params.error[i]]); fprintf(stderr, "Error: not known or error at parameter %s.\n",
arg[params.error[i]]);
} }
return -1; return -1;
} }
@ -279,13 +281,17 @@ int main(int argc, char **arg) {
return -1; return -1;
} }
if (params.method != 0 && arg[params.method][0] != 'g' && arg[params.method][0] != 'p' && arg[params.method][0] != 'o' && arg[params.method][0] != 'l') { if (params.method != 0 && arg[params.method][0] != 'g' &&
arg[params.method][0] != 'p' && arg[params.method][0] != 'o' &&
arg[params.method][0] != 'l') {
printhelp(argc, arg); printhelp(argc, arg);
fprintf(stderr, "Error: you must choose a calculation method beetween [p]robability, [g]radient, [l]ine search, [o]nline.\n"); fprintf(stderr, "Error: you must choose a calculation method beetween "
"[p]robability, [g]radient, [l]ine search, [o]nline.\n");
return -1; return -1;
} }
if (params.debug) DEBUGON; if (params.debug)
DEBUGON;
RAPIDLOADON; RAPIDLOADON;
SETMAXBUFSIZE(params.maxbufsize); SETMAXBUFSIZE(params.maxbufsize);
#ifndef _WIN32 #ifndef _WIN32
@ -307,36 +313,42 @@ int main(int argc, char **arg) {
ivarcnt = GetVarCount(MyManager.manager); ivarcnt = GetVarCount(MyManager.manager);
} else { } else {
fileheader = ReadFileHeader(arg[params.loadfile]); fileheader = ReadFileHeader(arg[params.loadfile]);
switch(fileheader.filetype) { switch (fileheader.filetype) {
case BDDFILE_SCRIPT: case BDDFILE_SCRIPT:
if (params.inputfile == -1) { if (params.inputfile == -1) {
printhelp(argc, arg); printhelp(argc, arg);
fprintf(stderr, "Error: an input file is necessary for this type of loading file.\n"); fprintf(stderr, "Error: an input file is necessary for this type of "
"loading file.\n");
return -1; return -1;
} }
MyManager.manager = simpleBDDinit(fileheader.varcnt); MyManager.manager = simpleBDDinit(fileheader.varcnt);
MyManager.t = HIGH(MyManager.manager); MyManager.t = HIGH(MyManager.manager);
MyManager.f = LOW(MyManager.manager); MyManager.f = LOW(MyManager.manager);
MyManager.varmap = InitNamedMultiVars(fileheader.varcnt, fileheader.varstart,fileheader.bvarcnt); MyManager.varmap = InitNamedMultiVars(
if (LoadMultiVariableData(MyManager.manager,MyManager.varmap, arg[params.inputfile]) == -1) return -1; fileheader.varcnt, fileheader.varstart, fileheader.bvarcnt);
if (LoadMultiVariableData(MyManager.manager, MyManager.varmap,
arg[params.inputfile]) == -1)
return -1;
start = clock(); start = clock();
bdd = FileGenerateBDD(MyManager.manager, MyManager.varmap, fileheader); bdd = FileGenerateBDD(MyManager.manager, MyManager.varmap, fileheader);
endc=clock(); endc = clock();
elapsedc = ((double) (endc - start)) / CLOCKS_PER_SEC; elapsedc = ((double)(endc - start)) / CLOCKS_PER_SEC;
printf("elapsed_construction(%lf).\n",elapsedc); printf("elapsed_construction(%lf).\n", elapsedc);
ivarcnt = fileheader.varcnt; ivarcnt = fileheader.varcnt;
break; break;
case BDDFILE_NODEDUMP: case BDDFILE_NODEDUMP:
if (params.inputfile == -1) { if (params.inputfile == -1) {
printhelp(argc, arg); printhelp(argc, arg);
fprintf(stderr, "Error: an input file is necessary for this type of loading file.\n"); fprintf(stderr, "Error: an input file is necessary for this type of "
"loading file.\n");
return -1; return -1;
} }
MyManager.manager = simpleBDDinit(fileheader.varcnt); MyManager.manager = simpleBDDinit(fileheader.varcnt);
MyManager.t = HIGH(MyManager.manager); MyManager.t = HIGH(MyManager.manager);
MyManager.f = LOW(MyManager.manager); MyManager.f = LOW(MyManager.manager);
MyManager.varmap = InitNamedVars(fileheader.varcnt, fileheader.varstart); MyManager.varmap = InitNamedVars(fileheader.varcnt, fileheader.varstart);
bdd = LoadNodeDump(MyManager.manager, MyManager.varmap, fileheader.inputfile); bdd = LoadNodeDump(MyManager.manager, MyManager.varmap,
fileheader.inputfile);
ivarcnt = fileheader.varcnt; ivarcnt = fileheader.varcnt;
break; break;
default: default:
@ -355,44 +367,58 @@ int main(int argc, char **arg) {
code = 0; code = 0;
/* /*
if (params.inputfile != -1) { if (params.inputfile != -1) {
if (LoadVariableData(MyManager.varmap, arg[params.inputfile]) == -1) return -1; if (LoadVariableData(MyManager.varmap, arg[params.inputfile]) == -1)
return -1;
if (!all_loaded(MyManager.varmap, 1)) return -1; if (!all_loaded(MyManager.varmap, 1)) return -1;
}*/ }*/
MyManager.his = InitHistory(ivarcnt); MyManager.his = InitHistory(ivarcnt);
if (params.method != 0) { if (params.method != 0) {
switch(arg[params.method][0]) { switch (arg[params.method][0]) {
case 'g': case 'g':
for (i = 0; i < MyManager.varmap.varcnt; i++) { for (i = 0; i < MyManager.varmap.varcnt; i++) {
if (MyManager.varmap.vars[i] != NULL) { if (MyManager.varmap.vars[i] != NULL) {
varpattern = extractpattern(MyManager.varmap.vars[i]); varpattern = extractpattern(MyManager.varmap.vars[i]);
if ((varpattern == NULL) || (!patterncalculated(varpattern, MyManager, i))) { if ((varpattern == NULL) ||
tvalue = CalcGradient(MyManager, bdd, i + MyManager.varmap.varstart, varpattern); (!patterncalculated(varpattern, MyManager, i))) {
tvalue = CalcGradient(MyManager, bdd,
i + MyManager.varmap.varstart, varpattern);
probability = tvalue.probability; probability = tvalue.probability;
double factor = sigmoid(MyManager.varmap.dvalue[i], params.sigmoid_slope) * (1 - sigmoid(MyManager.varmap.dvalue[i], params.sigmoid_slope)) * params.sigmoid_slope; double factor =
sigmoid(MyManager.varmap.dvalue[i], params.sigmoid_slope) *
(1 -
sigmoid(MyManager.varmap.dvalue[i], params.sigmoid_slope)) *
params.sigmoid_slope;
if (varpattern == NULL) { if (varpattern == NULL) {
printf("query_gradient(%s,%s,%1.12f).\n", arg[params.queryid], MyManager.varmap.vars[i], tvalue.gradient * factor); printf("query_gradient(%s,%s,%1.12f).\n", arg[params.queryid],
MyManager.varmap.vars[i], tvalue.gradient * factor);
} else { } else {
varpattern[strlen(varpattern) - 2] = '\0'; varpattern[strlen(varpattern) - 2] = '\0';
printf("query_gradient(%s,%s,%1.12f).\n", arg[params.queryid], varpattern, tvalue.gradient * factor); printf("query_gradient(%s,%s,%1.12f).\n", arg[params.queryid],
varpattern, tvalue.gradient * factor);
} }
ReInitHistory(MyManager.his, MyManager.varmap.varcnt); ReInitHistory(MyManager.his, MyManager.varmap.varcnt);
} }
if (varpattern != NULL) free(varpattern); if (varpattern != NULL)
free(varpattern);
} else { } else {
fprintf(stderr, "Error: no variable name given for parameter.\n"); fprintf(stderr, "Error: no variable name given for parameter.\n");
} }
} }
if (probability < 0.0) { if (probability < 0.0) {
// no nodes, so we have to calculate probability ourself // no nodes, so we have to calculate probability ourself
tvalue = CalcGradient(MyManager, bdd, 0 + MyManager.varmap.varstart, NULL); tvalue =
CalcGradient(MyManager, bdd, 0 + MyManager.varmap.varstart, NULL);
probability = tvalue.probability; probability = tvalue.probability;
} }
printf("query_probability(%s,%1.12f).\n", arg[params.queryid], probability); printf("query_probability(%s,%1.12f).\n", arg[params.queryid],
probability);
break; break;
case 'l': case 'l':
tvalue = CalcGradient(MyManager, bdd, 0 + MyManager.varmap.varstart, NULL); tvalue =
CalcGradient(MyManager, bdd, 0 + MyManager.varmap.varstart, NULL);
probability = tvalue.probability; probability = tvalue.probability;
printf("query_probability(%s,%1.12f).\n", arg[params.queryid], probability); printf("query_probability(%s,%1.12f).\n", arg[params.queryid],
probability);
break; break;
case 'p': case 'p':
printf("probability(%1.12f).\n", CalcProbability(MyManager, bdd)); printf("probability(%1.12f).\n", CalcProbability(MyManager, bdd));
@ -405,27 +431,31 @@ int main(int argc, char **arg) {
break; break;
} }
} else { } else {
start=clock(); start = clock();
// simpleNamedBDDtoDot(MyManager.manager, MyManager.varmap, bdd, "bdd.dot"); // simpleNamedBDDtoDot(MyManager.manager, MyManager.varmap, bdd,
//"bdd.dot");
printf("probability(%1.12f).\n", ret_prob(MyManager, bdd)); printf("probability(%1.12f).\n", ret_prob(MyManager, bdd));
endt=clock(); endt = clock();
elapsedt = ((double) (endt - start)) / CLOCKS_PER_SEC; elapsedt = ((double)(endt - start)) / CLOCKS_PER_SEC;
printf("elapsed_traversing(%lf).\n",elapsedt); printf("elapsed_traversing(%lf).\n", elapsedt);
// myexpand(MyManager, bdd); // myexpand(MyManager, bdd);
} }
if (params.savedfile > -1) SaveNodeDump(MyManager.manager, MyManager.varmap, bdd, arg[params.savedfile]); if (params.savedfile > -1)
if (params.exportfile > -1) simpleNamedBDDtoDot(MyManager.manager, MyManager.varmap, bdd, arg[params.exportfile]); SaveNodeDump(MyManager.manager, MyManager.varmap, bdd,
arg[params.savedfile]);
if (params.exportfile > -1)
simpleNamedBDDtoDot(MyManager.manager, MyManager.varmap, bdd,
arg[params.exportfile]);
ReInitHistory(MyManager.his, MyManager.varmap.varcnt); ReInitHistory(MyManager.his, MyManager.varmap.varcnt);
free(MyManager.his); free(MyManager.his);
} }
if (MyManager.manager != NULL) { if (MyManager.manager != NULL) {
KillBDD(MyManager.manager); KillBDD(MyManager.manager);
exit(code); exit(code);
free(MyManager.varmap.dvalue); free(MyManager.varmap.dvalue);
free(MyManager.varmap.ivalue); free(MyManager.varmap.ivalue);
free(MyManager.varmap.dynvalue); free(MyManager.varmap.dynvalue);
for (i = 0; i < MyManager.varmap.varcnt; i++) for (i = 0; i < MyManager.varmap.varcnt; i++) {
{
free(MyManager.varmap.vars[i]); free(MyManager.varmap.vars[i]);
free(MyManager.varmap.mvars[i].probabilities); free(MyManager.varmap.mvars[i].probabilities);
free(MyManager.varmap.mvars[i].booleanVars); free(MyManager.varmap.mvars[i].booleanVars);
@ -434,50 +464,83 @@ exit(code);
free(MyManager.varmap.mvars); free(MyManager.varmap.mvars);
free(MyManager.varmap.bVar2mVar); free(MyManager.varmap.bVar2mVar);
} }
if (params.error != NULL) free(params.error); if (params.error != NULL)
free(params.error);
return code; return code;
} }
/* Shell Parameters handling */ /* Shell Parameters handling */
int argtype(const char *arg) { int argtype(const char *arg) {
if (strcmp(arg, "-l") == 0 || strcmp(arg, "--load") == 0) return 0; if (strcmp(arg, "-l") == 0 || strcmp(arg, "--load") == 0)
if (strcmp(arg, "-e") == 0 || strcmp(arg, "--export") == 0) return 2; return 0;
if (strcmp(arg, "-m") == 0 || strcmp(arg, "--method") == 0) return 3; if (strcmp(arg, "-e") == 0 || strcmp(arg, "--export") == 0)
if (strcmp(arg, "-i") == 0 || strcmp(arg, "--input") == 0) return 4; return 2;
if (strcmp(arg, "-h") == 0 || strcmp(arg, "--help") == 0) return 5; if (strcmp(arg, "-m") == 0 || strcmp(arg, "--method") == 0)
if (strcmp(arg, "-d") == 0 || strcmp(arg, "--debug") == 0) return 6; return 3;
if (strcmp(arg, "-id") == 0 || strcmp(arg, "--queryid") == 0) return 7; if (strcmp(arg, "-i") == 0 || strcmp(arg, "--input") == 0)
if (strcmp(arg, "-t") == 0 || strcmp(arg, "--timeout") == 0) return 8; return 4;
if (strcmp(arg, "-sd") == 0 || strcmp(arg, "--savedump") == 0) return 9; if (strcmp(arg, "-h") == 0 || strcmp(arg, "--help") == 0)
if (strcmp(arg, "-sl") == 0 || strcmp(arg, "--slope") == 0) return 10; return 5;
if (strcmp(arg, "-o") == 0 || strcmp(arg, "--online") == 0) return 11; if (strcmp(arg, "-d") == 0 || strcmp(arg, "--debug") == 0)
if (strcmp(arg, "-bs") == 0 || strcmp(arg, "--bufsize") == 0) return 12; return 6;
if (strcmp(arg, "-pid") == 0 || strcmp(arg, "--pid") == 0) return 13; if (strcmp(arg, "-id") == 0 || strcmp(arg, "--queryid") == 0)
return 7;
if (strcmp(arg, "-t") == 0 || strcmp(arg, "--timeout") == 0)
return 8;
if (strcmp(arg, "-sd") == 0 || strcmp(arg, "--savedump") == 0)
return 9;
if (strcmp(arg, "-sl") == 0 || strcmp(arg, "--slope") == 0)
return 10;
if (strcmp(arg, "-o") == 0 || strcmp(arg, "--online") == 0)
return 11;
if (strcmp(arg, "-bs") == 0 || strcmp(arg, "--bufsize") == 0)
return 12;
if (strcmp(arg, "-pid") == 0 || strcmp(arg, "--pid") == 0)
return 13;
return -1; return -1;
} }
void printhelp(int argc, char **arg) { void printhelp(int argc, char **arg) {
fprintf(stderr, "\nUsage: %s -l [filename] -i [filename] -o (-s(d) [filename] -e [filename] -m [method] -id [queryid] -sl [double]) (-t [seconds] -d -h)\n", arg[0]); fprintf(stderr, "\nUsage: %s -l [filename] -i [filename] -o (-s(d) "
"[filename] -e [filename] -m [method] -id [queryid] -sl "
"[double]) (-t [seconds] -d -h)\n",
arg[0]);
fprintf(stderr, "Generates and traverses a BDD\nMandatory parameters:\n"); fprintf(stderr, "Generates and traverses a BDD\nMandatory parameters:\n");
fprintf(stderr, "\t-l [filename]\t->\tfilename to load supports two formats:\n\t\t\t\t\t\t1. script with generation instructions\n\t\t\t\t\t\t2. node dump saved file\n"); fprintf(stderr, "\t-l [filename]\t->\tfilename to load supports two "
fprintf(stderr, "\t-i [filename]\t->\tfilename to input problem specifics (mandatory with file formats 1, 2)\n"); "formats:\n\t\t\t\t\t\t1. script with generation "
fprintf(stderr, "\t-o\t\t->\tgenerates the BDD in online mode instead from a file can be used instead of -l\n"); "instructions\n\t\t\t\t\t\t2. node dump saved file\n");
fprintf(stderr, "\t-i [filename]\t->\tfilename to input problem specifics "
"(mandatory with file formats 1, 2)\n");
fprintf(stderr, "\t-o\t\t->\tgenerates the BDD in online mode instead from a "
"file can be used instead of -l\n");
fprintf(stderr, "Optional parameters:\n"); fprintf(stderr, "Optional parameters:\n");
fprintf(stderr, "\t-sd [filename]\t->\tfilename to save generated BDD in node dump format (fast loading, traverse valid only)\n"); fprintf(stderr, "\t-sd [filename]\t->\tfilename to save generated BDD in "
fprintf(stderr, "\t-e [filename]\t->\tfilename to export generated BDD in dot format\n"); "node dump format (fast loading, traverse valid only)\n");
fprintf(stderr, "\t-m [method]\t->\tthe calculation method to be used: none(default), [p]robability, [g]radient, [o]nline\n"); fprintf(
fprintf(stderr, "\t-id [queryid]\t->\tthe queries identity name (used by gradient) default: %s\n", arg[0]); stderr,
fprintf(stderr, "\t-sl [double]\t->\tthe sigmoid slope (used by gradient) default: 1.0\n"); "\t-e [filename]\t->\tfilename to export generated BDD in dot format\n");
fprintf(stderr, "\t-m [method]\t->\tthe calculation method to be used: "
"none(default), [p]robability, [g]radient, [o]nline\n");
fprintf(stderr, "\t-id [queryid]\t->\tthe queries identity name (used by "
"gradient) default: %s\n",
arg[0]);
fprintf(stderr, "\t-sl [double]\t->\tthe sigmoid slope (used by gradient) "
"default: 1.0\n");
fprintf(stderr, "Extra parameters:\n"); fprintf(stderr, "Extra parameters:\n");
fprintf(stderr, "\t-t [seconds]\t->\tthe seconds (int) for BDD generation timeout default 0 = no timeout\n"); fprintf(stderr, "\t-t [seconds]\t->\tthe seconds (int) for BDD generation "
fprintf(stderr, "\t-pid [pid]\t->\ta process id (int) to check for termination default 0 = no process to check works only under POSIX OS\n"); "timeout default 0 = no timeout\n");
fprintf(stderr, "\t-bs [bytes]\t->\tthe bytes (int) to use as a maximum buffer size to read files default 0 = no max\n"); fprintf(stderr, "\t-pid [pid]\t->\ta process id (int) to check for "
fprintf(stderr, "\t-d\t\t->\tRun in debug mode (gives extra messages in stderr)\n"); "termination default 0 = no process to check works only "
"under POSIX OS\n");
fprintf(stderr, "\t-bs [bytes]\t->\tthe bytes (int) to use as a maximum "
"buffer size to read files default 0 = no max\n");
fprintf(stderr,
"\t-d\t\t->\tRun in debug mode (gives extra messages in stderr)\n");
fprintf(stderr, "\t-h\t\t->\tHelp (displays this message)\n\n"); fprintf(stderr, "\t-h\t\t->\tHelp (displays this message)\n\n");
fprintf(stderr, "Example: %s -l testbdd -i input.txt -m g -id testbdd\n", arg[0]); fprintf(stderr, "Example: %s -l testbdd -i input.txt -m g -id testbdd\n",
arg[0]);
} }
parameters loadparam(int argc, char **arg) { parameters loadparam(int argc, char **arg) {
@ -496,9 +559,9 @@ parameters loadparam(int argc, char **arg) {
params.online = 0; params.online = 0;
params.maxbufsize = 0; params.maxbufsize = 0;
params.ppid = NULL; params.ppid = NULL;
params.error = (int *) malloc(argc * sizeof(int)); params.error = (int *)malloc(argc * sizeof(int));
for (i = 1; i < argc; i++) { for (i = 1; i < argc; i++) {
switch(argtype(arg[i])) { switch (argtype(arg[i])) {
case 0: case 0:
if (argc > i + 1) { if (argc > i + 1) {
i++; i++;
@ -592,7 +655,7 @@ parameters loadparam(int argc, char **arg) {
case 13: case 13:
if ((argc > i + 1) && (IsPosNumber(arg[i + 1]))) { if ((argc > i + 1) && (IsPosNumber(arg[i + 1]))) {
i++; i++;
params.ppid = (char *) malloc(sizeof(char) * (strlen(arg[i]) + 1)); params.ppid = (char *)malloc(sizeof(char) * (strlen(arg[i]) + 1));
strcpy(params.ppid, arg[i]); strcpy(params.ppid, arg[i]);
} else { } else {
params.error[params.errorcnt] = i; params.error[params.errorcnt] = i;
@ -624,9 +687,12 @@ void pidhandler(int num) {
exit(-1); exit(-1);
} }
} }
s = (char *) malloc(sizeof(char) * (19 + strlen(params.ppid))); s = (char *)malloc(sizeof(char) * (19 + strlen(params.ppid)));
strcpy(s, "ps "); strcat(s, params.ppid); strcat(s, " >/dev/null"); strcpy(s, "ps ");
if (system(s) != 0) exit(4); strcat(s, params.ppid);
strcat(s, " >/dev/null");
if (system(s) != 0)
exit(4);
#ifndef _WIN32 #ifndef _WIN32
signal(SIGALRM, pidhandler); signal(SIGALRM, pidhandler);
alarm(5); alarm(5);
@ -634,15 +700,11 @@ void pidhandler(int num) {
free(s); free(s);
} }
void termhandler(int num) { void termhandler(int num) { exit(3); }
exit(3);
}
/* General Functions */ /* General Functions */
double sigmoid(double x, double slope) { double sigmoid(double x, double slope) { return 1 / (1 + exp(-x * slope)); }
return 1 / (1 + exp(-x * slope));
}
/* Debugging traverse function */ /* Debugging traverse function */
@ -653,7 +715,8 @@ void myexpand(extmanager MyManager, DdNode *Current) {
curnode = GetNodeVarNameDisp(MyManager.manager, MyManager.varmap, Current); curnode = GetNodeVarNameDisp(MyManager.manager, MyManager.varmap, Current);
printf("%s\n", curnode); printf("%s\n", curnode);
if ((Current != MyManager.t) && (Current != MyManager.f) && if ((Current != MyManager.t) && (Current != MyManager.f) &&
((Found = GetNode(MyManager.his, MyManager.varmap.varstart, Current)) == NULL)) { ((Found = GetNode(MyManager.his, MyManager.varmap.varstart, Current)) ==
NULL)) {
l = LowNodeOf(MyManager.manager, Current); l = LowNodeOf(MyManager.manager, Current);
h = HighNodeOf(MyManager.manager, Current); h = HighNodeOf(MyManager.manager, Current);
printf("l(%s)->", curnode); printf("l(%s)->", curnode);
@ -675,16 +738,23 @@ double CalcProbability(extmanager MyManager, DdNode *Current) {
curnode = GetNodeVarNameDisp(MyManager.manager, MyManager.varmap, Current); curnode = GetNodeVarNameDisp(MyManager.manager, MyManager.varmap, Current);
fprintf(stderr, "%s\n", curnode); fprintf(stderr, "%s\n", curnode);
} }
if (Current == MyManager.t) return 1.0; if (Current == MyManager.t)
if (Current == MyManager.f) return 0.0; return 1.0;
if ((Found = GetNode(MyManager.his, MyManager.varmap.varstart, Current)) != NULL) return Found->dvalue; if (Current == MyManager.f)
return 0.0;
if ((Found = GetNode(MyManager.his, MyManager.varmap.varstart, Current)) !=
NULL)
return Found->dvalue;
l = LowNodeOf(MyManager.manager, Current); l = LowNodeOf(MyManager.manager, Current);
h = HighNodeOf(MyManager.manager, Current); h = HighNodeOf(MyManager.manager, Current);
if (params.debug) fprintf(stderr, "l(%s)->", curnode); if (params.debug)
fprintf(stderr, "l(%s)->", curnode);
lvalue = CalcProbability(MyManager, l); lvalue = CalcProbability(MyManager, l);
if (params.debug) fprintf(stderr, "h(%s)->", curnode); if (params.debug)
fprintf(stderr, "h(%s)->", curnode);
hvalue = CalcProbability(MyManager, h); hvalue = CalcProbability(MyManager, h);
tvalue = MyManager.varmap.dvalue[GetIndex(Current) - MyManager.varmap.varstart]; tvalue =
MyManager.varmap.dvalue[GetIndex(Current) - MyManager.varmap.varstart];
tvalue = tvalue * hvalue + lvalue * (1.0 - tvalue); tvalue = tvalue * hvalue + lvalue * (1.0 - tvalue);
AddNode(MyManager.his, MyManager.varmap.varstart, Current, tvalue, 0, NULL); AddNode(MyManager.his, MyManager.varmap.varstart, Current, tvalue, 0, NULL);
return tvalue; return tvalue;
@ -692,7 +762,8 @@ double CalcProbability(extmanager MyManager, DdNode *Current) {
/* Bernds Algorithm */ /* Bernds Algorithm */
gradientpair CalcGradient(extmanager MyManager, DdNode *Current, int TargetVar, char *TargetPattern) { gradientpair CalcGradient(extmanager MyManager, DdNode *Current, int TargetVar,
char *TargetPattern) {
DdNode *h, *l; DdNode *h, *l;
hisnode *Found; hisnode *Found;
char *curnode; char *curnode;
@ -713,37 +784,48 @@ gradientpair CalcGradient(extmanager MyManager, DdNode *Current, int TargetVar,
tvalue.gradient = 0.0; tvalue.gradient = 0.0;
return tvalue; return tvalue;
} }
if ((Found = GetNode(MyManager.his, MyManager.varmap.varstart, Current)) != NULL) { if ((Found = GetNode(MyManager.his, MyManager.varmap.varstart, Current)) !=
NULL) {
tvalue.probability = Found->dvalue; tvalue.probability = Found->dvalue;
tvalue.gradient = *((double *) Found->dynvalue); tvalue.gradient = *((double *)Found->dynvalue);
return tvalue; return tvalue;
} }
l = LowNodeOf(MyManager.manager, Current); l = LowNodeOf(MyManager.manager, Current);
h = HighNodeOf(MyManager.manager, Current); h = HighNodeOf(MyManager.manager, Current);
if (params.debug) fprintf(stderr, "l(%s)->", curnode); if (params.debug)
fprintf(stderr, "l(%s)->", curnode);
lvalue = CalcGradient(MyManager, l, TargetVar, TargetPattern); lvalue = CalcGradient(MyManager, l, TargetVar, TargetPattern);
if (params.debug) fprintf(stderr, "h(%s)->", curnode); if (params.debug)
fprintf(stderr, "h(%s)->", curnode);
hvalue = CalcGradient(MyManager, h, TargetVar, TargetPattern); hvalue = CalcGradient(MyManager, h, TargetVar, TargetPattern);
this_probability = sigmoid(MyManager.varmap.dvalue[GetIndex(Current) - MyManager.varmap.varstart], params.sigmoid_slope); this_probability = sigmoid(
tvalue.probability = this_probability * hvalue.probability + (1 - this_probability) * lvalue.probability; MyManager.varmap.dvalue[GetIndex(Current) - MyManager.varmap.varstart],
tvalue.gradient = this_probability * hvalue.gradient + (1 - this_probability) * lvalue.gradient; params.sigmoid_slope);
tvalue.probability = this_probability * hvalue.probability +
(1 - this_probability) * lvalue.probability;
tvalue.gradient = this_probability * hvalue.gradient +
(1 - this_probability) * lvalue.gradient;
if ((GetIndex(Current) == TargetVar) || if ((GetIndex(Current) == TargetVar) ||
((TargetPattern != NULL) && patternmatch(TargetPattern, MyManager.varmap.vars[GetIndex(Current)]))) { ((TargetPattern != NULL) &&
patternmatch(TargetPattern, MyManager.varmap.vars[GetIndex(Current)]))) {
tvalue.gradient += hvalue.probability - lvalue.probability; tvalue.gradient += hvalue.probability - lvalue.probability;
} }
gradient = (double *) malloc(sizeof(double)); gradient = (double *)malloc(sizeof(double));
*gradient = tvalue.gradient; *gradient = tvalue.gradient;
AddNode(MyManager.his, MyManager.varmap.varstart, Current, tvalue.probability, 0, gradient); AddNode(MyManager.his, MyManager.varmap.varstart, Current, tvalue.probability,
0, gradient);
return tvalue; return tvalue;
} }
char * extractpattern(char *thestr) { char *extractpattern(char *thestr) {
char *p; char *p;
int i = 0, sl = strlen(thestr); int i = 0, sl = strlen(thestr);
while((thestr[i] != '_') && (i < sl)) i++; while ((thestr[i] != '_') && (i < sl))
if (i == sl) return NULL;
i++; i++;
p = (char *) malloc(sizeof(char) * (i + 2)); if (i == sl)
return NULL;
i++;
p = (char *)malloc(sizeof(char) * (i + 2));
strncpy(p, thestr, i); strncpy(p, thestr, i);
p[i] = '*'; p[i] = '*';
p[i + 1] = '\0'; p[i + 1] = '\0';
@ -752,9 +834,11 @@ char * extractpattern(char *thestr) {
int patterncalculated(char *pattern, extmanager MyManager, int loc) { int patterncalculated(char *pattern, extmanager MyManager, int loc) {
int i; int i;
if (pattern == NULL) return 0; if (pattern == NULL)
return 0;
for (i = loc - 1; i > -1; i--) for (i = loc - 1; i > -1; i--)
if (patternmatch(pattern, MyManager.varmap.vars[i])) return 1; if (patternmatch(pattern, MyManager.varmap.vars[i]))
return 1;
return 0; return 0;
} }
@ -764,109 +848,91 @@ nodes is used to store nodes for which the probability has alread been computed
so that it is not recomputed so that it is not recomputed
*/ */
{ {
int mVarIndex,nBit,index; int mVarIndex, nBit, index;
variable v; variable v;
hisnode *Found; hisnode *Found;
double res; double res;
double value; double value;
if (Cudd_IsConstant(node)) {
if (Cudd_IsConstant(node)) value = Cudd_V(node);
{ if (comp) {
value=Cudd_V(node);
if (comp)
{
return 0.0; return 0.0;
} } else {
else
{
return 1.0; return 1.0;
} }
} } else {
else Found = GetNode1(MyManager.varmap.bVar2mVar, MyManager.his,
{ MyManager.varmap.varstart, node);
Found = GetNode1(MyManager.varmap.bVar2mVar,MyManager.his, MyManager.varmap.varstart, node);
if (Found!=NULL) if (Found != NULL) {
{
return Found->dvalue; return Found->dvalue;
} } else {
else index = Cudd_NodeReadIndex(node);
{ mVarIndex = MyManager.varmap.bVar2mVar[index];
index=Cudd_NodeReadIndex(node); v = MyManager.varmap.mvars[mVarIndex];
mVarIndex=MyManager.varmap.bVar2mVar[index]; nBit = v.nBit;
v=MyManager.varmap.mvars[mVarIndex]; res = ProbBool(MyManager, node, 0, nBit, 0, v, comp);
nBit=v.nBit; AddNode1(MyManager.varmap.bVar2mVar, MyManager.his,
res=ProbBool(MyManager,node,0,nBit,0,v,comp); MyManager.varmap.varstart, node, res, 0, NULL);
AddNode1(MyManager.varmap.bVar2mVar,MyManager.his, MyManager.varmap.varstart, node, res, 0, NULL);
return res; return res;
} }
} }
} }
double ProbBool(extmanager MyManager, DdNode *node, int bits, int nBit,int posBVar,variable v, int comp) double ProbBool(extmanager MyManager, DdNode *node, int bits, int nBit,
int posBVar, variable v, int comp)
/* explores a group of binary variables making up the multivalued variable v */ /* explores a group of binary variables making up the multivalued variable v */
{ {
DdNode *T,*F; DdNode *T, *F;
double p,res; double p, res;
double * probs; double *probs;
int index; int index;
probs=v.probabilities; probs = v.probabilities;
if (nBit==0) if (nBit == 0) {
{ if (bits >= v.nVal) {
if (bits>=v.nVal)
{
return 0.0; return 0.0;
} } else {
else p = probs[bits];
{ res = p * Prob(MyManager, node, comp);
p=probs[bits];
res=p*Prob(MyManager,node,comp);
return res; return res;
} }
} } else {
else index = Cudd_NodeReadIndex(node);
{ if (correctPosition(index, v, posBVar)) {
index=Cudd_NodeReadIndex(node);
if (correctPosition(index,v,posBVar))
{
T = Cudd_T(node); T = Cudd_T(node);
F = Cudd_E(node); F = Cudd_E(node);
bits=bits<<1; bits = bits << 1;
res=ProbBool(MyManager,T,bits+1,nBit-1,posBVar+1,v,comp); res = ProbBool(MyManager, T, bits + 1, nBit - 1, posBVar + 1, v, comp);
comp=(!comp && Cudd_IsComplement(F)) || (comp && !Cudd_IsComplement(F)); comp = (!comp && Cudd_IsComplement(F)) || (comp && !Cudd_IsComplement(F));
res=res+ res = res + ProbBool(MyManager, F, bits, nBit - 1, posBVar + 1, v, comp);
ProbBool(MyManager,F,bits,nBit-1,posBVar+1,v,comp); return res;
} else {
bits = bits << 1;
res = ProbBool(MyManager, node, bits + 1, nBit - 1, posBVar + 1, v, comp);
res =
res + ProbBool(MyManager, node, bits, nBit - 1, posBVar + 1, v, comp);
return res; return res;
}
else
{
bits=bits<<1;
res=ProbBool(MyManager,node,bits+1,nBit-1,posBVar+1,v,comp);
res=res+
ProbBool(MyManager,node,bits,nBit-1,posBVar+1,v,comp);
return res;
} }
} }
} }
int correctPosition(int index,variable v,int posBVar) int correctPosition(int index, variable v, int posBVar)
/* returns 1 is the boolean variable with index posBVar is in the correct position /* returns 1 is the boolean variable with index posBVar is in the correct
position
currently explored by ProbBool */ currently explored by ProbBool */
{ {
int bvar; int bvar;
bvar=v.booleanVars[posBVar]; bvar = v.booleanVars[posBVar];
return(bvar==index); return (bvar == index);
} }
double ret_prob(extmanager MyManager, DdNode * bdd) double ret_prob(extmanager MyManager, DdNode *bdd) {
{
double prob; double prob;
/* dividend is a global variable used by my_hash /* dividend is a global variable used by my_hash
it is equal to an unsigned int with binary representation 11..1 */ it is equal to an unsigned int with binary representation 11..1 */
prob=Prob(MyManager,bdd,Cudd_IsComplement(bdd)); prob = Prob(MyManager, bdd, Cudd_IsComplement(bdd));
return prob; return prob;
} }

11
packages/cplint/approx/simplecuddLPADs/simplecudd.c
View File

@ -287,7 +287,7 @@ DdNode *D_BDDXnor(DdManager *manager, DdNode *bdd1, DdNode *bdd2) {
/* file manipulation */ /* file manipulation */
bddfileheader ReadFileHeader(char *filename) { bddfileheader ReadFileHeader(const char *filename) {
bddfileheader temp; bddfileheader temp;
char *header; char *header;
temp.inputfile = NULL; temp.inputfile = NULL;
@ -362,7 +362,7 @@ int CheckFileVersion(const char *version) {
return -1; return -1;
} }
int simpleBDDtoDot(DdManager *manager, DdNode *bdd, char *filename) { int simpleBDDtoDot(DdManager *manager, DdNode *bdd, const char *filename) {
DdNode *f[1]; DdNode *f[1];
int ret; int ret;
FILE *fd; FILE *fd;
@ -378,7 +378,7 @@ int simpleBDDtoDot(DdManager *manager, DdNode *bdd, char *filename) {
} }
int simpleNamedBDDtoDot(DdManager *manager, namedvars varmap, DdNode *bdd, int simpleNamedBDDtoDot(DdManager *manager, namedvars varmap, DdNode *bdd,
char *filename) { const char *filename) {
DdNode *f[1]; DdNode *f[1];
int ret; int ret;
FILE *fd; FILE *fd;
@ -388,13 +388,14 @@ int simpleNamedBDDtoDot(DdManager *manager, namedvars varmap, DdNode *bdd,
perror(filename); perror(filename);
return -1; return -1;
} }
ret = Cudd_DumpDot(manager, 1, f, varmap.vars, NULL, fd); const char *vs = varmap.vars;
ret = Cudd_DumpDot(manager, 1, f, vs, NULL, fd);
fclose(fd); fclose(fd);
return ret; return ret;
} }
int SaveNodeDump(DdManager *manager, namedvars varmap, DdNode *bdd, int SaveNodeDump(DdManager *manager, namedvars varmap, DdNode *bdd,
char *filename) { const char *filename) {
hisqueue *Nodes; hisqueue *Nodes;
FILE *outputfile; FILE *outputfile;
int i; int i;

10
packages/cplint/approx/simplecuddLPADs/simplecudd.h
View File

@ -256,7 +256,7 @@ typedef struct _bddfileheader {
typedef struct { typedef struct {
int nVal, nBit, init; int nVal, nBit, init;
double *probabilities; double *probabilities;
int *booleanVars; DdNode **booleanVars;
} variable; } variable;
typedef struct _namedvars { typedef struct _namedvars {
@ -357,7 +357,7 @@ void onlinetraverse(DdManager *manager, namedvars varmap, hisqueue *HisQueue,
/* Save-load */ /* Save-load */
bddfileheader ReadFileHeader(char *filename); bddfileheader ReadFileHeader(const char *filename);
int CheckFileVersion(const char *version); int CheckFileVersion(const char *version);
DdNode *LoadNodeDump(DdManager *manager, namedvars varmap, FILE *inputfile); DdNode *LoadNodeDump(DdManager *manager, namedvars varmap, FILE *inputfile);
@ -367,16 +367,16 @@ DdNode *GetIfExists(DdManager *manager, namedvars varmap, hisqueue *Nodes,
char *varname, int nodenum); char *varname, int nodenum);
int SaveNodeDump(DdManager *manager, namedvars varmap, DdNode *bdd, int SaveNodeDump(DdManager *manager, namedvars varmap, DdNode *bdd,
char *filename); const char *filename);
void SaveExpand(DdManager *manager, namedvars varmap, hisqueue *Nodes, void SaveExpand(DdManager *manager, namedvars varmap, hisqueue *Nodes,
DdNode *Current, FILE *outputfile); DdNode *Current, FILE *outputfile);
void ExpandNodes(hisqueue *Nodes, int index, int nodenum); void ExpandNodes(hisqueue *Nodes, int index, int nodenum);
/* Export */ /* Export */
int simpleBDDtoDot(DdManager *manager, DdNode *bdd, char *filename); int simpleBDDtoDot(DdManager *manager, DdNode *bdd, const char *filename);
int simpleNamedBDDtoDot(DdManager *manager, namedvars varmap, DdNode *bdd, int simpleNamedBDDtoDot(DdManager *manager, namedvars varmap, DdNode *bdd,
char *filename); const char *filename);
DdNode *equality(DdManager *mgr, int varIndex, int value, namedvars varmap); DdNode *equality(DdManager *mgr, int varIndex, int value, namedvars varmap);
hisnode *GetNodei1(int *bVar2mVar, hisqueue *HisQueue, int varstart, hisnode *GetNodei1(int *bVar2mVar, hisqueue *HisQueue, int varstart,

1
packages/myddas/CMakeLists.txt
View File

@ -48,6 +48,7 @@ add_component(myddas
${MYDDAS_UTIL_SOURCES} ${MYDDAS_UTIL_SOURCES}
${MYDDAS_HEADERS} ${MYDDAS_HEADERS}
) )
MY_add_dependencies(myddas plmyddas) MY_add_dependencies(myddas plmyddas)
add_subdirectory(pl) add_subdirectory(pl)

12
packages/myddas/pl/CMakeLists.txt
View File

@ -12,13 +12,17 @@ set(MYDDAS_DRIVERS
myddas_driver.ypp myddas_driver.ypp
) )
if (ANDROID)
set (PREFIX ${libpl} )
else()
set (PREFIX ${CMAKE_CURRENT_BINARY_DIR} )
endif()
get_property(MYDDAS_FLAGS GLOBAL PROPERTY COMPILE_DEFINITIONS) get_property(MYDDAS_FLAGS GLOBAL PROPERTY COMPILE_DEFINITIONS)
function(cpp_compile output filename) function(cpp_compile output filename)
get_filename_component(base ${filename} NAME_WE) get_filename_component(base ${filename} NAME_WE)
set(base_abs ${CMAKE_CURRENT_BINARY_DIR}/${base}) set(base_abs ${PREFIX}/${base})
set(outfile ${base_abs}.yap) set(outfile ${base_abs}.yap)
set(${output} ${${output}} ${outfile} PARENT_SCOPE) set(${output} ${${output}} ${outfile} PARENT_SCOPE)
IF (MSVC) IF (MSVC)
@ -61,9 +65,9 @@ foreach (driver ${MYDDAS_DBMS})
cpp_driver(MYDDAS_YAP ${driver} myddas_driver.ypp) cpp_driver(MYDDAS_YAP ${driver} myddas_driver.ypp)
endforeach () endforeach ()
MY_add_custom_target(plmyddas ALL DEPENDS ${MYDDAS_YAP} add_custom_target(plmyddas ALL DEPENDS ${MYDDAS_YAP}
) # WORKING_DIRECTORY ${CMAKE_BINARY_DIR} ) )
MY_install(FILES ${MYDDAS_YAP} MY_install(FILES ${MYDDAS_YAP}
DESTINATION ${libpl} DESTINATION ${libpl}

3
packages/python/__init__.py Normal file
View File

@ -0,0 +1,3 @@
"""A Prolog kernel for Jupyter"""
__version__ = '0.0.1'

3
packages/python/__main__.py Normal file
View File

@ -0,0 +1,3 @@
if __name__ == '__main__':
from yapkernel import kernelapp as app
app.launch_new_instance()

10
packages/python/examples/plot.py Normal file
View File

@ -0,0 +1,10 @@
:- [library(python)].
main :-
:= import matplotlib.pyplot,
:= Plt = ematplotlib.pyplot,
Plt.plot([1,2,3,4]),
Plt.ylabel(`some numbers`),
Plt.show().

44
packages/python/install.py Normal file
View File

@ -0,0 +1,44 @@
import json
import os
import sys
try:
from jupyter_client.kernelspec import install_kernel_spec
except ImportError:
from IPython.kernel.kernelspec import install_kernel_spec
from IPython.utils.tempdir import TemporaryDirectory
kernel_json = {
"argv": [sys.executable,
"-m", "yap_kernel",
"-f", "{connection_file}"],
"display_name": "yap",
"mimetype": "text/x-prolog",
"language": "prolog",
"name": "yap",
}
def install_my_kernel_spec(user=False):
with TemporaryDirectory() as td:
os.chmod(td, 0o755) # Starts off as 700, not user readable
with open(os.path.join(td, 'kernel.json'), 'w') as f:
json.dump(kernel_json, f, sort_keys=True)
# TODO: Copy resources once they're specified
print('Installing IPython kernel spec')
install_kernel_spec(td, 'yap', user=False, replace=True)
def _is_root():
return True
try:
return os.geteuid() == 0
except AttributeError:
return False # assume not an admin on non-Unix platforms
def main(argv=[]):
user = '--user' in argv or not _is_root()
install_my_kernel_spec(user=user)
if __name__ == '__main__':
main(argv=sys.argv)

1
packages/python/pytils.yap Normal file
View File

@ -0,0 +1 @@

488
packages/python/yap_kernel/x/kernelapp.py Normal file
View File

@ -0,0 +1,488 @@
"""An Application for launching a kernel"""
# Copyright (c) IPython Development Team.
# Distributed under the terms of the Modified BSD License.
from __future__ import print_function
import atexit
import os
import sys
import signal
import traceback
import logging
from tornado import ioloop
import zmq
from zmq.eventloop import ioloop as zmq_ioloop
from zmq.eventloop.zmqstream import ZMQStream
from IPython.core.application import (
BaseIPythonApplication, base_flags, base_aliases, catch_config_error
)
from IPython.core.profiledir import ProfileDir
from IPython.core.shellapp import (
InteractiveShellApp, shell_flags, shell_aliases
)
from IPython.utils import io
from ipython_genutils.path import filefind, ensure_dir_exists
from traitlets import (
Any, Instance, Dict, Unicode, Integer, Bool, DottedObjectName, Type, default
)
from ipython_genutils.importstring import import_item
from jupyter_core.paths import jupyter_runtime_dir
from jupyter_client import write_connection_file
from jupyter_client.connect import ConnectionFileMixin
# local imports
from ipykernel.iostream import IOPubThread
from ipykernel.heartbeat import Heartbeat
from .yap_kernel import YAPKernel
from ipykernel.parentpoller import ParentPollerUnix, ParentPollerWindows
from jupyter_client.session import (
Session, session_flags, session_aliases,
)
from ipykernel.zmqshell import ZMQInteractiveShell
#-----------------------------------------------------------------------------
# Flags and Aliases
#-----------------------------------------------------------------------------
kernel_aliases = dict(base_aliases)
kernel_aliases.update({
'ip' : 'YAPKernelApp.ip',
'hb' : 'YAPKernelApp.hb_port',
'shell' : 'YAPKernelApp.shell_port',
'iopub' : 'YAPKernelApp.iopub_port',
'stdin' : 'YAPKernelApp.stdin_port',
'control' : 'YAPKernelApp.control_port',
'f' : 'YAPKernelApp.connection_file',
'transport': 'YAPKernelApp.transport',
})
kernel_flags = dict(base_flags)
kernel_flags.update({
'no-stdout' : (
{'YAPKernelApp' : {'no_stdout' : True}},
"redirect stdout to the null device"),
'no-stderr' : (
{'YAPKernelApp' : {'no_stderr' : True}},
"redirect stderr to the null device"),
'pylab' : (
{'YAPKernelApp' : {'pylab' : 'auto'}},
"""Pre-load matplotlib and numpy for interactive use with
the default matplotlib backend."""),
})
# inherit flags&aliases for any IPython shell apps
kernel_aliases.update(shell_aliases)
kernel_flags.update(shell_flags)
# inherit flags&aliases for Sessions
kernel_aliases.update(session_aliases)
kernel_flags.update(session_flags)
_ctrl_c_message = """\
NOTE: When using the `ipython kernel` entry point, Ctrl-C will not work.
To exit, you will have to explicitly quit this process, by either sending
"quit" from a client, or using Ctrl-\\ in UNIX-like environments.
To read more about this, see https://github.com/ipython/ipython/issues/2049
"""
#-----------------------------------------------------------------------------
# Application class for starting an IPython Kernel
#-----------------------------------------------------------------------------
class YAPKernelApp(BaseIPythonApplication, InteractiveShellApp,
ConnectionFileMixin):
name='YAP-kernel'
aliases = Dict(kernel_aliases)
flags = Dict(kernel_flags)
classes = [YAPKernel, ZMQInteractiveShell, ProfileDir, Session]
# the kernel class, as an importstring
kernel_class = Type('yap_kernel.yap_kernel.YAPKernel',
klass='ipykernel.kernelbase.Kernel',
help="""The Kernel subclass to be used.
This should allow easy re-use of the IPKernelApp entry point
to configure and launch kernels other than IPython's own.
""").tag(config=True)
kernel = Any()
poller = Any() # don't restrict this even though current pollers are all Threads
heartbeat = Instance(Heartbeat, allow_none=True)
ports = Dict()
subcommands = {
'install': (
'.kernelspec.InstallYAPKernelSpecApp',
'Install the YAP kernel'
),
}
# connection info:
connection_dir = Unicode()
@default('connection_dir')
def _default_connection_dir(self):
return jupyter_runtime_dir()
@property
def abs_connection_file(self):
if os.path.basename(self.connection_file) == self.connection_file:
return os.path.join(self.connection_dir, self.connection_file)
else:
return self.connection_file
# streams, etc.
no_stdout = Bool(False, help="redirect stdout to the null device").tag(config=True)
no_stderr = Bool(False, help="redirect stderr to the null device").tag(config=True)
outstream_class = DottedObjectName('ipykernel.iostream.OutStream',
help="The importstring for the OutStream factory").tag(config=True)
displayhook_class = DottedObjectName('ipykernel.displayhook.ZMQDisplayHook',
help="The importstring for the DisplayHook factory").tag(config=True)
# polling
parent_handle = Integer(int(os.environ.get('JPY_PARENT_PID') or 0),
help="""kill this process if its parent dies. On Windows, the argument
specifies the HANDLE of the parent process, otherwise it is simply boolean.
""").tag(config=True)
interrupt = Integer(int(os.environ.get('JPY_INTERRUPT_EVENT') or 0),
help="""ONLY USED ON WINDOWS
Interrupt this process when the parent is signaled.
""").tag(config=True)
def init_crash_handler(self):
sys.excepthook = self.excepthook
def excepthook(self, etype, evalue, tb):
# write uncaught traceback to 'real' stderr, not zmq-forwarder
traceback.print_exception(etype, evalue, tb, file=sys.__stderr__)
def init_poller(self):
if sys.platform == 'win32':
if self.interrupt or self.parent_handle:
self.poller = ParentPollerWindows(self.interrupt, self.parent_handle)
elif self.parent_handle:
self.poller = ParentPollerUnix()
def _bind_socket(self, s, port):
iface = '%s://%s' % (self.transport, self.ip)
if self.transport == 'tcp':
if port <= 0:
port = s.bind_to_random_port(iface)
else:
s.bind("tcp://%s:%i" % (self.ip, port))
elif self.transport == 'ipc':
if port <= 0:
port = 1
path = "%s-%i" % (self.ip, port)
while os.path.exists(path):
port = port + 1
path = "%s-%i" % (self.ip, port)
else:
path = "%s-%i" % (self.ip, port)
s.bind("ipc://%s" % path)
return port
def write_connection_file(self):
"""write connection info to JSON file"""
cf = self.abs_connection_file
self.log.debug("Writing connection file: %s", cf)
write_connection_file(cf, ip=self.ip, key=self.session.key, transport=self.transport,
shell_port=self.shell_port, stdin_port=self.stdin_port, hb_port=self.hb_port,
iopub_port=self.iopub_port, control_port=self.control_port)
def cleanup_connection_file(self):
cf = self.abs_connection_file
self.log.debug("Cleaning up connection file: %s", cf)
try:
os.remove(cf)
except (IOError, OSError):
pass
self.cleanup_ipc_files()
def init_connection_file(self):
if not self.connection_file:
self.connection_file = "kernel-%s.json"%os.getpid()
try:
self.connection_file = filefind(self.connection_file, ['.', self.connection_dir])
except IOError:
self.log.debug("Connection file not found: %s", self.connection_file)
# This means I own it, and I'll create it in this directory:
ensure_dir_exists(os.path.dirname(self.abs_connection_file), 0o700)
# Also, I will clean it up:
atexit.register(self.cleanup_connection_file)
return
try:
self.load_connection_file()
except Exception:
self.log.error("Failed to load connection file: %r", self.connection_file, exc_info=True)
self.exit(1)
def init_sockets(self):
# Create a context, a session, and the kernel sockets.
self.log.info("Starting the kernel at pid: %i", os.getpid())
context = zmq.Context.instance()
# Uncomment this to try closing the context.
# atexit.register(context.term)
self.shell_socket = context.socket(zmq.ROUTER)
self.shell_socket.linger = 1000
self.shell_port = self._bind_socket(self.shell_socket, self.shell_port)
self.log.debug("shell ROUTER Channel on port: %i" % self.shell_port)
self.stdin_socket = context.socket(zmq.ROUTER)
self.stdin_socket.linger = 1000
self.stdin_port = self._bind_socket(self.stdin_socket, self.stdin_port)
self.log.debug("stdin ROUTER Channel on port: %i" % self.stdin_port)
self.control_socket = context.socket(zmq.ROUTER)
self.control_socket.linger = 1000
self.control_port = self._bind_socket(self.control_socket, self.control_port)
self.log.debug("control ROUTER Channel on port: %i" % self.control_port)
self.init_iopub(context)
def init_iopub(self, context):
self.iopub_socket = context.socket(zmq.PUB)
self.iopub_socket.linger = 1000
self.iopub_port = self._bind_socket(self.iopub_socket, self.iopub_port)
self.log.debug("iopub PUB Channel on port: %i" % self.iopub_port)
self.configure_tornado_logger()
self.iopub_thread = IOPubThread(self.iopub_socket, pipe=True)
self.iopub_thread.start()
# backward-compat: wrap iopub socket API in background thread
self.iopub_socket = self.iopub_thread.background_socket
def init_heartbeat(self):
"""start the heart beating"""
# heartbeat doesn't share context, because it mustn't be blocked
# by the GIL, which is accessed by libzmq when freeing zero-copy messages
hb_ctx = zmq.Context()
self.heartbeat = Heartbeat(hb_ctx, (self.transport, self.ip, self.hb_port))
self.hb_port = self.heartbeat.port
self.log.debug("Heartbeat REP Channel on port: %i" % self.hb_port)
self.heartbeat.start()
def log_connection_info(self):
"""display connection info, and store ports"""
basename = os.path.basename(self.connection_file)
if basename == self.connection_file or \
os.path.dirname(self.connection_file) == self.connection_dir:
# use shortname
tail = basename
else:
tail = self.connection_file
lines = [
"To connect another client to this kernel, use:",
" --existing %s" % tail,
]
# log connection info
# info-level, so often not shown.
# frontends should use the %connect_info magic
# to see the connection info
for line in lines:
self.log.info(line)
# also raw print to the terminal if no parent_handle (`ipython kernel`)
# unless log-level is CRITICAL (--quiet)
if not self.parent_handle and self.log_level < logging.CRITICAL:
io.rprint(_ctrl_c_message)
for line in lines:
io.rprint(line)
self.ports = dict(shell=self.shell_port, iopub=self.iopub_port,
stdin=self.stdin_port, hb=self.hb_port,
control=self.control_port)
def init_blackhole(self):
"""redirects stdout/stderr to devnull if necessary"""
if self.no_stdout or self.no_stderr:
blackhole = open(os.devnull, 'w')
if self.no_stdout:
sys.stdout = sys.__stdout__ = blackhole
if self.no_stderr:
sys.stderr = sys.__stderr__ = blackhole
def init_io(self):
"""Redirect input streams and set a display hook."""
if self.outstream_class:
outstream_factory = import_item(str(self.outstream_class))
sys.stdout = outstream_factory(self.session, self.iopub_thread, u'stdout')
sys.stderr = outstream_factory(self.session, self.iopub_thread, u'stderr')
if self.displayhook_class:
displayhook_factory = import_item(str(self.displayhook_class))
self.displayhook = displayhook_factory(self.session, self.iopub_socket)
sys.displayhook = self.displayhook
self.patch_io()
def patch_io(self):
"""Patch important libraries that can't handle sys.stdout forwarding"""
try:
import faulthandler
except ImportError:
pass
else:
# Warning: this is a monkeypatch of `faulthandler.enable`, watch for possible
# updates to the upstream API and update accordingly (up-to-date as of Python 3.5):
# https://docs.python.org/3/library/faulthandler.html#faulthandler.enable
# change default file to __stderr__ from forwarded stderr
faulthandler_enable = faulthandler.enable
def enable(file=sys.__stderr__, all_threads=True, **kwargs):
return faulthandler_enable(file=file, all_threads=all_threads, **kwargs)
faulthandler.enable = enable
if hasattr(faulthandler, 'register'):
faulthandler_register = faulthandler.register
def register(signum, file=sys.__stderr__, all_threads=True, chain=False, **kwargs):
return faulthandler_register(signum, file=file, all_threads=all_threads,
chain=chain, **kwargs)
faulthandler.register = register
def init_signal(self):
signal.signal(signal.SIGINT, signal.SIG_IGN)
def init_kernel(self):
"""Create the Kernel object itself"""
shell_stream = ZMQStream(self.shell_socket)
control_stream = ZMQStream(self.control_socket)
kernel_factory = self.kernel_class.instance
kernel = kernel_factory(parent=self, session=self.session,
shell_streams=[shell_stream, control_stream],
iopub_thread=self.iopub_thread,
iopub_socket=self.iopub_socket,
stdin_socket=self.stdin_socket,
log=self.log,
profile_dir=self.profile_dir,
user_ns=self.user_ns,
)
kernel.record_ports({
name + '_port': port for name, port in self.ports.items()
})
self.kernel = kernel
# Allow the displayhook to get the execution count
self.displayhook.get_execution_count = lambda: kernel.execution_count
def init_gui_pylab(self):
"""Enable GUI event loop integration, taking pylab into account."""
# Register inline backend as default
# this is higher priority than matplotlibrc,
# but lower priority than anything else (mpl.use() for instance).
# This only affects matplotlib >= 1.5
if not os.environ.get('MPLBACKEND'):
os.environ['MPLBACKEND'] = 'module://ipykernel.pylab.backend_inline'
# Provide a wrapper for :meth:`InteractiveShellApp.init_gui_pylab`
# to ensure that any exception is printed straight to stderr.
# Normally _showtraceback associates the reply with an execution,
# which means frontends will never draw it, as this exception
# is not associated with any execute request.
shell = self.shell
_showtraceback = shell._showtraceback
try:
# replace error-sending traceback with stderr
def print_tb(etype, evalue, stb):
print ("GUI event loop or pylab initialization failed",
file=sys.stderr)
print (shell.InteractiveTB.stb2text(stb), file=sys.stderr)
shell._showtraceback = print_tb
InteractiveShellApp.init_gui_pylab(self)
finally:
shell._showtraceback = _showtraceback
def init_shell(self):
self.shell = getattr(self.kernel, 'shell', None)
if self.shell:
self.shell.configurables.append(self)
def init_extensions(self):
super(YAPKernelApp, self).init_extensions()
# BEGIN HARDCODED WIDGETS HACK
# Ensure ipywidgets extension is loaded if available
extension_man = self.shell.extension_manager
if 'ipywidgets' not in extension_man.loaded:
try:
extension_man.load_extension('ipywidgets')
except ImportError as e:
self.log.debug('ipywidgets package not installed. Widgets will not be available.')
# END HARDCODED WIDGETS HACK
def configure_tornado_logger(self):
""" Configure the tornado logging.Logger.
Must set up the tornado logger or else tornado will call
basicConfig for the root logger which makes the root logger
go to the real sys.stderr instead of the capture streams.
This function mimics the setup of logging.basicConfig.
"""
logger = logging.getLogger('tornado')
handler = logging.StreamHandler()
formatter = logging.Formatter(logging.BASIC_FORMAT)
handler.setFormatter(formatter)
logger.addHandler(handler)
@catch_config_error
def initialize(self, argv=None):
super(YAPKernelApp, self).initialize(argv)
if self.subapp is not None:
return
# register zmq IOLoop with tornado
zmq_ioloop.install()
self.init_blackhole()
self.init_connection_file()
self.init_poller()
self.init_sockets()
self.init_heartbeat()
# writing/displaying connection info must be *after* init_sockets/heartbeat
self.write_connection_file()
# Log connection info after writing connection file, so that the connection
# file is definitely available at the time someone reads the log.
self.log_connection_info()
self.init_io()
self.init_signal()
self.init_kernel()
# shell init steps
self.init_path()
self.init_shell()
if self.shell:
self.init_gui_pylab()
self.init_extensions()
self.init_code()
# flush stdout/stderr, so that anything written to these streams during
# initialization do not get associated with the first execution request
sys.stdout.flush()
sys.stderr.flush()
def start(self):
if self.subapp is not None:
return self.subapp.start()
if self.poller is not None:
self.poller.start()
self.kernel.start()
try:
ioloop.IOLoop.instance().start()
except KeyboardInterrupt:
pass
launch_new_instance = YAPKernelApp.launch_instance
def main():
"""Run an IPKernel as an application"""
app = YAPKernelApp.instance()
app.initialize()
app.start()
if __name__ == '__main__':
main()

36
packages/python/yap_kernel/yap_kernel.py
View File

@ -5,14 +5,14 @@ from ipykernel.ipkernel import IPythonKernel
import sys import sys
import signal import signal
import yap import yap
#import ipdb # import ipdb
#ipdb,set_trace() # ipdb,set_trace()
kernel_json = { kernel_json = {
"argv": [sys.executable, "argv": [sys.executable,
"-m", "yap_kernel", "-m", "yap_kernel",
"-f", "{connection_file}"], "-f", "{connection_file}"],
"display_name": " YAP-6.3" , "display_name": " YAP-6.3",
"language": "prolog", "language": "prolog",
"name": "yap_kernel", "name": "yap_kernel",
} }
@ -21,8 +21,9 @@ kernel_json = {
def eprint(*args, **kwargs): def eprint(*args, **kwargs):
print(*args, file=sys.stderr, **kwargs) print(*args, file=sys.stderr, **kwargs)
class YAPKernel(IPythonKernel): class YAPKernel(IPythonKernel):
implementation = 'MetaKernel YAP' implementation = 'YAP Kernel'
implementation_version = '1.0' implementation_version = '1.0'
language = 'text' language = 'text'
language_version = '0.1' language_version = '0.1'
@ -36,15 +37,19 @@ class YAPKernel(IPythonKernel):
"name": "prolog" "name": "prolog"
}, },
'pygments_lexer': 'prolog', 'pygments_lexer': 'prolog',
'version' : "0.0.1", 'version': "0.0.1",
'file_extension': '.yap', 'file_extension': '.yap',
} }
def init_yap(self, **kwargs): def init_yap(self, **kwargs):
# Signal handlers are inherited by forked processes, and we can't easily # Signal handlers are inherited by
# reset it from the subprocess. Since kernelapp ignores SIGINT except in # forked processes,
# message handlers, we need to temporarily reset the SIGINT handler here # and we can't easily
# so that yap and its children are interruptible. # reset it from the subprocess. Since kernelapp
# ignores SIGINT except in
# message handlers, we need to temporarily
# reset the SIGINT handler
# here so that yap and its children are interruptible.
sig = signal.signal(signal.SIGINT, signal.SIG_DFL) sig = signal.signal(signal.SIGINT, signal.SIG_DFL)
try: try:
self.engine = yap.YAPEngine() self.engine = yap.YAPEngine()
@ -57,21 +62,20 @@ class YAPKernel(IPythonKernel):
signal.signal(signal.SIGINT, sig) signal.signal(signal.SIGINT, sig)
def __init__(self, **kwargs): def __init__(self, **kwargs):
super(YAPKernel, self).__init__( **kwargs) super(YAPKernel, self).__init__(**kwargs)
self.init_yap( **kwargs ) self.init_yap(**kwargs)
self.shell.run_cell = self.yap_run_cell self.shell.run_cell = self.yap_run_cell
def get_usage(self): def get_usage(self):
return "This is the YAP kernel." return "This is the YAP kernel."
def yap_run_cell(self, s, store_history=False, silent=False,
def yap_run_cell(self, s, store_history=False, silent=False, shell_futures=True): shell_futures=True):
if not self.q: if not self.q:
self.q = self.engine.query(s) self.q = self.engine.query(s)
if self.q.next(): if self.q.next():
myvs = self.q.namedVarsCopy() myvs = self.q.namedVarsCopy()
wrote = False
if myvs: if myvs:
i = 0 i = 0
for peq in myvs: for peq in myvs:
@ -84,7 +88,7 @@ class YAPKernel(IPythonKernel):
else: else:
i = bind.numberVars(i, True) i = bind.numberVars(i, True)
print(name.text() + " = " + bind.text()) print(name.text() + " = " + bind.text())
wrote = True else:
print("yes") print("yes")
if self.q.deterministic(): if self.q.deterministic():
self.closeq() self.closeq()
@ -93,7 +97,7 @@ class YAPKernel(IPythonKernel):
self.closeq() self.closeq()
return return
def closeq( self): def closeq(self):
if self.q: if self.q:
self.q.close() self.q.close()
self.q = None self.q = None

15
packages/python/yapex.py
View File

@ -1,3 +1,4 @@
import yap import yap
import sys import sys
@ -19,10 +20,19 @@ class T(tuple):
return str(self.name) + str(self.tuple) return str(self.name) + str(self.tuple)
def query_prolog(engine, s): def query_prolog(engine, s):
def answer( q ):
try:
return q.next()
except Exception as e:
print( e.args[1] )
return False
q = engine.query(s) q = engine.query(s)
ask = True ask = True
while q.next(): while answer(q):
vs = q.namedVarsCopy() vs = q.namedVarsCopy()
if vs: if vs:
i = 0 i = 0
@ -75,8 +85,9 @@ def live():
except: except:
print("Unexpected error:", sys.exc_info()[0]) print("Unexpected error:", sys.exc_info()[0])
raise raise
engine.close()
# #
# initialize engine # initialize engine
# engine = yap.YAPEngine(); # engine = yap.YAPEngine();
# engine = yap.YAPEngine(yap.YAPParams()); # engine = yap.YAPEngine(yap.YAPParams());
live()

2
packages/swig/CMakeLists.txt
View File

@ -7,7 +7,7 @@ macro_log_feature (SWIG_FOUND "Swig"
if (SWIG_FOUND) if (SWIG_FOUND)
# #
# SWIG_FOUND - set to true if SWIG is found # SWIG_FOUND - set to true if SWIG is found
# SWIG_DIR - the directory where swig is installed # SWIG_DIR - t he directory where swig is installed
# SWIG_EXECUTABLE - the path to the swig executable # SWIG_EXECUTABLE - the path to the swig executable
# SWIG_VERSION - the version number of the swig executable # SWIG_VERSION - the version number of the swig executable
# #

59
packages/swig/android/CMakeLists.txt
View File

@ -1,19 +1,15 @@
# This is a CMake example for Python and Java # This is a CMake example for Python and Java
INCLUDE(UseSWIG)
INCLUDE(UseJava) INCLUDE(UseJava)
SET(CMAKE_SWIG_FLAGS -package pt.up.yap.lib)
SET(SWIG_SOURCES
../yap.i
)
# set(ANDROID_SO_OUTDIR ${libdir}) # set(ANDROID_SO_OUTDIR ${libdir})
# set(CMAKE_SWIG_OUTDIR ${CMAKE_SOURCE_DIR}/android/yaplib/build/generated/source/pt/up/yap/lib) # set(CMAKE_SWIG_OUTDIR ${CMAKE_SOURCE_DIR}/android/yaplib/build/generated/source/pt/up/yap/lib)
#set(CMAKE_SWIG_OUTDIR ${CMAKE_CURRENT_BINARY_DIR}/derived) #set(CMAKE_SWIG_OUTDIR ${CMAKE_CURRENT_BINARY_DIR}/derived)
SET_SOURCE_FILES_PROPERTIES(${SWIG_SOURCES} PROPERTIES CPLUSPLUS ON) SET_SOURCE_FILES_PROPERTIES(${SWIG_SOURCES} PROPERTIES CPLUSPLUS ON)
include_directories ( include_directories (
@ -22,55 +18,8 @@
${JNI_INCLUDE_DIRS} ${JNI_INCLUDE_DIRS}
) )
if ( ${C_COMPILER} MATCHES "Clang")
set( CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wno-missing-prototypes")
endif()
if ( ${C_COMPILER} MATCHES "GNU")
set( CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wno-missing-declarations -Wno-strict-aliasing")
endif()
set (CMAKE_SHARED_LIBRARY_SONAME_CXX_FLAG "") add_custom_command (OUTPUT ${SWIG_CXX}
COMMAND ${SWIG} -java -outdir ${CMAKE_CURRENT_BINARY_DIR} -c++ -addextern -I${CMAKE_SOURCE_DIR}/CXX ${SWIG_SOURCES} -o ${SWIG_CXX}
if (ANDROID) ${SWIG_SOURCES}
SWIG_ADD_MODULE(YAPDroid java ${SWIG_SOURCES} )
ADD_LIBRARY( YAPAndroid OBJECT ${swig_generated_file_fullname})
else()
SWIG_LINK_LIBRARIES (YAPDroid Yap++ )
set (LIBDIR ${CMAKE_SOURCE_DIR}/YAPDroid/app/libs/${ANDROID_ABI})
add_custom_command (TARGET YAPDroid
POST_BUILD
COMMAND ${CMAKE_COMMAND} -E make_directory ${LIBDIR}
COMMAND ${CMAKE_COMMAND} -E copy $<TARGET_FILE:YAPDroid> ${LIBDIR}
COMMAND ${CMAKE_COMMAND} -E copy $<TARGET_FILE:libYap> ${LIBDIR}
COMMAND ${CMAKE_COMMAND} -E copy $<TARGET_FILE:Yap++> ${LIBDIR}
COMMAND ${CMAKE_COMMAND} -E copy $<TARGET_FILE:Yapsqlite3> ${LIBDIR}
COMMAND ${CMAKE_COMMAND} -E copy $<TARGET_FILE:utf8proc> ${LIBDIR}
COMMAND ${CMAKE_COMMAND} -E copy ${GMP_LIBRARIES} ${LIBDIR}
DEPENDS YAPDroid
)
endif()
# set( LIBDIR ${CMAKE_SOURCE_DIR}/YAPDroid/app/src/main/jniLibs/${ANDROID_ABI})
# add_custom_command(TARGET YAPDroid
# COMMAND ${CMAKE_COMMAND} -E make_directory ${CMAKE_SOURCE_DIR}/YAPDroid/app/src/main/java/pt/up/yap/lib
# COMMAND ${CMAKE_COMMAND} -E copy_directory ${CMAKE_SWIG_OUTDIR} ${CMAKE_SOURCE_DIR}/YAPDroid/app/src/main/java/pt/up/yap/lib
# COMMAND ${CMAKE_COMMAND} -E make_directory ${LIBDIR}
# COMMAND ${CMAKE_COMMAND} -E copy $<TARGET_FILE:YAPDroid> ${LIBDIR}
# COMMAND ${CMAKE_COMMAND} -E copy $<TARGET_FILE:libYap> ${LIBDIR}
# COMMAND ${CMAKE_COMMAND} -E copy $<TARGET_FILE:Yap++> ${LIBDIR}
# COMMAND ${CMAKE_COMMAND} -E copy $<TARGET_FILE:Yapsqlite3> ${LIBDIR}
# COMMAND ${CMAKE_COMMAND} -E copy $<TARGET_FILE:utf8proc> ${LIBDIR}
# COMMAND ${CMAKE_COMMAND} -E make_directory ${CMAKE_SOURCE_DIR}/YAPDroid/app/src/main/java/org/sqlite/database
# COMMAND ${CMAKE_COMMAND} -E copy_directory ${CMAKE_SOURCE_DIR}/packages/myddas/sqlite3/Android/src/org/sqlite/database
# ${CMAKE_SOURCE_DIR}/android/app/src/main/java/org/sqlite/database
# POST_BUILD
# )
install(TARGETS YAPDroid
LIBRARY DESTINATION ${dlls}
ARCHIVE DESTINATION ${dlls}
) )

334
packages/swig/yap.i
View File

@ -1,7 +1,7 @@
/* example.i */ /* example.i */
%module(directors="1") yap %module(directors = "1") yap
// Language independent exception handler // Language independent exception handler
%include exception.i %include exception.i
%include stdint.i %include stdint.i
@ -10,10 +10,8 @@
class YAPPredicate; class YAPPredicate;
class YAPEngine; class YAPEngine;
#define arity_t uintptr_t #define arity_t uintptr_t
#ifdef SWIGPYTHON #ifdef SWIGPYTHON
%typemap(out) YAPTerm { %typemap(out) YAPTerm {
@ -21,24 +19,21 @@ class YAPEngine;
return NULL; return NULL;
} }
} }
%extend(out) YAPTerm { %extend(out) YAPTerm{YAPTerm & __getitem__(size_t i){Term t0 = $self->term();
YAPTerm & __getitem__ (size_t i) {
Term t0 = $self->term();
if (IsApplTerm(t0)) { if (IsApplTerm(t0)) {
Functor f = FunctorOfTerm(t0); Functor f = FunctorOfTerm(t0);
if (!IsExtensionFunctor(f)) if (!IsExtensionFunctor(f))
return *new YAPTerm(ArgOfTerm(i + 1, t0)); return *new YAPTerm(ArgOfTerm(i + 1, t0));
} else if (IsPairTerm(t0)) { } else if (IsPairTerm(t0)) {
if (i==0) if (i == 0)
return * new YAPTerm(HeadOfTerm(t0)); return *new YAPTerm(HeadOfTerm(t0));
else if (i==1) else if (i == 1)
return * new YAPTerm(TailOfTerm(t0)); return *new YAPTerm(TailOfTerm(t0));
} }
return * new YAPTerm(); return *new YAPTerm();
} }
}
}
%typemap(out) YAPIntegerTerm { %typemap(out) YAPIntegerTerm {
Term t = $1.term(); Term t = $1.term();
@ -48,13 +43,13 @@ class YAPEngine;
#else #else
return PyLong_FromLong(j); return PyLong_FromLong(j);
#endif #endif
} }
%typemap(out) YAPFloatTerm { %typemap(out) YAPFloatTerm {
Term t = $1.term(); Term t = $1.term();
Int double j = FloatOfTerm(t); Int double j = FloatOfTerm(t);
return PyFloat_FromDouble(j); return PyFloat_FromDouble(j);
} }
// translate well-known names and existing // translate well-known names and existing
// Python symbols // Python symbols
@ -63,72 +58,264 @@ class YAPEngine;
%typemap(out) YAPAtomTerm { %typemap(out) YAPAtomTerm {
const char *s = RepAtom(AtomOfTerm($1.term()))->StrOfAE; const char *s = RepAtom(AtomOfTerm($1.term()))->StrOfAE;
PyObject *p; PyObject *p;
if ((p = AtomToPy( s))) { if ((p = AtomToPy(s))) {
return p; return p;
} }
} }
// translate lists as Python Lists // translate lists as Python Lists
// Python symbols // Python symbols
// Everthing else let wrapped. // Everthing else let wrapped.
// as a term // as a term
%typemap(out) YAPListTerm { %typemap(out) YAPListTerm {
Term l =$1.term(), *end; Term l = $1.term(), *end;
PyObject *list; PyObject *list;
Int len = Yap_SkipList( & l, &end ); Int len = Yap_SkipList(&l, &end);
$result = list = PyList_New( len ); $result = list = PyList_New(len);
for (Int i = 0 ; i < len ; i++) { for (Int i = 0; i < len; i++) {
Term a = HeadOfTerm(l); Term a = HeadOfTerm(l);
YAPTerm *argp1 = new YAPTerm( a ); YAPTerm *argp1 = new YAPTerm(a);
PyObject *obj0 = PyObject *obj0 =
SWIG_NewPointerObj(SWIG_as_voidptr(argp1), SWIGTYPE_p_YAPTerm, 0 | 0 ); SWIG_NewPointerObj(SWIG_as_voidptr(argp1), SWIGTYPE_p_YAPTerm, 0 | 0);
l = TailOfTerm(l); l = TailOfTerm(l);
PyList_SetItem( list, i, obj0 ); PyList_SetItem(list, i, obj0);
} }
return list; return list;
}
%exception YAPPredicate {
try {
$action
} catch (...) {
PyErr_SetString(PyExc_SyntaxError, "syntax error");
return NULL;
}
} }
#endif
// Language independent exception handler
%exception query {
try {
$action
}
catch (YAPError YAP_SYMTAX_ERROR) {
SWIG_exception(SWIG_SyntaxError,"Syntax Error exception");
}
catch (...) {
SWIG_exception(SWIG_RuntimeError,"Unknown exception");
}
}
%exception next { %exception next {
try { try {
$action $action
} catch (YAPError &e) {
yap_error_number en = e.getID();
PyObject *pyerr = PyExc_RuntimeError;
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:
pyerr = PyExc_IndexError;
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:
pyerr = PyExc_KeyError;
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:
pyerr = PyExc_IOError;
break;
default:
pyerr = PyExc_ValueError;
} }
catch (...) { } break;
SWIG_exception(SWIG_RuntimeError,"Unknown exception"); /// bad arithmetic
case EVALUATION_ERROR: {
switch (en) {
case EVALUATION_ERROR_FLOAT_OVERFLOW:
case EVALUATION_ERROR_INT_OVERFLOW:
pyerr = PyExc_OverflowError;
break;
case EVALUATION_ERROR_FLOAT_UNDERFLOW:
case EVALUATION_ERROR_UNDERFLOW:
case EVALUATION_ERROR_ZERO_DIVISOR:
pyerr = PyExc_ArithmeticError;
break;
default:
pyerr = PyExc_RuntimeError;
}
} break;
/// missing object (I/O mostly)
case EXISTENCE_ERROR:
pyerr = PyExc_NotImplementedError;
break;
/// should be bound
case INSTANTIATION_ERROR_CLASS:
pyerr = PyExc_RuntimeError;
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:
pyerr = PyExc_OverflowError;
break;
default:
pyerr = PyExc_RuntimeError;
}
} break;
/// something that could not be represented into a type
case REPRESENTATION_ERROR:
pyerr = PyExc_RuntimeError;
break;
/// not enough ....
case RESOURCE_ERROR:
pyerr = PyExc_RuntimeError;
break;
/// bad text
case SYNTAX_ERROR_CLASS:
pyerr = PyExc_SyntaxError;
break;
/// OS or internal
case SYSTEM_ERROR_CLASS:
pyerr = PyExc_RuntimeError;
break;
/// bad typing
case TYPE_ERROR:
pyerr = PyExc_TypeError;
break;
/// should be unbound
case UNINSTANTIATION_ERROR_CLASS:
pyerr = PyExc_RuntimeError;
break;
/// escape hatch
default:
break;
}
PyErr_SetString(pyerr, e.text());
} }
} }
#else
// Language independent exception handler
%include exception.i
%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;
}
}
}
#endif
%{ %{
/* Put header files here or function declarations like below */ /* Put header files here or function declarations like below */
#define YAP_CPP_INTERFACE 1 #define YAP_CPP_INTERFACE 1
#include "yapi.hh" #include "yapi.hh"
extern "C" { extern "C" {
@ -137,45 +324,30 @@ class YAPEngine;
#define Yap_regp regcache #define Yap_regp regcache
#endif #endif
// we cannot consult YapInterface.h, that conflicts with what we declare, though // we cannot consult YapInterface.h, that conflicts with what we
// declare, though
// it shouldn't // it shouldn't
} }
%} %}
/* turn on director wrapping Callback */
/* turn on director wrapping Callback */
%feature("director") YAPCallback; %feature("director") YAPCallback;
// %include "yapi.hh" // %include "yapi.hh"
%include "yapa.hh" %include "yapa.hh"
%include "yapie.hh" %include "yapie.hh"
%include "yapt.hh" %include "yapt.hh"
%include "yapdb.hh"
%include "yapq.hh"
#ifdef SWIGJAVA
%javaexception("java.text.ParseException") YAPPredicate {
try {
$action
} catch (YAPError::SYNTAX_ERROR &e) {
jclass clazz = jenv->FindClass("java/text/ParseException");
jenv->ThrowNew(clazz, "Syntax error");
return $null;
}
}
#endif
%include "yapdb.hh"
%include "yapq.hh"
%init %{ %init %{
#ifdef SWIGPYTHON #ifdef SWIGPYTHON
init_python(); init_python();
#endif #endif
%} %}

120
pl/CMakeLists.txt
View File

@ -1,62 +1,68 @@
set(PL_SOURCES set(PL_SOURCES
absf.yap absf.yap
arith.yap arith.yap
arithpreds.yap arithpreds.yap
arrays.yap arrays.yap
attributes.yap atoms.yap
atoms.yap attributes.yap
boot.yap boot.yap
bootutils.yap bootlists.yap
callcount.yap bootutils.yap
checker.yap callcount.yap
consult.yap checker.yap
control.yap consult.yap
corout.yap control.yap
debug.yap corout.yap
dbload.yap dbload.yap
depth_bound.yap debug.yap
dialect.yap depth_bound.yap
directives.yap dialect.yap
eam.yap directives.yap
eval.yap eam.yap
errors.yap error.yap
flags.yap errors.yap
grammar.yap eval.yap
ground.yap flags.yap
hacks.yap grammar.yap
init.yap ground.yap
listing.yap hacks.yap
bootlists.yap init.yap
load_foreign.yap listing.yap
messages.yap load_foreign.yap
meta.yap messages.yap
modules.yap meta.yap
newmod.yap modules.yap
os.yap newmod.yap
preddecls.yap os.yap
preddyns.yap pathconf.yap
preds.yap pl
profile.yap preddecls.yap
protect.yap preddyns.yap
qly.yap preds.yap
save.yap profile.yap
setof.yap protect.yap
signals.yap qly.yap
sort.yap save.yap
statistics.yap setof.yap
strict_iso.yap signals.yap
tabling.yap sort.yap
threads.yap spy.yap
udi.yap statistics.yap
undefined.yap strict_iso.yap
utils.yap swi.yap
swi.yap tabling.yap
yapor.yap threads.yap
yio.yap udi.yap
undefined.yap
utils.yap
yapor.yap
yio.yap
) )
if (NOT ANDROID) if (ANDROID)
file(INSTALL ${PL_SOURCES} DESTINATION ${libpl}/pl)
else()
add_custom_target (${YAP_STARTUP} ALL SOURCES ${PL_SOURCES} ${YAPOS_PL_SOURCES} WORKING_DIRECTORY ${CMAKE_BINARY_DIR} ) add_custom_target (${YAP_STARTUP} ALL SOURCES ${PL_SOURCES} ${YAPOS_PL_SOURCES} WORKING_DIRECTORY ${CMAKE_BINARY_DIR} )
# Create a startup.yss on the top directory. # Create a startup.yss on the top directory.
@ -73,7 +79,7 @@ install (FILES ${CMAKE_TOP_BINARY_DIR}/${YAP_STARTUP}
) )
endif (NOT ANDROID) endif (ANDROID)
install (FILES ${PL_SOURCES} install (FILES ${PL_SOURCES}

2
pl/errors.yap
View File

@ -107,6 +107,7 @@ system_error(Type,Goal,Culprit) :-
fail. fail.
'$LoopError'(_, _) :- '$LoopError'(_, _) :-
flush_output, flush_output,
'$close_error',
fail. fail.
'$process_error'('$forward'(Msg), _) :- '$process_error'('$forward'(Msg), _) :-
@ -114,7 +115,6 @@ system_error(Type,Goal,Culprit) :-
throw( '$forward'(Msg) ). throw( '$forward'(Msg) ).
'$process_error'('$abort', Level) :- '$process_error'('$abort', Level) :-
!, !,
'$process_error'(abort, Level).
'$process_error'(abort, Level) :- '$process_error'(abort, Level) :-
!, !,
( (

2
pl/meta.yap
View File

@ -405,6 +405,8 @@ o:p(B) :- n:g, X is 2+3, call(B).
'$build_up'(HM, NH, SM, B1, (NH :- B1), BO, ( NH :- BO)) :- HM == SM, !. '$build_up'(HM, NH, SM, B1, (NH :- B1), BO, ( NH :- BO)) :- HM == SM, !.
'$build_up'(HM, NH, _SM, B1, (NH :- B1), BO, ( HM:NH :- BO)) :- !. '$build_up'(HM, NH, _SM, B1, (NH :- B1), BO, ( HM:NH :- BO)) :- !.
'$expand_clause_body'(V, _NH1, _HM1, _SM, M, call(M:V), call(M:V) ) :-
var(V), !.
'$expand_clause_body'(true, _NH1, _HM1, _SM, _M, true, true ) :- !. '$expand_clause_body'(true, _NH1, _HM1, _SM, _M, true, true ) :- !.
'$expand_clause_body'(B, H, HM, SM, M, B1, BO ) :- '$expand_clause_body'(B, H, HM, SM, M, B1, BO ) :-
'$module_u_vars'(HM , H, UVars), % collect head variables in '$module_u_vars'(HM , H, UVars), % collect head variables in

5
swi/library/CMakeLists.txt
View File

@ -37,7 +37,12 @@ set (LIBRARY_PL
) )
if (ANDROID)
file(INSTALL ${LIBRARY_PL} DESTINATION ${libpl})
else()
install(FILES ${LIBRARY_PL} install(FILES ${LIBRARY_PL}
DESTINATION ${libpl} DESTINATION ${libpl}
) )
endif()