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

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

Browse Source
This commit is contained in:
Vitor Santoss Costa 2017-02-22 11:32:28 +00:00
commit 477772e703
374 changed files with 33890 additions and 39248 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

203
#.gitignore# Normal file
View File

@ -0,0 +1,203 @@
*~
*.itf
*.po
*.qlf
*.xwam
*.wam
*.ma
*.s
*.o
*.so
*.dylib
*.dll
docs/yap.info*
.build
tags
TGSautom4te.cache
cscope.*
GPATH
m32
GRTAGS
GTAGS
tmtags*
.autotools
.Rhistory
.zedstate
config.h
Yap.h
YapConfig.h
YapTermConfig.h
.graffiti
.#*#
*/#*#
*bak
*rej
*.db
groups
*.ede
.??*
*ggtags*
.atom-build.josn
.autotools
.cproject
.dir-locals.el
.DS_store
.kateproject
.project
.pydevproject
.Rhistory
.zedstate
.graffiti
.kateproject
autom4te.cache
*rej
#*
#*#
config.h
*.html
packages/gecode/dev
JIT/HPP/bkp
cmake_install.cmake
cmake_clean.cmake
*.build
C/myabsmi.c
*.ctags#
*.hs
CMakeFiles
*.make
C/new_iop.c
*.pdf
*.log
*.orig
JIT/HPP/#JIT_In#
*.text
yap
*startup.yss
*cmake_files
C/pl-yap.c
GitSHA1.c
.vscode
CMakeLists.txt.*
FindPackageLog.txt
GitSHA1.c
clang
cmake-build-debug
os/YapIOConfig.h
CodeBlocks
os/readterm.c.cpp
os/readterm.c.cpp
packages/ProbLog/problog_examples/output/,_query_1_cluster_1.dot
packages/ProbLog/#problog_lbdd.yap#
packages/ProbLog/problog_examples/output/,_query_1_cluster_1.dot
packages/ProbLog/problog_examples/output/out.dat
packages/ProbLog/problog_examples/outputvalues.pl
packages/ProbLog/problogbdd
packages/raptor/raptor_config.h
packages/real/rconfig.h
packages/ProbLog/problog/#completion.yap#
packages/ProbLog/problog_examples/output
packages/ProbLog/problog_examples/queries
packages/swig/java/*.java
packages/swig/java/*.class
packages/swig/java/*.jar
packages/swig/java/*wrap*
*jnilib
*.jar
*LOG
packages/cplint/approx/simplecuddLPADs/LPADBDD
packages/swi-minisat2/˜:ilp
packages/swig/android/app
packages/cplint/L
packages/CLPBN/horus/hcli
tmp
Eclipse
packages/bdd/simplecudd/problogbdd
trace
packages/bdd/cudd_config.h
Makefile
build
Debug
debug
Release
Build
xcode
Threads
droid
mxe
mxe32
msys2
caret
codelite
configure
Qt
cmake/cmake-android
sublime
yap-6.3.workspace
yap-6.3.geany
YAP.project
CBlocks
yPQ
*.tmp
YAP.sublime*
yap32
Eclipse
codeblocks
yap-6.3.tags
android
yap.prj
yap.VITORs-MBP.vsc.pui
vc
packages/myddas/pl/myddas_odbc.yap
packages/myddas/pl/myddas_postgres.yap
packages/myddas/pl/myddas_sqlite3.ypp
packages/myddas/pl/#myddas_postgres.ypp#
packages/myddas/hh
packages/myddas/DaysInHospital_Y3.csv
packages/myddas/agile.csv
*.pyc
*.cmake#
*.tex
*.c#
packages/swig/yap_wrap.cxx
packages/swig/yap_wrap.h
packages/swig/yap_wrap.cpp
packages/swig/yap.py
*.ipynb
yap
packages/python/yap_kernel/x/__init__.py
x
packages/python/yap_kernel/x/__main__.py
*.gch
mxe
build

2
#GitSHA1.c.in# Normal file
View File

@ -0,0 +1,2 @@
eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee#define GIT_SHA1 "@GIT_SHA1@"
const char g_GIT_SHA1[] = GIT_SHA1;

22
.configure-custom.sh
View File

@ -1,2 +1,20 @@
ENABLE_VARS="jit|no|WITH_JIT clpbn|yes|WITH_CLPBN cplint|yes|WITH_CPLINT horus|yes|WITH_HORUS docs|no|WITH_DOCS problog|yes|WITH_PROBLOG"
WITH_VARS="swig|yes|WITH_SWIG gecode|yes|WITH_GECODE R|yes|WITH_REAL cudd|yes|WITH_BDD python|yes|WITH_PYTHON "
ENABLE_VARS="clpbn|yes|WITH_CLPBN \
cplint|yes|WITH_CPLINT \
horus|yes|WITH_HORUS \
clpr|yes|WITH_CLPR \
problog|yes|WITH_PROBLOG \
jit|no|WITH_JIT \
chr|no|WITH_CHR \
threads|no|WITH_THREADS"
WITH_VARS="swig|yes|WITH_SWIG \
mpi|yes|WITH_MPI \
gecode|yes|WITH_GECODE \
docs|yes|WITH_DOCS \
r|yes|WITH_REAL \
cudd|yes|WITH_CUDD \
xml2|yes|WITH_XML2 \
raptor|yes|WITH_RAPTOR \
python|yes|WITH_PYTHON \
openssl|yes|WITH_OPENSSL\
readline|yes|WITH_READLINE \
gmp|yes|WITH_GMP "

6
.ctags
View File

@ -6,6 +6,7 @@
--regex-Prolog=/^([a-z][A-Za-z0-9_]*:)?\'(.*)\'\(.*\)\.[ \t]*.*/\2/p,predicate,predicate definition/
--regex-Prolog=/^:-[ \t]+(discontiguous|dynamic|multifile|table|thread_local)[ \t]+([a-z][_a-zA-Z0-9]*:)?([a-z0-9_][_a-zA-Z0-9]*)/\1/p,predicate,predicate metadata/
--regex-Prolog=/^[ \t]*Yap_InitCPred[ \t]*\"(\$?[A-Za-z0-9_]*)\"([ \t]*).*/\1/p,predicate,predicate definition/
--langmap=C:+.(h.cmake).(h.config)
--exclude=\._*
--exclude=*\.bak
--exclude=\.svn
@ -22,3 +23,8 @@
--exclude=\#.*
--exclude=(.)\#*
--exclude=*.dylib
--exclude=docs
--exclude=build
--exclude=cmake-build-debug
--exclude=clang

14
.gitignore vendored
View File

@ -80,15 +80,11 @@ GitSHA1.c
CMakeLists.txt.*
FindPackageLog.txt
GitSHA1.c
GitSHA1.c
clang
cmake-build-debug
os/YapIOConfig.h
os/YapIOConfig.h
os/YapIOConfig.h
CodeBlocks
x
os/readterm.c.cpp
os/readterm.c.cpp
@ -203,3 +199,5 @@ packages/python/yap_kernel/x/__init__.py
packages/python/yap_kernel/x/__main__.py
*.gch
mxe
build

2
BEAM/eamamasm.c
View File

@ -12,7 +12,7 @@
#ifdef BEAM
#include "Yap.h"
#include "compile.h"
#include "YapCompile.h"
#include "clause.h"
#include "eam.h"
#include "eamamasm.h"

2
BEAM/eamindex.c
View File

@ -12,7 +12,7 @@
#ifdef BEAM
#include "Yap.h"
#include "compile.h"
#include "YapCompile.h"
#include "clause.h"
#include "eam.h"
#include <stdio.h>

4
C/alloc.c
View File

