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);

1102
C/amasm.c
View File

File diff suppressed because it is too large Load Diff

31
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,9 +11,7 @@
* @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)) {
@ -31,9 +27,7 @@ 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)) {
@ -46,23 +40,15 @@ 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) {
@ -139,9 +125,7 @@ Yap_ArgListToVector (Term listl, const param_t *def, int n)
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)) {
@ -153,13 +137,10 @@ 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) {

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;
} }
} }

166
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,6 +73,21 @@ 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
@ -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 {
@ -214,7 +225,6 @@ static void error_exit_yap(int value) {
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,14 +347,22 @@ 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,
// function);
// tf = MkAtomTerm(Yap_LookupAtom(LOCAL_FileNameBuf)); // 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))
@ -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;
@ -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) {
@ -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]);
} }
} }
} }
@ -568,14 +585,11 @@ 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)) {
@ -585,9 +599,7 @@ 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)) {
@ -597,11 +609,7 @@ is_atom( USES_REGS1 )
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) {
@ -638,9 +646,7 @@ 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;
@ -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);
} }

114
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 */
@ -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 */

146
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,7 +1846,8 @@ 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,
GLOBAL_MaxPriority);
fputc('\n', stderr); fputc('\n', stderr);
} else { } else {
UNLOCK(pe->PELock); UNLOCK(pe->PELock);
@ -1812,17 +1882,20 @@ void DumpActiveGoals(USES_REGS1) {
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,
GLOBAL_MaxPriority);
fputc('(', stderr); fputc('(', stderr);
for (i = 0; i < arity; i++) { for (i = 0; i < arity; i++) {
if (i > 0) if (i > 0)
@ -1835,11 +1908,13 @@ void DumpActiveGoals(USES_REGS1) {
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,
GLOBAL_MaxPriority);
fputc('(', stderr); fputc('(', stderr);
for (i = 0; i < arity; i++) { for (i = 0; i < arity; i++) {
if (i > 0) if (i > 0)
@ -1849,7 +1924,8 @@ void DumpActiveGoals(USES_REGS1) {
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,
GLOBAL_MaxPriority);
fputc('(', stderr); fputc('(', stderr);
for (i = 0; i < arity; i++) { for (i = 0; i < arity; i++) {
if (i > 0) if (i > 0)
@ -1865,8 +1941,7 @@ void DumpActiveGoals(USES_REGS1) {
} }
} }
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;
@ -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) {

86
C/text.c
View File

@ -39,21 +39,24 @@ 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) \ #define unprotect_stack(s) TR = ov__, LOCAL_ScannerStack = ocur__
TR = ov__, LOCAL_ScannerStack = ocur__
// LOCAL_ScannerStack = ov__, TR = ot__ // 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;
} }
@ -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 |
@ -342,14 +340,14 @@ 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)) &&
IsPairOrNilTerm(inp->val.t)) {
// Yap_DebugPlWriteln(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)) {
@ -404,8 +402,7 @@ unsigned char *Yap_readText(seq_tv_t *inp, size_t *lengp) {
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);
@ -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';
@ -582,7 +580,8 @@ 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;
@ -614,7 +613,7 @@ size_t write_buffer(unsigned char *s0, seq_tv_t *out, size_t leng USES_REGS) {
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);
@ -682,8 +681,7 @@ 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);
@ -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,11 +704,8 @@ 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 (
(out->val.t = write_number(inp, out, leng PASS_REGS)) !=
0L) {
// Yap_DebugPlWriteln(out->val.t); // Yap_DebugPlWriteln(out->val.t);
return true; return true;
@ -721,8 +715,7 @@ 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);
@ -766,8 +759,7 @@ bool write_Text(unsigned char *inp, seq_tv_t *out, size_t leng USES_REGS) {
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;
} }
@ -889,8 +881,9 @@ static unsigned char *concat(int n, unsigned char *sv[] USES_REGS) {
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,8 +1087,7 @@ 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);
@ -1119,8 +1110,7 @@ const char *Yap_PredIndicatorToUTF8String(PredEntry *ap) {
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;
} }

106
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__)
@ -142,7 +160,7 @@ check_area(void)
// 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;
@ -151,11 +169,7 @@ void low_level_trace(yap_low_level_port port, PredEntry *pred, CELL *args) {
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)

119
CXX/yapdb.hh
View File