@ -78,7 +78,7 @@ void *my_malloc(size_t sz) {
p = malloc(sz);
// Yap_DebugPuts(stderr,"gof\n");
if (Yap_do_low_level_trace)
fprintf(stderr, "+ %p : %lu\n", p, sz);
fprintf(stderr, "+ %p: %" Sizet_F "\n", p, sz);
if (sz > 500 && write_malloc++ > 0)
__android_log_print(ANDROID_LOG_ERROR, "YAPDroid ", "+ %d %p", write_malloc,
p);
@ -90,7 +90,7 @@ void *my_realloc(void *ptr, size_t sz) {
p = realloc(ptr, sz);
if (Yap_do_low_level_trace)
// fprintf(stderr, "+ %p -> %p : %lu\n", ptr, p, sz);
// fprintf(stderr, "+ %p -> %p : " Sizet_F "\n", ptr, p, sz);
// Yap_DebugPuts(stderr,"gof\n");
if (sz > 500 && write_malloc++ > 0)
__android_log_print(ANDROID_LOG_ERROR, "YAPDroid ", "* %d %p", write_malloc,

2
C/amasm.c
View File

@ -188,7 +188,7 @@ static char SccsId[] = "@(#)amasm.c 1.3 3/15/90";
#include "Yap.h"
#include "clause.h"
#include "compile.h"
#include "YapCompile.h"
#include "yapio.h"
#ifdef BEAM

2
C/arith0.c
View File

@ -111,7 +111,7 @@ static char SccsId[] = "%W% %G%";
#include "Yap.h"
#include "Yatom.h"
#include "YapHeap.h"
#include "eval.h"
#include "YapEval.h"

3
C/arith1.c
View File

@ -228,7 +228,7 @@ X is Y*10+C-48.
#include "Yap.h"
#include "Yatom.h"
#include "YapHeap.h"
#include "eval.h"
#include "YapEval.h"
static Term
float_to_int(Float v USES_REGS)
@ -1075,4 +1075,3 @@ Yap_ReInitUnaryExps(void)
{
return TRUE;
}

2
C/arith2.c
View File

@ -127,7 +127,7 @@ These are the binary numeric operators currently supported by YAP.
#include "Yap.h"
#include "Yatom.h"
#include "YapHeap.h"
#include "eval.h"
#include "YapEval.h"
#include "arith2.h"

2
C/arrays.c
View File

@ -102,7 +102,7 @@ The following predicates manipulate arrays:
#include "Yap.h"
#include "Yatom.h"
#include "clause.h"
#include "eval.h"
#include "YapEval.h"
#include "heapgc.h"
#if HAVE_ERRNO_H
#include <errno.h>

156
C/atomic.c Normal file → Executable file
View File

@ -36,10 +36,10 @@ The following predicates are used to manipulate atoms:
*/
#include "Yap.h"
#include "YapEval.h"
#include "YapHeap.h"
#include "YapText.h"
#include "Yatom.h"
#include "eval.h"
#include "yapio.h"
#ifdef TABLING
#include "tab.macros.h"
@ -68,22 +68,6 @@ static Int hide_atom(USES_REGS1);
static Int hidden_atom(USES_REGS1);
static Int unhide_atom(USES_REGS1);
#define ReleaseAndReturn(r) \
{ \
pop_text_stack(l); \
return r; \
}
#define release_cut_fail() \
{ \
pop_text_stack(l); \
cut_fail(); \
}
#define release_cut_succeed() \
{ \
pop_text_stack(l); \
cut_succeed(); \
}
static int AlreadyHidden(unsigned char *name) {
AtomEntry *chain;
@ -1715,22 +1699,24 @@ static Int atom_split(USES_REGS1) {
ReleaseAndReturn((FALSE));
}
at = AtomOfTerm(t1);
unsigned char *s, *s1, *s10;
s = RepAtom(at)->UStrOfAE;
if (len > (Int)strlen_utf8(s))
char *s;
unsigned char *s1, *s10, *s0;
s = RepAtom(at)->StrOfAE;
if (len > strlen(s))
ReleaseAndReturn((FALSE));
s1 = s10 = Malloc(len);
s0 = RepAtom(at)->UStrOfAE;
if (s1 + len > (unsigned char *)ASP - 1024)
Yap_Error(RESOURCE_ERROR_STACK, t1, "$atom_split/4");
size_t j;
for (j = 0; j < len; j++) {
int32_t val;
s += get_utf8(s, 1, &val);
s1 += put_utf8(s, val);
s0 += get_utf8(s0, 1, &val);
s1 += put_utf8(s1, val);
}
s1[0] = '\0';
to1 = MkAtomTerm(Yap_ULookupAtom(s10));
to2 = MkAtomTerm(Yap_ULookupAtom(s));
to2 = MkAtomTerm(Yap_LookupAtom(s));
ReleaseAndReturn(
(Yap_unify_constant(ARG3, to1) && Yap_unify_constant(ARG4, to2)));
}
@ -1790,8 +1776,8 @@ restart_aux:
#define SUB_ATOM_HAS_ATOM 16
#define SUB_ATOM_HAS_UTF8 32
static Term build_new_atomic(int mask, wchar_t *wp, const unsigned char *p,
size_t minv, size_t len USES_REGS) {
static Term build_new_atomic(int mask, const unsigned char *p, size_t minv,
size_t len USES_REGS) {
int n;
seq_tv_t outv[5], inp;
size_t cuts[3];
@ -1876,7 +1862,6 @@ static Int cont_sub_atomic(USES_REGS1) {
Term tat5 = Deref(ARG5);
int mask;
size_t minv, len, after, sz;
wchar_t *wp = NULL;
const unsigned char *p = NULL, *p5 = NULL;
mask = IntegerOfTerm(EXTRA_CBACK_ARG(5, 1));
@ -1936,7 +1921,7 @@ static Int cont_sub_atomic(USES_REGS1) {
cut_fail();
}
} else if (mask & SUB_ATOM_HAS_SIZE) {
Term nat = build_new_atomic(mask, wp, p, minv, len PASS_REGS);
Term nat = build_new_atomic(mask, p, minv, len PASS_REGS);
Yap_unify(ARG2, MkIntegerTerm(minv));
Yap_unify(ARG4, MkIntegerTerm(after));
Yap_unify(ARG5, nat);
@ -1945,7 +1930,7 @@ static Int cont_sub_atomic(USES_REGS1) {
cut_succeed();
} else if (mask & SUB_ATOM_HAS_MIN) {
after = sz - (minv + len);
Term nat = build_new_atomic(mask, wp, p, minv, len PASS_REGS);
Term nat = build_new_atomic(mask, p, minv, len PASS_REGS);
Yap_unify(ARG3, MkIntegerTerm(len));
Yap_unify(ARG4, MkIntegerTerm(after));
Yap_unify(ARG5, nat);
@ -1954,7 +1939,7 @@ static Int cont_sub_atomic(USES_REGS1) {
cut_succeed();
} else if (mask & SUB_ATOM_HAS_AFTER) {
len = sz - (minv + after);
Term nat = build_new_atomic(mask, wp, p, minv, len PASS_REGS);
Term nat = build_new_atomic(mask, p, minv, len PASS_REGS);
Yap_unify(ARG2, MkIntegerTerm(minv));
Yap_unify(ARG3, MkIntegerTerm(len));
Yap_unify(ARG5, nat);
@ -1962,7 +1947,7 @@ static Int cont_sub_atomic(USES_REGS1) {
if (len-- == 0)
cut_succeed();
} else {
Term nat = build_new_atomic(mask, wp, p, minv, len PASS_REGS);
Term nat = build_new_atomic(mask, p, minv, len PASS_REGS);
Yap_unify(ARG2, MkIntegerTerm(minv));
Yap_unify(ARG3, MkIntegerTerm(len));
Yap_unify(ARG4, MkIntegerTerm(after));
@ -1984,12 +1969,10 @@ static Int cont_sub_atomic(USES_REGS1) {
return TRUE;
}
static Int sub_atomic(bool sub_atom, bool sub_string USES_REGS) {
Term tat1, tbef, tsize, tafter, tout;
int mask = SUB_ATOM_HAS_UTF8;
size_t minv, len, after, sz;
wchar_t *wp = NULL;
const unsigned char *p = NULL;
int bnds = 0;
Term nat = 0L;
@ -2015,11 +1998,18 @@ static Int cont_sub_atomic(USES_REGS1) {
p = UStringOfTerm(tat1);
sz = strlen_utf8(p);
} else {
Yap_Error(TYPE_ERROR_STRING, tat1, "sub_atom/5");
Yap_Error(TYPE_ERROR_STRING, tat1, "sub_string/5");
ReleaseAndReturn(false);
}
} else {
if ((p = Yap_TextToUTF8Buffer(tat1 PASS_REGS))) {
sz = strlen_utf8(p);
} else {
ReleaseAndReturn(false)
}
}
} else {
Yap_Error(INSTANTIATION_ERROR, tat1, "sub_atom/5: first variable\n");
ReleaseAndReturn(false);
}
@ -2101,7 +2091,7 @@ static Int cont_sub_atomic(USES_REGS1) {
release_cut_fail();
if ((Int)(after = (sz - (minv + len))) < 0)
release_cut_fail();
nat = build_new_atomic(mask, wp, p, minv, len PASS_REGS);
nat = build_new_atomic(mask, p, minv, len PASS_REGS);
if (!nat)
release_cut_fail();
out = Yap_unify(ARG4, MkIntegerTerm(after)) && Yap_unify(ARG5, nat);
@ -2110,7 +2100,7 @@ static Int cont_sub_atomic(USES_REGS1) {
if (sz < minv + after)
release_cut_fail();
len = sz - (minv + after);
nat = build_new_atomic(mask, wp, p, minv, len PASS_REGS);
nat = build_new_atomic(mask, p, minv, len PASS_REGS);
if (!nat)
release_cut_fail();
out = Yap_unify(ARG3, MkIntegerTerm(len)) && Yap_unify(ARG5, nat);
@ -2119,7 +2109,7 @@ static Int cont_sub_atomic(USES_REGS1) {
if (len + after > sz)
release_cut_fail();
minv = sz - (len + after);
nat = build_new_atomic(mask, wp, p, minv, len PASS_REGS);
nat = build_new_atomic(mask, p, minv, len PASS_REGS);
if (!nat)
release_cut_fail();
out = Yap_unify(ARG2, MkIntegerTerm(minv)) && Yap_unify(ARG5, nat);
@ -2142,7 +2132,7 @@ static Int cont_sub_atomic(USES_REGS1) {
if (!out)
release_cut_fail();
} else {
out = (strlen_utf8(RepAtom(AtomOfTerm(tout))->UStrOfAE) == len);
out = (strlen(RepAtom(AtomOfTerm(tout))->StrOfAE) == len);
if (!out)
release_cut_fail();
}
@ -2193,9 +2183,7 @@ static Int cont_sub_atomic(USES_REGS1) {
sub-strings of _A_.
*/
static Int sub_atom(USES_REGS1) {
return (sub_atomic(true, false PASS_REGS));
}
static Int sub_atom(USES_REGS1) { return (sub_atomic(true, false PASS_REGS)); }
/** @pred sub_string(+ _S_,? _Bef_, ? _Size_, ? _After_, ? _S_out_) is
iso
@ -2212,76 +2200,7 @@ static Int cont_sub_atomic(USES_REGS1) {
sub-strings of _S_.
*/
static Int sub_string(USES_REGS1) {
return sub_atomic(false, true PASS_REGS);
}
static Int atomic_to_term(USES_REGS1) {
Term t1 = Deref(ARG1), rc;
const char *s;
size_t len;
if (IsVarTerm(t1)) {
Yap_Error(INSTANTIATION_ERROR, t1, "read_term_from_string/3");
return (FALSE);
} else if (!IsAtomicTerm(t1)) {
Yap_Error(TYPE_ERROR_ATOMIC, t1, "read_term_from_atomic/3");
return (FALSE);
} else {
Term t = Yap_AtomicToString(t1 PASS_REGS);
s = (const char *)UStringOfTerm(t);
len = strlen_utf8((unsigned char *)s);
}
encoding_t enc = ENC_ISO_UTF8;
rc = Yap_StringToTerm(s, len, &enc, 1200, ARG3);
if (!rc)
return false;
return Yap_unify(rc, ARG2);
}
static Int atom_to_term(USES_REGS1) {
Term t1 = Deref(ARG1), rc;
const char *s;
size_t len;
if (IsVarTerm(t1)) {
Yap_Error(INSTANTIATION_ERROR, t1, "read_term_from_string/3");
return (FALSE);
} else if (!IsAtomTerm(t1)) {
Yap_Error(TYPE_ERROR_ATOM, t1, "read_term_from_atomic/3");
return (FALSE);
} else {
Term t = Yap_AtomicToString(t1 PASS_REGS);
s = StringOfTerm(t);
len = strlen_utf8((const unsigned char *)s);
}
encoding_t enc = ENC_ISO_UTF8;
rc = Yap_StringToTerm(s, len, &enc, 1200, ARG3);
if (!rc)
return false;
return Yap_unify(rc, ARG2);
}
static Int string_to_term(USES_REGS1) {
Term t1 = Deref(ARG1), rc;
const char *s;
size_t len;
if (IsVarTerm(t1)) {
Yap_Error(INSTANTIATION_ERROR, t1, "read_term_from_string/3");
return (FALSE);
} else if (!IsStringTerm(t1)) {
Yap_Error(TYPE_ERROR_STRING, t1, "read_term_from_string/3");
return (FALSE);
} else {
s = StringOfTerm(t1);
len = strlen_utf8((const unsigned char *)s);
}
encoding_t enc = ENC_ISO_UTF8;
rc = Yap_StringToTerm(s, len, &enc, 1200, ARG3);
if (!rc)
return false;
return Yap_unify(rc, ARG2);
}
static Int sub_string(USES_REGS1) { return sub_atomic(false, true PASS_REGS); }
static Int cont_current_atom(USES_REGS1) {
Atom catom;
@ -2363,16 +2282,14 @@ static Int cont_sub_atomic(USES_REGS1) {
void Yap_InitBackAtoms(void) {
Yap_InitCPredBack("$current_atom", 1, 2, current_atom, cont_current_atom,
SafePredFlag | SyncPredFlag);
Yap_InitCPredBack("atom_concat", 3, 2, atom_concat3, cont_atom_concat3,
Yap_InitCPredBack("atom_concat", 3, 2, atom_concat3, cont_atom_concat3, 0);
Yap_InitCPredBack("atomic_concat", 3, 2, atomic_concat3, cont_atomic_concat3,
0);
Yap_InitCPredBack("string_concat", 3, 2, string_concat3, cont_string_concat3,
0);
Yap_InitCPredBack("atomic_concat", 3, 2, atomic_concat3,
cont_atomic_concat3, 0);
Yap_InitCPredBack("string_concat", 3, 2, string_concat3,
cont_string_concat3, 0);
Yap_InitCPredBack("sub_atom", 5, 5, sub_atom, cont_sub_atomic, 0);
Yap_InitCPredBack("sub_string", 5, 5, sub_string, cont_sub_atomic, 0);
Yap_InitCPredBack("string_code", 3, 1, string_code3, cont_string_code3,
0);
Yap_InitCPredBack("string_code", 3, 1, string_code3, cont_string_code3, 0);
}
void Yap_InitAtomPreds(void) {
@ -2421,11 +2338,6 @@ static Int cont_sub_atomic(USES_REGS1) {
*/
Yap_InitCPred("atom_to_term", 3, atom_to_term, 0);
Yap_InitCPred("atomic_to_term", 3, atomic_to_term, 0);
Yap_InitCPred("string_to_term", 3, string_to_term, 0);
Yap_InitCPred("atom_chars", 2, atom_chars, 0);
/** @pred atom_chars(? _A_,? _L_) is iso

7
C/attvar.c
View File

@ -28,10 +28,11 @@ static char SccsId[] = "%W% %G%";
#define NULL (void *)0
#endif
/** @{ */
/** @file attvars.c
@{ */
/** @defgroup AttributeVariables_Builtins Implementation of Attribute
Declarations
/**
* @defgroup AttributeVariables_Builtins Implementation of Attribute Declarations
@ingroup AttributeVariables
*/

2
C/bignum.c
View File

@ -30,7 +30,7 @@ static char SccsId[] = "%W% %G%";
#ifdef USE_GMP
#include "eval.h"
#include "YapEval.h"
#include "alloc.h"
Term

89
C/c_interface.c
View File

@ -127,8 +127,7 @@ X_API yhandle_t YAP_CurrentSlot(void);
/// @brief allocate n empty new slots
///
/// Return a handle to the system's default slot.
X_API yhandle_t YAP_NewSlots(int NumberOfSlots);
/// Return a handle to the system's default slo t. iX_API yhandle_t YAP_NewSlots(int NumberOfSlots);
/// @brief allocate n empty new slots
///
@ -246,6 +245,8 @@ X_API YAP_Bool YAP_IsRationalTerm(YAP_Term t) {
#endif
}
X_API YAP_Bool YAP_IsStringTerm(YAP_Term t) { return (IsStringTerm(t)); }
X_API YAP_Bool YAP_IsVarTerm(YAP_Term t) { return (IsVarTerm(t)); }
X_API YAP_Bool YAP_IsNonVarTerm(YAP_Term t) { return (IsNonVarTerm(t)); }
@ -277,6 +278,32 @@ X_API Term YAP_MkIntTerm(Int n) {
return I;
}
X_API Term YAP_MkStringTerm(const char *n) {
CACHE_REGS
Term I;
BACKUP_H();
I = MkStringTerm(n);
RECOVER_H();
return I;
}
X_API Term YAP_MkUnsignedStringTerm(const unsigned char *n) {
CACHE_REGS
Term I;
BACKUP_H();
I = MkUStringTerm(n);
RECOVER_H();
return I;
}
X_API const char *YAP_StringOfTerm(Term t) { return StringOfTerm(t); }
X_API const unsigned char *YAP_UnsignedStringOfTerm(Term t) {
return UStringOfTerm(t);
}
X_API Int YAP_IntOfTerm(Term t) {
if (!IsApplTerm(t))
return IntOfTerm(t);
@ -453,7 +480,6 @@ X_API Atom YAP_LookupWideAtom(const wchar_t *c) {
CACHE_REGS
Atom a;
while (TRUE) {
a = Yap_NWCharsToAtom(c, -1 USES_REGS);
if (a == NIL || Yap_get_signal(YAP_CDOVF_SIGNAL)) {
@ -493,7 +519,6 @@ X_API size_t YAP_AtomNameLength(Atom at) {
unsigned char *c = RepAtom(at)->UStrOfAE;
return strlen_utf8(c);
}
X_API Term YAP_MkVarTerm(void) {
@ -1376,9 +1401,13 @@ X_API Term YAP_ReadBuffer(const char *s, Term *tp) {
Term tv, t;
BACKUP_H();
if (*tp) tv = *tp; else tv = 0;
if (*tp)
tv = *tp;
else
tv = 0;
LOCAL_ErrorMessage = NULL;
while (!(t = Yap_StringToTerm(s, strlen(s) + 1, &LOCAL_encoding,
const unsigned char *us = (const unsigned char *)s;
while (!(t = Yap_BufferToTermWithPrioBindings(us, strlen(s) + 1, TermNil,
GLOBAL_MaxPriority, tv))) {
if (LOCAL_ErrorMessage) {
if (!strcmp(LOCAL_ErrorMessage, "Stack Overflow")) {
@ -1636,7 +1665,6 @@ X_API PredEntry *YAP_AtomToPredInModule(Atom at, Term mod) {
static int run_emulator(USES_REGS1) {
int out;
LOCAL_PrologMode &= ~(UserCCallMode | CCallMode);
out = Yap_absmi(0);
LOCAL_PrologMode |= UserCCallMode;
return out;
@ -1659,7 +1687,7 @@ X_API bool YAP_EnterGoal(PredEntry *pe, CELL *ptr, YAP_dogoalinfo *dgi) {
// slot=%d", pe, pe->CodeOfPred->opc, FAILCODE, Deref(ARG1), Deref(ARG2),
// LOCAL_CurSlot);
dgi->b = LCL0 - (CELL *)B;
out = run_emulator(PASS_REGS1);
out = Yap_exec_absmi(true, false);
RECOVER_MACHINE_REGS();
if (out) {
dgi->EndSlot = LOCAL_CurSlot;
@ -2107,7 +2135,7 @@ X_API void YAP_Write(Term t, FILE *f, int flags) {
RECOVER_MACHINE_REGS();
}
X_API Term YAP_CopyTerm(Term t) {
X_API YAP_Term YAP_CopyTerm(Term t) {
Term tn;
BACKUP_MACHINE_REGS();
@ -2115,21 +2143,25 @@ X_API Term YAP_CopyTerm(Term t) {
RECOVER_MACHINE_REGS();
return tn;
return (tn);
}
X_API char *YAP_WriteBuffer(Term t, char *buf, size_t sze, int flags) {
CACHE_REGS
size_t length;
seq_tv_t inp, out;
size_t length = sze;
char *b;
BACKUP_MACHINE_REGS();
if ((b = Yap_TermToString(t, &length, LOCAL_encoding, flags)) != buf) {
inp.val.t = t;
inp.type = YAP_STRING_TERM;
out.type = YAP_STRING_CHARS;
out.val.c = buf;
out.enc = LOCAL_encoding;
if (!Yap_CVT_Text(&inp, &out PASS_REGS))
return NULL;
RECOVER_MACHINE_REGS();
return b;
}
RECOVER_MACHINE_REGS();
return buf;
return out.val.c;
}
/// write a a term to n user-provided buffer: make sure not tp
@ -2251,13 +2283,11 @@ static void do_bootfile(const char *bootfilename USES_REGS) {
the module.
*/
static bool initialized = false;
X_API bool YAP_initialized = false;
static int n_mdelays = 0;
static YAP_delaymodule_t *m_delays;
X_API bool YAP_DelayInit(YAP_ModInit_t f, const char s[]) {
if (initialized)
return false;
if (m_delays) {
m_delays = realloc(m_delays, (n_mdelays + 1) * sizeof(YAP_delaymodule_t));
} else {
@ -2269,6 +2299,17 @@ X_API bool YAP_DelayInit(YAP_ModInit_t f, const char s[]) {
return true;
}
bool Yap_LateInit(const char s[]) {
int i;
for (i = 0; i < n_mdelays; i++) {
if (!strcmp(m_delays[i].s, s)) {
m_delays[i].f();
return true;
}
}
return false;
}
static void start_modules(void) {
Term cm = CurrentModule;
size_t i;
@ -2280,7 +2321,7 @@ static void start_modules(void) {
}
/// whether Yap is under control of some other system
bool Yap_embedded;
bool Yap_embedded = true;
/* this routine is supposed to be called from an external program
that wants to control Yap */
@ -2294,9 +2335,8 @@ YAP_file_type_t YAP_Init(YAP_init_args *yap_init) {
const char *yroot;
/* ignore repeated calls to YAP_Init */
if (initialized)
if (YAP_initialized)
return YAP_FOUND_BOOT_ERROR;
initialized = true;
Yap_embedded = yap_init->Embedded;
Yap_page_size = Yap_InitPageSize(); /* init memory page size, required by
@ -2304,7 +2344,9 @@ YAP_file_type_t YAP_Init(YAP_init_args *yap_init) {
#if defined(YAPOR_COPY) || defined(YAPOR_COW) || defined(YAPOR_SBA)
Yap_init_yapor_global_local_memory();
#endif /* YAPOR_COPY || YAPOR_COW || YAPOR_SBA */
GLOBAL_PrologShouldHandleInterrupts = yap_init->PrologShouldHandleInterrupts;
// GLOBAL_PrologShouldHandleInterrupts =
// yap_init->PrologShouldHandleInterrupts &&
if (!yap_init->Embedded)
Yap_InitSysbits(0); /* init signal handling and time, required by later
functions */
GLOBAL_argv = yap_init->Argv;
@ -2489,6 +2531,7 @@ YAP_file_type_t YAP_Init(YAP_init_args *yap_init) {
setBooleanGlobalPrologFlag(SAVED_PROGRAM_FLAG, false);
}
start_modules();
YAP_initialized = true;
return rc;
}

2
C/cdmgr.c
View File

@ -20,7 +20,7 @@ static char SccsId[] = "@(#)cdmgr.c 1.1 05/02/98";
#include "Yap.h"
#include "clause.h"
#include "eval.h"
#include "YapEval.h"
#include "tracer.h"
#include "yapio.h"
#ifdef YAPOR

0
CXX/_yap/__init__.pxd → C/cdmgr.c708 in C-function cleanup_dangling_indices
View File

20
C/cmppreds.c
View File

@ -57,7 +57,7 @@ static char SccsId[] = "%W% %G%";
#include "Yap.h"
#include "YapHeap.h"
#include "Yatom.h"
#include "eval.h"
#include "YapEval.h"
#if HAVE_STRING_H
#include <string.h>
#endif
@ -595,10 +595,12 @@ inline static Int flt_cmp(Float dif) {
static Int a_cmp(Term t1, Term t2 USES_REGS) {
if (IsVarTerm(t1)) {
Yap_ThrowError( INSTANTIATION_ERROR, t1, 4, "while doing arithmetic comparison" );
Yap_ArithError(INSTANTIATION_ERROR, t1,
"while doing arithmetic comparison");
}
if (IsVarTerm(t2)) {
Yap_ThrowError( INSTANTIATION_ERROR, t1, 4, "while doing arithmetic comparison" );
Yap_ArithError(INSTANTIATION_ERROR, t2,
"while doing arithmetic comparison");
}
if (IsFloatTerm(t1) && IsFloatTerm(t2)) {
return flt_cmp(FloatOfTerm(t1) - FloatOfTerm(t2));
@ -621,7 +623,8 @@ static Int a_cmp(Term t1, Term t2 USES_REGS) {
Float f2 = FloatOfTerm(t2);
#if HAVE_ISNAN
if (isnan(f2)) {
Yap_ThrowError( EVALUATION_ERROR_UNDEFINED, t2, 4, "trying to evaluate nan" );
Yap_ArithError(EVALUATION_ERROR_UNDEFINED, t2,
"trying to evaluate nan");
}
#endif
return flt_cmp(i1 - f2);
@ -636,7 +639,8 @@ static Int a_cmp(Term t1, Term t2 USES_REGS) {
Float f1 = FloatOfTerm(t1);
#if HAVE_ISNAN
if (isnan(f1)) {
Yap_ThrowError( EVALUATION_ERROR_UNDEFINED, t1, 4, "trying to evaluate nan" );
Yap_ArithError(EVALUATION_ERROR_UNDEFINED, t1,
"trying to evaluate nan");
}
#endif
t2 = Yap_Eval(t2);
@ -652,7 +656,8 @@ static Int a_cmp(Term t1, Term t2 USES_REGS) {
Float f2 = FloatOfTerm(t2);
#if HAVE_ISNAN
if (isnan(f2)) {
Yap_ThrowError( EVALUATION_ERROR_UNDEFINED, t2, 4, "trying to evaluate nan" );
Yap_ArithError(EVALUATION_ERROR_UNDEFINED, t2,
"trying to evaluate nan");
}
#endif
return flt_cmp(f1 - f2);
@ -674,7 +679,8 @@ static Int a_cmp(Term t1, Term t2 USES_REGS) {
Float f2 = FloatOfTerm(t2);
#if HAVE_ISNAN
if (isnan(f2)) {
Yap_ThrowError( EVALUATION_ERROR_UNDEFINED, t2, 4, "trying to evaluate nan" );
Yap_ArithError(EVALUATION_ERROR_UNDEFINED, t2,
"trying to evaluate nan");
}
#endif
return Yap_gmp_cmp_big_float(t1, f2);

21
C/compiler.c
View File

@ -174,7 +174,7 @@ static char SccsId[] = "%W% %G%";
#include "Yap.h"
#include "alloc.h"
#include "clause.h"
#include "compile.h"
#include "YapCompile.h"
#include "yapio.h"
#if HAVE_STRING_H
#include <string.h>
@ -1081,7 +1081,8 @@ static void c_bifun(basic_preds Op, Term t1, Term t2, Term t3, Term Goal,
char s[32];
Yap_bip_name(Op, s);
Yap_ThrowError( TYPE_ERROR_NUMBER, t2, "compiling %s/2 with output bound", s);
Yap_ThrowError(TYPE_ERROR_NUMBER, t2, 1,
"compiling %s/2 with output bound", s);
save_machine_regs();
siglongjmp(cglobs->cint.CompilerBotch, 1);
}
@ -1093,7 +1094,7 @@ static void c_bifun(basic_preds Op, Term t1, Term t2, Term t3, Term Goal,
char s[32];
Yap_bip_name(Op, s);
Yap_ThrowError(INSTANTIATION_ERROR , t2, "compiling %s/3", s);
Yap_ThrowError(INSTANTIATION_ERROR, t2, 1, "compiling %s/3", s);
save_machine_regs();
siglongjmp(cglobs->cint.CompilerBotch, 1);
}
@ -1103,17 +1104,17 @@ static void c_bifun(basic_preds Op, Term t1, Term t2, Term t3, Term Goal,
Int i2;
if (!IsIntegerTerm(t2)) {
Yap_Error( TYPE_ERROR_INTEGER, t2, "compiling functor/3");
Yap_ThrowError(TYPE_ERROR_INTEGER, t2, 1, "compiling functor/3");
save_machine_regs();
siglongjmp(cglobs->cint.CompilerBotch, 1);
}
i2 = IntegerOfTerm(t2);
if (i2 < 0) {
Yap_ThrowError(DOMAIN_ERROR_NOT_LESS_THAN_ZERO , t2, "compiling functor/3");
Yap_ThrowError(DOMAIN_ERROR_NOT_LESS_THAN_ZERO, t2,
"compiling functor/3");
save_machine_regs();
siglongjmp(cglobs->cint.CompilerBotch, 1);
}
if (IsNumTerm(t1)) {
/* we will always fail */
@ -1122,9 +1123,8 @@ static void c_bifun(basic_preds Op, Term t1, Term t2, Term t3, Term Goal,
} else if (!IsAtomTerm(t1)) {
char s[32];
LOCAL_Error_TYPE = TYPE_ERROR_ATOM;
Yap_bip_name(Op, s);
sprintf(LOCAL_ErrorMessage, "compiling functor/3");
Yap_ThrowError(TYPE_ERROR_ATOM, t2, 4, "compiling functor/3");
save_machine_regs();
siglongjmp(cglobs->cint.CompilerBotch, 1);
}
@ -1178,9 +1178,8 @@ static void c_bifun(basic_preds Op, Term t1, Term t2, Term t3, Term Goal,
else {
char s[32];
LOCAL_Error_TYPE = TYPE_ERROR_INTEGER;
Yap_bip_name(Op, s);
sprintf(LOCAL_ErrorMessage, "compiling %s/2", s);
Yap_ThrowError(TYPE_ERROR_INTEGER, t1, 1, "compiling %s/2", s);
save_machine_regs();
siglongjmp(cglobs->cint.CompilerBotch, 1);
}
@ -1190,6 +1189,8 @@ static void c_bifun(basic_preds Op, Term t1, Term t2, Term t3, Term Goal,
LOCAL_Error_TYPE = TYPE_ERROR_COMPOUND;
Yap_bip_name(Op, s);
Yap_ThrowError(TYPE_ERROR_COMPOUND, t2, 1, "compiling %s/2", 1, s);
save_machine_regs();
siglongjmp(cglobs->cint.CompilerBotch, 1);
} else if (IsApplTerm(t2)) {

3
C/computils.c
View File

@ -60,7 +60,7 @@ static char SccsId[] = "%W% %G%";
#include "Yap.h"
#include "Yatom.h"
#include "YapHeap.h"
#include "compile.h"
#include "YapCompile.h"
#include "yapio.h"
#if HAVE_STRING_H
#include <string.h>
@ -795,4 +795,3 @@ Yap_ShowCode (struct intermediates *cint)
}
#endif /* DEBUG */

2
C/depth_bound.c
View File

@ -22,7 +22,7 @@ static char SccsId[] = "%W% %G%";
#include "Yap.h"
#include "Yatom.h"
#include "eval.h"
#include "YapEval.h"
#ifdef DEPTH_LIMIT

4
C/errors.c
View File

@ -207,7 +207,7 @@ void Yap_RestartYap(int flag) {
#if PUSH_REGS
restore_absmi_regs(&Yap_standard_regs);
#endif
siglongjmp(LOCAL_RestartEnv, 1);
siglongjmp(*LOCAL_RestartEnv, 1);
}
static void error_exit_yap(int value) {
@ -328,7 +328,7 @@ Yap_Error__(file, function, lineno, type, where, tmpbuf);
} else {
Yap_Error__(file, function, lineno, type, where);
}
siglongjmp(LOCAL_RestartEnv, 4);
siglongjmp(*LOCAL_RestartEnv, 4);
}
/**

2
C/eval.c
View File

@ -31,7 +31,7 @@ static char SccsId[] = "%W% %G%";
#include "YapHeap.h"
#include "Yatom.h"
#include "eval.h"
#include "YapEval.h"
#if HAVE_STDARG_H
#include <stdarg.h>
#endif

46
C/exec.c
View File

@ -1421,7 +1421,10 @@ static bool exec_absmi(bool top, yap_reset_t reset_mode USES_REGS) {
int lval, out;
Int OldBorder = LOCAL_CBorder;
LOCAL_CBorder = LCL0 - (CELL *)B;
if (top && (lval = sigsetjmp(LOCAL_RestartEnv, 1)) != 0) {
sigjmp_buf signew, *sighold = LOCAL_RestartEnv;
LOCAL_RestartEnv = &signew;
if (top && (lval = sigsetjmp(signew, 1)) != 0) {
switch (lval) {
case 1: { /* restart */
/* otherwise, SetDBForThrow will fail entering critical mode */
@ -1446,7 +1449,6 @@ static bool exec_absmi(bool top, yap_reset_t reset_mode USES_REGS) {
/* must be done here, otherwise siglongjmp will clobber all the
* registers
*/
Yap_Error(LOCAL_Error_TYPE, TermNil, NULL);
/* reset the registers so that we don't have trash in abstract
* machine */
Yap_set_fpu_exceptions(
@ -1454,14 +1456,20 @@ static bool exec_absmi(bool top, yap_reset_t reset_mode USES_REGS) {
P = (yamop *)FAILCODE;
LOCAL_PrologMode = UserMode;
} break;
case 3: { /* saved state */
LOCAL_CBorder = OldBorder;
LOCAL_RestartEnv = sighold;
return false;
}
case 4: {
/* abort */
/* can be called from anywgerre, must reset registers,
*/
LOCAL_RestartEnv = sighold;
Yap_JumpToEnv(TermDAbort);
P = (yamop *)FAILCODE;
LOCAL_PrologMode = UserMode;
} break;
case 3: { /* saved state */
LOCAL_CBorder = OldBorder;
return false;
}
default:
/* do nothing */
LOCAL_PrologMode = UserMode;
@ -1477,6 +1485,7 @@ static bool exec_absmi(bool top, yap_reset_t reset_mode USES_REGS) {
if (!Yap_has_a_signal())
CalculateStackGap(PASS_REGS1);
LOCAL_CBorder = OldBorder;
LOCAL_RestartEnv = sighold;
return out;
}
@ -2015,14 +2024,17 @@ static Int JumpToEnv() {
/* find the first choicepoint that may be a catch */
// DBTerm *dbt = Yap_RefToException();
while (handler && Yap_PredForChoicePt(handler, NULL) != PredDollarCatch) {
//printf("--handler=%p, max=%p\n", handler, LCL0-LOCAL_CBorder);
while (POP_CHOICE_POINT(handler)) {
POP_FAIL_EXECUTE(handler);
}
if (handler == (choiceptr)(LCL0-LOCAL_CBorder)) {
break;
}
/* we are already doing a catch */
/* make sure we prune C-choicepoints */
if (handler->cp_ap == NOCODE &&
(handler >= (choiceptr)(LCL0 - LOCAL_CBorder) ||
handler->cp_b == NULL)) {
if ((handler->cp_ap == NOCODE && handler->cp_b == NULL) ||
(handler->cp_b >= (choiceptr)(LCL0 - LOCAL_CBorder))) {
break;
}
handler = handler->cp_b;
@ -2077,19 +2089,20 @@ static Int jump_env(USES_REGS1) {
Yap_Error(INSTANTIATION_ERROR, t, "throw ball must be bound");
return false;
} else if (IsApplTerm(t) && FunctorOfTerm(t) == FunctorError) {
Term t2, te;
Term t2;
Yap_find_prolog_culprit(PASS_REGS1);
te = ArgOfTerm(1, t);
if (IsApplTerm(te) && IsAtomTerm((t2 = ArgOfTerm(1, te)))) {
// 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(FunctorOfTerm(te));
} else if (IsAtomTerm(te)) {
LOCAL_ActiveError->errorAsText = AtomOfTerm(te);
LOCAL_ActiveError->classAsText = NameOfFunctor(FunctorOfTerm(t));
} else if (IsAtomTerm(t)) {
LOCAL_ActiveError->errorAsText = AtomOfTerm(t);
LOCAL_ActiveError->classAsText = NULL;
}
} else {
LOCAL_Error_TYPE = THROW_EVENT;
// LOCAL_Error_TYPE = THROW_EVENT;
}
LOCAL_ActiveError->prologPredName = NULL;
Yap_PutException(t);
@ -2231,7 +2244,6 @@ bool Yap_ResetException(int wid) {
Yap_PopTermFromDB(REMOTE_ActiveError(wid)->errorTerm);
}
REMOTE_ActiveError(wid)->errorTerm = NULL;
REMOTE_ActiveError(wid)->errorTerm = NULL;
return true;
}

2
C/exo.c
View File

@ -21,7 +21,7 @@
#include "Yap.h"
#include "clause.h"
#include "yapio.h"
#include "eval.h"
#include "YapEval.h"
#include "tracer.h"
#ifdef YAPOR
#include "or.macros.h"

2
C/exo_udi.c
View File

@ -20,7 +20,7 @@
#include "Yap.h"
#include "clause.h"
#include "yapio.h"
#include "eval.h"
#include "YapEval.h"
#include "tracer.h"
#include "attvar.h"
#ifdef YAPOR

79
C/flags.c
View File

@ -60,7 +60,7 @@ static Int current_prolog_flag(USES_REGS1);
static Int set_prolog_flag(USES_REGS1);
#include "Yatom.h"
#include "eval.h"
#include "YapEval.h"
#include "yapio.h"
#define YAP_FLAG(ID, NAME, WRITABLE, DEF, INIT, HELPER) \
@ -175,40 +175,37 @@ static Term isaccess(Term inp) {
static Term stream(Term inp) {
if (IsVarTerm(inp))
return inp;
if (Yap_CheckStream( inp, Input_Stream_f | Output_Stream_f |
Append_Stream_f | Socket_Stream_f, "yap_flag/3" ) >= 0)
if (Yap_CheckStream(inp, Input_Stream_f | Output_Stream_f | Append_Stream_f |
Socket_Stream_f,
"yap_flag/3") >= 0)
return inp;
return 0;
}
static bool
set_error_stream( Term inp ) {
static bool set_error_stream(Term inp) {
if (IsVarTerm(inp))
return Yap_unify(inp, Yap_StreamUserName(LOCAL_c_error_stream));
LOCAL_c_error_stream = Yap_CheckStream( inp, Output_Stream_f |
Append_Stream_f | Socket_Stream_f, "yap_flag/3" );
LOCAL_c_error_stream = Yap_CheckStream(
inp, Output_Stream_f | Append_Stream_f | Socket_Stream_f, "yap_flag/3");
return true;
}
static bool
set_input_stream( Term inp ) {
static bool set_input_stream(Term inp) {
if (IsVarTerm(inp))
return Yap_unify(inp, Yap_StreamUserName(LOCAL_c_input_stream));
LOCAL_c_input_stream = Yap_CheckStream( inp, Input_Stream_f | Socket_Stream_f, "yap_flag/3" );
LOCAL_c_input_stream =
Yap_CheckStream(inp, Input_Stream_f | Socket_Stream_f, "yap_flag/3");
return true;
}
static bool
set_output_stream( Term inp ) {
static bool set_output_stream(Term inp) {
if (IsVarTerm(inp))
return Yap_unify(inp, Yap_StreamUserName(LOCAL_c_output_stream));
LOCAL_c_output_stream = Yap_CheckStream( inp, Output_Stream_f |
Append_Stream_f | Socket_Stream_f, "yap_flag/3" );
LOCAL_c_output_stream = Yap_CheckStream(
inp, Output_Stream_f | Append_Stream_f | Socket_Stream_f, "yap_flag/3");
return true;
}
static Term isground(Term inp) {
return Yap_IsGroundTerm(inp) ? inp : TermZERO;
}
@ -669,12 +666,19 @@ static bool setYapFlagInModule(Term tflag, Term t2, Term mod) {
flag_term *tarr = GLOBAL_Flags;
if (!(fv->type(t2)))
return false;
if (fv->helper && !(fv->helper(t2)))
return false;
Term tout = tarr[fv->FlagOfVE].at;
if (IsVarTerm(tout))
Yap_PopTermFromDB(tarr[fv->FlagOfVE].DBT);
if (IsAtomOrIntTerm(t2))
if (IsVarTerm(tout)) {
Term t;
while ((t = Yap_PopTermFromDB(tarr[fv->FlagOfVE].DBT)) == 0) {
if (!Yap_gc(2, ENV, gc_P(P, CP))) {
Yap_Error(RESOURCE_ERROR_STACK, TermNil, LOCAL_ErrorMessage);
return false;
}
}
} else if (IsAtomOrIntTerm(t2))
tarr[fv->FlagOfVE].at = t2;
else {
tarr[fv->FlagOfVE].DBT = Yap_StoreTermInDB(t2, 2);
@ -1182,24 +1186,26 @@ static Int source_mode(USES_REGS1) {
static bool setInitialValue(bool bootstrap, flag_func f, const char *s,
flag_term *tarr) {
errno = 0;
const char *ss = (const char *)s;
if (f == booleanFlag) {
if (!bootstrap) {
return 0;
}
if (!strcmp(s, "true")) {
const char *ss = (const char *)s;
if (!strcmp(ss, "true")) {
tarr->at = TermTrue;
return true;
}
if (!strcmp(s, "false")) {
if (!strcmp(ss, "false")) {
tarr->at = TermFalse;
return true;
}
if (!strcmp(s, "on")) {
if (!strcmp(ss, "on")) {
tarr->at = TermTrue;
return true;
}
if (!strcmp(s, "off")) {
if (!strcmp(ss, "off")) {
tarr->at = TermFalse;
return true;
}
@ -1210,7 +1216,7 @@ static bool setInitialValue(bool bootstrap, flag_func f, const char *s,
if (!bootstrap) {
return 0;
}
UInt r = strtoul(s, NULL, 10);
UInt r = strtoul(ss, NULL, 10);
Term t;
if (errno) {
Yap_Error(DOMAIN_ERROR_OUT_OF_RANGE, TermNil,
@ -1229,27 +1235,27 @@ static bool setInitialValue(bool bootstrap, flag_func f, const char *s,
if (!bootstrap) {
return false;
}
if (!strcmp(s, "INT_MAX")) {
if (!strcmp(ss, "INT_MAX")) {
tarr->at = MkIntTerm(Int_MAX);
return true;
}
if (!strcmp(s, "MAX_THREADS")) {
if (!strcmp(ss, "MAX_THREADS")) {
tarr->at = MkIntTerm(MAX_THREADS);
return true;
}
if (!strcmp(s, "MAX_WORKERS")) {
if (!strcmp(ss, "MAX_WORKERS")) {
tarr->at = MkIntTerm(MAX_WORKERS);
return true;
}
if (!strcmp(s, "INT_MIN")) {
if (!strcmp(ss, "INT_MIN")) {
tarr->at = MkIntTerm(Int_MIN);
return true;
}
if (!strcmp(s, "YAP_NUMERIC_VERSION")) {
if (!strcmp(ss, "YAP_NUMERIC_VERSION")) {
tarr->at = MkIntTerm(atol(YAP_NUMERIC_VERSION));
return true;
}
if (!strcmp(s, "YAP_NUMERIC_VERSION")) {
if (!strcmp(ss, "YAP_NUMERIC_VERSION")) {
tarr->at = MkIntTerm(atol(YAP_NUMERIC_VERSION));
return true;
}
@ -1297,7 +1303,7 @@ static bool setInitialValue(bool bootstrap, flag_func f, const char *s,
return true;
}
}
} else if (strcmp(s, "@boot") == 0) {
} else if (strcmp(ss, "@boot") == 0) {
if (bootstrap) {
return true;
}
@ -1317,9 +1323,9 @@ static bool setInitialValue(bool bootstrap, flag_func f, const char *s,
return false;
}
CACHE_REGS
encoding_t encoding = ENC_ISO_UTF8;
t0 =
Yap_StringToTerm(s, strlen(s) + 1, &encoding, GLOBAL_MaxPriority, 0L);
const unsigned char *us = (const unsigned char *)s;
t0 = Yap_BufferToTermWithPrioBindings(us, strlen(s) + 1, TermNil,
GLOBAL_MaxPriority, 0L);
if (!t0)
return false;
if (IsAtomTerm(t0) || IsIntTerm(t0)) {
@ -1621,8 +1627,9 @@ void Yap_InitFlags(bool bootstrap) {
while (f->name != NULL) {
bool itf = setInitialValue(bootstrap, f->def, f->init,
LOCAL_Flags + LOCAL_flagCount);
// Term itf = Yap_StringToTerm(f->init, strlen(f->init)+1,
// EBC_ISO_UTF8, GLOBAL_MaxPriority, &tp);
// Term itf = Yap_BufferToTermWithPrioBindings(f->init,
// strlen(f->init)+1,
// LOBAL_MaxPriority, &tp);
if (itf) {
initFlag(f, LOCAL_flagCount, false);
}

2
C/globals.c
View File

@ -115,7 +115,7 @@ threads that are created <em>after</em> the registration.
#include "YapHeap.h"
#include "yapio.h"
#include "iopreds.h"
#include "eval.h"
#include "YapEval.h"
#include "attvar.h"
#include <math.h>

2
C/gmp_support.c
View File

@ -18,7 +18,7 @@
#include "Yap.h"
#include "Yatom.h"
#include "YapHeap.h"
#include "eval.h"
#include "YapEval.h"
#if HAVE_STRING_H
#include <string.h>
#endif

2
C/grow.c
View File

@ -20,7 +20,7 @@
#include "yapio.h"
#include "alloc.h"
#include "sshift.h"
#include "compile.h"
#include "YapCompile.h"
#include "attvar.h"
#include "cut_c.h"
#if HAVE_STRING_H

13
C/heapgc.c
View File

@ -134,7 +134,7 @@ gc_growtrail(int committed, tr_fr_ptr begsTR, cont *old_cont_top0 USES_REGS)
#endif
/* could not find more trail */
save_machine_regs();
siglongjmp(LOCAL_gc_restore, 2);
siglongjmp(*LOCAL_gc_restore, 2);
}
}
@ -397,7 +397,7 @@ check_pr_trail( tr_fr_ptr rc USES_REGS)
if (!Yap_locked_growtrail(0, TRUE) || TRUE) {
/* could not find more trail */
save_machine_regs();
siglongjmp(LOCAL_gc_restore, 2);
siglongjmp(*LOCAL_gc_restore, 2);
}
rc = TR-n;
}
@ -525,7 +525,7 @@ pop_registers(Int num_regs, yamop *nextop USES_REGS)
/* error: we don't have enough room */
/* could not find more trail */
save_machine_regs();
siglongjmp(LOCAL_gc_restore, 4);
siglongjmp(*LOCAL_gc_restore, 4);
}
}
}
@ -1450,7 +1450,7 @@ mark_variable(CELL_PTR current USES_REGS)
/* error: we don't have enough room */
/* could not find more trail */
save_machine_regs();
siglongjmp(LOCAL_gc_restore, 3);
siglongjmp(*LOCAL_gc_restore, 3);
} else if (n > 0) {
CELL *ptr = LOCAL_extra_gc_cells;
@ -3934,6 +3934,9 @@ do_gc(Int predarity, CELL *current_env, yamop *nextop USES_REGS)
UInt gc_phase;
UInt alloc_sz;
int jmp_res;
sigjmp_buf jmp;
LOCAL_gc_restore = &jmp;
heap_cells = HR-H0;
gc_verbose = is_gc_verbose();
@ -3989,7 +3992,7 @@ do_gc(Int predarity, CELL *current_env, yamop *nextop USES_REGS)
}
#endif
time_start = Yap_cputime();
jmp_res = sigsetjmp(LOCAL_gc_restore, 0);
jmp_res = sigsetjmp(jmp, 0);
if (jmp_res == 2) {
UInt sz;

2
C/index.c
View File

@ -634,7 +634,7 @@ type_of_verb(rest,passive).
*/
#include "absmi.h"
#include "compile.h"
#include "YapCompile.h"
#if DEBUG
#include "yapio.h"
#endif

11
C/load_dll.c
View File

@ -42,13 +42,13 @@ Yap_FindExecutable(void)
void *
Yap_LoadForeignFile(char *file, int flags)
{
char *buf = malloc(1024);
printf("file=%s\n" , file );
void *ptr= (void *)LoadLibrary(file);
if (!ptr) {
CACHE_REGS
LOCAL_ErrorMessage = NULL;
FormatMessage(FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS,
NULL, GetLastError(),
MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), LOCAL_ErrorMessage, 256,
MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), buf, 1023,
NULL);
}
return ptr;
@ -83,16 +83,17 @@ LoadForeign(StringList ofiles, StringList libs,
HINSTANCE handle;
const char *file = AtomName(ofiles->name);
if (!Yap_findFile(file, NULL, NULL, LOCAL_FileNameBuf, true, YAP_OBJ, true, true) &&
if (Yap_findFile(file, NULL, NULL, LOCAL_FileNameBuf, true, YAP_OBJ, true, true) &&
(handle=LoadLibrary(LOCAL_FileNameBuf)) != 0)
{
LOCAL_ErrorMessage = NULL;
if (*init_proc == NULL)
*init_proc = (YapInitProc)GetProcAddress((HMODULE)handle, proc_name);
} else {
char *buf = malloc(1024);
FormatMessage(FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS,
NULL, GetLastError(),
MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), LOCAL_ErrorMessage, 256,
MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), buf, 1023,
NULL);
//fprintf(stderr,"WinError: %s\n", LOCAL_ErrorSay);
}

8
C/load_foreign.c
View File

@ -46,7 +46,7 @@ p_load_foreign( USES_REGS1 )
YapInitProc InitProc = NULL;
Term t, t1;
StringList new;
Int returncode = FALSE;
bool returncode = FALSE;
yhandle_t CurSlot = Yap_StartSlots();
// Yap_DebugPlWrite(ARG1); printf("%s\n", " \n");
@ -81,12 +81,16 @@ p_load_foreign( USES_REGS1 )
t1 = Deref(ARG3);
InitProcName = (char *)RepAtom(AtomOfTerm(t1))->StrOfAE;
// verify if it was waiting for initialization
if (Yap_LateInit( InitProcName ) ){
returncode = true;
} else
/* call the OS specific function for dynamic loading */
if(Yap_LoadForeign(ofiles,libs,InitProcName,&InitProc)==LOAD_SUCCEEDED) {
Yap_StartSlots( );
(*InitProc)();
Yap_CloseSlots(CurSlot);
returncode = TRUE;
returncode = true;
}
/* I should recover space if load foreign fails */

2
C/mavar.c
View File

@ -48,7 +48,7 @@ deterministic computations.
#include "Yatom.h"
#include "YapHeap.h"
#include "eval.h"
#include "YapEval.h"
static Int p_setarg( USES_REGS1 );
static Int p_create_mutable( USES_REGS1 );

8
C/parser.c
View File

@ -141,7 +141,7 @@ dot with single quotes.
#include "YapHeap.h"
#include "YapText.h"
#include "Yatom.h"
#include "eval.h"
#include "YapEval.h"
#include "yapio.h"
/* stuff we want to use in standard YAP code */
#include "iopreds.h"
@ -302,7 +302,7 @@ static Term VarNames(VarEntry *p, Term l USES_REGS) {
VarNames(p->VarLeft, l PASS_REGS) PASS_REGS));
if (HR > ASP - 4096) {
save_machine_regs();
siglongjmp(LOCAL_IOBotch, 1);
longjmp(*LOCAL_IOBotch, 1);
}
return (o);
} else {
@ -332,7 +332,7 @@ static Term Singletons(VarEntry *p, Term l USES_REGS) {
Singletons(p->VarLeft, l PASS_REGS) PASS_REGS));
if (HR > ASP - 4096) {
save_machine_regs();
siglongjmp(LOCAL_IOBotch, 1);
longjmp(*LOCAL_IOBotch, 1);
}
return (o);
} else {
@ -357,7 +357,7 @@ static Term Variables(VarEntry *p, Term l USES_REGS) {
Variables(p->VarRight, Variables(p->VarLeft, l PASS_REGS) PASS_REGS));
if (HR > ASP - 4096) {
save_machine_regs();
siglongjmp(LOCAL_IOBotch, 1);
siglongjmp(*LOCAL_IOBotch, 1);
}
return (o);
} else {

1047
C/pold.c
View File

File diff suppressed because it is too large Load Diff

2
C/range.c
View File

@ -21,7 +21,7 @@ static char SccsId[] = "%W% %G%";
#include "Yap.h"
#include "Yatom.h"
#include "YapHeap.h"
#include "eval.h"
#include "YapEval.h"
static Int
p_in_range( USES_REGS1 ) {

13
C/scanner.c
View File

@ -407,7 +407,7 @@ writing, writing a BOM can be requested using the option
#include "YapHeap.h"
#include "Yatom.h"
#include "alloc.h"
#include "eval.h"
#include "YapEval.h"
#include "yapio.h"
/* stuff we want to use in standard YAP code */
#include "YapText.h"
@ -1206,12 +1206,14 @@ Term Yap_tokRep(void *tokptre) {
case eot_tok:
return MkAtomTerm(Yap_LookupAtom("EOT"));
case Ponctuation_tok:
if (info == Terml)
return TermBeginBracket;
else
return info;
}
return TermDot;
}
const char *Yap_tokText(void *tokptre) {
CACHE_REGS
TokEntry *tokptr = tokptre;
@ -1221,6 +1223,8 @@ const char * Yap_tokText(void *tokptre) {
case eot_tok:
return "EOT";
case Ponctuation_tok:
if (info == Terml)
return "(";
case Error_tok:
case BQString_tok:
case String_tok:
@ -1244,13 +1248,13 @@ const char * Yap_tokText(void *tokptre) {
}
break;
case Var_tok:
if (info == 0) return "[]";
if (info == 0)
return "[]";
return ((Atom)info)->StrOfAE;
}
return ".";
}
static void open_comment(int ch, StreamDesc *inp_stream USES_REGS) {
CELL *h0 = HR;
HR += 5;
@ -1972,7 +1976,6 @@ TokEntry *Yap_tokenizer(struct stream_desc *inp_stream, bool store_comments,
return (l);
}
void Yap_clean_tokenizer(TokEntry *tokstart, VarEntry *vartable,
VarEntry *anonvartable) {
CACHE_REGS

29
C/signals.c
View File

@ -25,18 +25,18 @@ static char SccsId[] = "%W% %G%";
#include <unistd.h>
#endif
#if _WIN32
#include <stdio.h>
#include <io.h>
#include <stdio.h>
#endif
#include "Yatom.h"
#include "YapHeap.h"
#include "eval.h"
#include "Yatom.h"
#include "YapEval.h"
#include "yapio.h"
#ifdef TABLING
#include "tab.macros.h"
#endif /* TABLING */
#include <stdlib.h>
#include <stdio.h>
#include <stdlib.h>
#if HAVE_STRING_H
#include <string.h>
#endif
@ -64,6 +64,10 @@ static yap_signals InteractSIGINT(int ch) {
switch (ch) {
case 'a':
/* abort computation */
#if PUSH_REGS
// restore_absmi_regs(&Yap_standard_regs);
#endif
siglongjmp(&LOCAL_RestartEnv, 4);
return YAP_ABORT_SIGNAL;
case 'b':
/* continue */
@ -183,35 +187,32 @@ inline static bool get_signal(yap_signals sig USES_REGS) {
#endif
}
bool Yap_DisableInterrupts(int wid)
{
bool Yap_DisableInterrupts(int wid) {
LOCAL_InterruptsDisabled = true;
YAPEnterCriticalSection();
return true;
}
bool Yap_EnableInterrupts(int wid)
{
bool Yap_EnableInterrupts(int wid) {
LOCAL_InterruptsDisabled = false;
YAPLeaveCriticalSection();
return true;
}
/**
Function called to handle delayed interrupts.
*/
int Yap_HandleInterrupts(void) {
bool Yap_HandleSIGINT(void) {
CACHE_REGS
yap_signals sig;
if (get_signal(YAP_INT_SIGNAL PASS_REGS)) {
do {
if ((sig = ProcessSIGINT()) != YAP_NO_SIGNAL)
do_signal(worker_id, sig PASS_REGS);
LOCAL_PrologMode &= ~InterruptMode;
return 1;
}
return 0;
return true;
} while (get_signal(YAP_INT_SIGNAL PASS_REGS));
return false;
}
static Int p_creep(USES_REGS1) {

2
C/stack.c
View File

@ -30,7 +30,7 @@
#include "Yap.h"
#include "clause.h"
#include "eval.h"
#include "YapEval.h"
#include "iopreds.h"
#include "tracer.h"
#include "yapio.h"

2
C/stackinfo.c
View File

@ -31,7 +31,7 @@
#include "Yap.h"
#include "clause.h"
#include "yapio.h"
#include "eval.h"
#include "YapEval.h"
#include "tracer.h"
#ifdef YAPOR
#include "or.macros.h"

28
C/stdpreds.c
View File

@ -37,7 +37,7 @@ static char SccsId[] = "%W% %G%";
#include "Foreign.h"
#include "YapHeap.h"
#include "Yatom.h"
#include "eval.h"
#include "YapEval.h"
#include "yapio.h"
#ifdef TABLING
#include "tab.macros.h"
@ -58,6 +58,9 @@ static char SccsId[] = "%W% %G%";
#include <fcntl.h>
#include <wchar.h>
extern int init_tries(void);
static Int p_setval(USES_REGS1);
static Int p_value(USES_REGS1);
static Int p_values(USES_REGS1);
@ -74,7 +77,7 @@ static Int p_halt(USES_REGS1);
#endif
static Int current_predicate(USES_REGS1);
static Int cont_current_predicate(USES_REGS1);
static OpEntry *NextOp(OpEntry *CACHE_TYPE);
static OpEntry *NextOp(Prop CACHE_TYPE);
static Int init_current_op(USES_REGS1);
static Int cont_current_op(USES_REGS1);
static Int init_current_atom_op(USES_REGS1);
@ -943,22 +946,24 @@ static Int current_predicate(USES_REGS1) {
return cont_current_predicate(PASS_REGS1);
}
static OpEntry *NextOp(OpEntry *pp USES_REGS) {
static OpEntry *NextOp(Prop pp USES_REGS) {
while (!EndOfPAEntr(pp) && pp->KindOfPE != OpProperty &&
(pp->OpModule != PROLOG_MODULE || pp->OpModule != CurrentModule))
pp = RepOpProp(pp->NextOfPE);
return (pp);
(RepOpProp(pp)->OpModule != PROLOG_MODULE
|| RepOpProp(pp)->OpModule != CurrentModule) )
pp = pp->NextOfPE;
return RepOpProp(pp);
}
int Yap_IsOp(Atom at) {
CACHE_REGS
OpEntry *op = NextOp(RepOpProp((Prop)(RepAtom(at)->PropsOfAE)) PASS_REGS);
OpEntry *op = NextOp(RepAtom(at)->PropsOfAE PASS_REGS);
return (!EndOfPAEntr(op));
}
int Yap_IsOpMaxPrio(Atom at) {
CACHE_REGS
OpEntry *op = NextOp(RepOpProp((Prop)(RepAtom(at)->PropsOfAE)) PASS_REGS);
OpEntry *op = NextOp(RepAtom(at)->PropsOfAE PASS_REGS);
int max;
if (EndOfPAEntr(op))
@ -1020,7 +1025,7 @@ static Int cont_current_atom_op(USES_REGS1) {
OpEntry *op = (OpEntry *)IntegerOfTerm(EXTRA_CBACK_ARG(5, 1)), *next;
READ_LOCK(op->OpRWLock);
next = NextOp(RepOpProp(op->NextOfPE) PASS_REGS);
next = NextOp(op->NextOfPE PASS_REGS);
if (unify_op(op PASS_REGS)) {
READ_UNLOCK(op->OpRWLock);
if (next) {
@ -1053,7 +1058,7 @@ static Int init_current_atom_op(
cut_fail();
}
ae = RepAtom(AtomOfTerm(t));
if (EndOfPAEntr((ope = NextOp(RepOpProp(ae->PropsOfAE) PASS_REGS)))) {
if (EndOfPAEntr((ope = NextOp(ae->PropsOfAE PASS_REGS)))) {
cut_fail();
}
EXTRA_CBACK_ARG(5, 1) = (CELL)MkIntegerTerm((Int)ope);
@ -1074,7 +1079,7 @@ static Int
cut_fail();
}
ae = RepAtom(AtomOfTerm(t));
if (EndOfPAEntr((ope = NextOp(RepOpProp(ae->PropsOfAE) PASS_REGS)))) {
if (EndOfPAEntr((ope = NextOp(ae->PropsOfAE PASS_REGS)))) {
cut_fail();
}
EXTRA_CBACK_ARG(5, 1) = (CELL)MkIntegerTerm((Int)ope);
@ -1629,7 +1634,6 @@ void Yap_InitCPreds(void) {
#if SUPPORT_CONDOR
init_sys();
init_random();
// init_tries();
init_regexp();
#endif
}

104
C/text.c
View File

@ -16,10 +16,10 @@
*************************************************************************/
#include "Yap.h"
#include "YapEval.h"
#include "YapHeap.h"
#include "YapText.h"
#include "Yatom.h"
#include "eval.h"
#include "yapio.h"
#include <YapText.h>
@ -51,9 +51,7 @@ typedef struct TextBuffer_manager {
int lvl;
} text_buffer_t;
int push_text_stack(USES_REGS1) {
return LOCAL_TextBuffer->lvl++;
}
int push_text_stack(USES_REGS1) { return LOCAL_TextBuffer->lvl++; }
int pop_text_stack(int i) {
int lvl = LOCAL_TextBuffer->lvl;
@ -72,6 +70,33 @@ int pop_text_stack(int i) {
return lvl;
}
void *protected_pop_text_stack(int i, void *protected, bool tmp,
size_t sz USES_REGS) {
void *out = protected;
int lvl = LOCAL_TextBuffer->lvl;
while (lvl > i) {
struct mblock *p = LOCAL_TextBuffer->first[lvl];
while (p) {
struct mblock *np = p->next;
if (p + 1 == protected) {
if (tmp)
out = LOCAL_FileNameBuf;
else
out = p;
memcpy(out, protected, sz);
} else {
free(p);
}
p = np;
}
LOCAL_TextBuffer->first[lvl] = NULL;
LOCAL_TextBuffer->last[lvl] = NULL;
lvl--;
}
LOCAL_TextBuffer->lvl = lvl;
return out;
}
// void pop_text_stack(int i) { LOCAL_TextBuffer->lvl = i; }
void *Malloc(size_t sz USES_REGS) {
@ -111,6 +136,7 @@ void *Realloc(void *pt, size_t sz USES_REGS) {
if (LOCAL_TextBuffer->last[lvl] == old) {
LOCAL_TextBuffer->last[lvl] = o;
}
return o + 1;
}
@ -356,10 +382,16 @@ static yap_error_number gen_type_error(int flags) {
}
#endif
// static int cnt;
unsigned char *Yap_readText(seq_tv_t *inp, size_t *lengp) {
unsigned char *s0 = NULL;
bool wide;
if (LOCAL_Error_TYPE != YAP_NO_ERROR) {
fprintf(stderr, "Sourious error %u\n", LOCAL_Error_TYPE);
LOCAL_Error_TYPE = YAP_NO_ERROR;
}
/* we know what the term is */
if (!(inp->type & (YAP_STRING_CHARS | YAP_STRING_WCHARS))) {
if (!(inp->type & YAP_STRING_TERM)) {
@ -387,81 +419,66 @@ unsigned char *Yap_readText(seq_tv_t *inp, size_t *lengp) {
// Yap_DebugPlWriteln(inp->val.t);
Atom at = AtomOfTerm(inp->val.t);
if (lengp)
*lengp = strlen_utf8(at->UStrOfAE);
*lengp = strlen(at->StrOfAE);
return at->UStrOfAE;
}
if (IsStringTerm(inp->val.t) && inp->type & YAP_STRING_STRING) {
// this is a term, extract to a buffer, and representation is wide
// Yap_DebugPlWriteln(inp->val.t);
if (lengp)
*lengp = strlen_utf8(UStringOfTerm(inp->val.t));
*lengp = strlen(StringOfTerm(inp->val.t));
return (unsigned char *)UStringOfTerm(inp->val.t);
}
if (((inp->type & (YAP_STRING_CODES | YAP_STRING_ATOMS)) ==
(YAP_STRING_CODES | YAP_STRING_ATOMS)) &&
IsPairOrNilTerm(inp->val.t)) {
// Yap_DebugPlWriteln(inp->val.t);
return
Yap_ListToBuffer(s0, inp->val.t, inp, &wide, lengp PASS_REGS);
return Yap_ListToBuffer(s0, inp->val.t, inp, &wide, lengp PASS_REGS);
// this is a term, extract to a sfer, and representation is wide
}
if (inp->type & YAP_STRING_CODES && IsPairOrNilTerm(inp->val.t)) {
// Yap_DebugPlWriteln(inp->val.t);
return Yap_ListOfCodesToBuffer(s0, inp->val.t, inp, &wide,
lengp PASS_REGS);
return Yap_ListOfCodesToBuffer(s0, inp->val.t, inp, &wide, lengp PASS_REGS);
// this is a term, extract to a sfer, and representation is wide
}
if (inp->type & YAP_STRING_ATOMS && IsPairOrNilTerm(inp->val.t)) {
// Yap_DebugPlWriteln(inp->val.t);
return Yap_ListOfAtomsToBuffer(s0, inp->val.t, inp, &wide,
lengp PASS_REGS);
return Yap_ListOfAtomsToBuffer(s0, inp->val.t, inp, &wide, lengp PASS_REGS);
// this is a term, extract to a buffer, and representation is wide
}
if (inp->type & YAP_STRING_INT && IsIntegerTerm(inp->val.t)) {
// ASCII, so both LATIN1 and UTF-8
// Yap_DebugPlWriteln(inp->val.t);
char *s;
if (s0)
s = (char *)s0;
else
s = Malloc(0);
if (snprintf(s, MaxTmp(PASS_REGS1) - 1, Int_FORMAT,
IntegerOfTerm(inp->val.t)) < 0) {
AUX_ERROR(inp->val.t, 2 * MaxTmp(PASS_REGS1), s, char);
}
if (lengp)
*lengp = strlen(s);
return (unsigned char *)s;
}
if (inp->type & YAP_STRING_FLOAT && IsFloatTerm(inp->val.t)) {
char *s;
size_t sz = 1024;
// Yap_DebugPlWriteln(inp->val.t);
if (s0)
{ s = (char *)s0; sz = strlen(s);}
else
s = Malloc(sz);
if (!s)
AUX_ERROR(inp->val.t, MaxTmp(PASS_REGS1), s, char);
while (!Yap_FormatFloat(FloatOfTerm(inp->val.t), &s, sz - 1)) {
if (s0) { s = Malloc(sz=1024); s0 = NULL; }
else s = Realloc(s, sz+1024);
if (!Yap_FormatFloat(FloatOfTerm(inp->val.t), &s, 1024)) {
return NULL;
}
if (lengp)
*lengp = strlen(s);
return inp->val.uc = (unsigned char *)s;
return (unsigned char *)s;
}
#if USE_GMP
if (inp->type & YAP_STRING_BIG && IsBigIntTerm(inp->val.t)) {
// Yap_DebugPlWriteln(inp->val.t);
char *s;
if (s0)
s = 0;
else
s = Malloc(0);
if (!Yap_mpz_to_string(Yap_BigIntOfTerm(inp->val.t), s, MaxTmp() - 1, 10)) {
AUX_ERROR(inp->val.t, MaxTmp(PASS_REGS1), s, char);
}
if (lengp)
*lengp = strlen(s);
Malloc(*lengp);
return inp->val.uc = (unsigned char *)s;
}
#endif
@ -471,17 +488,16 @@ unsigned char *Yap_readText(seq_tv_t *inp, size_t *lengp) {
return inp->val.uc = (unsigned char *)s;
}
if (inp->type & YAP_STRING_CHARS) {
// printf("%s\n",inp->val.c);
if (inp->enc == ENC_ISO_UTF8) {
if (lengp)
*lengp = strlen_utf8(inp->val.uc);
return inp->val.uc;
} else if (inp->enc == ENC_ISO_LATIN1) {
if (inp->enc == ENC_ISO_LATIN1) {
return latin2utf8(inp, lengp);
} else if (inp->enc == ENC_ISO_ASCII) {
if (lengp)
*lengp = strlen(inp->val.c);
return inp->val.uc;
}else { //if (inp->enc == ENC_ISO_UTF8) {
if (lengp)
*lengp = strlen(inp->val.c);
return inp->val.uc;
}
}
if (inp->type & YAP_STRING_WCHARS) {
@ -651,7 +667,7 @@ size_t write_buffer(unsigned char *s0, seq_tv_t *out, size_t leng USES_REGS) {
size_t min = 0, max = leng, room_end;
if (out->enc == ENC_ISO_UTF8) {
room_end = strlen((char *)s0) + 1;
if (out->val.uc == NULL) {
if (out->val.uc == NULL) { // this should always be the case
out->val.uc = malloc(room_end < 16 ? 16 : room_end);
}
if (out->val.uc != s0) {
@ -720,7 +736,8 @@ static size_t write_length(const unsigned char *s0, seq_tv_t *out,
return leng;
}
static Term write_number(unsigned char *s, seq_tv_t *out, int size, bool error_on USES_REGS) {
static Term write_number(unsigned char *s, seq_tv_t *out, int size,
bool error_on USES_REGS) {
Term t;
int i = push_text_stack();
t = Yap_StringToNumberTerm((char *)s, &out->enc, error_on);
@ -730,8 +747,7 @@ static Term write_number(unsigned char *s, seq_tv_t *out, int size, bool error_o
static Term string_to_term(void *s, seq_tv_t *out, size_t leng USES_REGS) {
Term o;
o = out->val.t =
Yap_StringToTerm(s, strlen(s) + 1, &out->enc, GLOBAL_MaxPriority, 0L);
o = out->val.t = Yap_BufferToTerm(s, strlen(s) + 1, TermNil);
return o;
}
@ -746,7 +762,8 @@ bool write_Text(unsigned char *inp, seq_tv_t *out, size_t leng USES_REGS) {
return out->val.t != 0;
}
if (out->type & (YAP_STRING_INT | YAP_STRING_FLOAT | YAP_STRING_BIG)) {
if ((out->val.t = write_number(inp, out, leng,!(out->type & YAP_STRING_ATOM) PASS_REGS)) != 0L) {
if ((out->val.t = write_number(
inp, out, leng, !(out->type & YAP_STRING_ATOM) PASS_REGS)) != 0L) {
// Yap_DebugPlWriteln(out->val.t);
return true;
@ -845,10 +862,11 @@ bool Yap_CVT_Text(seq_tv_t *inp, seq_tv_t *out USES_REGS) {
.w);
else fprintf(stderr,"s %s\n", inp->val.c);
*/
// cnt++;
buf = Yap_readText(inp, &leng PASS_REGS);
if (out->type & (YAP_STRING_NCHARS | YAP_STRING_TRUNC)) {
if (out->max < leng) {
const unsigned char *ptr = skip_utf8(buf, leng);
const unsigned char *ptr = skip_utf8(buf, out->max);
size_t diff = (ptr - buf);
char *nbuf = Malloc(diff + 1);
memcpy(nbuf, buf, diff);
@ -858,10 +876,10 @@ bool Yap_CVT_Text(seq_tv_t *inp, seq_tv_t *out USES_REGS) {
// else if (out->type & YAP_STRING_NCHARS &&
// const unsigned char *ptr = skip_utf8(buf, leng)
}
if (!buf) {
return 0L;
}
if (out->type & (YAP_STRING_UPCASE | YAP_STRING_DOWNCASE)) {
if (out->type & YAP_STRING_UPCASE) {
if (!upcase(buf, out)) {

2
C/threads.c
View File

@ -26,7 +26,7 @@ static char SccsId[] = "%W% %G%";
#include "Yap.h"
#include "Yatom.h"
#include "YapHeap.h"
#include "eval.h"
#include "YapEval.h"
#include "yapio.h"
#include "blobs.h"
#include <stdio.h>

124
C/tracer.c
View File

@ -28,53 +28,88 @@
#include "tracer.h"
#include "yapio.h"
static char *send_tracer_message(char *start, char *name, Int arity,
char *mname, CELL *args, char *s, char *top) {
static char *send_tracer_message(char *start, char *name, arity_t arity,
char *mname, CELL *args, char **s0, char *s,
char **top) {
bool expand = false;
size_t max = *top - (s + 1);
int d, min = 1024;
char *s1 = s;
do {
if (expand || max < 32) {
Int cbeg = s1 - *s0;
max = *top - *s0;
max += min;
*s0 = Realloc(*s0, max);
*top = *s0 + max;
max--;
s1 = *s0 + cbeg;
s = s1;
expand = false;
}
min = 1024;
if (name == NULL) {
#ifdef YAPOR
s += snprintf(s, top - s, "(%d)%s", worker_id, start);
d = snprintf(s, max, "(%d)%s", worker_id, start);
#else
s += snprintf(s, top - s, "%s", start);
d = snprintf(s, max, "%s", start);
#endif
} else {
int i;
if (arity) {
if (args)
s += snprintf(s, top - s, "%s %s:%s(", start, mname, name);
d = snprintf(s, max, "%s %s:%s(", start, mname, name);
else
s += snprintf(s, top - s, "%s %s:%s/%lu", start, mname, name,
d = snprintf(s, max, "%s %s:%s/%lu", start, mname, name,
(unsigned long int)arity);
} else {
s += snprintf(s, top - s, "%s %s:%s", start, mname, name);
d = snprintf(s, max, "%s %s:%s", start, mname, name);
}
}
if (d >= max) {
expand = true;
min = d + 1024;
continue;
}
max -= d;
s += d;
if (args) {
int i;
for (i = 0; i < arity; i++) {
size_t length = top - (s + 4);
if ((ssize_t)length < 16) {
s[0] = '\0';
return s;
}
if (i > 0) {
if (max > 16) {
*s++ = ',';
*s++ = ' ';
max-=2;
} else {
expand = true;
continue;
}
}
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(sn);
if (max <= sz) {
min = sz + 1024;
expand = true;
continue;
}
sz = strlen(s);
strcpy(s, sn);
s += sz;
max -= sz;
}
if (arity) {
*s++ = ' ';
*s++ = ')';
max -= 2;
}
}
}
} while (expand);
s[0] = '\0';
return s;
}
@ -154,22 +189,22 @@ check_area(void)
jmp_deb(i);
}
*/
// PredEntry *old_p[10000];
// Term old_x1[10000], old_x2[10000], old_x3[10000];
// static CELL oldv = 0;
void low_level_trace__(yap_low_level_port port, PredEntry *pred, CELL *args) {
bool low_level_trace__(yap_low_level_port port, PredEntry *pred, CELL *args) {
CACHE_REGS
char *s;
char *mname;
Int arity;
int l = push_text_stack();
/* extern int gc_calls; */
vsc_count++;
// if (HR < ASP ) return;
// fif (vsc_count == 12534) jmp_deb( 2 );
char buf[512], *top = buf + 511, *b = buf;
char *buf = Malloc(512), *top = buf + 511, *b = buf;
// if (!worker_id) return;
LOCK(Yap_low_level_trace_lock);
@ -308,12 +343,10 @@ void low_level_trace__(yap_low_level_port port, PredEntry *pred, CELL *args) {
while (env_ptr) {
PredEntry *pe = EnvPreg(env_ptr[E_CP]);
printf("%p->", env_ptr, pe);
if (vsc_count == 52LL)
printf("\n");
if (p == pe) {
UNLOCK(Yap_heap_regs->low_level_trace_lock);
return;
pop_text_stack(l);
ReleaseAndReturn(true);
}
if (env_ptr != NULL)
env_ptr = (CELL *)(env_ptr[E_E]);
@ -329,12 +362,13 @@ void low_level_trace__(yap_low_level_port port, PredEntry *pred, CELL *args) {
/* check_trail_consistency(); */
if (pred == NULL) {
UNLOCK(Yap_low_level_trace_lock);
return;
pop_text_stack(l);
ReleaseAndReturn(true);
}
if (pred->ModuleOfPred == PROLOG_MODULE) {
if (!LOCAL_do_trace_primitives) {
UNLOCK(Yap_low_level_trace_lock);
return;
ReleaseAndReturn(true);
}
mname = "prolog";
} else {
@ -350,42 +384,45 @@ void low_level_trace__(yap_low_level_port port, PredEntry *pred, CELL *args) {
}
/* if ((pred->ModuleOfPred == 0) && (s[0] == '$'))
return; */
b = send_tracer_message("CALL: ", s, arity, mname, args, b, top);
b = send_tracer_message("CALL: ", s, arity, mname, args, &buf, b, &top);
break;
case try_or:
b = send_tracer_message("TRY_OR ", NULL, 0, NULL, args, b, top);
b = send_tracer_message("TRY_OR ", NULL, 0, NULL, args, &buf, b, &top);
break;
case retry_or:
b = send_tracer_message("FAIL ", NULL, 0, NULL, args, b, top);
b = send_tracer_message("RETRY_OR ", NULL, 0, NULL, args, b, top);
b = send_tracer_message("FAIL ", NULL, 0, NULL, args, &buf, b, &top);
b = send_tracer_message("RETRY_OR ", NULL, 0, NULL, args, &buf, b, &top);
break;
case retry_table_generator:
b = send_tracer_message("FAIL ", NULL, 0, NULL, args, b, top);
b = send_tracer_message("FAIL ", NULL, 0, NULL, args, &buf, b, &top);
mname = (char *)RepAtom(AtomOfTerm(Yap_Module_Name(pred)))->StrOfAE;
arity = pred->ArityOfPE;
if (arity == 0)
s = (char *)RepAtom((Atom)pred->FunctorOfPred)->StrOfAE;
else
s = (char *)RepAtom(NameOfFunctor((pred->FunctorOfPred)))->StrOfAE;
b = send_tracer_message("RETRY GENERATOR: ", s, arity, mname, args, b, top);
b = send_tracer_message("RETRY GENERATOR: ", s, arity, mname, args, &buf, b,
&top);
break;
case retry_table_consumer:
b = send_tracer_message("FAIL ", NULL, 0, NULL, args, b, top);
b = send_tracer_message("FAIL ", NULL, 0, NULL, args, &buf, b, &top);
mname = (char *)RepAtom(AtomOfTerm(Yap_Module_Name(pred)))->StrOfAE;
arity = pred->ArityOfPE;
if (arity == 0) {
s = (char *)RepAtom((Atom)pred->FunctorOfPred)->StrOfAE;
b = send_tracer_message("RETRY CONSUMER: ", s, 0, mname, NULL, b, top);
b = send_tracer_message("RETRY CONSUMER: ", s, 0, mname, NULL, &buf, b,
&top);
} else {
s = (char *)RepAtom(NameOfFunctor((pred->FunctorOfPred)))->StrOfAE;
b = send_tracer_message("RETRY CONSUMER: ", s, pred->ArityOfPE, mname,
NULL, b, top);
NULL, &buf, b, &top);
}
break;
case retry_table_loader:
b = send_tracer_message("FAIL ", NULL, 0, NULL, args, b, top);
b = send_tracer_message("FAIL ", NULL, 0, NULL, args, &buf, b, &top);
if (pred == UndefCode) {
b = send_tracer_message("RETRY LOADER ", NULL, 0, NULL, NULL, b, top);
b = send_tracer_message("RETRY LOADER ", NULL, 0, NULL, NULL, &buf, b,
&top);
} else {
mname = (char *)RepAtom(AtomOfTerm(Yap_Module_Name(pred)))->StrOfAE;
arity = pred->ArityOfPE;
@ -393,11 +430,12 @@ void low_level_trace__(yap_low_level_port port, PredEntry *pred, CELL *args) {
s = (char *)RepAtom((Atom)pred->FunctorOfPred)->StrOfAE;
else
s = (char *)RepAtom(NameOfFunctor((pred->FunctorOfPred)))->StrOfAE;
b = send_tracer_message("RETRY LOADER: ", s, 0, mname, NULL, b, top);
b = send_tracer_message("RETRY LOADER: ", s, 0, mname, NULL, &buf, b,
&top);
}
break;
case retry_pred:
b = send_tracer_message("FAIL ", NULL, 0, NULL, args, b, top);
b = send_tracer_message("FAIL ", NULL, 0, NULL, args, &buf, b, &top);
if (pred != NULL) {
mname = (char *)RepAtom(AtomOfTerm(Yap_Module_Name(pred)))->StrOfAE;
arity = pred->ArityOfPE;
@ -409,7 +447,7 @@ void low_level_trace__(yap_low_level_port port, PredEntry *pred, CELL *args) {
} else {
s = (char *)RepAtom(NameOfFunctor((pred->FunctorOfPred)))->StrOfAE;
}
b = send_tracer_message("RETRY: ", s, arity, mname, args, b, top);
b = send_tracer_message("RETRY: ", s, arity, mname, args, &buf, b, &top);
}
break;
}
@ -418,9 +456,11 @@ void low_level_trace__(yap_low_level_port port, PredEntry *pred, CELL *args) {
__android_log_print(ANDROID_LOG_DEBUG, "YAPDroid", "%s\n", buf);
#else
*b++ = '\n';
*b++ = '\0';
*b = '\0';
fputs(buf, stderr);
#endif
pop_text_stack(l);
ReleaseAndReturn(true);
}
void toggle_low_level_trace(void) {
@ -442,7 +482,7 @@ static Int reset_total_choicepoints(USES_REGS1) {
}
static Int show_low_level_trace(USES_REGS1) {
fprintf(stderr, "Call counter=%lld\n", vsc_count);
fprintf(stderr, "Call counter=%llu\n", vsc_count);
return (TRUE);
}

12
C/write.c
View File

@ -385,15 +385,16 @@ int Yap_FormatFloat(Float f, char **s, size_t sz) {
sno = Yap_open_buf_write_stream(GLOBAL_Stream[LOCAL_c_output_stream].encoding,
0);
if (sno < 0)
return FALSE;
return false;
wglb.lw = separator;
wglb.stream = GLOBAL_Stream + sno;
wrputf(f, &wglb);
wrputc('\0', wglb.stream);
so = Yap_MemExportStreamPtr(sno);
*s = Malloc( strlen(so) )+1;
strcpy(*s, so );
Yap_CloseStream(sno);
*s = so;
return TRUE;
return true;
}
/* writes a data base reference */
@ -568,11 +569,12 @@ static void write_string(const unsigned char *s,
int delta;
ptr += (delta = get_utf8(ptr, -1, &chr) );
if (chr == '\0')
if (chr == '\0') {
break;
}
if (delta == 0) {chr = *ptr++; }
write_quoted(chr, qt, stream);
} while (TRUE);
} while (true);
wrputc(qt, stream);
}

5
C/yap-args.c
View File

@ -370,7 +370,6 @@ X_API YAP_file_type_t YAP_parse_yap_arguments(int argc, char *argv[],
}
} else {
YAP_SetOutputMessage();
}
break;
#endif
@ -446,13 +445,13 @@ X_API YAP_file_type_t YAP_parse_yap_arguments(int argc, char *argv[],
break;
case 'n':
if (!strcmp("nosignals", p)) {
iap->PrologShouldHandleInterrupts = FALSE;
iap->PrologCannotHandleInterrupts = true;
break;
}
break;
case '-':
if (!strcmp("-nosignals", p)) {
iap->PrologShouldHandleInterrupts = FALSE;
iap->PrologCannotHandleInterrupts = true;
break;
} else if (!strncmp("-home=", p, strlen("-home="))) {
GLOBAL_Home = p + strlen("-home=");

69
CMakeLists.txt
View File

@ -1,9 +1,7 @@
# Sets the minimum version of CMake required to build the native
# library. You should either keep the default value or only pass a
# value of 3.4.0 or lower.
# Sets the minimum version of CMake required to build the native
# library. You should either keep the default value or only pass a
# Sets the version of CMake required to build the native
# library. You should either keep the default value or pass a
# value of 3.4.0 or lower.
project( YAP )
@ -15,14 +13,13 @@ if (ANDROID)
else ()
cmake_minimum_required(VERSION 2.8)
include(CMakeToolsHelpers OPTIONAL)
endif()
set(
CMAKE_MODULE_PATH
"${CMAKE_SOURCE_DIR}"
"${CMAKE_SOURCE_DIR}/cmake")
"${CMAKE_SOURCE_DIR}/cmake"
)
include(CheckIncludeFiles)
include(CheckLibraryExists)
@ -34,14 +31,15 @@ include(MacroOptionalFindPackage)
include(MacroLogFeature)
include(FindPackageHandleStandardArgs)
include (GNUInstallDirs)
# Creates and names a library, sets it as either STATIC
# or SHARED, and provides the relative paths to its source code.
# You can define multiple libraries, and CMake builds it for you.
# or SHARED, and provides the relative paths to its source code.z
# You can define libraries, and CMake builds it for you.
# Gradle automatically packages shared libraries with your APK.
#cross-compilation support
# Search packages for host system instead of packages for target system
# in case of cross compilation these macro should be defined by toolchain file
# in case of cross compilation define these macro by toolchain file
if(NOT COMMAND find_host_package)
macro(find_host_package)
find_package(${ARGN})
@ -54,6 +52,8 @@ if(NOT COMMAND find_host_program)
endif()
option(BUILD_SHARED_LIBS "Build shared library" ON)
set (CMAKE_POSITION_INDEPENDENT_CODE TRUE)
set (CMAKE_WINDOWS_EXPORT_ALL_SYMBOLS TRUE)
include(Prelims NO_POLICY_SCOPE)
@ -61,15 +61,17 @@ include(Sources NO_POLICY_SCOPE)
include(Model NO_POLICY_SCOPE)
include_directories ( utf8proc packages/myddas packages/myddas/sqlite3)
include_directories ( utf8proc packages/myddas packages/myddas/sqlite3/src)
if (ANDROID)
include_directories (
packages/myddas/sqlite3/Android/jni/sqlite
packages/myddas/sqlite3/Android/jni/sqlite/nativehelper
packages/myddas/sqlite3/src/Android/jni/sqlite
packages/myddas/sqlite3/src/Android/jni/sqlite/nativehelper
)
endif (ANDROID)
set_property( SOURCE ${LIBYAP_SOURCES} APPEND PROPERTY COMPILE_DEFINITIONS YAP_KERNEL=1)
add_definitions(-DUSE_MYDDAS=1 -DMYDDAS_SQLITE3=1)
if (MYSQL_FOUND)
@ -83,37 +85,33 @@ if (ODBC_FOUND)
if (MYSQL_POSTGRES)
add_definitions(= -DMYDDAS_POSTGRES=1)
endif()
if (MYSQL_POSTGRES)
set(SWIG_SOURCES packages/swig/python/yap_PYTHONwrapper.cxx )
endif()
if (ANDROID)
ADD_SUBDIRECTORY(os)
ADD_SUBDIRECTORY(OPTYap)
ADD_SUBDIRECTORY(packages/myddas)
ADD_SUBDIRECTORY(library/random)
ADD_SUBDIRECTORY(library/system)
ADD_SUBDIRECTORY(utf8proc)
ADD_SUBDIRECTORY(CXX)
set (SWIG_FILES ${CMAKE_SOURCE_DIR}/../generated/jni/yap_wrap.cpp )
else()
set(YLIBS
$<TARGET_OBJECTS:libYAPOs>
$<TARGET_OBJECTS:libOPTYap>
$<TARGET_OBJECTS:myddas>
$<TARGET_OBJECTS:Yapsqlite3>
$<TARGET_OBJECTS:libswi>
$<TARGET_OBJECTS:utf8proc>
)
endif ()
List (APPEND YLIBS $<TARGET_OBJECTS:libOPTYap> )
List (APPEND YLIBS $<TARGET_OBJECTS:libYAPOs> )
List (APPEND YLIBS $<TARGET_OBJECTS:utf8proc> )
List (APPEND YLIBS $<TARGET_OBJECTS:myddas> )
List (APPEND YLIBS $<TARGET_OBJECTS:Yapsqlite3> )
List (APPEND YLIBS $<TARGET_OBJECTS:libswi> )
if (WIN32)
list (APPEND YLIBS $<TARGET_OBJECTS:Yap++>)
List (APPEND YLIBS $<TARGET_OBJECTS:YAP++> )
endif()
add_library( # Sets the name of the library.
libYap
@ -121,22 +119,24 @@ add_library( # Sets the name of the library.
SHARED
${ENGINE_SOURCES}
${SWIG_FILES}
${C_INTERFACE_SOURCES}
${STATIC_SOURCES}
${ALL_SOURCES}
//${STATIC_SOURCES}
# cmake object libraries
${YLIBS}
${WINDLLS}
)
if (WIN32)
target_link_libraries(libYap ${WINDLLS})
endif (WIN32)
include(libYap NO_POLICY_SCOPE)
endif()
if (USE_READLINE)
target_link_libraries(libYap ${READLINE_LIBRARIES})
endif (USE_READLINE)
if (ANDROID)
add_dependencies(libYap plmyddas )
@ -148,6 +148,5 @@ set_target_properties(libYap
PROPERTIES OUTPUT_NAME Yap
)
MY_include(Packages NO_POLICY_SCOPE)
include(Config NO_POLICY_SCOPE)

27
CXX/CMakeLists.txt
View File

@ -8,18 +8,29 @@ set (CXX_SOURCES
yapi.cpp
)
set (CXX_HEADERS
yapa.hh
yapdb.hh
yapi.h
yapie.hh
yapq.hh
- yapt.hh
-)
list(APPEND LIBYAP_SOURCES ${CXX_SOURCES} PARENT_SCOPE)
if (ANDROID OR WIN32)
add_component (Yap++ ${CXX_SOURCES} )
else()
add_external (Yap++ ${CXX_SOURCES} )
MY_target_link_libraries(Yap++ ${CMAKE_DL_LIBS} libYap)
if ( WIN32)
add_component (YAP++ ${CXX_SOURCES} )
MY_install(TARGETS Yap++
LIBRARY DESTINATION ${libdir}
ARCHIVE DESTINATION ${libdir}
set_property( DIRECTORY APPEND PROPERTY COMPILE_DEFINITIONS "_YAP_NOT_INSTALLED_=1;HAVE_CONFIG_H=1;_GNU_SOURCE;YAP_KERNEL=1" )
else()
add_external (YAP++ ${CXX_SOURCES} )
MY_target_link_libraries(YAP++ ${CMAKE_DL_LIBS} libYap)
MY_install(TARGETS YAP++
LIBRARY DESTINATION ${dlls}
RUNTIME DESTINATION ${dlls}
ARCHIVE DESTINATION ${dlls}
)
endif()

9
CXX/CXXSources.cmake
View File

@ -1,9 +0,0 @@
set (CXX_SOURCES
yapa.hh
yapdb.hh
yapi.cpp
yapi.hh
yapie.hh
yapq.hh
yapt.hh
)

1684
CXX/_yap/__init__.c
View File

File diff suppressed because it is too large Load Diff

5233
CXX/_yap/dtypes.c
View File

File diff suppressed because it is too large Load Diff

142
CXX/_yap/dtypes.pxd
View File

@ -1,142 +0,0 @@
###################
### WARNING!!! ###
###################
# This file has been autogenerated
# Cython imports
from cython.operator cimport dereference as deref
from cython.operator cimport preincrement as inc
from libc cimport stdio
from cpython.version cimport PY_MAJOR_VERSION
from cpython.ref cimport PyTypeObject, Py_INCREF, Py_XDECREF
from cpython.type cimport PyType_Ready
from cpython.object cimport PyObject
from cpython.object cimport Py_LT, Py_LE, Py_EQ, Py_NE, Py_GT, Py_GE
# Python imports
cimport numpy as np
# Local imports
cimport xdress_extra_types
# Cython imports for types
cdef extern from "Python.h":
ctypedef Py_ssize_t Py_ssize_t
cdef long Py_TPFLAGS_DEFAULT
cdef long Py_TPFLAGS_BASETYPE
cdef long Py_TPFLAGS_CHECKTYPES
cdef long Py_TPFLAGS_HEAPTYPE
ctypedef struct PyGetSetDef:
char * name
ctypedef struct PyTypeObject:
char * tp_name
int tp_basicsize
int tp_itemsize
object tp_alloc(PyTypeObject *, Py_ssize_t)
void tp_dealloc(object)
object tp_richcompare(object, object, int)
object tp_new(PyTypeObject *, object, object)
object tp_str(object)
object tp_repr(object)
long tp_hash(object)
long tp_flags
char * tp_doc
PyMemberDef * tp_members
PyGetSetDef * tp_getset
PyTypeObject * tp_base
void tp_free(void *)
# This is a dirty hack by declaring to Cython both the Python 2 & 3 APIs
int (*tp_compare)(object, object) # Python 2
void * (*tp_reserved)(object, object) # Python 3
# structmember.h isn't included in Python.h for some reason
cdef extern from "structmember.h":
ctypedef struct PyMemberDef:
char * name
int type
Py_ssize_t offset
int flags
char * doc
cdef extern from "numpy/arrayobject.h":
ctypedef object (*PyArray_GetItemFunc)(void *, void *)
ctypedef int (*PyArray_SetItemFunc)(object, void *, void *)
ctypedef void (*PyArray_CopySwapNFunc)(void *, np.npy_intp, void *, np.npy_intp, np.npy_intp, int, void *)
ctypedef void (*PyArray_CopySwapFunc)(void *, void *, int, void *)
ctypedef int (*PyArray_CompareFunc)(const void* d1, const void *, void *)
ctypedef int (*PyArray_ArgFunc)(void *, np.npy_intp, np.npy_intp *, void *)
ctypedef void (*PyArray_DotFunc)(void *, np.npy_intp, void *, np.npy_intp, void *, np.npy_intp, void *)
ctypedef int (*PyArray_ScanFunc)(stdio.FILE *, void *, void *, void *)
ctypedef int (*PyArray_FromStrFunc)(char *, void *, char **, void *)
ctypedef np.npy_bool (*PyArray_NonzeroFunc)(void *, void *)
ctypedef void (*PyArray_FillFunc)(void *, np.npy_intp, void *)
ctypedef void (*PyArray_FillWithScalarFunc)(void *, np.npy_intp, void *, void *)
ctypedef int (*PyArray_SortFunc)(void *, np.npy_intp, void *)
ctypedef int (*PyArray_ArgSortFunc)(void *, np.npy_intp *, np.npy_intp, void *)
ctypedef np.NPY_SCALARKIND (*PyArray_ScalarKindFunc)(np.PyArrayObject *)
ctypedef struct PyArray_ArrFuncs:
np.PyArray_VectorUnaryFunc ** cast
PyArray_GetItemFunc *getitem
PyArray_SetItemFunc *setitem
PyArray_CopySwapNFunc *copyswapn
PyArray_CopySwapFunc *copyswap
PyArray_CompareFunc *compare
PyArray_ArgFunc *argmax
PyArray_DotFunc *dotfunc
PyArray_ScanFunc *scanfunc
PyArray_FromStrFunc *fromstr
PyArray_NonzeroFunc *nonzero
PyArray_FillFunc *fill
PyArray_FillWithScalarFunc *fillwithscalar
PyArray_SortFunc *sort
PyArray_ArgSortFunc *argsort
PyObject *castdict
PyArray_ScalarKindFunc *scalarkind
int **cancastscalarkindto
int *cancastto
int listpickle
cdef void PyArray_InitArrFuncs(PyArray_ArrFuncs *)
ctypedef struct PyArray_ArrayDescr:
PyArray_Descr * base
PyObject *shape
cdef void ** PyArray_API
cdef PyTypeObject * PyArrayDescr_Type
ctypedef struct PyArray_Descr:
Py_ssize_t ob_refcnt
PyTypeObject * ob_type
PyTypeObject * typeobj
char kind
char type
char byteorder
int flags
int type_num
int elsize
int alignment
PyArray_ArrayDescr * subarray
PyObject * fields
PyObject * names
PyArray_ArrFuncs * f
cdef int PyArray_RegisterDataType(PyArray_Descr *)
cdef object PyArray_Scalar(void *, PyArray_Descr *, object)
cdef extern from "xdress_extra_types.h" namespace "xdress_extra_types":
cdef cppclass MemoryKnight[T]:
MemoryKnight() nogil except +
T * defnew() nogil except +
T * renew(void *) nogil except +
void deall(T *) nogil except +

43
CXX/_yap/dtypes.pyx
View File

@ -1,43 +0,0 @@
###################
### WARNING!!! ###
###################
# This file has been autogenerated
# Cython imports
from cython.operator cimport dereference as deref
from cython.operator cimport preincrement as inc
from libc.stdlib cimport malloc, free
from libc.string cimport memcpy
from cpython.version cimport PY_MAJOR_VERSION
from cpython.ref cimport PyTypeObject
from cpython.type cimport PyType_Ready
from cpython.object cimport Py_LT, Py_LE, Py_EQ, Py_NE, Py_GT, Py_GE
# Python Imports
import collections
cimport numpy as np
import numpy as np
np.import_array()
cimport xdress_extra_types
# Cython imports for types
# imports for types
dtypes = {}
if PY_MAJOR_VERSION >= 3:
basestring = str
# Dirty ifdef, else, else preprocessor hack
# see http://comments.gmane.org/gmane.comp.python.cython.user/4080
cdef extern from *:
cdef void emit_ifpy2k "#if PY_MAJOR_VERSION == 2 //" ()
cdef void emit_ifpy3k "#if PY_MAJOR_VERSION == 3 //" ()
cdef void emit_else "#else //" ()
cdef void emit_endif "#endif //" ()

5234
CXX/_yap/stlcontainers.c
View File

File diff suppressed because it is too large Load Diff

30
CXX/_yap/stlcontainers.pxd
View File

@ -1,30 +0,0 @@
###################
### WARNING!!! ###
###################
# This file has been autogenerated
# Cython imports
from cython.operator cimport dereference as deref
from cython.operator cimport preincrement as inc
from libcpp.string cimport string as std_string
from libcpp.utility cimport pair
from libcpp.map cimport map as cpp_map
from libcpp.set cimport set as cpp_set
from libcpp.vector cimport vector as cpp_vector
from libcpp cimport bool as cpp_bool
from libc cimport stdio
from cpython.version cimport PY_MAJOR_VERSION
from cpython.ref cimport PyTypeObject, Py_INCREF, Py_XDECREF
# Python Imports
cimport numpy as np
# Local imports
cimport xdress_extra_types
cimport numpy as np
# Cython Imports For Types

45
CXX/_yap/stlcontainers.pyx
View File

@ -1,45 +0,0 @@
###################
### WARNING!!! ###
###################
# This file has been autogenerated
# Cython imports
from cython.operator cimport dereference as deref
from cython.operator cimport preincrement as inc
from libc.stdlib cimport malloc, free
from libc.string cimport memcpy
from libcpp.string cimport string as std_string
from libcpp.utility cimport pair
from libcpp.map cimport map as cpp_map
from libcpp.set cimport set as cpp_set
from libcpp cimport bool as cpp_bool
from libcpp.vector cimport vector as cpp_vector
from cpython.version cimport PY_MAJOR_VERSION
# Python Imports
import collections
cimport numpy as np
import numpy as np
np.import_array()
cimport xdress_extra_types
# Cython Imports For Types
# Imports For Types
if PY_MAJOR_VERSION >= 3:
basestring = str
# Dirty ifdef, else, else preprocessor hack
# see http://comments.gmane.org/gmane.comp.python.cython.user/4080
cdef extern from *:
cdef void emit_ifpy2k "#if PY_MAJOR_VERSION == 2 //" ()
cdef void emit_ifpy3k "#if PY_MAJOR_VERSION == 3 //" ()
cdef void emit_else "#else //" ()
cdef void emit_endif "#endif //" ()

2276
CXX/_yap/tests/test_dtypes.c
View File

File diff suppressed because it is too large Load Diff

21
CXX/_yap/tests/test_dtypes.py
View File

@ -1,21 +0,0 @@
"""Tests the part of dtypes that is accessible from Python."""
###################
### WARNING!!! ###
###################
# This file has been autogenerated
from __future__ import print_function
import nose
from nose.tools import assert_equal, assert_not_equal, assert_raises, raises, \
assert_almost_equal, assert_true, assert_false, assert_in
from numpy.testing import assert_array_equal, assert_array_almost_equal
import os
import numpy as np
from _yap import dtypes
if __name__ == '__main__':
nose.run()

2340
CXX/_yap/tests/test_stlcontainers.c
View File

File diff suppressed because it is too large Load Diff

23
CXX/_yap/tests/test_stlcontainers.py
View File

@ -1,23 +0,0 @@
"""Tests the part of stlconverters that is accessible from Python."""
###################
### WARNING!!! ###
###################
# This file has been autogenerated
from __future__ import print_function
from unittest import TestCase
import nose
from nose.tools import assert_equal, assert_not_equal, assert_raises, raises, \
assert_almost_equal, assert_true, assert_false, assert_in
from numpy.testing import assert_array_equal, assert_array_almost_equal
import os
import numpy as np
from collections import Container, Mapping
from _yap import stlcontainers
if __name__ == '__main__':
nose.run()

1962
CXX/_yap/xdress_extra_types.c
View File

File diff suppressed because it is too large Load Diff

62
CXX/_yap/xdress_extra_types.h
View File

@ -1,62 +0,0 @@
/// \file extra_types.h
/// \author Anthony Scopatz (scopatz\@gmail.com)
///
/// Provides some extra types that may be generally useful
#if !defined(_XDRESS_EXTRA_TYPES_)
#define _XDRESS_EXTRA_TYPES_
#if defined(__cplusplus)
namespace xdress_extra_types
{
/// complex type struct, matching PyTables definition
// typedef struct {
// double re; ///< real part
// double im; ///< imaginary part
// } complex_t;
/// Chivalrously handles C++ memory issues that Cython does
/// not yet have a syntax for. This is a template class,
/// rather than three template functions, because Cython does
/// not yet support template function wrapping.
template <class T>
class MemoryKnight
{
public:
MemoryKnight(){}; ///< Default constructor
~MemoryKnight(){}; ///< Default Destructor
/// Creates a new instance of type T on the heap using
/// its default constructor.
/// \return T *
T * defnew(){return new T();};
/// Creates a new instance of type T, using T's default
/// constructor, at a given location.
/// \param void * ptr, location to create T instance
/// \return value of ptr recast as T *
T * renew(void * ptr){return new (ptr) T();};
/// Deallocates a location in memory using delete.
/// \param T * ptr, location to remove
void deall(T * ptr){delete ptr;};
};
// End namespace xdress_extra_types
};
#elif defined(__STDC__)
// de nada
#endif
/// complex type struct, matching PyTables definition
typedef struct {
double re; ///< real part
double im; ///< imaginary part
} xd_complex_t;
#endif

45
CXX/_yap/xdress_extra_types.pxd
View File

@ -1,45 +0,0 @@
"""C++ wrapper for extra types header."""
from libc.stdio cimport FILE
# Dirty ifdef, else, else preprocessor hack
# see http://comments.gmane.org/gmane.comp.python.cython.user/4080
cdef extern from *:
cdef void emit_ifc "#if defined(__STDC__) //" ()
cdef void emit_ifcpp "#if defined(__cplusplus) //" ()
cdef void emit_elifc "#elif defined(__STDC__) //" ()
cdef void emit_elifcpp "#elif defined(__cplusplus) //" ()
cdef void emit_else "#else //" ()
cdef void emit_endif "#endif //" ()
ctypedef unsigned char uchar
ctypedef long long int64
ctypedef unsigned short uint16
ctypedef unsigned int uint32
ctypedef unsigned long long uint64
ctypedef long double float128
cdef extern from "xdress_extra_types.h":
ctypedef struct complex_t "xd_complex_t":
double re
double im
cdef complex_t py2c_complex(object pyv)
cdef extern from "Python.h":
object PyFile_FromFile(FILE *fp, char *name, char *mode, int (*close)(FILE*))
FILE* PyFile_AsFile(object p)
#emit_ifcpp()
#cdef extern from "<exception>" namespace "std":
# cdef cppclass exception:
# exception()
# exception(const exception&)
# exception& operator= (const exception&)
# ~exception()
# const char * what()
#emit_endif()

12
CXX/_yap/xdress_extra_types.pyx
View File

@ -1,12 +0,0 @@
#
# This file has been autogenerated by xdress
#
cdef complex_t py2c_complex(object pyv):
cdef complex_t cv = complex_t(0, 0)
pyv = complex(pyv)
cv.re = pyv.real
cv.im = pyv.imag
return cv

3
CXX/yapa.hh
View File

@ -89,10 +89,11 @@ class YAPProp {
PropTag tag( Prop p ) { return (PropTag)(p->KindOfPE); }
public:
/// get name of property
virtual YAPAtom name() = 0;
// virtual YAPAtom name();
virtual ~YAPProp() {};
};
#endif /* YAPA_HH */

31
CXX/yapdb.hh
View File

@ -34,12 +34,12 @@ class YAPModule;
*/
class YAPModule : protected YAPAtomTerm {
friend class YAPPredicate;
friend class YAPModuleProp;
YAPModule(Term t) : YAPAtomTerm(t){};
Term t() { return gt(); }
Term curModule() { CACHE_REGS return Yap_CurrentModule(); }
public:
~YAPModule(){};
YAPModule() : YAPAtomTerm(curModule()){};
YAPModule(YAPAtom t) : YAPAtomTerm(t){};
};
@ -57,8 +57,8 @@ class YAPModuleProp : public YAPProp {
YAPModuleProp(Term tmod) { m = Yap_GetModuleEntry(tmod); };
public:
YAPModuleProp(YAPModule tmod) { m = Yap_GetModuleEntry(tmod.gt()); };
YAPModuleProp() { CACHE_REGS m = Yap_GetModuleEntry(Yap_CurrentModule()); };
YAPModuleProp(YAPModule tmod);
virtual YAPModule module() { return YAPModule(m->AtomOfME); };
};
@ -99,7 +99,6 @@ public:
inline YAPFunctor(const wchar_t *s, uintptr_t arity) {
CACHE_REGS f = Yap_MkFunctor(UTF32ToAtom(s PASS_REGS), arity);
}
~YAPFunctor(){};
/// Getter: extract name of functor as an atom
///
/// this is for external usage.
@ -137,8 +136,10 @@ protected:
CACHE_REGS
BACKUP_MACHINE_REGS();
Term *modp = NULL;
out = Yap_StringToTerm(s0, strlen(s0) + 1, &LOCAL_encoding, 1200, names);
names = MkVarTerm ();
const unsigned char *us = (const unsigned char *)s0;
out =
Yap_BufferToTermWithPrioBindings(us, strlen(s0), TermNil, 1200, names);
// extern char *s0;
// fprintf(stderr,"ap=%p arity=%d text=%s", ap, ap->ArityOfPE, s);
// Yap_DebugPlWrite(out);
@ -173,7 +174,6 @@ protected:
inline YAPPredicate(PredEntry *pe) { ap = pe; }
public:
~YAPPredicate(){};
/// Functor constructor for predicates
///
@ -217,13 +217,15 @@ public:
/// char */module constructor for predicates.
///
inline YAPPredicate(const char *at, uintptr_t arity) {
ap = RepPredProp(PredPropByFunc(Yap_MkFunctor(Yap_LookupAtom(at), arity), CurrentModule));
ap = RepPredProp(PredPropByFunc(Yap_MkFunctor(Yap_LookupAtom(at), arity),
CurrentModule));
};
/// char */module constructor for predicates.
///
inline YAPPredicate(const char *at, uintptr_t arity, YAPTerm mod) {
ap = RepPredProp(PredPropByFunc(Yap_MkFunctor(Yap_LookupAtom(at), arity), mod.t));
ap = RepPredProp(
PredPropByFunc(Yap_MkFunctor(Yap_LookupAtom(at), arity), mod.t));
};
/// char */module constructor for predicates.
@ -252,6 +254,15 @@ public:
return YAPAtom(NameOfFunctor(ap->FunctorOfPred));
}
/// functor of predicate
///
/// onlu defined if arity >= 1
YAPFunctor functor() {
if (ap->ArityOfPE)
return YAPFunctor(ap->FunctorOfPred);
return NULL;
}
/// arity of predicate
///
/// we return a positive number.
@ -269,10 +280,10 @@ public:
YAPPrologPredicate(YAPTerm t) : YAPPredicate(t){};
YAPPrologPredicate(const char *s, arity_t arity) : YAPPredicate(s, arity){};
/// add a new clause
void *assertClause(YAPTerm clause, bool last = true,
bool assertClause(YAPTerm clause, bool last = true,
YAPTerm source = YAPTerm());
/// add a new tuple
void *assertFact(YAPTerm *tuple, bool last = true);
bool assertFact(YAPTerm *tuple, bool last = true);
/// retract at least the first clause matching the predicate.
void *retractClause(YAPTerm skeleton, bool all = false);
/// return the Nth clause (if source is available)

650
CXX/yapi.cpp
View File

File diff suppressed because it is too large Load Diff

34
CXX/yapi.hh
View File

@ -5,6 +5,8 @@
#include <gmpxx.h>
#include <vector>
#include <string>
#include <iostream>
//! @{
/**
@ -67,38 +69,6 @@ extern "C" {
// taken from yap_structs.h
#include "iopreds.h"
#ifdef SWIGPYTHON
extern PyObject *yap_to_pythond(YAP_Term t, bool eval);
extern PyObject *term_to_python(yhandle_t t, bool eval);
extern PyObject *deref_term_to_python(yhandle_t t);
X_API bool init_python(void);
extern Term pythonToYAP(PyObject *p);
extern PyObject *py_Main;
extern inline PyObject *AtomToPy(const char *s) {
if (strcmp(s, "true") == 0)
return Py_True;
if (strcmp(s, "false") == 0)
return Py_False;
if (strcmp(s, "none") == 0)
return Py_None;
if (strcmp(s, "[]") == 0)
return PyList_New(0);
else if (strcmp(s, "{}") == 0)
return PyDict_New();
/* return __main__,s */
else if (PyObject_HasAttrString(py_Main, s)) {
return PyObject_GetAttrString(py_Main, s);
}
// no way to translate
return NULL;
}
X_API extern PyObject *yap_to_python(YAP_Term t, bool eval);
#endif
X_API void YAP_UserCPredicate(const char *, YAP_UserCPred, YAP_Arity arity);
/* void UserCPredicateWithArgs(const char *name, int *fn(), unsigned int arity)

13
CXX/yapie.hh
View File

@ -7,12 +7,17 @@ class YAPTerm;
/// take information on a Prolog error:
class YAPError {
std::string name, errorClass, info;
yap_error_number ID;
std::string goal, info;
int swigcode;
public:
/// error handling when receiving the error term
YAPError(){};
YAPError(){
//ID = LOCAL_ActiveError->errorNo;
}
/// error handler object with initial data when receiving the error term
YAPError(yap_error_number id, YAPTerm culprit, std::string txt);
/// we just know the error number
/// exact error ID
yap_error_number getID() { return LOCAL_ActiveError->errorNo; };
@ -27,7 +32,7 @@ public:
/// the term that caused the bug
// YAPTerm getCulprit(LOCAL_ActiveError->errorFile){};
/// text describing the Error
const char *text();
std::string text();
};
#endif

61
CXX/yapq.hh
View File

@ -13,19 +13,19 @@ class YAPPredicate;
* interface to a YAP Query;
* uses an SWI-like status info internally.
*/
class YAPQuery : public YAPPredicate {
class YAPQuery : public YAPPredicate
{
bool q_open;
int q_state;
yhandle_t q_g, q_handles;
struct yami *q_p, *q_cp;
jmp_buf q_env;
sigjmp_buf q_env;
int q_flags;
YAP_dogoalinfo q_h;
YAPQuery *oq;
YAPListTerm vnames;
YAPTerm goal;
Term names;
Term goal;
// temporaries
Term tgoal, names;
void openQuery();
@ -46,20 +46,19 @@ public:
///
/// It is given a functor, and an array of terms that must have at least
/// the same arity as the functor. Works within the current module.
YAPQuery(YAPFunctor f, YAPTerm t[]);
//YAPQuery(YAPFunctor f, YAPTerm t[]);
/// string constructor without varnames
///
/// It is given a string, calls the parser and obtains a Prolog term that
/// should be a callable
/// goal.
inline YAPQuery(const char *s) : YAPPredicate(s, tgoal, names) {
inline YAPQuery(const char *s) : YAPPredicate(s, goal, names)
{
BACKUP_H();
__android_log_print(ANDROID_LOG_INFO, "YAPDroid", "got game %ld",
LOCAL_CurSlot);
if (!ap)
return;
goal = YAPTerm(tgoal);
vnames = YAPListTerm(names);
__android_log_print(ANDROID_LOG_INFO, "YAPDroid", "%s", vnames.text());
openQuery();
RECOVER_H();
@ -68,9 +67,10 @@ public:
///
/// It is given an atom, and a Prolog term that should be a callable
/// goal, say `main`, `init`, `live`.
inline YAPQuery(YAPAtom g) : YAPPredicate(g) {
goal = YAPAtomTerm(g);
vnames = YAPListTerm();
inline YAPQuery(YAPAtom g) : YAPPredicate(g)
{
goal = YAPAtomTerm(g).gt();
names = TermNil;
openQuery();
};
@ -92,19 +92,20 @@ public:
const char *text();
/// remove alternatives in the current search space, and finish the current
/// query
void cut();
/// finish the current query: undo all bindings.
void close();
/// query variables.
YAPListTerm namedVars();
void cut();
Term namedVars();
/// query variables, but copied out
YAPListTerm namedVarsCopy();
Term namedVarsCopy();
/// convert a ref to a binding.
YAPTerm getTerm(yhandle_t t);
/// simple YAP Query;
/// just calls YAP and reports success or failure, Useful when we just
/// want things done, eg YAPCommand("load_files(library(lists), )")
inline bool command() {
inline bool command()
{
bool rc = next();
close();
return rc;
@ -116,7 +117,8 @@ public:
/// This class implements a callback Prolog-side. It will be inherited by the
/// Java or Python
/// class that actually implements the callback.
class YAPCallback {
class YAPCallback
{
public:
virtual ~YAPCallback() {}
virtual void run() { LOG("callback"); }
@ -129,7 +131,8 @@ public:
*
*
*/
class YAPEngine {
class YAPEngine
{
private:
YAPCallback *_callback;
YAP_init_args init_args;
@ -156,14 +159,16 @@ public:
/// remove current callback
void delYAPCallback() { _callback = 0; }
/// set a new callback
void setYAPCallback(YAPCallback *cb) {
void setYAPCallback(YAPCallback *cb)
{
delYAPCallback();
_callback = cb;
}
/// execute the callback.
////void run() { if (_callback) _callback->run(); }
/// execute the callback with a text argument.
void run(char *s) {
void run(char *s)
{
if (_callback)
_callback->run(s);
}
@ -181,22 +186,30 @@ public:
/// current directory for the engine
bool call(YAPPredicate ap, YAPTerm ts[]);
/// current directory for the engine
bool goalt(YAPTerm t);
bool goalt(YAPTerm Yt) { return Yt.term(); };
/// current directory for the engine
bool goal(Term t);
bool mgoal(Term t, Term tmod);
/// current directory for the engine
bool goal(Term t)
{
return mgoal(t, CurrentModule);
}
/// reset Prolog state
void reSet();
/// release: assune that there are no stack pointers, just release memory
// for last execution
void release();
const char *currentDir() {
const char *currentDir()
{
char dir[1024];
std::string s = Yap_getcwd(dir, 1024 - 1);
return s.c_str();
};
/// report YAP version as a string
const char *version() {
const char *version()
{
std::string s = Yap_version();
return s.c_str();
};

192
CXX/yapt.hh
View File

@ -2,9 +2,12 @@
#ifndef YAPT_HH
#define YAPT_HH 1
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
*/
@ -19,19 +22,31 @@ class YAPTerm {
protected:
yhandle_t t; /// handle to term, equivalent to term_t
void mk(Term t0); /// internal method to convert from term to handle
Term gt(); /// get handle and obtain term
public:
virtual ~YAPTerm(){ LOCAL_HandleBase[t] = TermFreeTerm;
while ( LOCAL_HandleBase[LOCAL_CurSlot-1] == TermFreeTerm)
LOCAL_CurSlot--;
}
YAPTerm(Term tn) {
mk(tn);
} /// private method to convert from Term (internal YAP representation) to
Term gt() {
CACHE_REGS
// fprintf(stderr,"?%d,%lx,%p\n",t,LOCAL_HandleBase[t], HR);
// Yap_DebugPlWriteln(LOCAL_HandleBase[t]);
return Yap_GetFromSlot(t);
};
void mk(Term t0) {
CACHE_REGS t = Yap_InitSlot(t0);
// fprintf(stderr,"+%d,%lx,%p,%p",t,t0,HR,ASP); Yap_DebugPlWriteln(t0);
};
YAPTerm(Term tn) { mk(tn); };
#ifdef SWIGPYTHON
// YAPTerm(struct _object *inp) {
// Term tinp = pythonToYAP(inp);
// t = Yap_InitSlot(tinp);
//}
#endif
/// private method to convert from Term (internal YAP representation) to
/// YAPTerm
// do nothing constructor
YAPTerm() { mk(MkVarTerm()); }
YAPTerm() { mk(MkVarTerm()); };
// YAPTerm(yhandle_t i) { t = i; };
/// pointer to term
YAPTerm(void *ptr);
@ -40,6 +55,21 @@ public:
Term tp;
mk(YAP_ReadBuffer(s, &tp));
}
#if 1
/// Term destructor, tries to recover slot
virtual ~YAPTerm() {
// fprintf(stderr,"-%d,%lx,%p ",t,LOCAL_HandleBase[t] ,HR);
if (!t)
return;
Yap_DebugPlWriteln(LOCAL_HandleBase[t]);
LOCAL_HandleBase[t] = TermFreeTerm;
while (LOCAL_HandleBase[LOCAL_CurSlot - 1] == TermFreeTerm) {
LOCAL_CurSlot--;
}
};
#endif
/// construct a term out of an integer (if you know object type use
/// YAPIntegerTerm)
/// YAPTerm(long int num) { mk(MkIntegerTerm(num)); }
@ -51,23 +81,64 @@ public:
/// extract the tag of a term, after dereferencing.
YAP_tag_t tag();
/// copy the term ( term copy )
YAPTerm deepCopy();
Term deepCopy();
/// numbervars ( int start, bool process=false )
intptr_t numberVars(intptr_t start, bool skip_singletons = false);
inline Term term() {
return gt();
} /// from YAPTerm to Term (internal YAP representation)
inline void bind(Term b) { LOCAL_HandleBase[t] = b; }
inline void bind(YAPTerm *b) { LOCAL_HandleBase[t] = b->term(); }
/// from YAPTerm to Term (internal YAP representation)
/// fetch a sub-term
YAPTerm &operator[](size_t n);
Term &operator[](arity_t n);
// const YAPTerm *vars();
/// this term is == to t1
virtual bool exactlyEqual(YAPTerm t1);
virtual bool unify(YAPTerm t1); /// t = t1
virtual bool unifiable(YAPTerm t1); /// we can unify t and t1
virtual bool variant(
YAPTerm t1); /// t =@= t1, the two terms are equal up to variable renaming
virtual intptr_t hashTerm(size_t sz, size_t depth,
bool variant); /// term hash,
virtual bool exactlyEqual(YAPTerm t1) {
bool out;
BACKUP_MACHINE_REGS();
out = Yap_eq(gt(), t1.term());
RECOVER_MACHINE_REGS();
return out;
};
/// t = t1
virtual bool unify(YAPTerm t1) {
intptr_t out;
BACKUP_MACHINE_REGS();
out = Yap_unify(gt(), t1.term());
RECOVER_MACHINE_REGS();
return out;
};
/// we can unify t and t1
virtual bool unifiable(YAPTerm t1) {
bool out;
BACKUP_MACHINE_REGS();
out = Yap_eq(gt(), t1.term());
RECOVER_MACHINE_REGS();
return out;
};
/// t =@= t1, the two terms are equal up to variable renamingvirtual bool
/// variant(
inline virtual YAP_Term variant(YAPTerm t1) {
intptr_t out;
BACKUP_MACHINE_REGS();
out = Yap_Variant(gt(), t1.term());
RECOVER_MACHINE_REGS();
return out;
};
virtual intptr_t hashTerm(size_t sz, size_t depth, bool variant) {
intptr_t out;
BACKUP_MACHINE_REGS();
out = Yap_TermHash(gt(), sz, depth, variant);
RECOVER_MACHINE_REGS();
return out;
};
/// term hash,
virtual bool isVar() { return IsVarTerm(gt()); } /// type check for unound
virtual bool isAtom() { return IsAtomTerm(gt()); } /// type check for atom
virtual bool isInteger() {
@ -88,19 +159,19 @@ public:
virtual bool isList() { return Yap_IsListTerm(gt()); } /// term is a list
/// extract the argument i of the term, where i in 1...arity
virtual YAPTerm getArg(arity_t i) {
virtual Term getArg(arity_t i) {
BACKUP_MACHINE_REGS();
Term tf = 0;
Term t0 = gt();
YAPTerm tf;
if (IsApplTerm(t0))
tf = YAPTerm(ArgOfTerm(i, t0));
tf = (ArgOfTerm(i, t0));
else if (IsPairTerm(t0)) {
if (i == 1)
tf = YAPTerm(HeadOfTerm(t0));
tf = (HeadOfTerm(t0));
else if (i == 2)
tf = YAPTerm(TailOfTerm(t0));
tf = (TailOfTerm(t0));
} else {
tf = YAPTerm((Term)0);
tf = ((Term)0);
}
RECOVER_MACHINE_REGS();
return tf;
@ -123,7 +194,24 @@ public:
}
/// return a string with a textual representation of the term
virtual const char *text();
virtual const char *text() {
CACHE_REGS
size_t length = 0;
encoding_t enc = LOCAL_encoding;
char *os;
BACKUP_MACHINE_REGS();
if (!(os = Yap_TermToString(Yap_GetFromSlot(t), &length, enc,
Handle_vars_f))) {
RECOVER_MACHINE_REGS();
return 0;
}
RECOVER_MACHINE_REGS();
length = strlen(os) + 1;
char *sm = (char *)malloc(length + 1);
strcpy(sm, os);
return sm;
};
/// return a handle to the term
inline yhandle_t handle() { return t; };
@ -169,16 +257,21 @@ class YAPApplTerm : public YAPTerm {
YAPApplTerm(Term t0) { mk(t0); }
public:
~YAPApplTerm() {}
YAPApplTerm(Functor f, Term ts[]) {
BACKUP_MACHINE_REGS();
Term t0 = Yap_MkApplTerm(f, f->ArityOfFE, ts);
mk(t0);
RECOVER_MACHINE_REGS();
};
YAPApplTerm(YAPFunctor f, YAPTerm ts[]);
YAPApplTerm(const char *s, std::vector<YAPTerm> ts);
YAPApplTerm(const std::string s, std::vector<YAPTerm> ts);
YAPApplTerm(YAPFunctor f);
YAPFunctor getFunctor();
YAPTerm getArg(arity_t i) {
Term getArg(arity_t i) {
BACKUP_MACHINE_REGS();
Term t0 = gt();
YAPTerm tf;
tf = YAPTerm(ArgOfTerm(i, t0));
Term tf;
tf = ArgOfTerm(i, t0);
RECOVER_MACHINE_REGS();
return tf;
};
@ -209,8 +302,8 @@ class YAPPairTerm : public YAPTerm {
public:
YAPPairTerm(YAPTerm hd, YAPTerm tl);
YAPPairTerm();
YAPTerm getHead() { return YAPTerm(HeadOfTerm(gt())); }
YAPTerm getTail() { return YAPTerm(TailOfTerm(gt())); }
Term getHead() { return (HeadOfTerm(gt())); }
Term getTail() { return (TailOfTerm(gt())); }
};
/**
@ -267,28 +360,27 @@ public:
return Yap_SkipList(&t1, &tailp);
}
/// Extract the nth element.
YAPTerm &operator[](size_t n);
Term &operator[](size_t n);
/// Extract the first element of a list.
///
/// @param[in] the list
YAPTerm car();
Term car();
/// Extract the tail elements of a list.
///
/// @param[in] the list
YAPListTerm cdr() {
Term cdr() {
Term to = gt();
if (IsPairTerm(to))
return YAPListTerm(TailOfTerm(to));
return (TailOfTerm(to));
else if (to == TermNil)
return YAPListTerm();
return TermNil;
/* error */
Yap_Error(TYPE_ERROR_LIST, t, 0);
throw YAPError();
throw YAPError(TYPE_ERROR_LIST, YAPTerm(to), "");
}
/// copy a list.
///
/// @param[in] the list
YAPListTerm dup();
Term dup();
/// Check if the list is empty.
///
@ -337,14 +429,14 @@ public:
YAPAtomTerm(wchar_t *s);
// Constructor: receives a sequence of n wchar_ts, whatever they may be;
YAPAtomTerm(wchar_t *s, size_t len);
virtual bool isVar() { return false; } /// type check for unbound
virtual bool isAtom() { return true; } /// type check for atom
virtual bool isInteger() { return false; } /// type check for integer
virtual bool isFloat() { return false; } /// type check for floating-point
virtual bool isString() { return false; } /// type check for a string " ... "
virtual bool isCompound() { return false; } /// is a primitive term
virtual bool isAppl() { return false; } /// is a structured term
virtual bool isPair() { return false; } /// is a pair term
bool isVar() { return false; } /// type check for unbound
bool isAtom() { return true; } /// type check for atom
bool isInteger() { return false; } /// type check for integer
bool isFloat() { return false; } /// type check for floating-point
bool isString() { return false; } /// type check for a string " ... "
bool isCompound() { return false; } /// is a primitive term
bool isAppl() { return false; } /// is a structured term
bool isPair() { return false; } /// is a pair term
virtual bool isGround() { return true; } /// term is ground
virtual bool isList() { return gt() == TermNil; } /// [] is a list
// Getter: outputs the atom;

5
H/ATOMS
View File

@ -95,7 +95,7 @@ A Csult F "$csult"
A CurrentModule F "$current_module"
A Cut N "!"
A CutBy F "$cut_by"
A DAbort F "$abort"
A DAbort N "abort"
A DBLoad F "$db_load"
A DBREF N "DBRef"
A DBReference N "db_reference"
@ -294,6 +294,7 @@ A PastEndOfStream N "past_end_of_stream"
A PermissionError N "permission_error"
A Pi N "pi"
A Pipe N "pipe"
A Priority N "priority"
A Plus N "+"
A Pointer N "pointer"
A Portray F "portray"
@ -546,11 +547,13 @@ F NBQueue Queue 4
F Not Not 1
F Obj Obj 1
F Or Semic 2
F Output Output 1
F PermissionError PermissionError 3
F Plus Plus 2
F Portray Portray 1
F PrintMessage PrintMessage 2
F Procedure Procedure 5
F Priority Priority 1
F PrologConstraint Prolog 2
F ProtectStack ProtectStack 4
F Query Query 1

10
H/LOCALS
View File

@ -145,7 +145,7 @@ ADDR db_vec0 =NULL
struct RB_red_blk_node* db_root =NULL
struct RB_red_blk_node* db_nil =NULL
sigjmp_buf gc_restore void
sigjmp_buf* gc_restore void
CELL* extra_gc_cells void
CELL* extra_gc_cells_base void
CELL* extra_gc_cells_top void
@ -160,8 +160,8 @@ struct mem_blk* CMemFirstBlock =NULL
UInt CMemFirstBlockSz =0L
// Variable used by the compiler to store number of permanent vars in a clause
int nperm =0L
int nperm =0
int jMP =0
// Thread Local Area for Labels
Int* LabelFirstArray =NULL
UInt LabelFirstArraySz =0L
@ -198,7 +198,7 @@ ADDR TrailTop void
yap_error_descriptor_t* ActiveError =calloc(sizeof(yap_error_descriptor_t),1)
/// pointer to an exception term, from throw
jmp_buf IOBotch void
jmp_buf* IOBotch void
TokEntry* tokptr void
TokEntry* toktide void
VarEntry* VarTable void
@ -209,7 +209,7 @@ CELL* CommentsNextChar void
wchar_t* CommentsBuff void
size_t CommentsBuffPos void
size_t CommentsBuffLim void
sigjmp_buf RestartEnv void
sigjmp_buf* RestartEnv void
char FileNameBuf[YAP_FILENAME_MAX+1] void
char FileNameBuf2[YAP_FILENAME_MAX+1] void

2
H/TermExt.h
View File

@ -302,6 +302,8 @@ INLINE_ONLY inline EXTERN Term __MkStringTerm(const char *s USES_REGS) {
return t;
}
#define MkUStringTerm(i) __MkUStringTerm((i)PASS_REGS)
INLINE_ONLY inline EXTERN Term
__MkUStringTerm(const unsigned char *s USES_REGS);

39
H/Yap.h
View File

@ -129,37 +129,6 @@
#endif
#endif /* defined(HAVE_NULLPTR) */
/* Microsoft's Visual C++ Compiler */
#ifdef _MSC_VER /* adjust a config.h from mingw32 to work with vc++ */
#ifdef HAVE_GCC
#undef HAVE_GCC
#endif /* HAVE_GCC */
#ifdef USE_THREADED_CODE
#undef USE_THREADED_CODE
#endif /* USE_THREADED_CODE */
#define inline __inline
#define YAP_VERSION "YAP-6.3.4"
#define BIN_DIR "c:\\Yap\\bin"
#define LIB_DIR "c:\\Yap\\lib\\Yap"
#define SHARE_DIR "c:\\Yap\\share\\Yap"
#ifdef HOST_ALIAS
#undef HOST_ALIAS
#endif /* HOST_ALIAS */
#define HOST_ALIAS "i386-pc-win32"
#ifdef HAVE_IEEEFP_H
#undef HAVE_IEEEFP_H
#endif /* HAVE_IEEEFP_H */
#ifdef HAVE_UNISTD_H
#undef HAVE_UNISTD_H
#endif /* HAVE_UNISTD_H */
#ifdef HAVE_SYS_TIME_H
#undef HAVE_SYS_TIME_H
#endif /* HAVE_SYS_TIME_H */
#endif /* _MSC_VER */
#if HAVE_TIME_H
#include <time.h>
#endif
#ifdef __MINGW32__
#ifndef _WIN32
@ -727,10 +696,10 @@ typedef struct thandle {
struct timeval *start_of_times_sysp;
struct timeval *last_time_sysp;
#elif _WIN32
struct _FILETIME *start_of_timesp;
struct _FILETIME *last_timep;
struct _FILETIME *start_of_times_sysp;
struct _FILETIME *last_time_sysp;
win64_time_t *start_of_timesp;
win64_time_t *last_timep;
win64_time_t *start_of_times_sysp;
win64_time_t *last_time_sysp;
#endif
} yap_thandle;
#endif /* THREADS */

2
H/compile.h → H/YapCompile.h
View File

@ -8,7 +8,7 @@
* *
**************************************************************************
* *
* File: compile.h *
* File: YapCompile.h *
* Last rev: *
* mods: *
* comments: compiler data structures and routines *

8
H/eval.h → H/YapEval.h
View File

@ -1,6 +1,6 @@
/*************************************************************************
* *
* YAP Prolog @(#)eval.h 1.2
* YAP Prolog @(#)YapEval.h 1.2
* *
* Yap Prolog was developed at NCCUP - Universidade do Porto *
* *
@ -8,7 +8,7 @@
* *
**************************************************************************
* *
* File: eval.h *
* File: YapEval.h *
* Last rev: *
* mods: *
* comments: arithmetical functions info *
@ -17,7 +17,7 @@
/**
@file eval.h
@file YapEval.h
@defgroup arithmetic Arithmetic in YAP
@ -407,7 +407,7 @@ yamop *Yap_EvalError__(const char *, const char *, int, yap_error_number, Term,
...);
#define Yap_ArithError(id, t, ...) \
Yap_ThrowError__(__FILE__, __FUNCTION__, __LINE__, id, t, 2, __VA_ARGS__)
Yap_ThrowError__(__FILE__, __FUNCTION__, __LINE__, id, t, __VA_ARGS__)
#define Yap_BinError(id) \
Yap_Error__(__FILE__, __FUNCTION__, __LINE__, id, 0L, "")
#define Yap_AbsmiError(id) \

2
H/YapFlags.h
View File

@ -204,7 +204,7 @@ typedef struct x_el {
} xarg;
typedef struct struct_param {
char *name;
const char *name;
flag_func type;
int id;
} param_t;

2
H/YapHeap.h
View File

@ -154,7 +154,7 @@ typedef struct thandle {
/*******************
this is the data base: everything here should be possible to restore
********************/
#if __INIT_C__
#if __INIT_C__ || defined(MSC_VER)
#define EXTERNAL
#else
#define EXTERNAL extern

66
H/YapTags.h
View File

@ -166,13 +166,15 @@ INLINE_ONLY inline EXTERN Term *VarOfTerm(Term t) { return (Term *)(t); }
INLINE_ONLY inline EXTERN Term MkVarTerm__(USES_REGS1);
INLINE_ONLY inline EXTERN Term MkVarTerm__(USES_REGS1) {
INLINE_ONLY
inline EXTERN Term MkVarTerm__(USES_REGS1) {
return (Term)((*HR = 0, HR++));
}
INLINE_ONLY inline EXTERN bool IsUnboundVar(Term *);
INLINE_ONLY inline EXTERN bool IsUnboundVar(Term *t) { return (int)(*(t) ==
INLINE_ONLY
inline EXTERN bool IsUnboundVar(Term *t) { return (int)(*(t) ==
0); }
#else
@ -181,13 +183,15 @@ INLINE_ONLY inline EXTERN bool IsUnboundVar(Term *t) { return (int)(*(t) ==
INLINE_ONLY inline EXTERN Term MkVarTerm__(USES_REGS1);
INLINE_ONLY inline EXTERN Term MkVarTerm__(USES_REGS1) {
INLINE_ONLY
inline EXTERN Term MkVarTerm__(USES_REGS1) {
return (Term)((*HR = (CELL)HR, HR++));
}
INLINE_ONLY inline EXTERN bool IsUnboundVar(Term *);
INLINE_ONLY inline EXTERN bool IsUnboundVar(Term *t) {
INLINE_ONLY
inline EXTERN bool IsUnboundVar(Term *t) {
return *(t) == (Term)(t);
}
@ -195,13 +199,15 @@ INLINE_ONLY inline EXTERN bool IsUnboundVar(Term *t) {
INLINE_ONLY inline EXTERN CELL *PtrOfTerm(Term);
INLINE_ONLY inline EXTERN CELL *PtrOfTerm(Term t) {
INLINE_ONLY
inline EXTERN CELL *PtrOfTerm(Term t) {
return (CELL *)(*(CELL *)(t));
}
INLINE_ONLY inline EXTERN Functor FunctorOfTerm(Term);
INLINE_ONLY inline EXTERN Functor FunctorOfTerm(Term t) {
INLINE_ONLY
inline EXTERN Functor FunctorOfTerm(Term t) {
return (Functor)(*RepAppl(t));
}
@ -209,13 +215,15 @@ INLINE_ONLY inline EXTERN Functor FunctorOfTerm(Term t) {
INLINE_ONLY inline EXTERN Term MkAtomTerm(Atom);
INLINE_ONLY inline EXTERN Term MkAtomTerm(Atom a) {
INLINE_ONLY
inline EXTERN Term MkAtomTerm(Atom a) {
return (Term)(AtomTag | (CELL)(a));
}
INLINE_ONLY inline EXTERN Atom AtomOfTerm(Term t);
INLINE_ONLY inline EXTERN Atom AtomOfTerm(Term t) {
INLINE_ONLY
inline EXTERN Atom AtomOfTerm(Term t) {
return (Atom)((~AtomTag & (CELL)(t)));
}
@ -223,13 +231,15 @@ INLINE_ONLY inline EXTERN Atom AtomOfTerm(Term t) {
INLINE_ONLY inline EXTERN Term MkAtomTerm(Atom);
INLINE_ONLY inline EXTERN Term MkAtomTerm(Atom at) {
INLINE_ONLY
inline EXTERN Term MkAtomTerm(Atom at) {
return (Term)(TAGGEDA((CELL)AtomTag, (CELL)(at)));
}
INLINE_ONLY inline EXTERN Atom AtomOfTerm(Term t);
INLINE_ONLY inline EXTERN Atom AtomOfTerm(Term t) {
INLINE_ONLY
inline EXTERN Atom AtomOfTerm(Term t) {
return (Atom)(NonTagPart(t));
}
@ -237,13 +247,15 @@ INLINE_ONLY inline EXTERN Atom AtomOfTerm(Term t) {
INLINE_ONLY inline EXTERN bool IsAtomTerm(Term);
INLINE_ONLY inline EXTERN bool IsAtomTerm(Term t) {
INLINE_ONLY
inline EXTERN bool IsAtomTerm(Term t) {
return CHKTAG((t), AtomTag);
}
INLINE_ONLY inline EXTERN Term MkIntTerm(Int);
INLINE_ONLY inline EXTERN Term MkIntTerm(Int n) {
INLINE_ONLY
inline EXTERN Term MkIntTerm(Int n) {
return (Term)(TAGGED(NumberTag, (n)));
}
@ -254,19 +266,22 @@ INLINE_ONLY inline EXTERN Term MkIntTerm(Int n) {
INLINE_ONLY inline EXTERN Term MkIntConstant(Int);
INLINE_ONLY inline EXTERN Term MkIntConstant(Int n) {
INLINE_ONLY
inline EXTERN Term MkIntConstant(Int n) {
return (Term)(NONTAGGED(NumberTag, (n)));
}
INLINE_ONLY inline EXTERN bool IsIntTerm(Term);
INLINE_ONLY inline EXTERN bool IsIntTerm(Term t) {
INLINE_ONLY
inline EXTERN bool IsIntTerm(Term t) {
return CHKTAG((t), NumberTag);
}
INLINE_ONLY EXTERN inline Term MkPairTerm__(Term head, Term tail USES_REGS);
INLINE_ONLY EXTERN inline Term MkPairTerm__(Term head, Term tail USES_REGS) {
INLINE_ONLY
EXTERN inline Term MkPairTerm__(Term head, Term tail USES_REGS) {
CELL *p = HR;
HR[0] = head;
@ -308,20 +323,23 @@ INLINE_ONLY EXTERN inline Term MkPairTerm__(Term head, Term tail USES_REGS) {
INLINE_ONLY inline EXTERN Term __MkIntegerTerm(Int USES_REGS);
INLINE_ONLY inline EXTERN Term __MkIntegerTerm(Int n USES_REGS) {
INLINE_ONLY
inline EXTERN Term __MkIntegerTerm(Int n USES_REGS) {
return (Term)(IntInBnd(n) ? MkIntTerm(n) : MkLongIntTerm(n));
}
#endif
INLINE_ONLY inline EXTERN bool IsIntegerTerm(Term);
INLINE_ONLY inline EXTERN bool IsIntegerTerm(Term t) {
INLINE_ONLY
inline EXTERN bool IsIntegerTerm(Term t) {
return (int)(IsIntTerm(t) || IsLongIntTerm(t));
}
INLINE_ONLY inline EXTERN Int IntegerOfTerm(Term);
INLINE_ONLY inline EXTERN Int IntegerOfTerm(Term t) {
INLINE_ONLY
inline EXTERN Int IntegerOfTerm(Term t) {
return (Int)(IsIntTerm(t) ? IntOfTerm(t) : LongIntOfTerm(t));
}
@ -332,7 +350,8 @@ INLINE_ONLY inline EXTERN Int IntegerOfTerm(Term t) {
INLINE_ONLY inline EXTERN Term __MkAddressTerm(void *USES_REGS);
INLINE_ONLY inline EXTERN Term __MkAddressTerm(void *n USES_REGS) {
INLINE_ONLY
inline EXTERN Term __MkAddressTerm(void *n USES_REGS) {
return __MkIntegerTerm((Int)n PASS_REGS);
}
@ -340,20 +359,23 @@ INLINE_ONLY inline EXTERN Term __MkAddressTerm(void *n USES_REGS) {
INLINE_ONLY inline EXTERN bool IsAddressTerm(Term);
INLINE_ONLY inline EXTERN bool IsAddressTerm(Term t) {
INLINE_ONLY
inline EXTERN bool IsAddressTerm(Term t) {
return (bool)IsIntegerTerm(t);
}
INLINE_ONLY inline EXTERN void *AddressOfTerm(Term);
INLINE_ONLY inline EXTERN void *AddressOfTerm(Term t) {
INLINE_ONLY
inline EXTERN void *AddressOfTerm(Term t) {
return (void *)(IsIntTerm(t) ? IntOfTerm(t) : LongIntOfTerm(t));
}
INLINE_ONLY inline EXTERN Int IsPairTermOrNil (Term);
INLINE_ONLY inline EXTERN Int
INLINE_ONLY
inline EXTERN Int
IsPairOrNilTerm (Term t)
{
return IsPairTerm(t) || t == TermNil;

27
H/YapTerm.h
View File

@ -33,7 +33,7 @@ typedef void *Atom;
(((CELL)(X) + (sizeof(TYPE) - 1)) & ~(sizeof(TYPE) - 1))
#ifndef EXTERN
#ifdef _MSC_VER
#ifdef MSC_VER
#define EXTERN
#else
#define EXTERN extern
@ -44,51 +44,30 @@ typedef void *Atom;
** and integer types Short and UShort with half the size of a ptr */
#if defined(PRIdPTR)
#define Int_FORMAT "%" PRIdPTR
#define Int_ANYFORMAT "%" PRIuPTR
#define UInt_FORMAT "%" PRIuPTR
#define Int_F PRIdPTR
#define Int_ANYF PRIuPTR
#define UInt_F PRIuPTR
typedef intptr_t Int;
typedef uintptr_t UInt;
#elif defined(_WIN64)
typedef int64_t Int;
typedef uint64_t UInt;
#define Int_FORMAT "%I64d"
#define UInt_FORMAT "%I64u"
#define Int_F "I64d"
#define UInt_F "I64u"
#elif defined(_WIN32)
typedef int32_t Int;
typedef uint32_t UInt;
#define Int_FORMAT "%I32d"
#define UInt_FORMAT "%I32u"
#define Int_F "I32d"
#define UInt_F "I32u"
#elif SIZEOF_LONG_INT == SIZEOF_INT_P
typedef long int Int;
typedef unsigned long int UInt;
#define Int_FORMAT "%ld"
#define UInt_FORMAT "%uld"
#define Int_F "ld"
#define UInt_F "uld"
#elif SIZEOF_INT == SIZEOF_INT_P
typedef int Int;
typedef unsigned int UInt;
#define Int_FORMAT "%l"
#define UInt_FORMAT "%ul"
#define Int_F "l"
#define UInt_F "ul"
#else
#error Yap require integer types of the same size as a pointer
@ -107,6 +86,8 @@ typedef uint32_t BITS32;
#define CellSize sizeof(CELL)
#define SmallSize sizeof(SMALLUNSGN)
#include "YapFormat.h"
/*************************************************************************************************
type casting macros
*************************************************************************************************/

28
H/YapText.h
View File

@ -31,6 +31,23 @@
#include "../utf8proc/utf8proc.h"
#include "Yap.h"
#define ReleaseAndReturn(r) \
{ \
pop_text_stack(l); \
return r; \
}
#define release_cut_fail() \
{ \
pop_text_stack(l); \
cut_fail(); \
}
#define release_cut_succeed() \
{ \
pop_text_stack(l); \
cut_succeed(); \
}
/// allocate a temporary text block
///
extern void *Malloc(size_t sz USES_REGS);
@ -39,6 +56,8 @@ extern void Free(void *buf USES_REGS);
extern int push_text_stack(USES_REGS1);
extern int pop_text_stack(int lvl USES_REGS);
extern void *protected_pop_text_stack(int lvl, void *safe, bool tmp,
size_t sz USES_REGS);
#ifndef min
#define min(x, y) (x < y ? x : y)
@ -53,6 +72,8 @@ extern int pop_text_stack( int lvl USES_REGS );
#define NUMBER_OF_CHARS 256
extern char *Yap_chtype;
#define Yap_strlen(s) strlen((void *)(s))
typedef enum {
BG = 0, /* initial state */
UC = 1, /* Upper case */
@ -156,10 +177,12 @@ INLINE_ONLY EXTERN inline char_kind_t chtype(Int ch) {
#define __android_log_print(...)
#endif
INLINE_ONLY inline EXTERN utf8proc_ssize_t get_utf8(const utf8proc_uint8_t *ptr, size_t n,
INLINE_ONLY inline EXTERN utf8proc_ssize_t get_utf8(const utf8proc_uint8_t *ptr,
size_t n,
utf8proc_int32_t *valp);
INLINE_ONLY inline EXTERN utf8proc_ssize_t get_utf8(const utf8proc_uint8_t *ptr, size_t n,
INLINE_ONLY inline EXTERN utf8proc_ssize_t get_utf8(const utf8proc_uint8_t *ptr,
size_t n,
utf8proc_int32_t *valp) {
return utf8proc_iterate(ptr, n, valp);
}
@ -1394,7 +1417,6 @@ static inline Atom UTF32ToAtom(const wchar_t *s USES_REGS) {
return out.val.a;
}
static inline Term Yap_WCharsToListOfCodes(const wchar_t *s USES_REGS) {
seq_tv_t inp, out;
inp.val.w0 = s;

7
H/Yapproto.h
View File

@ -13,12 +13,6 @@
* version: $Id: Yapproto.h,v 1.90 2008-08-07 20:51:23 vsc Exp $ *
*************************************************************************/
#if defined(_WIN32)
#define X_API __declspec(dllexport)
#else
#define X_API
#endif
/* prototype file for Yap */
/* absmi.c */
@ -309,6 +303,7 @@ extern struct vfs *Yap_InitAssetManager(void);
/* load_foreign.c */
extern void Yap_InitLoadForeign(void);
extern bool Yap_LateInit(const char s[]);
/* mavar.c */
extern void Yap_InitMaVarCPreds(void);

6
H/absmi.h
View File

@ -139,7 +139,7 @@ register struct yami *P1REG asm("bp"); /* can't use yamop before Yap.h */
#include "Yap.h"
#include "clause.h"
#include "eval.h"
#include "YapEval.h"
#ifdef HAVE_STRING_H
#include <string.h>
#endif
@ -2327,6 +2327,8 @@ static inline void prune(choiceptr cp USES_REGS) {
if (POP_CHOICE_POINT(B->cp_b)) {
POP_EXECUTE();
}
if (B->cp_b == NULL)
break;
B = B->cp_b;
}
if (POP_CHOICE_POINT(B->cp_b)) {
@ -2455,7 +2457,7 @@ extern yamop *headoftrace;
#define Yap_AsmError(e, d) \
{ \
saveregs(); \
Yap_ThrowError(e, d, 4, ""); \
Yap_ThrowError(e, d, "while exwcuting inlined built-in"); \
setregs(); \
}

2
H/blobs.h
View File

@ -11,7 +11,7 @@
#ifndef BLOBS_H
#define BLOBS_H
#ifndef X_API
#if !defined(X_API) && !defined(SWIGYAP)
#if (defined(_MSC_VER) || defined(__MINGW32__)) && defined(PL_KERNEL)
#define X_API __declspec(dllexport)
#else

2
H/generated/dlocals.h
View File

@ -250,6 +250,8 @@
#define LOCAL_nperm LOCAL->nperm_
#define REMOTE_nperm(wid) REMOTE(wid)->nperm_
#define LOCAL_jMP LOCAL->jMP_
#define REMOTE_jMP(wid) REMOTE(wid)->jMP_
#define LOCAL_LabelFirstArray LOCAL->LabelFirstArray_
#define REMOTE_LabelFirstArray(wid) REMOTE(wid)->LabelFirstArray_

7
H/generated/hlocals.h
View File

@ -126,7 +126,7 @@ typedef struct worker_local {
ADDR db_vec0_;
struct RB_red_blk_node* db_root_;
struct RB_red_blk_node* db_nil_;
sigjmp_buf gc_restore_;
sigjmp_buf* gc_restore_;
CELL* extra_gc_cells_;
CELL* extra_gc_cells_base_;
CELL* extra_gc_cells_top_;
@ -140,6 +140,7 @@ typedef struct worker_local {
UInt CMemFirstBlockSz_;
// Variable used by the compiler to store number of permanent vars in a clause
int nperm_;
int jMP_;
// Thread Local Area for Labels
Int* LabelFirstArray_;
UInt LabelFirstArraySz_;
@ -166,7 +167,7 @@ typedef struct worker_local {
/* error handling info, designed to be easy to pass to the foreign world */
yap_error_descriptor_t* ActiveError_;
/// pointer to an exception term, from throw
jmp_buf IOBotch_;
jmp_buf* IOBotch_;
TokEntry* tokptr_;
TokEntry* toktide_;
VarEntry* VarTable_;
@ -177,7 +178,7 @@ typedef struct worker_local {
wchar_t* CommentsBuff_;
size_t CommentsBuffPos_;
size_t CommentsBuffLim_;
sigjmp_buf RestartEnv_;
sigjmp_buf* RestartEnv_;
char FileNameBuf_[YAP_FILENAME_MAX+1];
char FileNameBuf2_[YAP_FILENAME_MAX+1];
struct TextBuffer_manager* TextBuffer_;

5
H/generated/iatoms.h
View File

@ -90,7 +90,7 @@
AtomCurrentModule = Yap_FullLookupAtom("$current_module"); TermCurrentModule = MkAtomTerm(AtomCurrentModule);
AtomCut = Yap_LookupAtom("!"); TermCut = MkAtomTerm(AtomCut);
AtomCutBy = Yap_FullLookupAtom("$cut_by"); TermCutBy = MkAtomTerm(AtomCutBy);
AtomDAbort = Yap_FullLookupAtom("$abort"); TermDAbort = MkAtomTerm(AtomDAbort);
AtomDAbort = Yap_LookupAtom("abort"); TermDAbort = MkAtomTerm(AtomDAbort);
AtomDBLoad = Yap_FullLookupAtom("$db_load"); TermDBLoad = MkAtomTerm(AtomDBLoad);
AtomDBREF = Yap_LookupAtom("DBRef"); TermDBREF = MkAtomTerm(AtomDBREF);
AtomDBReference = Yap_LookupAtom("db_reference"); TermDBReference = MkAtomTerm(AtomDBReference);
@ -289,6 +289,7 @@
AtomPermissionError = Yap_LookupAtom("permission_error"); TermPermissionError = MkAtomTerm(AtomPermissionError);
AtomPi = Yap_LookupAtom("pi"); TermPi = MkAtomTerm(AtomPi);
AtomPipe = Yap_LookupAtom("pipe"); TermPipe = MkAtomTerm(AtomPipe);
AtomPriority = Yap_LookupAtom("priority"); TermPriority = MkAtomTerm(AtomPriority);
AtomPlus = Yap_LookupAtom("+"); TermPlus = MkAtomTerm(AtomPlus);
AtomPointer = Yap_LookupAtom("pointer"); TermPointer = MkAtomTerm(AtomPointer);
AtomPortray = Yap_FullLookupAtom("portray"); TermPortray = MkAtomTerm(AtomPortray);
@ -541,11 +542,13 @@
FunctorNot = Yap_MkFunctor(AtomNot,1);
FunctorObj = Yap_MkFunctor(AtomObj,1);
FunctorOr = Yap_MkFunctor(AtomSemic,2);
FunctorOutput = Yap_MkFunctor(AtomOutput,1);
FunctorPermissionError = Yap_MkFunctor(AtomPermissionError,3);
FunctorPlus = Yap_MkFunctor(AtomPlus,2);
FunctorPortray = Yap_MkFunctor(AtomPortray,1);
FunctorPrintMessage = Yap_MkFunctor(AtomPrintMessage,2);
FunctorProcedure = Yap_MkFunctor(AtomProcedure,5);
FunctorPriority = Yap_MkFunctor(AtomPriority,1);
FunctorPrologConstraint = Yap_MkFunctor(AtomProlog,2);
FunctorProtectStack = Yap_MkFunctor(AtomProtectStack,4);
FunctorQuery = Yap_MkFunctor(AtomQuery,1);

3
H/generated/ilocals.h
View File

@ -139,7 +139,8 @@ static void InitWorker(int wid) {
REMOTE_CMemFirstBlock(wid) = NULL;
REMOTE_CMemFirstBlockSz(wid) = 0L;
REMOTE_nperm(wid) = 0L;
REMOTE_nperm(wid) = 0;
REMOTE_jMP(wid) = 0;
REMOTE_LabelFirstArray(wid) = NULL;
REMOTE_LabelFirstArraySz(wid) = 0L;

3
H/generated/ratoms.h
View File

@ -289,6 +289,7 @@
AtomPermissionError = AtomAdjust(AtomPermissionError); TermPermissionError = MkAtomTerm(AtomPermissionError);
AtomPi = AtomAdjust(AtomPi); TermPi = MkAtomTerm(AtomPi);
AtomPipe = AtomAdjust(AtomPipe); TermPipe = MkAtomTerm(AtomPipe);
AtomPriority = AtomAdjust(AtomPriority); TermPriority = MkAtomTerm(AtomPriority);
AtomPlus = AtomAdjust(AtomPlus); TermPlus = MkAtomTerm(AtomPlus);
AtomPointer = AtomAdjust(AtomPointer); TermPointer = MkAtomTerm(AtomPointer);
AtomPortray = AtomAdjust(AtomPortray); TermPortray = MkAtomTerm(AtomPortray);
@ -541,11 +542,13 @@
FunctorNot = FuncAdjust(FunctorNot);
FunctorObj = FuncAdjust(FunctorObj);
FunctorOr = FuncAdjust(FunctorOr);
FunctorOutput = FuncAdjust(FunctorOutput);
FunctorPermissionError = FuncAdjust(FunctorPermissionError);
FunctorPlus = FuncAdjust(FunctorPlus);
FunctorPortray = FuncAdjust(FunctorPortray);
FunctorPrintMessage = FuncAdjust(FunctorPrintMessage);
FunctorProcedure = FuncAdjust(FunctorProcedure);
FunctorPriority = FuncAdjust(FunctorPriority);
FunctorPrologConstraint = FuncAdjust(FunctorPrologConstraint);
FunctorProtectStack = FuncAdjust(FunctorProtectStack);
FunctorQuery = FuncAdjust(FunctorQuery);

1
H/generated/rlocals.h
View File

@ -145,6 +145,7 @@ static void RestoreWorker(int wid USES_REGS) {
#ifdef THREADS
#endif /* THREADS */

1592
H/generated/tatoms.h
View File

File diff suppressed because it is too large Load Diff

6
H/tracer.h
View File

@ -38,8 +38,8 @@ typedef enum {
#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 toggle_low_level_trace(void);
extern bool low_level_trace__(yap_low_level_port, PredEntry *, CELL *);
extern void Yap_InitLowLevelTrace(void);
extern void toggle_low_level_trace(void);
#endif

2
JIT/HPP/jit_predicates.hpp
View File

@ -1,7 +1,7 @@
#include "Yap.h"
#include "amijit.h"
#include "clause.h"
#include "eval.h"
#include "YapEval.h"
#if HAVE_ERRNO_H
#include <errno.h>
#else

5
OPTYap/CMakeLists.txt
View File

@ -76,16 +76,17 @@ endif (WITH_YAPOR_SBA)
if (WITH_YAPOR)
set_property(DIRECTORY .. APPEND PROPERTY COMPILE_DEFINITIONS YAPOR=1)
set_property(DIRECTORY .. APPEND PROPERTY COMPILE_DEFINITIONS YAPOR=1;YAP_KERNEL=1)
endif ()
set (POSITION_INDEPENDENT_CODE TRUE)
SET_PROPERTY(DIRECTORY PROPERTY COMPILE_DEFINITIONS YAP_KERNEL=1 )
add_component (libOPTYap
${OPTYap_SOURCES} )
MY_set_target_properties(libOPTYap
My_set_target_properties(libOPTYap
PROPERTIES
# RPATH ${libdir} VERSION ${LIBYAPTAI_FULL_VERSION}
# SOVERSION ${LIBYAPTAI_MAJOR_VERSION}.${LIBYAPTAI_MINOR_VERSION}

2
OPTYap/opt.preds.c
View File

@ -170,7 +170,7 @@ struct page_statistics {
#define INCREMENT_AUX_STATS(STATS, BYTES, PAGES) \
BYTES += PgEnt_bytes_in_use(STATS)
#define SHOW_PAGE_STATS_MSG(STR_NAME) \
" %s %10" Int_F "s bytes (%ld structs in use)\n", STR_NAME
" %s %10" Int_F "s bytes (%" Sizet_F " ; structs in use)\n", STR_NAME
#define SHOW_PAGE_STATS_ARGS(STATS, STR_TYPE) \
PgEnt_strs_in_use(STATS) * sizeof(STR_TYPE), PgEnt_strs_in_use(STATS)
#endif /* USE_PAGES_MALLOC */

Some files were not shown because too many files have changed in this diff Show More