@ -1,5 +1,4 @@
#ifndef _YAPDB_H #ifndef _YAPDB_H
#define _YAPDB_H #define _YAPDB_H
@ -38,6 +37,7 @@ class YAPModule : protected YAPAtomTerm {
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()){};
@ -55,6 +55,7 @@ class YAPModuleProp: public YAPProp {
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);
@ -66,12 +67,15 @@ public:
*/ */
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
/// ///
@ -83,9 +87,9 @@ public:
/// 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
@ -93,23 +97,18 @@ public:
/// 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 );
}
}; };
/** /**
@ -119,6 +118,7 @@ public:
*/ */
class YAPPredicate : public YAPModuleProp { class YAPPredicate : public YAPModuleProp {
friend class YAPQuery; friend class YAPQuery;
friend class YAPEngine;
protected: protected:
PredEntry *ap; PredEntry *ap;
@ -126,6 +126,8 @@ protected:
/// 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[]
@ -134,7 +136,7 @@ protected:
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;
@ -142,12 +144,11 @@ protected:
// 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
@ -159,9 +160,7 @@ protected:
/// 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(){};
@ -186,7 +185,6 @@ public:
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);
@ -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));
@ -239,24 +237,16 @@ public:
*/ */
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,
bool unspyable = false,
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 *retractClause(YAPTerm skeleton, bool all = false);
void *clause(YAPTerm skeleton, YAPTerm &body); void *clause(YAPTerm skeleton, YAPTerm &body);
}; };
@ -268,50 +258,33 @@ public:
*/ */
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);

15
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,7 +28,7 @@ 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);
@ -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
*************************************************************************************************/ *************************************************************************************************/

21
H/YapFlags.h
View File

@ -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);

33
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;
} }
@ -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;
@ -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_

24
H/generated/hlocals.h
View File

@ -1,5 +1,6 @@
/* 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
@ -75,8 +76,6 @@ typedef struct worker_local {
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
struct DB_TERM* BallTerm_;
/// stack limit after which the stack is managed by C-code. /// 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)
@ -147,7 +146,8 @@ typedef struct worker_local {
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 */
@ -168,12 +168,10 @@ typedef struct worker_local {
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_;
@ -186,8 +184,8 @@ const char* Error_Function_;
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_;
@ -264,7 +262,7 @@ const char* Error_Function_;
// 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_;

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) {

17
H/rheap.h
View File

@ -934,9 +934,18 @@ 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) {
@ -948,14 +957,6 @@ static void RestoreYapRecords__(USES_REGS1) {
} }
} }
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

23
Prelims.cmake
View File

@ -140,32 +140,23 @@ 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

88
include/YapError.h
View File

@ -36,22 +36,28 @@
#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))
@ -59,7 +65,8 @@ Yap_ensure_atom__( const char *fu, const char *fi, int line, Term in )
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;
} }
@ -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()

15
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
@ -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);

5
os/mem.c
View File

@ -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;

326
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,14 +228,12 @@ 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);
parameters loadparam(int argc, char **arg); parameters loadparam(int argc, char **arg);
@ -247,7 +247,8 @@ 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);
@ -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
@ -311,14 +317,18 @@ int main(int argc, char **arg) {
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();
@ -329,14 +339,16 @@ int main(int argc, char **arg) {
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,7 +367,8 @@ 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);
@ -365,34 +378,47 @@ int main(int argc, char **arg) {
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));
@ -406,15 +432,20 @@ int main(int argc, char **arg) {
} }
} 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);
} }
@ -424,8 +455,7 @@ 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) {
@ -625,8 +688,11 @@ void pidhandler(int num) {
} }
} }
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,35 +784,46 @@ 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++;
if (i == sl)
return NULL;
i++; i++;
p = (char *)malloc(sizeof(char) * (i + 2)); p = (char *)malloc(sizeof(char) * (i + 2));
strncpy(p, thestr, i); strncpy(p, thestr, i);
@ -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;
} }
@ -770,41 +854,34 @@ so that it is not recomputed
double res; double res;
double value; double value;
if (Cudd_IsConstant(node)) {
if (Cudd_IsConstant(node))
{
value = Cudd_V(node); value = Cudd_V(node);
if (comp) 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); index = Cudd_NodeReadIndex(node);
mVarIndex = MyManager.varmap.bVar2mVar[index]; mVarIndex = MyManager.varmap.bVar2mVar[index];
v = MyManager.varmap.mvars[mVarIndex]; v = MyManager.varmap.mvars[mVarIndex];
nBit = v.nBit; nBit = v.nBit;
res = ProbBool(MyManager, node, 0, nBit, 0, v, comp); res = ProbBool(MyManager, node, 0, nBit, 0, v, comp);
AddNode1(MyManager.varmap.bVar2mVar,MyManager.his, 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;
@ -812,46 +889,37 @@ double ProbBool(extmanager MyManager, DdNode *node, int bits, int nBit,int posBV
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]; p = probs[bits];
res = p * Prob(MyManager, node, comp); res = p * Prob(MyManager, node, comp);
return res; return res;
} }
} } else {
else
{
index = Cudd_NodeReadIndex(node); index = Cudd_NodeReadIndex(node);
if (correctPosition(index,v,posBVar)) 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; return res;
} } else {
else
{
bits = bits << 1; bits = bits << 1;
res = ProbBool(MyManager, node, bits + 1, nBit - 1, posBVar + 1, v, comp); res = ProbBool(MyManager, node, bits + 1, nBit - 1, posBVar + 1, v, comp);
res=res+ res =
ProbBool(MyManager,node,bits,nBit-1,posBVar+1,v,comp); res + ProbBool(MyManager, node, bits, nBit - 1, posBVar + 1, v, comp);
return res; 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;
@ -860,13 +928,11 @@ currently explored by ProbBool */
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()

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

@ -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'
@ -41,10 +42,14 @@ class YAPKernel(IPythonKernel):
} }
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()
@ -64,14 +69,13 @@ class YAPKernel(IPythonKernel):
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()

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()

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}
) )

272
packages/swig/yap.i
View File

@ -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,9 +19,7 @@ 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);
@ -37,7 +33,6 @@ class YAPEngine;
} }
return *new YAPTerm(); return *new YAPTerm();
} }
} }
%typemap(out) YAPIntegerTerm { %typemap(out) YAPIntegerTerm {
@ -68,7 +63,6 @@ class YAPEngine;
} }
} }
// translate lists as Python Lists // translate lists as Python Lists
// Python symbols // Python symbols
// Everthing else let wrapped. // Everthing else let wrapped.
@ -89,46 +83,239 @@ class YAPEngine;
return list; return list;
} }
// Language independent exception handler
%exception YAPPredicate {
try {
$action
} catch (...) {
PyErr_SetString(PyExc_SyntaxError, "syntax error");
return NULL;
}
}
#endif
%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,17 +324,16 @@ 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"
@ -160,20 +346,6 @@ class YAPEngine;
%include "yapq.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
%init %{ %init %{
#ifdef SWIGPYTHON #ifdef SWIGPYTHON
init_python(); init_python();

20
pl/CMakeLists.txt
View File

@ -3,36 +3,39 @@ set(PL_SOURCES
arith.yap arith.yap
arithpreds.yap arithpreds.yap
arrays.yap arrays.yap
attributes.yap
atoms.yap atoms.yap
attributes.yap
boot.yap boot.yap
bootlists.yap
bootutils.yap bootutils.yap
callcount.yap callcount.yap
checker.yap checker.yap
consult.yap consult.yap
control.yap control.yap
corout.yap corout.yap
debug.yap
dbload.yap dbload.yap
debug.yap
depth_bound.yap depth_bound.yap
dialect.yap dialect.yap
directives.yap directives.yap
eam.yap eam.yap
eval.yap error.yap
errors.yap errors.yap
eval.yap
flags.yap flags.yap
grammar.yap grammar.yap
ground.yap ground.yap
hacks.yap hacks.yap
init.yap init.yap
listing.yap listing.yap
bootlists.yap
load_foreign.yap load_foreign.yap
messages.yap messages.yap
meta.yap meta.yap
modules.yap modules.yap
newmod.yap newmod.yap
os.yap os.yap
pathconf.yap
pl
preddecls.yap preddecls.yap
preddyns.yap preddyns.yap
preds.yap preds.yap
@ -43,20 +46,23 @@ set(PL_SOURCES
setof.yap setof.yap
signals.yap signals.yap
sort.yap sort.yap
spy.yap
statistics.yap statistics.yap
strict_iso.yap strict_iso.yap
swi.yap
tabling.yap tabling.yap
threads.yap threads.yap
udi.yap udi.yap
undefined.yap undefined.yap
utils.yap utils.yap
swi.yap
yapor.yap yapor.yap
yio.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()