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

less invasive error handling

Browse Source
This commit is contained in:
Vitor Santos Costa 2016-10-19 22:44:59 -05:00
parent 8a6de8b157
commit d082af605d
44 changed files with 4258 additions and 5045 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

7
C/absmi_insts.i
View File

@ -8160,12 +8160,7 @@
saveregs();
d0 = p_plus(Yap_Eval(d0), Yap_Eval(d1) PASS_REGS);
setregs();
if (d0 == 0L) {
saveregs();
Yap_PreProcessedError(LOCAL_Error_TYPE, LOCAL_Error_Term, LOCAL_ErrorMessage);
setregs();
FAIL();
}
}
XREG(PREG->y_u.xxx.x) = d0;
PREG = NEXTOP(PREG, xxx);

51
C/atomic.c
View File

@ -527,18 +527,23 @@ static Int number_chars(USES_REGS1) {
restart_aux:
t1 = Deref(ARG1);
if (IsNumTerm(t1)) {
Term tf;
tf = Yap_NumberToListOfAtoms(t1 PASS_REGS);
if (tf) {
LOCAL_Error_TYPE = YAP_NO_ERROR;
return Yap_unify(ARG2, tf);
Term t2 = Deref(ARG2);
if (IsVarTerm(t2)) {
t1 = Yap_NumberToListOfAtoms(t1 PASS_REGS);
}
if (t1) {
return Yap_unify(t1, t2);
} else {
t2 = Yap_ListToNumber(t2 PASS_REGS);
if (t2) {
return Yap_unify(t1, t2);
}
}
} else if (IsVarTerm(t1)) {
/* ARG1 unbound */
Term t = Deref(ARG2);
Term tf = Yap_ListToNumber(t PASS_REGS);
if (tf) {
LOCAL_Error_TYPE = YAP_NO_ERROR;
return Yap_unify(ARG1, tf);
}
} else if (IsVarTerm(t1)) {
@ -556,15 +561,24 @@ static Int number_atom(USES_REGS1) {
restart_aux:
t1 = Deref(ARG1);
if (IsNumTerm(t1)) {
Term t2 = Deref(ARG2);
Atom af;
af = Yap_NumberToAtom(t1 PASS_REGS);
if (af)
return Yap_unify(ARG2, MkAtomTerm(af));
if (af) {
if (IsVarTerm(t2)) {
return Yap_unify(t1, t2);
} else {
t2 = Yap_AtomToNumber(t2 PASS_REGS);
if (t2) {
return Yap_unify(t1, t2);
}
}
}
} else if (IsVarTerm(t1)) {
/* ARG1 unbound */
Term t = Deref(ARG2);
Term tf = Yap_AtomToNumber(t PASS_REGS);
if (tf)
return Yap_unify(ARG1, tf);
} else if (IsVarTerm(t1)) {
LOCAL_Error_TYPE = TYPE_ERROR_NUMBER;
@ -634,8 +648,8 @@ restart_aux:
i = IntOfTerm(EXTRA_CBACK_ARG(3, 1));
max = IntOfTerm(EXTRA_CBACK_ARG(3, 2));
EXTRA_CBACK_ARG(3, 1) = MkIntTerm(i + 1);
if (!Yap_SpliceAtom(t3, ats, i, max PASS_REGS) && LOCAL_Error_TYPE ==
YAP_NO_ERROR) {
if (!Yap_SpliceAtom(t3, ats, i, max PASS_REGS) &&
LOCAL_Error_TYPE == YAP_NO_ERROR) {
cut_fail();
} else {
if (i < max)
@ -684,7 +698,6 @@ restart_aux:
return cont_atom_concat3(PASS_REGS1);
} else {
LOCAL_Error_TYPE = INSTANTIATION_ERROR;
LOCAL_Error_Term = t1;
at = NULL;
}
if (at) {
@ -704,7 +717,6 @@ restart_aux:
cut_fail();
}
#define CastToNumeric(x) CastToNumeric__(x PASS_REGS)
static Term CastToNumeric__(Atom at USES_REGS) {
@ -772,7 +784,6 @@ restart_aux:
return cont_atomic_concat3(PASS_REGS1);
} else {
LOCAL_Error_TYPE = INSTANTIATION_ERROR;
LOCAL_Error_Term = t1;
at = NULL;
}
if (at) {
@ -849,7 +860,6 @@ restart_aux:
return cont_string_concat3(PASS_REGS1);
} else {
LOCAL_Error_TYPE = INSTANTIATION_ERROR;
LOCAL_Error_Term = t1;
at = NULL;
}
if (tf) {
@ -913,10 +923,8 @@ restart_aux:
t2 = Deref(ARG2);
if (IsVarTerm(t2)) {
LOCAL_Error_TYPE = INSTANTIATION_ERROR;
LOCAL_Error_Term = t2;
} else if (!IsStringTerm(t2)) {
LOCAL_Error_TYPE = TYPE_ERROR_STRING;
LOCAL_Error_Term = t2;
} else {
s = UStringOfTerm(t2);
t1 = Deref(ARG1);
@ -926,7 +934,6 @@ restart_aux:
return cont_string_code3(PASS_REGS1);
} else if (!IsIntegerTerm(t1)) {
LOCAL_Error_TYPE = TYPE_ERROR_INTEGER;
LOCAL_Error_Term = t1;
} else {
const unsigned char *ns = s;
utf8proc_int32_t chr;
@ -934,7 +941,6 @@ restart_aux:
if (indx <= 0) {
if (indx < 0) {
LOCAL_Error_TYPE = DOMAIN_ERROR_NOT_LESS_THAN_ZERO;
LOCAL_Error_Term = t1;
}
cut_fail();
}
@ -970,19 +976,16 @@ restart_aux:
t2 = Deref(ARG2);
if (IsVarTerm(t2)) {
LOCAL_Error_TYPE = INSTANTIATION_ERROR;
LOCAL_Error_Term = t2;
} else if (!IsStringTerm(t2)) {
LOCAL_Error_TYPE = TYPE_ERROR_STRING;
LOCAL_Error_Term = t2;
} else {
s = UStringOfTerm(t2);
t1 = Deref(ARG1);
if (IsVarTerm(t1)) {
LOCAL_Error_TYPE = INSTANTIATION_ERROR;
LOCAL_Error_Term = t1;
} else if (!IsIntegerTerm(t1)) {
LOCAL_Error_TYPE = TYPE_ERROR_INTEGER;
LOCAL_Error_Term = t1;
} else {
const unsigned char *ns = s;
utf8proc_int32_t chr;
@ -991,7 +994,6 @@ restart_aux:
if (indx <= 0) {
if (indx < 0) {
LOCAL_Error_TYPE = DOMAIN_ERROR_NOT_LESS_THAN_ZERO;
LOCAL_Error_Term = t1;
} else {
return false;
}
@ -1813,7 +1815,6 @@ static Term build_new_atomic(int mask, wchar_t *wp, const unsigned char *p,
src = skip_utf8((unsigned char *)src, min);
const unsigned char *cp = src;
LOCAL_TERM_ERROR(t, 4 * (len + 1));
buf = buf_from_tstring(HR);
while (len) {
utf8proc_int32_t chr;

9
C/cdmgr.c
View File

@ -1452,8 +1452,6 @@ static void addcl_permission_error(AtomEntry *ap, Int Arity, int in_use) {
ti[0] = MkAtomTerm(AbsAtom(ap));
ti[1] = MkIntegerTerm(Arity);
t = Yap_MkApplTerm(FunctorSlash, 2, ti);
LOCAL_ErrorMessage = LOCAL_ErrorSay;
LOCAL_Error_Term = t;
LOCAL_Error_TYPE = PERMISSION_ERROR_MODIFY_STATIC_PROCEDURE;
if (in_use) {
if (Arity == 0)
@ -2028,9 +2026,7 @@ static Int p_compile(USES_REGS1) { /* '$compile'(+C,+Flags,+C0,-Ref) */
YAPLeaveCriticalSection();
}
if (LOCAL_ErrorMessage) {
if (!LOCAL_Error_Term)
LOCAL_Error_Term = TermNil;
Yap_Error(LOCAL_Error_TYPE, LOCAL_Error_Term, LOCAL_ErrorMessage);
Yap_Error(LOCAL_Error_TYPE, ARG1, LOCAL_ErrorMessage);
YAPLeaveCriticalSection();
return false;
}
@ -3590,7 +3586,8 @@ static Int p_predicate_erased_statistics(USES_REGS1) {
Term tpred = ArgOfTerm(2, Deref(ARG1));
Term tmod = ArgOfTerm(1, Deref(ARG1));
if (EndOfPAEntr(pe = Yap_get_pred(tpred, tmod, "predicate_erased_statistics")))
if (EndOfPAEntr(pe =
Yap_get_pred(tpred, tmod, "predicate_erased_statistics")))
return FALSE;
while (cl) {
if (cl->ClPred == pe) {

208
C/cmppreds.c
View File

@ -18,8 +18,6 @@
/// @file cmppreds.c
/**
@defgroup Comparing_Terms Comparing Terms
@ingroup builtins
@ -52,14 +50,13 @@ left-to-right order.
*/
#ifdef SCCS
static char SccsId[] = "%W% %G%";
#endif
#include "Yap.h"
#include "Yatom.h"
#include "YapHeap.h"
#include "Yatom.h"
#include "eval.h"
#if HAVE_STRING_H
#include <string.h>
@ -83,19 +80,19 @@ static Int a_gen_ge(Term,Term);
#define rfloat(X) (X > 0.0 ? 1 : (X == 0.0 ? 0 : -1))
static int
cmp_atoms(Atom a1, Atom a2)
{
static int cmp_atoms(Atom a1, Atom a2) {
if (IsWideAtom(a1)) {
if (IsWideAtom(a2)) {
return wcscmp((wchar_t *)RepAtom(a1)->StrOfAE,(wchar_t *)RepAtom(a2)->StrOfAE);
return wcscmp((wchar_t *)RepAtom(a1)->StrOfAE,
(wchar_t *)RepAtom(a2)->StrOfAE);
} else {
/* The standard does not seem to have nothing on this */
unsigned char *s1 = (unsigned char *)RepAtom(a1)->StrOfAE;
wchar_t *s2 = (wchar_t *)RepAtom(a2)->StrOfAE;
while (*s1 == *s2) {
if (!*s1) return 0;
if (!*s1)
return 0;
s1++;
s2++;
}
@ -107,7 +104,8 @@ cmp_atoms(Atom a1, Atom a2)
unsigned char *s2 = (unsigned char *)RepAtom(a2)->StrOfAE;
while (*s1 == *s2) {
if (!*s1) return 0;
if (!*s1)
return 0;
s1++;
s2++;
}
@ -117,9 +115,8 @@ cmp_atoms(Atom a1, Atom a2)
}
}
static Int compare_complex(register CELL *pt0, register CELL *pt0_end, register
CELL *pt1)
{
static Int compare_complex(register CELL *pt0, register CELL *pt0_end,
register CELL *pt1) {
CACHE_REGS
register CELL **to_visit = (CELL **)HR;
register Int out = 0;
@ -134,9 +131,9 @@ static Int compare_complex(register CELL *pt0, register CELL *pt0_end, register
if (IsVarTerm(d0)) {
if (IsVarTerm(d1)) {
out = Signed(d0) - Signed(d1);
if (out) goto done;
}
else {
if (out)
goto done;
} else {
out = -1;
goto done;
}
@ -144,17 +141,18 @@ static Int compare_complex(register CELL *pt0, register CELL *pt0_end, register
out = 1;
goto done;
} else {
if (d0 == d1) continue;
if (d0 == d1)
continue;
else if (IsAtomTerm(d0)) {
if (IsAtomTerm(d1))
out = cmp_atoms(AtomOfTerm(d0), AtomOfTerm(d1));
else if (IsPrimitiveTerm(d1))
out = 1;
else out = -1;
else
out = -1;
/* I know out must be != 0 */
goto done;
}
else if (IsIntTerm(d0)) {
} else if (IsIntTerm(d0)) {
if (IsIntTerm(d1))
out = IntOfTerm(d0) - IntOfTerm(d1);
else if (IsFloatTerm(d1)) {
@ -167,7 +165,8 @@ static Int compare_complex(register CELL *pt0, register CELL *pt0_end, register
#endif
} else if (IsRefTerm(d1))
out = 1;
else out = -1;
else
out = -1;
if (out != 0)
goto done;
} else if (IsFloatTerm(d0)) {
@ -231,7 +230,8 @@ static Int compare_complex(register CELL *pt0, register CELL *pt0_end, register
out = Yap_gmp_tcmp_big_big(d0, d1);
} else if (IsRefTerm(d1))
out = 1;
else out = -1;
else
out = -1;
if (out != 0)
goto done;
}
@ -244,7 +244,8 @@ static Int compare_complex(register CELL *pt0, register CELL *pt0_end, register
out = 1;
else if (!(out = 2 - ArityOfFunctor(f)))
out = strcmp(".", (char *)RepAtom(NameOfFunctor(f))->StrOfAE);
} else out = 1;
} else
out = 1;
goto done;
}
#ifdef RATIONAL_TREES
@ -267,12 +268,11 @@ static Int compare_complex(register CELL *pt0, register CELL *pt0_end, register
pt0_end = RepPair(d0) + 1;
pt1 = RepPair(d1) - 1;
continue;
}
else if (IsRefTerm(d0)) {
} else if (IsRefTerm(d0)) {
if (IsRefTerm(d1))
out = Unsigned(RefOfTerm(d1)) -
Unsigned(RefOfTerm(d0));
else out = -1;
out = Unsigned(RefOfTerm(d1)) - Unsigned(RefOfTerm(d0));
else
out = -1;
goto done;
} else if (IsApplTerm(d0)) {
register Functor f;
@ -324,7 +324,6 @@ static Int compare_complex(register CELL *pt0, register CELL *pt0_end, register
continue;
}
}
}
}
/* Do we still have compound terms to visit */
@ -358,8 +357,7 @@ static Int compare_complex(register CELL *pt0, register CELL *pt0_end, register
return (out);
}
inline static Int
compare(Term t1, Term t2) /* compare terms t1 and t2 */
inline static Int compare(Term t1, Term t2) /* compare terms t1 and t2 */
{
if (t1 == t2)
@ -417,11 +415,10 @@ compare(Term t1, Term t2) /* compare terms t1 and t2 */
}
}
if (IsPairTerm(t2)) {
return(compare_complex(RepPair(t1)-1,
RepPair(t1)+1,
RepPair(t2)-1));
}
else return 1;
return (
compare_complex(RepPair(t1) - 1, RepPair(t1) + 1, RepPair(t2) - 1));
} else
return 1;
} else {
/* compound term */
Functor fun1 = FunctorOfTerm(t1);
@ -429,16 +426,14 @@ compare(Term t1, Term t2) /* compare terms t1 and t2 */
if (IsExtensionFunctor(fun1)) {
/* float, long, big, dbref */
switch ((CELL)fun1) {
case double_e:
{
case double_e: {
if (IsFloatTerm(t2))
return (rfloat(FloatOfTerm(t1) - FloatOfTerm(t2)));
if (IsRefTerm(t2))
return 1;
return -1;
}
case long_int_e:
{
case long_int_e: {
if (IsIntTerm(t2))
return LongIntOfTerm(t1) - IntOfTerm(t2);
if (IsFloatTerm(t2)) {
@ -456,8 +451,7 @@ compare(Term t1, Term t2) /* compare terms t1 and t2 */
return -1;
}
#ifdef USE_GMP
case big_int_e:
{
case big_int_e: {
if (IsIntTerm(t2))
return Yap_gmp_tcmp_big_int(t1, IntOfTerm(t2));
if (IsFloatTerm(t2)) {
@ -473,8 +467,7 @@ compare(Term t1, Term t2) /* compare terms t1 and t2 */
return -1;
}
#endif
case string_e:
{
case string_e: {
if (IsApplTerm(t2)) {
Functor fun2 = FunctorOfTerm(t2);
switch ((CELL)fun2) {
@ -497,8 +490,7 @@ compare(Term t1, Term t2) /* compare terms t1 and t2 */
}
case db_ref_e:
if (IsRefTerm(t2))
return Unsigned(RefOfTerm(t2)) -
Unsigned(RefOfTerm(t1));
return Unsigned(RefOfTerm(t2)) - Unsigned(RefOfTerm(t1));
return -1;
}
}
@ -526,15 +518,13 @@ compare(Term t1, Term t2) /* compare terms t1 and t2 */
if (r)
return r;
else
return(compare_complex(RepAppl(t1),
RepAppl(t1)+ArityOfFunctor(fun1),
return (compare_complex(RepAppl(t1), RepAppl(t1) + ArityOfFunctor(fun1),
RepAppl(t2)));
}
}
}
Int Yap_compare_terms(Term d0, Term d1)
{
Int Yap_compare_terms(Term d0, Term d1) {
return compare(Deref(d0), Deref(d1));
}
@ -552,9 +542,7 @@ the following values:
`>` if _Y_ precedes _X_ in the defined order;
*/
Int
p_compare( USES_REGS1 )
{ /* compare(?Op,?T1,?T2) */
Int p_compare(USES_REGS1) { /* compare(?Op,?T1,?T2) */
Int r = compare(Deref(ARG2), Deref(ARG3));
Atom p;
Term t = Deref(ARG1);
@ -569,9 +557,7 @@ p_compare( USES_REGS1 )
Atom a = AtomOfTerm(t);
if (a == p)
return true;
if (a != AtomLT &&
a != AtomGT &&
a != AtomEq)
if (a != AtomLT && a != AtomGT && a != AtomEq)
Yap_Error(DOMAIN_ERROR_ORDER, ARG1, NULL);
} else {
Yap_Error(TYPE_ERROR_ATOM, ARG1, NULL);
@ -582,22 +568,13 @@ p_compare( USES_REGS1 )
return Yap_unify_constant(ARG1, MkAtomTerm(p));
}
/** @pred _X_ \== _Y_ is iso
Terms _X_ and _Y_ are not strictly identical.
*/
static Int
a_noteq(Term t1, Term t2)
{
return (compare(t1, t2) != 0);
}
static Int a_noteq(Term t1, Term t2) { return (compare(t1, t2) != 0); }
static Int
a_gen_lt(Term t1, Term t2)
{
return (compare(t1, t2) < 0);
}
static Int a_gen_lt(Term t1, Term t2) { return (compare(t1, t2) < 0); }
/** @pred _X_ @=< _Y_ is iso
@ -605,33 +582,20 @@ a_gen_lt(Term t1, Term t2)
Term _X_ does not follow term _Y_ in the standard order.
*/
static Int
a_gen_le(Term t1, Term t2)
{
return (compare(t1, t2) <= 0);
}
static Int a_gen_le(Term t1, Term t2) { return (compare(t1, t2) <= 0); }
/** @pred _X_ @> _Y_ is iso
Term _X_ does not follow term _Y_ in the standard order
*/
static Int
a_gen_gt(Term t1, Term t2)
{
return compare(t1, t2) > 0;
}
static Int a_gen_gt(Term t1, Term t2) { return compare(t1, t2) > 0; }
/** @pred _X_ @>= _Y_ is iso
Term _X_ does not precede term _Y_ in the standard order.
*/
static Int
a_gen_ge(Term t1, Term t2)
{
return compare(t1, t2) >= 0;
}
static Int a_gen_ge(Term t1, Term t2) { return compare(t1, t2) >= 0; }
/**
@}
@ -642,19 +606,14 @@ a_gen_ge(Term t1, Term t2)
@defgroup arithmetic_cmps Arithmetic Comparison Predicates
@ingroup arithmetic
Comparison of Numeric Expressions. Both arguments must be valid ground expressions at time of call.
Comparison of Numeric Expressions. Both arguments must be valid ground
expressions at time of call.
@{
*/
inline static Int
int_cmp(Int dif)
{
return dif;
}
inline static Int int_cmp(Int dif) { return dif; }
inline static Int
flt_cmp(Float dif)
{
inline static Int flt_cmp(Float dif) {
if (dif < 0.0)
return -1;
if (dif > 0.0)
@ -662,18 +621,12 @@ flt_cmp(Float dif)
return dif = 0.0;
}
static inline Int
a_cmp(Term t1, Term t2 USES_REGS)
{
LOCAL_ArithError = FALSE;
static inline Int a_cmp(Term t1, Term t2 USES_REGS) {
if (IsVarTerm(t1)) {
LOCAL_ArithError = TRUE;
Yap_Error(INSTANTIATION_ERROR, t1, "=:=/2");
return FALSE;
}
if (IsVarTerm(t2)) {
LOCAL_ArithError = TRUE;
Yap_Error(INSTANTIATION_ERROR, t2, "=:=/2");
return FALSE;
}
@ -699,9 +652,7 @@ a_cmp(Term t1, Term t2 USES_REGS)
#if HAVE_ISNAN
if (isnan(f2)) {
LOCAL_Error_TYPE = EVALUATION_ERROR_UNDEFINED;
LOCAL_Error_Term = t2;
LOCAL_ErrorMessage = "trying to evaluate nan";
LOCAL_ArithError = TRUE;
}
#endif
return flt_cmp(i1 - f2);
@ -717,9 +668,7 @@ a_cmp(Term t1, Term t2 USES_REGS)
#if HAVE_ISNAN
if (isnan(f1)) {
LOCAL_Error_TYPE = EVALUATION_ERROR_UNDEFINED;
LOCAL_Error_Term = t1;
LOCAL_ErrorMessage = "trying to evaluate nan";
LOCAL_ArithError = TRUE;
}
#endif
t2 = Yap_Eval(t2);
@ -736,9 +685,7 @@ a_cmp(Term t1, Term t2 USES_REGS)
#if HAVE_ISNAN
if (isnan(f2)) {
LOCAL_Error_TYPE = EVALUATION_ERROR_UNDEFINED;
LOCAL_Error_Term = t2;
LOCAL_ErrorMessage = "trying to evaluate nan";
LOCAL_ArithError = TRUE;
}
#endif
return flt_cmp(f1 - f2);
@ -761,9 +708,7 @@ a_cmp(Term t1, Term t2 USES_REGS)
#if HAVE_ISNAN
if (isnan(f2)) {
LOCAL_Error_TYPE = EVALUATION_ERROR_UNDEFINED;
LOCAL_Error_Term = t2;
LOCAL_ErrorMessage = "trying to evaluate nan";
LOCAL_ArithError = TRUE;
}
#endif
return Yap_gmp_cmp_big_float(t1, f2);
@ -779,23 +724,17 @@ a_cmp(Term t1, Term t2 USES_REGS)
}
}
Int
Yap_acmp(Term t1, Term t2 USES_REGS)
{
Int Yap_acmp(Term t1, Term t2 USES_REGS) {
Int out = a_cmp(t1, t2 PASS_REGS);
if (LOCAL_ArithError) { Yap_Error(LOCAL_Error_TYPE, LOCAL_Error_Term, LOCAL_ErrorMessage); return FALSE; }
return out;
}
static Int
p_acomp( USES_REGS1 )
{ /* $a_compare(?R,+X,+Y) */
static Int p_acomp(USES_REGS1) { /* $a_compare(?R,+X,+Y) */
Term t1 = Deref(ARG1);
Term t2 = Deref(ARG2);
Int out;
out = a_cmp(t1, t2 PASS_REGS);
if (LOCAL_ArithError) { Yap_Error(LOCAL_Error_TYPE, LOCAL_Error_Term, LOCAL_ErrorMessage); return FALSE; }
return out;
}
@ -806,9 +745,7 @@ p_acomp( USES_REGS1 )
The value of the expression _X_ is equal to the value of expression _Y_.
*/
/// @memberof =:=/2
static Int
a_eq(Term t1, Term t2)
{
static Int a_eq(Term t1, Term t2) {
CACHE_REGS
/* A =:= B */
Int out;
@ -838,24 +775,21 @@ a_eq(Term t1, Term t2)
}
}
out = a_cmp(t1, t2 PASS_REGS);
if (LOCAL_ArithError) { Yap_Error(LOCAL_Error_TYPE, LOCAL_Error_Term, LOCAL_ErrorMessage); return FALSE; }
Yap_Error(LOCAL_Error_TYPE, t1, LOCAL_ErrorMessage);
return out == 0;
}
/*
@pred +_X_ =\\= _Y_ is iso
Difference of arithmetic expressions
The value of the expression _X_ is different from the value of expression _Y_.
The value of the expression _X_ is different from the value of expression
_Y_.
*/
/// @memberof =\\=/2
static Int
a_dif(Term t1, Term t2)
{
static Int a_dif(Term t1, Term t2) {
CACHE_REGS
Int out = a_cmp(Deref(t1), Deref(t2) PASS_REGS);
if (LOCAL_ArithError) { Yap_Error(LOCAL_Error_TYPE, LOCAL_Error_Term, LOCAL_ErrorMessage); return FALSE; }
return out != 0;
}
@ -866,12 +800,9 @@ a_dif(Term t1, Term t2)
The value of the expression _X_ is less than or equal to the value
of expression _Y_.
*/
static Int
a_gt(Term t1, Term t2)
{ /* A > B */
static Int a_gt(Term t1, Term t2) { /* A > B */
CACHE_REGS
Int out = a_cmp(Deref(t1), Deref(t2) PASS_REGS);
if (LOCAL_ArithError) { Yap_Error(LOCAL_Error_TYPE, LOCAL_Error_Term, LOCAL_ErrorMessage); return FALSE; }
return out > 0;
}
@ -882,12 +813,9 @@ a_gt(Term t1, Term t2)
The value of the expression _X_ is greater than or equal to the
value of expression _Y_.
*/
static Int
a_ge(Term t1, Term t2)
{ /* A >= B */
static Int a_ge(Term t1, Term t2) { /* A >= B */
CACHE_REGS
Int out = a_cmp(Deref(t1), Deref(t2) PASS_REGS);
if (LOCAL_ArithError) { Yap_Error(LOCAL_Error_TYPE, LOCAL_Error_Term, LOCAL_ErrorMessage); return FALSE; }
return out >= 0;
}
@ -899,12 +827,9 @@ a_ge(Term t1, Term t2)
_Y_.
*/
/// @memberof </2
static Int
a_lt(Term t1, Term t2)
{ /* A < B */
static Int a_lt(Term t1, Term t2) { /* A < B */
CACHE_REGS
Int out = a_cmp(Deref(t1), Deref(t2) PASS_REGS);
if (LOCAL_ArithError) { Yap_Error(LOCAL_Error_TYPE, LOCAL_Error_Term, LOCAL_ErrorMessage); return FALSE; }
return out < 0;
}
@ -918,12 +843,9 @@ a_lt(Term t1, Term t2)
of expression _Y_.
*/
/// @memberof =</2
static Int
a_le(Term t1, Term t2)
{ /* A <= B */
static Int a_le(Term t1, Term t2) { /* A <= B */
CACHE_REGS
Int out = a_cmp(Deref(t1), Deref(t2) PASS_REGS);
if (LOCAL_ArithError) { Yap_Error(LOCAL_Error_TYPE, LOCAL_Error_Term, LOCAL_ErrorMessage); return FALSE; }
return out <= 0;
}
@ -931,9 +853,7 @@ a_le(Term t1, Term t2)
@}
*/
void
Yap_InitCmpPreds(void)
{
void Yap_InitCmpPreds(void) {
Yap_InitCmpPred("=:=", 2, a_eq, SafePredFlag | BinaryPredFlag);
Yap_InitCmpPred("=\\=", 2, a_dif, SafePredFlag | BinaryPredFlag);
Yap_InitCmpPred(">", 2, a_gt, SafePredFlag | BinaryPredFlag);

817
C/compiler.c
View File

File diff suppressed because it is too large Load Diff

12
C/dbase.c
View File

@ -336,19 +336,18 @@ static int recover_from_record_error(int nargs) {
goto recover_record;
case RESOURCE_ERROR_HEAP:
if (!Yap_growheap(FALSE, LOCAL_Error_Size, NULL)) {
Yap_Error(RESOURCE_ERROR_HEAP, LOCAL_Error_Term, LOCAL_ErrorMessage);
Yap_Error(RESOURCE_ERROR_HEAP, TermNil, LOCAL_ErrorMessage);
return FALSE;
}
goto recover_record;
case RESOURCE_ERROR_AUXILIARY_STACK:
if (!Yap_ExpandPreAllocCodeSpace(LOCAL_Error_Size, NULL, TRUE)) {
Yap_Error(RESOURCE_ERROR_AUXILIARY_STACK, LOCAL_Error_Term,
LOCAL_ErrorMessage);
Yap_Error(RESOURCE_ERROR_AUXILIARY_STACK, TermNil, LOCAL_ErrorMessage);
return FALSE;
}
goto recover_record;
default:
Yap_Error(LOCAL_Error_TYPE, LOCAL_Error_Term, LOCAL_ErrorMessage);
Yap_Error(LOCAL_Error_TYPE, TermNil, LOCAL_ErrorMessage);
return FALSE;
}
recover_record:
@ -1121,7 +1120,6 @@ static void sf_include(SFKeep *sfp, struct db_globs *dbg) SFKeep *sfp;
j += 2;
} else {
LOCAL_Error_TYPE = TYPE_ERROR_DBTERM;
LOCAL_Error_Term = d0;
LOCAL_ErrorMessage = "wrong term in SF";
return (NULL);
}
@ -1242,7 +1240,6 @@ static DBRef generate_dberror_msg(int errnumb, UInt sz, char *msg) {
CACHE_REGS
LOCAL_Error_Size = sz;
LOCAL_Error_TYPE = errnumb;
LOCAL_Error_Term = TermNil;
LOCAL_ErrorMessage = msg;
return NULL;
}
@ -2611,7 +2608,6 @@ static int resize_int_keys(UInt new_size) {
if (new == NULL) {
YAPLeaveCriticalSection();
LOCAL_Error_TYPE = RESOURCE_ERROR_HEAP;
LOCAL_Error_Term = TermNil;
LOCAL_ErrorMessage = "could not allocate space";
return FALSE;
}
@ -2693,7 +2689,6 @@ static PredEntry *new_lu_int_key(Int key) {
if (INT_LU_KEYS == NULL) {
CACHE_REGS
LOCAL_Error_TYPE = RESOURCE_ERROR_HEAP;
LOCAL_Error_Term = TermNil;
LOCAL_ErrorMessage = "could not allocate space";
return NULL;
}
@ -2825,7 +2820,6 @@ static DBProp FetchIntDBPropFromKey(Int key, int flag, int new,
if (INT_KEYS == NULL) {
CACHE_REGS
LOCAL_Error_TYPE = RESOURCE_ERROR_HEAP;
LOCAL_Error_Term = TermNil;
LOCAL_ErrorMessage = "could not allocate space";
return NULL;
}

66
C/errors.c
View File

@ -74,16 +74,17 @@ bool Yap_Warning(const char *s, ...) {
return rc;
}
void Yap_InitError(yap_error_number e, Term t, const char *msg) {
if (LOCAL_ActiveError.status) {
if (LOCAL_ActiveError->status) {
Yap_exit(1);
}
LOCAL_ActiveError.errorNo = e;
LOCAL_ActiveError.errorFile = NULL;
LOCAL_ActiveError.errorFunction = NULL;
LOCAL_ActiveError.errorLine = 0;
LOCAL_ActiveError->errorNo = e;
LOCAL_ActiveError->errorFile = NULL;
LOCAL_ActiveError->errorFunction = NULL;
LOCAL_ActiveError->errorLine = 0;
if (msg) {
LOCAL_Error_Size = strlen(msg);
strcpy(LOCAL_ActiveError.errorComment, msg);
LOCAL_ActiveError->errorMsg = malloc(LOCAL_Error_Size + 1);
strcpy(LOCAL_ActiveError->errorMsg, msg);
} else {
LOCAL_Error_Size = 0;
}
@ -158,7 +159,7 @@ bool Yap_HandleError__(const char *file, const char *function, int lineno,
return false;
}
default:
Yap_Error__(file, function, lineno, err, LOCAL_Error_Term, serr);
Yap_Error__(file, function, lineno, err, TermNil, serr);
return false;
}
}
@ -196,7 +197,7 @@ int Yap_SWIHandleError(const char *s, ...) {
return FALSE;
}
default:
Yap_Error(err, LOCAL_Error_Term, serr);
Yap_Error(err, TermNil, serr);
return (FALSE);
}
}
@ -292,11 +293,23 @@ static char tmpbuf[YAP_BUF_SIZE];
return mkerrorct(B, ts);
#define END_ERRORS() \
} return TermNil; \
} \
return TermNil; \
}
#include "YapErrors.h"
void Yap_pushErrorContext(yap_error_descriptor_t *new_error) {
new_error->top_error = LOCAL_ActiveError;
LOCAL_ActiveError = new_error;
}
yap_error_descriptor_t *Yap_popErrorContext(void) {
yap_error_descriptor_t *new_error = LOCAL_ActiveError;
LOCAL_ActiveError = LOCAL_ActiveError->top_error;
return new_error;
}
/**
* @brief Yap_Error
* This function handles errors in the C code. Check errors.yap for the
@ -343,17 +356,17 @@ yamop *Yap_Error__(const char *file, const char *function, int lineno,
/* disallow recursive error handling */
if (LOCAL_PrologMode & InErrorMode) {
fprintf(stderr, "%% ERROR WITHIN ERROR %d: %s\n", LOCAL_CurrentError,
tmpbuf);
fprintf(stderr, "%% ERROR WITHIN ERROR %d: %s\n", LOCAL_Error_TYPE, tmpbuf);
Yap_RestartYap(1);
}
LOCAL_ActiveError.errorNo = type;
LOCAL_ActiveError.errorAsText = Yap_LookupAtom(Yap_errorName( type ));
LOCAL_ActiveError.errorClass = Yap_errorClass( type);
LOCAL_ActiveError.classAsText = Yap_LookupAtom(Yap_errorClassName( LOCAL_ActiveError.errorClass ));
LOCAL_ActiveError.errorLine = lineno;
LOCAL_ActiveError.errorFunction = function;
LOCAL_ActiveError.errorFile = file;
LOCAL_ActiveError->errorNo = type;
LOCAL_ActiveError->errorAsText = Yap_LookupAtom(Yap_errorName(type));
LOCAL_ActiveError->errorClass = Yap_errorClass(type);
LOCAL_ActiveError->classAsText =
Yap_LookupAtom(Yap_errorClassName(LOCAL_ActiveError->errorClass));
LOCAL_ActiveError->errorLine = lineno;
LOCAL_ActiveError->errorFunction = function;
LOCAL_ActiveError->errorFile = file;
Yap_find_prolog_culprit(PASS_REGS1);
LOCAL_PrologMode |= InErrorMode;
Yap_ClearExs();
@ -380,7 +393,7 @@ yamop *Yap_Error__(const char *file, const char *function, int lineno,
}
if (LOCAL_within_print_message) {
/* error within error */
fprintf(stderr, "%% ERROR WITHIN WARNING %d: %s\n", LOCAL_CurrentError,
fprintf(stderr, "%% ERROR WITHIN WARNING %d: %s\n", LOCAL_Error_TYPE,
tmpbuf);
LOCAL_PrologMode &= ~InErrorMode;
Yap_exit(1);
@ -395,8 +408,8 @@ yamop *Yap_Error__(const char *file, const char *function, int lineno,
#endif
// fprintf(stderr, "warning: ");
comment = MkAtomTerm(Yap_LookupAtom(s));
} else if (LOCAL_ErrorSay && LOCAL_ErrorSay[0]) {
comment = MkAtomTerm(Yap_LookupAtom(LOCAL_ErrorSay));
} else if (LOCAL_ErrorMessage && LOCAL_ErrorMessage[0]) {
comment = MkAtomTerm(Yap_LookupAtom(LOCAL_ErrorMessage));
} else {
comment = TermNil;
}
@ -410,7 +423,6 @@ yamop *Yap_Error__(const char *file, const char *function, int lineno,
if (type == ABORT_EVENT || LOCAL_PrologMode & BootMode) {
where = TermNil;
LOCAL_PrologMode &= ~AbortMode;
LOCAL_CurrentError = type;
LOCAL_PrologMode &= ~InErrorMode;
/* make sure failure will be seen at next port */
// no need to lock & unlock
@ -426,7 +438,6 @@ yamop *Yap_Error__(const char *file, const char *function, int lineno,
}
/* Exit Abort Mode, if we were there */
LOCAL_PrologMode &= ~AbortMode;
LOCAL_CurrentError = type;
LOCAL_PrologMode |= InErrorMode;
if (!(where = Yap_CopyTerm(where))) {
where = TermNil;
@ -528,14 +539,11 @@ yamop *Yap_Error__(const char *file, const char *function, int lineno,
/* This is used by some complex procedures to detect there was an error */
if (IsAtomTerm(nt[0])) {
strncpy(LOCAL_ErrorSay, (char *)RepAtom(AtomOfTerm(nt[0]))->StrOfAE,
strncpy(LOCAL_ErrorMessage, (char *)RepAtom(AtomOfTerm(nt[0]))->StrOfAE,
MAX_ERROR_MSG_SIZE);
LOCAL_ErrorMessage = LOCAL_ErrorSay;
} else {
strncpy(LOCAL_ErrorSay,
(char *)RepAtom(NameOfFunctor(FunctorOfTerm(nt[0])))->StrOfAE,
MAX_ERROR_MSG_SIZE);
LOCAL_ErrorMessage = LOCAL_ErrorSay;
LOCAL_ErrorMessage =
(char *)RepAtom(NameOfFunctor(FunctorOfTerm(nt[0])))->StrOfAE;
}
nt[1] = TermNil;
switch (type) {

129
C/eval.c
View File

@ -27,11 +27,10 @@ static char SccsId[] = "%W% %G%";
@ingroup arithmetic
*/
#include "Yap.h"
#include "Yatom.h"
#include "YapHeap.h"
#include "Yatom.h"
#include "eval.h"
#if HAVE_STDARG_H
#include <stdarg.h>
@ -46,9 +45,7 @@ static char SccsId[] = "%W% %G%";
static Term Eval(Term t1 USES_REGS);
static Term
get_matrix_element(Term t1, Term t2 USES_REGS)
{
static Term get_matrix_element(Term t1, Term t2 USES_REGS) {
if (!IsPairTerm(t2)) {
if (t2 == MkAtomTerm(AtomLength)) {
Int sz = 1;
@ -93,9 +90,7 @@ get_matrix_element(Term t1, Term t2 USES_REGS)
return Eval(t1 PASS_REGS);
}
static Term
Eval(Term t USES_REGS)
{
static Term Eval(Term t USES_REGS) {
if (IsVarTerm(t)) {
return Yap_ArithError(INSTANTIATION_ERROR, t, "in arithmetic");
@ -155,32 +150,29 @@ Eval(Term t USES_REGS)
return FALSE;
return Yap_eval_binary(p->FOfEE, t1, t2);
}
} /* else if (IsPairTerm(t)) */ {
} /* else if (IsPairTerm(t)) */
{
if (TailOfTerm(t) != TermNil) {
return Yap_ArithError(TYPE_ERROR_EVALUABLE, t,
"string must contain a single character to be evaluated as an arithmetic expression");
"string must contain a single character to be "
"evaluated as an arithmetic expression");
}
return Eval(HeadOfTerm(t) PASS_REGS);
}
}
Term
Yap_InnerEval__(Term t USES_REGS)
{
return Eval(t PASS_REGS);
}
Term Yap_InnerEval__(Term t USES_REGS) { return Eval(t PASS_REGS); }
#ifdef BEAM
Int BEAM_is(void);
Int
BEAM_is(void)
{ /* X is Y */
Int BEAM_is(void) { /* X is Y */
union arith_ret res;
blob_type bt;
bt = Eval(Deref(XREGS[2]), &res);
if (bt==db_ref_e) return (NULL);
if (bt == db_ref_e)
return (NULL);
return (EvalToTerm(bt, &res));
}
@ -197,14 +189,13 @@ X is 2+3*4
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
succeeds with `X = 14`.
Consult @ref arithmetic_operators for the complete list of arithmetic_operators
Consult @ref arithmetic_operators for the complete list of
arithmetic_operators
*/
/// @memberof is/2
static Int
p_is( USES_REGS1 )
{ /* X is Y */
static Int p_is(USES_REGS1) { /* X is Y */
Term out;
yap_error_number err;
@ -239,20 +230,18 @@ p_is( USES_REGS1 )
*/
/// @memberof isnan/1
static Int
p_isnan( USES_REGS1 )
{ /* X isnan Y */
static Int p_isnan(USES_REGS1) { /* X isnan Y */
Term out = 0L;
while (!(out = Eval(Deref(ARG1) PASS_REGS))) {
if (LOCAL_Error_TYPE == RESOURCE_ERROR_STACK) {
LOCAL_Error_TYPE = YAP_NO_ERROR;
if (!Yap_gcl(LOCAL_Error_Size, 1, ENV, CP)) {
Yap_EvalError(RESOURCE_ERROR_STACK, ARG2, LOCAL_ErrorMessage);
Yap_EvalError(RESOURCE_ERROR_STACK, TermNil, LOCAL_ErrorMessage);
return FALSE;
}
} else {
Yap_EvalError(LOCAL_Error_TYPE, LOCAL_Error_Term, LOCAL_ErrorMessage);
Yap_EvalError(LOCAL_Error_TYPE, ARG1, LOCAL_ErrorMessage);
return FALSE;
}
}
@ -274,9 +263,7 @@ p_isnan( USES_REGS1 )
*/
/// @memberof isnan/1
static Int
p_isinf( USES_REGS1 )
{ /* X is Y */
static Int p_isinf(USES_REGS1) { /* X is Y */
Term out = 0L;
while (!(out = Eval(Deref(ARG1) PASS_REGS))) {
@ -287,7 +274,7 @@ p_isinf( USES_REGS1 )
return FALSE;
}
} else {
Yap_EvalError(LOCAL_Error_TYPE, LOCAL_Error_Term, LOCAL_ErrorMessage);
Yap_EvalError(LOCAL_Error_TYPE, ARG1, LOCAL_ErrorMessage);
return FALSE;
}
}
@ -312,9 +299,7 @@ True if _Log1_ is the logarithm of the positive number _A1_,
*/
/// @memberof logsum/3
static Int
p_logsum( USES_REGS1 )
{ /* X is Y */
static Int p_logsum(USES_REGS1) { /* X is Y */
Term t1 = Deref(ARG1);
Term t2 = Deref(ARG2);
int done = FALSE;
@ -341,7 +326,7 @@ p_logsum( USES_REGS1 )
return FALSE;
}
} else {
Yap_EvalError(LOCAL_Error_TYPE, LOCAL_Error_Term, LOCAL_ErrorMessage);
Yap_EvalError(LOCAL_Error_TYPE, ARG1, LOCAL_ErrorMessage);
return FALSE;
}
}
@ -369,7 +354,7 @@ p_logsum( USES_REGS1 )
return FALSE;
}
} else {
Yap_EvalError(LOCAL_Error_TYPE, LOCAL_Error_Term, LOCAL_ErrorMessage);
Yap_EvalError(LOCAL_Error_TYPE, ARG1, LOCAL_ErrorMessage);
return FALSE;
}
}
@ -384,66 +369,51 @@ p_logsum( USES_REGS1 )
}
}
Int
Yap_ArithError__(const char *file, const char *function, int lineno, yap_error_number type, Term where,...)
{
Int Yap_ArithError__(const char *file, const char *function, int lineno,
yap_error_number type, Term where, ...) {
CACHE_REGS
va_list ap;
char *format;
char buf[MAX_ERROR_MSG_SIZE];
if (LOCAL_ArithError)
return 0L;
LOCAL_ArithError = TRUE;
LOCAL_Error_TYPE = type;
LOCAL_Error_File = file;
LOCAL_Error_Function = function;
LOCAL_Error_Lineno = lineno;
LOCAL_Error_Term = where;
if (!LOCAL_ErrorMessage)
LOCAL_ErrorMessage = LOCAL_ErrorSay;
va_start(ap, where);
format = va_arg(ap, char *);
if (format != NULL) {
#if HAVE_VSNPRINTF
(void) vsnprintf(LOCAL_ErrorMessage, MAX_ERROR_MSG_SIZE, format, ap);
(void)vsnprintf(buf, MAX_ERROR_MSG_SIZE, format, ap);
#else
(void) vsprintf(LOCAL_ErrorMessage, format, ap);
(void)vsprintf(buf, format, ap);
#endif
} else {
LOCAL_ErrorMessage[0] = '\0';
buf[0] = '\0';
}
va_end(ap);
return 0L;
}
yamop *
Yap_EvalError__(const char *file, const char *function, int lineno,yap_error_number type, Term where,...)
{
yamop *Yap_EvalError__(const char *file, const char *function, int lineno,
yap_error_number type, Term where, ...) {
CACHE_REGS
va_list ap;
char *format;
char *format, buf[MAX_ERROR_MSG_SIZE];
if (LOCAL_ArithError) {
LOCAL_ArithError = YAP_NO_ERROR;
return Yap_Error__(file, function, lineno, LOCAL_Error_TYPE, LOCAL_Error_Term, LOCAL_ErrorMessage);
}
if (!LOCAL_ErrorMessage)
LOCAL_ErrorMessage = LOCAL_ErrorSay;
va_start(ap, where);
format = va_arg(ap, char *);
if (format != NULL) {
#if HAVE_VSNPRINTF
(void) vsnprintf(LOCAL_ErrorMessage, MAX_ERROR_MSG_SIZE, format, ap);
(void)vsnprintf(buf, MAX_ERROR_MSG_SIZE, format, ap);
#else
(void) vsprintf(LOCAL_ErrorMessage, format, ap);
(void)vsprintf(buf, format, ap);
#endif
} else {
LOCAL_ErrorMessage[0] = '\0';
buf[0] = '\0';
}
va_end(ap);
return Yap_Error__(file, function, lineno, type, where, LOCAL_ErrorMessage);
return Yap_Error__(file, function, lineno, type, where, buf);
}
/**
@ -461,8 +431,7 @@ Yap_EvalError__(const char *file, const char *function, int lineno,yap_error_num
*/
/// @memberof between/3
static Int cont_between( USES_REGS1 )
{
static Int cont_between(USES_REGS1) {
Term t1 = EXTRA_CBACK_ARG(3, 1);
Term t2 = EXTRA_CBACK_ARG(3, 2);
@ -496,9 +465,7 @@ static Int cont_between( USES_REGS1 )
}
/// @memberof between/3
static Int
init_between( USES_REGS1 )
{
static Int init_between(USES_REGS1) {
Term t1 = Deref(ARG1);
Term t2 = Deref(ARG2);
@ -510,14 +477,11 @@ init_between( USES_REGS1 )
Yap_EvalError(INSTANTIATION_ERROR, t1, "between/3");
return FALSE;
}
if (!IsIntegerTerm(t1) &&
!IsBigIntTerm(t1)) {
if (!IsIntegerTerm(t1) && !IsBigIntTerm(t1)) {
Yap_EvalError(TYPE_ERROR_INTEGER, t1, "between/3");
return FALSE;
}
if (!IsIntegerTerm(t2) &&
!IsBigIntTerm(t2) &&
t2 != MkAtomTerm(AtomInf) &&
if (!IsIntegerTerm(t2) && !IsBigIntTerm(t2) && t2 != MkAtomTerm(AtomInf) &&
t2 != MkAtomTerm(AtomInfinity)) {
Yap_EvalError(TYPE_ERROR_INTEGER, t2, "between/3");
return FALSE;
@ -542,7 +506,8 @@ init_between( USES_REGS1 )
cut_fail();
}
}
if (i1 > i2) cut_fail();
if (i1 > i2)
cut_fail();
if (i1 == i2) {
Yap_unify(ARG3, t1);
cut_succeed();
@ -575,12 +540,14 @@ init_between( USES_REGS1 )
Yap_EvalError(TYPE_ERROR_INTEGER, t3, "between/3");
return FALSE;
}
if (Yap_acmp(t3, t1 PASS_REGS) >= 0 && Yap_acmp(t2,t3 PASS_REGS) >= 0 && P != FAILCODE)
if (Yap_acmp(t3, t1 PASS_REGS) >= 0 && Yap_acmp(t2, t3 PASS_REGS) >= 0 &&
P != FAILCODE)
cut_succeed();
cut_fail();
}
cmp = Yap_acmp(t1, t2 PASS_REGS);
if (cmp > 0) cut_fail();
if (cmp > 0)
cut_fail();
if (cmp == 0) {
Yap_unify(ARG3, t1);
cut_succeed();
@ -591,9 +558,7 @@ init_between( USES_REGS1 )
return cont_between(PASS_REGS1);
}
void
Yap_InitEval(void)
{
void Yap_InitEval(void) {
/* here are the arithmetical predicates */
Yap_InitConstExps();
Yap_InitUnaryExps();

18
C/exec.c
View File

@ -1446,7 +1446,7 @@ 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_matherror, TermNil, NULL);
Yap_Error(LOCAL_Error_TYPE, TermNil, NULL);
/* reset the registers so that we don't have trash in abstract
* machine */
Yap_set_fpu_exceptions(
@ -2080,16 +2080,16 @@ static Int jump_env(USES_REGS1) {
LOCAL_Error_TYPE = ERROR_EVENT;
t = ArgOfTerm(1, t);
if (IsApplTerm(t) && IsAtomTerm((t2 = ArgOfTerm(1, t)))) {
LOCAL_ActiveError.errorAsText = AtomOfTerm(t2);
LOCAL_ActiveError.classAsText = NameOfFunctor(FunctorOfTerm(t));
LOCAL_ActiveError->errorAsText = AtomOfTerm(t2);
LOCAL_ActiveError->classAsText = NameOfFunctor(FunctorOfTerm(t));
} else if (IsAtomTerm(t)) {
LOCAL_ActiveError.errorAsText = AtomOfTerm(t);
LOCAL_ActiveError.classAsText = NULL;
LOCAL_ActiveError->errorAsText = AtomOfTerm(t);
LOCAL_ActiveError->classAsText = NULL;
}
} else {
LOCAL_Error_TYPE = THROW_EVENT;
}
LOCAL_ActiveError.prologPredName = NULL;
LOCAL_ActiveError->prologPredName = NULL;
Yap_PutException(t);
bool out = JumpToEnv(PASS_REGS1);
if (B != NULL && P == FAILCODE && B->cp_ap == NOCODE &&
@ -2225,10 +2225,10 @@ bool Yap_PutException(Term t) {
}
bool Yap_ResetException(int wid) {
if (REMOTE_BallTerm(wid)) {
Yap_PopTermFromDB(REMOTE_BallTerm(wid));
if (REMOTE_ActiveError(wid)->errorTerm) {
Yap_PopTermFromDB(REMOTE_ActiveError(wid)->errorTerm);
}
REMOTE_BallTerm(wid) = NULL;
REMOTE_ActiveError(wid)->errorTerm = NULL;
return true;
}

4
C/flags.c
View File

@ -1369,7 +1369,7 @@ do_prolog_flag_property(Term tflag,
args = Yap_ArgList2ToVector(opts, prolog_flag_property_defs,
PROLOG_FLAG_PROPERTY_END);
if (args == NULL) {
Yap_Error(LOCAL_Error_TYPE, LOCAL_Error_Term, NULL);
Yap_Error(LOCAL_Error_TYPE, opts, NULL);
return false;
}
if (!IsAtomTerm(tflag)) {
@ -1533,7 +1533,7 @@ static Int do_create_prolog_flag(USES_REGS1) {
args = Yap_ArgList2ToVector(opts, prolog_flag_property_defs,
PROLOG_FLAG_PROPERTY_END);
if (args == NULL) {
Yap_Error(LOCAL_Error_TYPE, LOCAL_Error_Term, NULL);
Yap_Error(LOCAL_Error_TYPE, opts, NULL);
return false;
}
fv = GetFlagProp(AtomOfTerm(tflag));

11
C/load_dl.c
View File

@ -127,7 +127,8 @@ void *Yap_LoadForeignFile(char *file, int flags) {
if (out == NULL) {
const char *m_os = dlerror();
if (m_os) {
strncpy(LOCAL_ErrorSay, m_os, MAX_ERROR_MSG_SIZE - 1);
LOCAL_ErrorMessage = malloc(MAX_ERROR_MSG_SIZE);
strncpy(LOCAL_ErrorMessage, m_os, MAX_ERROR_MSG_SIZE - 1);
} else {
LOCAL_ErrorMessage = "dlopen failed";
}
@ -177,7 +178,8 @@ static Int LoadForeign(StringList ofiles, StringList libs, char *proc_name,
NULL)
#endif
{
strcpy(LOCAL_ErrorSay, dlerror());
LOCAL_ErrorMessage = malloc(MAX_ERROR_MSG_SIZE);
strcpy(LOCAL_ErrorMessage, dlerror());
return LOAD_FAILLED;
}
libs = libs->next;
@ -192,7 +194,8 @@ static Int LoadForeign(StringList ofiles, StringList libs, char *proc_name,
/* dlopen wants to follow the LD_CONFIG_PATH */
const char *file = AtomName(ofiles->name);
if (!Yap_findFile(file, NULL, NULL, LOCAL_FileNameBuf, true, YAP_OBJ, true, true)) {
strcpy(LOCAL_ErrorSay,
LOCAL_ErrorMessage = malloc(MAX_ERROR_MSG_SIZE);
strcpy(LOCAL_ErrorMessage,
"%% Trying to open unexisting file in LoadForeign");
return LOAD_FAILLED;
}
@ -217,7 +220,7 @@ static Int LoadForeign(StringList ofiles, StringList libs, char *proc_name,
}
if (!*init_proc) {
strcpy(LOCAL_ErrorSay, "Could not locate initialization routine");
LOCAL_ErrorMessage = "Could not locate initialization routine";
return LOAD_FAILLED;
}

3
C/load_foreign.c
View File

@ -140,7 +140,8 @@ p_open_shared_object( USES_REGS1 ) {
s = (char *)RepAtom(AtomOfTerm(t))->StrOfAE;
if ((handle = Yap_LoadForeignFile(s, IntegerOfTerm(tflags)))==NULL) {
Yap_Error(EXISTENCE_ERROR_SOURCE_SINK,t,"open_shared_object_failed for %s with %s\n", s, LOCAL_ErrorSay);
Yap_Error(EXISTENCE_ERROR_SOURCE_SINK,t,"open_shared_object_failed for %s"
" with %s\n", s, LOCAL_ErrorMessage);
return FALSE;
} else {
return Yap_unify(MkIntegerTerm((Int)handle),ARG3);

5
C/parser.c
View File

@ -175,10 +175,9 @@ static void syntax_msg(const char *msg, ...) {
va_list ap;
if (LOCAL_toktide == LOCAL_tokptr) {
char out[YAP_FILENAME_MAX];
LOCAL_ErrorMessage = malloc(MAX_ERROR_MSG_SIZE+1);
va_start(ap, msg);
vsnprintf(out, YAP_FILENAME_MAX - 1, msg, ap);
LOCAL_Error_Term = MkStringTerm( out );
vsnprintf(LOCAL_ErrorMessage, YAP_FILENAME_MAX , msg, ap);
LOCAL_Error_TYPE = SYNTAX_ERROR;
va_end(ap);
}

1101
C/prim_absmi_insts.h
View File

File diff suppressed because it is too large Load Diff

8
C/save.c
View File

@ -165,9 +165,11 @@ static Int
do_SYSTEM_ERROR_INTERNAL(yap_error_number etype, const char *msg)
{
CACHE_REGS
LOCAL_ErrorMessage = malloc(MAX_ERROR_MSG_SIZE+1);
#if HAVE_SNPRINTF
#if HAVE_STRERROR
snprintf(LOCAL_ErrorSay,MAX_ERROR_MSG_SIZE,"%s (%s when reading %s)", msg, strerror(errno), LOCAL_FileNameBuf);
snprintf(LOCAL_ErrorMessage,MAX_ERROR_MSG_SIZE,"%s (%s when reading %s)", msg,
strerror(errno), LOCAL_FileNameBuf);
#else
snprintf(LOCAL_ErrorSay,MAX_ERROR_MSG_SIZE,"%s, (system error %d when reading %s)",msg,errno,LOCAL_FileNameBuf);
#endif
@ -178,7 +180,6 @@ do_SYSTEM_ERROR_INTERNAL(yap_error_number etype, const char *msg)
sprintf(LOCAL_ErrorSay,"%s, (system error %d when reading %s)",msg,errno,LOCAL_FileNameBuf);
#endif
#endif
LOCAL_ErrorMessage = LOCAL_ErrorSay;
LOCAL_Error_TYPE = etype;
return -1;
}
@ -685,8 +686,7 @@ check_header(CELL *info, CELL *ATrail, CELL *AStack, CELL *AHeap USES_REGS)
}
}
if (strcmp(pp, msg) != 0) {
LOCAL_ErrorMessage = LOCAL_ErrorSay;
strncpy(LOCAL_ErrorMessage, "saved state ", MAX_ERROR_MSG_SIZE);
strncpy(LOCAL_ErrorMessage, "saved state ", MAX_ERROR_MSG_SIZE-1);
strncat(LOCAL_ErrorMessage, LOCAL_FileNameBuf, MAX_ERROR_MSG_SIZE-1);
strncat(LOCAL_ErrorMessage, " failed to match version ID", MAX_ERROR_MSG_SIZE-1);
LOCAL_Error_TYPE = SYSTEM_ERROR_SAVED_STATE;

3
C/scanner.c
View File

@ -1192,8 +1192,7 @@ Term Yap_scan_num(StreamDesc *inp) {
ef->TokNext = NULL;
LOCAL_tokptr = tokptr;
LOCAL_toktide = e;
LOCAL_ErrorMessage = NULL;
LOCAL_Error_Term = Yap_syntax_error(e, inp - GLOBAL_Stream);
LOCAL_ErrorMessage = Yap_syntax_error(e, inp - GLOBAL_Stream);
LOCAL_Error_TYPE = SYNTAX_ERROR;
}
}

32
C/stack.c
View File

@ -1074,40 +1074,40 @@ bool set_clause_info(yamop *codeptr, PredEntry *pp) {
Term ts[2];
void *begin;
if (pp->ArityOfPE == 0) {
LOCAL_ActiveError.prologPredName = (Atom)pp->FunctorOfPred;
LOCAL_ActiveError.prologPredArity = 0;
LOCAL_ActiveError->prologPredName = (Atom)pp->FunctorOfPred;
LOCAL_ActiveError->prologPredArity = 0;
} else {
LOCAL_ActiveError.prologPredName = NameOfFunctor(pp->FunctorOfPred);
LOCAL_ActiveError.prologPredArity = pp->ArityOfPE;
LOCAL_ActiveError->prologPredName = NameOfFunctor(pp->FunctorOfPred);
LOCAL_ActiveError->prologPredArity = pp->ArityOfPE;
}
LOCAL_ActiveError.prologPredModule =
LOCAL_ActiveError->prologPredModule =
(pp->ModuleOfPred ? pp->ModuleOfPred : TermProlog);
LOCAL_ActiveError.prologPredFile = pp->src.OwnerFile;
LOCAL_ActiveError->prologPredFile = pp->src.OwnerFile;
if (codeptr->opc == UNDEF_OPCODE) {
LOCAL_ActiveError.prologPredFirstLine = 0;
LOCAL_ActiveError.prologPredLine = 0;
LOCAL_ActiveError.prologPredLastLine = 0;
LOCAL_ActiveError->prologPredFirstLine = 0;
LOCAL_ActiveError->prologPredLine = 0;
LOCAL_ActiveError->prologPredLastLine = 0;
return true;
} else if (pp->cs.p_code.NOfClauses) {
if ((LOCAL_ActiveError.prologPredCl =
if ((LOCAL_ActiveError->prologPredCl =
find_code_in_clause(pp, codeptr, &begin, NULL)) <= 0) {
LOCAL_ActiveError.prologPredLine = 0;
LOCAL_ActiveError->prologPredLine = 0;
} else {
LOCAL_ActiveError.prologPredLine = IntegerOfTerm(clause_loc(begin, pp));
LOCAL_ActiveError->prologPredLine = IntegerOfTerm(clause_loc(begin, pp));
}
if (pp->PredFlags & LogUpdatePredFlag) {
LOCAL_ActiveError.prologPredFirstLine = IntegerOfTerm(
LOCAL_ActiveError->prologPredFirstLine = IntegerOfTerm(
ts[0] = clause_loc(
ClauseCodeToLogUpdClause(pp->cs.p_code.FirstClause), pp));
LOCAL_ActiveError.prologPredLastLine = IntegerOfTerm(
LOCAL_ActiveError->prologPredLastLine = IntegerOfTerm(
ts[1] = clause_loc(ClauseCodeToLogUpdClause(pp->cs.p_code.LastClause),
pp));
} else {
LOCAL_ActiveError.prologPredFirstLine = IntegerOfTerm(
LOCAL_ActiveError->prologPredFirstLine = IntegerOfTerm(
ts[0] = clause_loc(
ClauseCodeToStaticClause(pp->cs.p_code.FirstClause), pp));
LOCAL_ActiveError.prologPredLastLine = IntegerOfTerm(
LOCAL_ActiveError->prologPredLastLine = IntegerOfTerm(
ts[1] = clause_loc(ClauseCodeToStaticClause(pp->cs.p_code.LastClause),
pp));
}

56
C/text.c
View File

@ -35,46 +35,17 @@ inline static size_t min_size(size_t i, size_t j) { return (i < j ? i : j); }
#define NAN (0.0 / 0.0)
#endif
void *buf__, *cur__;
#ifndef MAX_PATHHNAME
#define MAX_PATHHNAME 1024
#endif
#define init_alloc(I) \
void *ov__ = TR, *ocur__ = LOCAL_ScannerStack; \
if (!LOCAL_ScannerStack) \
LOCAL_ScannerStack = (char *)TR
#define mark_stack() \
void *otr__ = TR; \
void *ost__ = LOCAL_ScannerStack; \
TR = (tr_fr_ptr)LOCAL_ScannerStack
#define restore_stack() \
TR = otr__; \
LOCAL_ScannerStack = ost__
#define export_buf(s) \
{}
#define unprotect_stack(s) TR = ov__, LOCAL_ScannerStack = ocur__
// LOCAL_ScannerStack = ov__, TR = ot__
static bool alloc_ovfl(size_t sz) {
return (char *)+(sz + 4096) > (char *)LOCAL_TrailTop;
}
static void *Malloc(size_t sz USES_REGS) {
sz = ALIGN_BY_TYPE(sz, CELL);
if (alloc_ovfl(sz))
return NULL;
void *o = LOCAL_ScannerStack;
LOCAL_ScannerStack = (void *)((char *)LOCAL_ScannerStack + sz);
return o;
}
static size_t MaxTmp(USES_REGS1) {
if (LOCAL_ScannerStack) {
return (char *)LOCAL_TrailTop - (char *)LOCAL_ScannerStack;
}
return 0;
void
Yap_InitTextAllocator( void )
{
struct TextBuffer_manager *new = malloc(sizeof(struct TextBuffer_manager)+MAX_PATHHNAME*2 );
new->prev = NULL;
new->ptr = new->buf = (struct TextBuffer_manager *)new+1;
LOCAL_TextBuffer = new;
}
static Term Globalize(Term v USES_REGS) {
@ -244,8 +215,6 @@ static unsigned char *to_buffer(unsigned char *buf, Term t, seq_tv_t *inp,
unsigned char *bufc = buf;
n = SkipListCodes(&bufc, &t, &r, atoms, widep, inp PASS_REGS);
if (n < 0) {
LOCAL_Error_TYPE = -n;
LOCAL_Error_Term = *r;
return NULL;
}
*lenp = n;
@ -319,7 +288,6 @@ unsigned char *Yap_readText(seq_tv_t *inp, size_t *lengp) {
YAP_STRING_BIG)) == inp->type) {
LOCAL_Error_TYPE = TYPE_ERROR_NUMBER;
}
LOCAL_Error_Term = inp->val.t;
}
}
if (LOCAL_Error_TYPE != YAP_NO_ERROR)
@ -370,9 +338,9 @@ unsigned char *Yap_readText(seq_tv_t *inp, size_t *lengp) {
s = (char *)s0;
else
s = Malloc(0);
if (snprintf(s, MaxTmp(PASS_REGS1) - 1, Int_FORMAT,
if (snprintf(s, MAX_PATHNAME - 1, Int_FORMAT,
IntegerOfTerm(inp->val.t)) < 0) {
AUX_ERROR(inp->val.t, 2 * MaxTmp(PASS_REGS1), s, char);
AUX_ERROR(inp->val.t, 2 * (MAX_PATHNAME), s, char);
}
*lengp = strlen(s);
Malloc(*lengp);

39
CXX/yapi.cpp
View File

@ -612,11 +612,14 @@ Term YAPEngine::fun(Term t) {
} else if (IsAtomTerm(t)) {
name = AtomOfTerm(t);
f = nullptr;
} else if (IsAtomTerm(t)) {
} else if (IsPairTerm(t)) {
XREGS[1] = ts[0];
XREGS[2] = ts[1];
name = AtomDot;
f = FunctorDot;
} else {
Yap_Error(TYPE_ERROR_CALLABLE, t, 0);
return 0L;
}
XREGS[arity+1] = MkVarTerm();
arity ++;
@ -1027,37 +1030,37 @@ const char *YAPError::text() {
char buf[256];
std::string s = "";
if (LOCAL_ActiveError.errorFunction) {
s += LOCAL_ActiveError.errorFile;
if (LOCAL_ActiveError->errorFunction) {
s += LOCAL_ActiveError->errorFile;
s += ":";
sprintf(buf, "%ld", (long int)LOCAL_ActiveError.errorLine);
sprintf(buf, "%ld", (long int)LOCAL_ActiveError->errorLine);
s += buf;
s += ":0 in C-code";
}
if (LOCAL_ActiveError.prologPredLine) {
if (LOCAL_ActiveError->prologPredLine) {
s += "\n";
s += LOCAL_ActiveError.prologPredFile->StrOfAE;
s += LOCAL_ActiveError->prologPredFile->StrOfAE;
s += ":";
sprintf(buf, "%ld", (long int)LOCAL_ActiveError.prologPredLine);
s += buf; // std::to_string(LOCAL_ActiveError.prologPredLine) ;
// YAPIntegerTerm(LOCAL_ActiveError.prologPredLine).text();
sprintf(buf, "%ld", (long int)LOCAL_ActiveError->prologPredLine);
s += buf; // std::to_string(LOCAL_ActiveError->prologPredLine) ;
// YAPIntegerTerm(LOCAL_ActiveError->prologPredLine).text();
s += ":0 ";
s += LOCAL_ActiveError.prologPredModule;
s += LOCAL_ActiveError->prologPredModule;
s += ":";
s += (LOCAL_ActiveError.prologPredName)->StrOfAE;
s += (LOCAL_ActiveError->prologPredName)->StrOfAE;
s += "/";
sprintf(buf, "%ld", (long int)LOCAL_ActiveError.prologPredArity);
s += // std::to_string(LOCAL_ActiveError.prologPredArity);
sprintf(buf, "%ld", (long int)LOCAL_ActiveError->prologPredArity);
s += // std::to_string(LOCAL_ActiveError->prologPredArity);
buf;
}
s += " error ";
if (LOCAL_ActiveError.classAsText != nullptr)
s += LOCAL_ActiveError.classAsText->StrOfAE;
if (LOCAL_ActiveError->classAsText != nullptr)
s += LOCAL_ActiveError->classAsText->StrOfAE;
s += ".";
s += LOCAL_ActiveError.errorAsText->StrOfAE;
s += LOCAL_ActiveError->errorAsText->StrOfAE;
s += ".\n";
if (LOCAL_ActiveError.errorTerm) {
Term t = Yap_PopTermFromDB(LOCAL_ActiveError.errorTerm);
if (LOCAL_ActiveError->errorTerm) {
Term t = Yap_PopTermFromDB(LOCAL_ActiveError->errorTerm);
if (t) {
s += "error term is: ";
s += YAPTerm(t).text();

10
CXX/yapie.hh
View File

@ -15,17 +15,17 @@ public:
YAPError(){};
/// we just know the error number
/// exact error ID
yap_error_number getID() { return LOCAL_ActiveError.errorNo; };
yap_error_number getID() { return LOCAL_ActiveError->errorNo; };
/// class of error
yap_error_class_number getErrorClass() {
return Yap_errorClass(LOCAL_ActiveError.errorNo);
return Yap_errorClass(LOCAL_ActiveError->errorNo);
};
/// where in the code things happened;
const char *getFile() { return LOCAL_ActiveError.errorFile; };
const char *getFile() { return LOCAL_ActiveError->errorFile; };
/// predicate things happened;
Int getLine() { return LOCAL_ActiveError.errorLine; };
Int getLine() { return LOCAL_ActiveError->errorLine; };
/// the term that caused the bug
// YAPTerm getCulprit(LOCAL_ActiveError.errorFile){};
// YAPTerm getCulprit(LOCAL_ActiveError->errorFile){};
/// text describing the Error
const char *text();
};

11
CXX/yapq.hh
View File

@ -183,9 +183,16 @@ public:
bool goalt(YAPTerm t);
/// current directory for the engine
bool goal(Term t);
#if SWIGPYTHON
bool unlockedGoal(Term t) {bool rc;Py_BEGIN_ALLOW_THREADS; rc = goal(t);Py_END_ALLOW_THREADS; return rc; }
bool unlockedGoal(Term t) {bool rc;
#ifdef SWIGPYTHON
Py_BEGIN_ALLOW_THREADS;
#endif
rc = goal(t);
#ifdef SWIGPYTHON
Py_END_ALLOW_THREADS;
#endif
return rc;
}
/// reset Prolog state
void reSet();
/// release: assune that there are no stack pointers, just release memory

12
H/LOCALS
View File

@ -79,7 +79,6 @@ UInt GlobalArenaOverflows =0L
Int ArenaOverflows =0L
Int DepthArenas =0
int ArithError =FALSE
struct pred_entry* LastAssertedPred =NULL
struct pred_entry* TmpPred =NULL
char* ScannerStack =NULL
@ -194,13 +193,10 @@ ADDR LocalBase void
ADDR GlobalBase void
ADDR TrailBase void
ADDR TrailTop void
char* ErrorMessage void
Term Error_Term void
/** error handling info, designed to be easy to pass to the foreign world */
struct yap_error_descriptor ActiveError void
/* error handling info, designed to be easy to pass to the foreign world */
yap_error_descriptor_t* ActiveError =calloc(sizeof(yap_error_descriptor_t),1)
/// pointer to an exception term, from throw
struct DB_TERM* BallTerm =NULL
jmp_buf IOBotch void
TokEntry* tokptr void
@ -217,6 +213,8 @@ sigjmp_buf RestartEnv void
char FileNameBuf[YAP_FILENAME_MAX+1] void
char FileNameBuf2[YAP_FILENAME_MAX+1] void
struct TextBuffer_manager* TextBuffer =Yap_InitTextAllocator()
// Prolog State
UInt BreakLevel =0
Int PrologMode =BootMode
@ -237,10 +235,8 @@ YAP_ULONG_LONG 2opcount[_std_top+1][_std_top+1] void
struct db_globs* s_dbg void
//eval.c
yap_error_number matherror =YAP_NO_ERROR
Term mathtt void
char* mathstring =NULL
yap_error_number CurrentError =YAP_NO_ERROR
//grow.c
int heap_overflows =0

42
H/YapText.h
View File

@ -31,6 +31,48 @@
#include "../utf8proc/utf8proc.h"
#include "Yap.h"
typedef struct TextBuffer_manager {
void *buf, *ptr;
size_t sz;
struct TextBuffer_manager *prev;
} text_buffer_t;
/**
* TextBuffer is allocated as a chain of blocks, They area
* recovered at the end if the translation.
*/
inline void init_alloc(int line) {
while (LOCAL_TextBuffer->prev ) {
struct TextBuffer_manager *old = LOCAL_TextBuffer;
LOCAL_TextBuffer = LOCAL_TextBuffer->prev;
free(old);
}
LOCAL_TextBuffer->sz = (YAP_FILENAME_MAX + 1);
LOCAL_TextBuffer->buf = LOCAL_TextBuffer->ptr = realloc(LOCAL_TextBuffer->ptr, YAP_FILENAME_MAX + 1 );
}
extern inline void mark_stack(void) {}
extern inline void restore_stack(void ) {} \
extern inline void unprotect_stack(void *ptr) {} \
extern inline void *Malloc(size_t sz USES_REGS) {
sz = ALIGN_BY_TYPE(sz, CELL);
void *o = LOCAL_TextBuffer->ptr;
if ((char*)LOCAL_TextBuffer->ptr+sz>(char*)LOCAL_TextBuffer->buf + LOCAL_TextBuffer->sz) {
struct TextBuffer_manager *new = malloc(sizeof(struct TextBuffer_manager)+YAP_FILENAME_MAX + 1);
new->prev = LOCAL_TextBuffer;
new->buf = (struct TextBuffer_manager *)new+1;
new->ptr = new->buf + sz;
LOCAL_TextBuffer= new;
return new->buf;
}
LOCAL_TextBuffer->ptr += sz;
return o;
}
/* Character types for tokenizer and write.c */
/****************** character definition table **************************/

13
H/absmi.h
View File

@ -99,7 +99,8 @@ register struct yami *P1REG asm("bp"); /* can't use yamop before Yap.h */
#define LIMITED_PREFETCH 1
#endif /* __x86_64__ */
#if defined(__arm__) || defined(__thumb__) || defined(mips) || defined(__mips64) || defined(__aarch64__)
#if defined(__arm__) || defined(__thumb__) || defined(mips) || \
defined(__mips64) || defined(__aarch64__)
#define Y_IN_MEM 1
#define S_IN_MEM 1
@ -2075,7 +2076,8 @@ cufail:
#endif
#if /* defined(IN_ABSMI_C) ||*/ defined(IN_INLINES_C) /*|| defined(IN_TRACED_ABSMI_C) */
#if /* defined(IN_ABSMI_C) ||*/ defined( \
IN_INLINES_C) /*|| defined(IN_TRACED_ABSMI_C) */
static int iequ_complex(register CELL *pt0, register CELL *pt0_end,
register CELL *pt1) {
@ -2450,4 +2452,11 @@ extern yamop *headoftrace;
ENDD(d0);
#endif
#define Yap_AsmError(e) \
{ \
saveregs(); \
Yap_Error(e, 0, ""); \
setregs(); \
}
#endif // ABSMI_H

15
H/eval.h
View File

@ -375,6 +375,7 @@ Functor EvalArg(Term);
eval_flt = (F); \
return (FFloat); \
}
#define REvalError() \
{ return (FError); }
@ -407,8 +408,12 @@ yamop *Yap_EvalError__(const char *, const char *, int, yap_error_number, Term,
#define Yap_ArithError(id, t, ...) \
Yap_ArithError__(__FILE__, __FUNCTION__, __LINE__, id, t, __VA_ARGS__)
Int Yap_ArithError__(const char *, const char *, int, yap_error_number, Term,
...);
#define Yap_BinError(id) \
Yap_Error__(__FILE__, __FUNCTION__, __LINE__, id, 0L, "")
#define Yap_AbsmiError(id) \
Yap_Error__(__FILE__, __FUNCTION__, __LINE__, id, 0L, "")
extern Int Yap_ArithError__(const char *, const char *, int, yap_error_number,
Term, ...);
#include "inline-only.h"
@ -463,7 +468,11 @@ Atom Yap_NameOfBinaryOp(int i);
#define RINT(v) return (MkIntegerTerm(v))
#define RFLOAT(v) return (MkFloatTerm(v))
#define RBIG(v) return (Yap_MkBigIntTerm(v))
#define RERROR() return (0L)
#define RERROR() \
{ \
Yap_BinError(LOCAL_Error_TYPE); \
return (0L); \
}
static inline blob_type ETypeOfTerm(Term t) {
if (IsIntTerm(t))

14
H/generated/dlocals.h
View File

@ -121,8 +121,6 @@
#define REMOTE_ArenaOverflows(wid) REMOTE(wid)->ArenaOverflows_
#define LOCAL_DepthArenas LOCAL->DepthArenas_
#define REMOTE_DepthArenas(wid) REMOTE(wid)->DepthArenas_
#define LOCAL_ArithError LOCAL->ArithError_
#define REMOTE_ArithError(wid) REMOTE(wid)->ArithError_
#define LOCAL_LastAssertedPred LOCAL->LastAssertedPred_
#define REMOTE_LastAssertedPred(wid) REMOTE(wid)->LastAssertedPred_
#define LOCAL_TmpPred LOCAL->TmpPred_
@ -288,16 +286,10 @@
#define REMOTE_TrailBase(wid) REMOTE(wid)->TrailBase_
#define LOCAL_TrailTop LOCAL->TrailTop_
#define REMOTE_TrailTop(wid) REMOTE(wid)->TrailTop_
#define LOCAL_ErrorMessage LOCAL->ErrorMessage_
#define REMOTE_ErrorMessage(wid) REMOTE(wid)->ErrorMessage_
#define LOCAL_Error_Term LOCAL->Error_Term_
#define REMOTE_Error_Term(wid) REMOTE(wid)->Error_Term_
#define LOCAL_ActiveError LOCAL->ActiveError_
#define REMOTE_ActiveError(wid) REMOTE(wid)->ActiveError_
#define LOCAL_BallTerm LOCAL->BallTerm_
#define REMOTE_BallTerm(wid) REMOTE(wid)->BallTerm_
#define LOCAL_IOBotch LOCAL->IOBotch_
#define REMOTE_IOBotch(wid) REMOTE(wid)->IOBotch_
#define LOCAL_tokptr LOCAL->tokptr_
@ -326,6 +318,8 @@
#define REMOTE_FileNameBuf(wid) REMOTE(wid)->FileNameBuf_
#define LOCAL_FileNameBuf2 LOCAL->FileNameBuf2_
#define REMOTE_FileNameBuf2(wid) REMOTE(wid)->FileNameBuf2_
#define LOCAL_TextBuffer LOCAL->TextBuffer_
#define REMOTE_TextBuffer(wid) REMOTE(wid)->TextBuffer_
#define LOCAL_BreakLevel LOCAL->BreakLevel_
#define REMOTE_BreakLevel(wid) REMOTE(wid)->BreakLevel_
@ -350,14 +344,10 @@
#define LOCAL_s_dbg LOCAL->s_dbg_
#define REMOTE_s_dbg(wid) REMOTE(wid)->s_dbg_
#define LOCAL_matherror LOCAL->matherror_
#define REMOTE_matherror(wid) REMOTE(wid)->matherror_
#define LOCAL_mathtt LOCAL->mathtt_
#define REMOTE_mathtt(wid) REMOTE(wid)->mathtt_
#define LOCAL_mathstring LOCAL->mathstring_
#define REMOTE_mathstring(wid) REMOTE(wid)->mathstring_
#define LOCAL_CurrentError LOCAL->CurrentError_
#define REMOTE_CurrentError(wid) REMOTE(wid)->CurrentError_
#define LOCAL_heap_overflows LOCAL->heap_overflows_
#define REMOTE_heap_overflows(wid) REMOTE(wid)->heap_overflows_

11
H/generated/hlocals.h
View File

@ -69,7 +69,6 @@ typedef struct worker_local {
UInt GlobalArenaOverflows_;
Int ArenaOverflows_;
Int DepthArenas_;
int ArithError_;
struct pred_entry* LastAssertedPred_;
struct pred_entry* TmpPred_;
char* ScannerStack_;
@ -164,12 +163,9 @@ typedef struct worker_local {
ADDR GlobalBase_;
ADDR TrailBase_;
ADDR TrailTop_;
char* ErrorMessage_;
Term Error_Term_;
/** error handling info, designed to be easy to pass to the foreign world */
struct yap_error_descriptor ActiveError_;
/* 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
struct DB_TERM* BallTerm_;
jmp_buf IOBotch_;
TokEntry* tokptr_;
TokEntry* toktide_;
@ -184,6 +180,7 @@ typedef struct worker_local {
sigjmp_buf RestartEnv_;
char FileNameBuf_[YAP_FILENAME_MAX+1];
char FileNameBuf2_[YAP_FILENAME_MAX+1];
struct TextBuffer_manager* TextBuffer_;
// Prolog State
UInt BreakLevel_;
Int PrologMode_;
@ -200,10 +197,8 @@ typedef struct worker_local {
//dbase.c
struct db_globs* s_dbg_;
//eval.c
yap_error_number matherror_;
Term mathtt_;
char* mathstring_;
yap_error_number CurrentError_;
//grow.c
int heap_overflows_;
Int total_heap_overflow_time_;

11
H/generated/ilocals.h
View File

@ -69,7 +69,6 @@ static void InitWorker(int wid) {
REMOTE_GlobalArenaOverflows(wid) = 0L;
REMOTE_ArenaOverflows(wid) = 0L;
REMOTE_DepthArenas(wid) = 0;
REMOTE_ArithError(wid) = FALSE;
REMOTE_LastAssertedPred(wid) = NULL;
REMOTE_TmpPred(wid) = NULL;
REMOTE_ScannerStack(wid) = NULL;
@ -165,11 +164,7 @@ static void InitWorker(int wid) {
REMOTE_BallTerm(wid) = NULL;
REMOTE_ActiveError(wid) = calloc(sizeof(yap_error_descriptor_t),1);
@ -185,6 +180,8 @@ static void InitWorker(int wid) {
REMOTE_TextBuffer(wid) = Yap_InitTextAllocator();
REMOTE_BreakLevel(wid) = 0;
REMOTE_PrologMode(wid) = BootMode;
REMOTE_CritLocks(wid) = 0;
@ -200,10 +197,8 @@ static void InitWorker(int wid) {
REMOTE_matherror(wid) = YAP_NO_ERROR;
REMOTE_mathstring(wid) = NULL;
REMOTE_CurrentError(wid) = YAP_NO_ERROR;
REMOTE_heap_overflows(wid) = 0;
REMOTE_total_heap_overflow_time(wid) = 0;

5
H/generated/rlocals.h
View File

@ -86,7 +86,6 @@ static void RestoreWorker(int wid USES_REGS) {
#ifdef COROUTINING
@ -188,8 +187,6 @@ static void RestoreWorker(int wid USES_REGS) {
@ -214,8 +211,6 @@ static void RestoreWorker(int wid USES_REGS) {
#ifdef LOAD_DYLD
#endif

2
H/walkclause.h
View File

@ -1,8 +1,6 @@
/* This file was generated automatically by "yap -L misc/buildops"
please do not update */
while (TRUE) {
op_numbers op;

50
include/YapError.h
View File

@ -76,7 +76,6 @@ INLINE_ONLY extern inline Term Yap_ensure_atom__(const char *fu, const char *fi,
#define JMP_LOCAL_ERROR(v, LAB) \
if (H + 2 * (v) > ASP - 1024) { \
LOCAL_Error_TYPE = RESOURCE_ERROR_STACK; \
LOCAL_Error_Term = t; \
LOCAL_Error_Size = 2 * (v) * sizeof(CELL); \
goto LAB; \
}
@ -84,7 +83,6 @@ INLINE_ONLY extern inline Term Yap_ensure_atom__(const char *fu, const char *fi,
#define LOCAL_ERROR(t, v) \
if (HR + (v) > ASP - 1024) { \
LOCAL_Error_TYPE = RESOURCE_ERROR_STACK; \
LOCAL_Error_Term = t; \
LOCAL_Error_Size = 2 * (v) * sizeof(CELL); \
return NULL; \
}
@ -92,7 +90,6 @@ INLINE_ONLY extern inline Term Yap_ensure_atom__(const char *fu, const char *fi,
#define LOCAL_TERM_ERROR(t, v) \
if (HR + (v) > ASP - 1024) { \
LOCAL_Error_TYPE = RESOURCE_ERROR_STACK; \
LOCAL_Error_Term = t; \
LOCAL_Error_Size = 2 * (v) * sizeof(CELL); \
return 0L; \
}
@ -100,7 +97,6 @@ INLINE_ONLY extern inline Term Yap_ensure_atom__(const char *fu, const char *fi,
#define AUX_ERROR(t, n, s, TYPE) \
if (s + (n + 1) > (TYPE *)AuxSp) { \
LOCAL_Error_TYPE = RESOURCE_ERROR_AUXILIARY_STACK; \
LOCAL_Error_Term = t; \
LOCAL_Error_Size = n * sizeof(TYPE); \
return NULL; \
}
@ -108,7 +104,6 @@ INLINE_ONLY extern inline Term Yap_ensure_atom__(const char *fu, const char *fi,
#define AUX_TERM_ERROR(t, n, s, TYPE) \
if (s + (n + 1) > (TYPE *)AuxSp) { \
LOCAL_Error_TYPE = RESOURCE_ERROR_AUXILIARY_STACK; \
LOCAL_Error_Term = t; \
LOCAL_Error_Size = n * sizeof(TYPE); \
return 0L; \
}
@ -116,7 +111,6 @@ INLINE_ONLY extern inline Term Yap_ensure_atom__(const char *fu, const char *fi,
#define JMP_AUX_ERROR(n, s, t, TYPE, LAB) \
if (s + (n + 1) > (TYPE *)AuxSp) { \
LOCAL_Error_TYPE = RESOURCE_ERROR_AUXILIARY_STACK; \
LOCAL_Error_Term = t; \
LOCAL_Error_Size = n * sizeof(TYPE); \
goto LAB; \
}
@ -124,7 +118,6 @@ INLINE_ONLY extern inline Term Yap_ensure_atom__(const char *fu, const char *fi,
#define HEAP_ERROR(a, TYPE) \
if (a == NIL) { \
LOCAL_Error_TYPE = RESOURCE_ERROR_HEAP; \
LOCAL_Error_Term = t; \
LOCAL_Error_Size = n * sizeof(TYPE); \
return NULL; \
}
@ -132,7 +125,6 @@ INLINE_ONLY extern inline Term Yap_ensure_atom__(const char *fu, const char *fi,
#define HEAP_TERM_ERROR(a, TYPE, n) \
if (a == NIL) { \
LOCAL_Error_TYPE = RESOURCE_ERROR_HEAP; \
LOCAL_Error_Term = t; \
LOCAL_Error_Size = n * sizeof(TYPE); \
return 0L; \
}
@ -140,7 +132,6 @@ INLINE_ONLY extern inline Term Yap_ensure_atom__(const char *fu, const char *fi,
#define JMP_HEAP_ERROR(a, n, t, TYPE, LAB) \
if (a == NIL) { \
LOCAL_Error_TYPE = RESOURCE_ERROR_HEAP; \
LOCAL_Error_Term = t; \
LOCAL_Error_Size = n * sizeof(TYPE); \
goto LAB; \
}
@ -174,6 +165,21 @@ INLINE_ONLY extern inline Term Yap_ensure_atom__(const char *fu, const char *fi,
/// go back t
} yap_error_stage_t;
/// a Prolo goal that caused a bug
typedef struct error_prolog_source {
YAP_Int prologPredCl;
YAP_UInt prologPredLine;
YAP_UInt prologPredFirstLine;
YAP_UInt prologPredLastLine;
YAP_Atom prologPredName;
YAP_UInt prologPredArity;
YAP_Term prologPredModule;
YAP_Atom prologPredFile;
struct DB_TERM *errorGoal;
struct error_prolog_source *errorParent;
} error_prolog_source_t;
/// all we need to know about an error/throw
typedef struct yap_error_descriptor {
enum yap_error_status status;
@ -184,6 +190,7 @@ INLINE_ONLY extern inline Term Yap_ensure_atom__(const char *fu, const char *fi,
YAP_Int errorLine;
const char *errorFunction;
const char *errorFile;
// struct error_prolog_source *errorSource;
YAP_Int prologPredCl;
YAP_UInt prologPredLine;
YAP_UInt prologPredFirstLine;
@ -192,22 +199,33 @@ INLINE_ONLY extern inline Term Yap_ensure_atom__(const char *fu, const char *fi,
YAP_UInt prologPredArity;
YAP_Term prologPredModule;
YAP_Atom prologPredFile;
YAP_UInt prologParserLine;
YAP_UInt prologParserFirstLine;
YAP_UInt prologParserLastLine;
YAP_Atom prologParserName;
YAP_Atom prologParserFile;
YAP_Bool prologConsulting;
struct DB_TERM *errorTerm;
char errorComment[MAX_ERROR_MSG_SIZE];
char *errorMsg;
size_t errorMsgLen;
struct yap_error_descriptor *top_error;
} yap_error_descriptor_t;
/// compatibility with existing code..
#define LOCAL_Error_TYPE LOCAL_ActiveError.errorNo
#define LOCAL_Error_File LOCAL_ActiveError.errorFile
#define LOCAL_Error_Function LOCAL_ActiveError.errorFunction
#define LOCAL_Error_Lineno LOCAL_ActiveError.errorLine
#define LOCAL_Error_Size LOCAL_ActiveError.errorMsgLen
#define LOCAL_ErrorSay LOCAL_ActiveError.errorComment
#define LOCAL_Error_TYPE LOCAL_ActiveError->errorNo
#define LOCAL_Error_File LOCAL_ActiveError->errorFile
#define LOCAL_Error_Function LOCAL_ActiveError->errorFunction
#define LOCAL_Error_Lineno LOCAL_ActiveError->errorLine
#define LOCAL_Error_Size LOCAL_ActiveError->errorMsgLen
#define LOCAL_BallTerm LOCAL_ActiveError->errorTerm
#define LOCAL_ErrorMessage LOCAL_ActiveError->errorMsg
extern bool Yap_find_prolog_culprit();
extern yap_error_class_number Yap_errorClass(yap_error_number e);
extern const char *Yap_errorName(yap_error_number e);
extern const char *Yap_errorClassName(yap_error_class_number e);
extern void Yap_pushErrorContext(yap_error_descriptor_t * new_error);
extern yap_error_descriptor_t *Yap_popErrorContext(void);
#endif

7
os/iopreds.c
View File

@ -1193,8 +1193,7 @@ do_open(Term file_name, Term t2,
if (LOCAL_Error_TYPE != YAP_NO_ERROR) {
if (LOCAL_Error_TYPE == DOMAIN_ERROR_PROLOG_FLAG)
LOCAL_Error_TYPE = DOMAIN_ERROR_OPEN_OPTION;
Yap_Error(LOCAL_Error_TYPE, LOCAL_Error_Term,
"option handling in open/3");
Yap_Error(LOCAL_Error_TYPE, tlist, "option handling in open/3");
}
return false;
}
@ -1700,7 +1699,7 @@ static Int close2(USES_REGS1) { /* '$close'(+GLOBAL_Stream) */
if (LOCAL_Error_TYPE != YAP_NO_ERROR) {
if (LOCAL_Error_TYPE == DOMAIN_ERROR_PROLOG_FLAG)
LOCAL_Error_TYPE = DOMAIN_ERROR_CLOSE_OPTION;
Yap_Error(LOCAL_Error_TYPE, LOCAL_Error_Term, NULL);
Yap_Error(LOCAL_Error_TYPE, tlist, NULL);
}
return false;
return FALSE;
@ -1762,7 +1761,7 @@ static Int abs_file_parameters(USES_REGS1) {
if (LOCAL_Error_TYPE != YAP_NO_ERROR) {
if (LOCAL_Error_TYPE == DOMAIN_ERROR_PROLOG_FLAG)
LOCAL_Error_TYPE = DOMAIN_ERROR_ABSOLUTE_FILE_NAME_OPTION;
Yap_Error(LOCAL_Error_TYPE, LOCAL_Error_Term, NULL);
Yap_Error(LOCAL_Error_TYPE, tlist, NULL);
}
return false;
}

55
os/iopreds.h
View File

@ -24,7 +24,8 @@
#include "YapStreams.h"
static inline bool IsStreamTerm(Term t) {
INLINE_ONLY EXTERN inline UInt PRED_HASH(FunctorEntry *, Term, UInt);
INLINE_ONLY EXTERN inline bool IsStreamTerm(Term t) {
return !IsVarTerm(t) &&
(IsAtomTerm(t) ||
(IsApplTerm(t) && (FunctorOfTerm(t) == FunctorStream)));
@ -121,28 +122,28 @@ extern bool Yap_ReadlineOps(StreamDesc *st);
extern int Yap_OpenBufWriteStream(USES_REGS1);
extern void Yap_ConsoleOps(StreamDesc *s);
void Yap_InitRandomPreds(void);
void Yap_InitSignalPreds(void);
void Yap_InitTimePreds(void);
extern void Yap_InitRandomPreds(void);
extern void Yap_InitSignalPreds(void);
extern void Yap_InitTimePreds(void);
void Yap_init_socks(char *host, long interface_port);
void Yap_InitPipes(void);
void Yap_InitMem(void);
void Yap_InitSockets(void);
void Yap_InitSocketLayer(void);
void Yap_InitMems(void);
void Yap_InitConsole(void);
void Yap_InitReadlinePreds(void);
extern void Yap_init_socks(char *host, long interface_port);
extern void Yap_InitPipes(void);
extern void Yap_InitMem(void);
extern void Yap_InitSockets(void);
extern void Yap_InitSocketLayer(void);
extern void Yap_InitMems(void);
extern void Yap_InitConsole(void);
extern void Yap_InitReadlinePreds(void);
bool Yap_InitReadline(Term);
void Yap_InitChtypes(void);
void Yap_InitCharsio(void);
void Yap_InitFormat(void);
void Yap_InitFiles(void);
void Yap_InitIOStreams(void);
void Yap_InitWriteTPreds(void);
void Yap_InitReadTPreds(void);
void Yap_socketStream(StreamDesc *s);
void Yap_ReadlineFlush(int sno);
extern void Yap_InitChtypes(void);
extern void Yap_InitCharsio(void);
extern void Yap_InitFormat(void);
extern void Yap_InitFiles(void);
extern void Yap_InitIOStreams(void);
extern void Yap_InitWriteTPreds(void);
extern void Yap_InitReadTPreds(void);
extern void Yap_socketStream(StreamDesc *s);
extern void Yap_ReadlineFlush(int sno);
Int Yap_ReadlinePeekChar(int sno);
int Yap_ReadlineForSIGINT(void);
bool Yap_DoPrompt(StreamDesc *s);
@ -150,7 +151,7 @@ bool Yap_DoPrompt(StreamDesc *s);
Int Yap_peek(int sno);
int Yap_MemPeekc(int sno);
Term Yap_syntax_error(TokEntry *tokptr, int sno);
char *Yap_syntax_error(TokEntry *tokptr, int sno);
int console_post_process_read_char(int, StreamDesc *);
int console_post_process_eof(StreamDesc *);
@ -173,15 +174,15 @@ int ResetEOF(StreamDesc *s);
int EOFPeek(int sno);
int EOFWPeek(int sno);
void Yap_SetAlias(Atom arg, int sno);
extern void Yap_SetAlias(Atom arg, int sno);
bool Yap_AddAlias(Atom arg, int sno);
int Yap_CheckAlias(Atom arg);
int Yap_RemoveAlias(Atom arg, int snoinline);
void Yap_SetAlias(Atom arg, int sno);
extern void Yap_SetAlias(Atom arg, int sno);
void Yap_InitAliases(void);
void Yap_DeleteAliases(int sno);
bool Yap_FindStreamForAlias(Atom al);
bool Yap_FetchStreamAlias(int sno, Term t2 USES_REGS);
extern bool Yap_FindStreamForAlias(Atom al);
extern bool Yap_FetchStreamAlias(int sno, Term t2 USES_REGS);
INLINE_ONLY inline EXTERN void count_output_char(int ch, StreamDesc *s);
@ -270,7 +271,7 @@ extern FILE *Yap_stderr;
char *Yap_MemExportStreamPtr(int sno);
bool Yap_Exists(const char *f);
extern bool Yap_Exists(const char *f);
static inline void freeBuffer(const void *ptr) {
CACHE_REGS

80
os/readterm.c
View File

@ -95,7 +95,7 @@ static char SccsId[] = "%W% %G%";
#define SYSTEM_STAT stat
#endif
static Term syntax_error(TokEntry *errtok, int sno, Term cmod);
static char *syntax_error(TokEntry *errtok, int sno, Term cmod);
static void clean_vars(VarEntry *p) {
if (p == NULL)
@ -215,7 +215,7 @@ static const param_t read_defs[] = {READ_DEFS()};
* Implicit arguments:
* +
*/
static Term syntax_error(TokEntry *errtok, int sno, Term cmod) {
static char * syntax_error(TokEntry *errtok, int sno, Term cmod) {
CACHE_REGS
Term info;
Term startline, errline, endline;
@ -264,76 +264,58 @@ static Term syntax_error(TokEntry *errtok, int sno, Term cmod) {
t0[0] = TermNil;
}
ts[0] = Yap_MkApplTerm(Yap_MkFunctor(AtomAtom, 1), 1, t0);
}
break;
case QuasiQuotes_tok:
{
} break;
case QuasiQuotes_tok: {
Term t0[2];
t0[0] = MkAtomTerm(Yap_LookupAtom("<QQ>"));
ts[0] = Yap_MkApplTerm(Yap_MkFunctor(AtomAtom, 1), 1, t0);
}
break;
case WQuasiQuotes_tok:
{
} break;
case WQuasiQuotes_tok: {
Term t0[2];
t0[0] = MkAtomTerm(Yap_LookupAtom("<WideQQ>"));
ts[0] = Yap_MkApplTerm(Yap_MkFunctor(AtomAtom, 1), 1, t0);
}
break;
} break;
case Number_tok:
ts[0] = Yap_MkApplTerm(Yap_MkFunctor(AtomNumber, 1), 1, &(tok->TokInfo));
break;
case Var_tok:
{
case Var_tok: {
Term t[2];
VarEntry *varinfo = (VarEntry *)info;
t[0] = MkIntTerm(0);
t[1] = Yap_CharsToString(varinfo->VarRep, ENC_ISO_LATIN1 PASS_REGS);
ts[0] = Yap_MkApplTerm(Yap_MkFunctor(AtomGVar, 2), 2, t);
}
break;
case String_tok:
{
} break;
case String_tok: {
Term t0 = Yap_CharsToTDQ((char *)info, cmod, ENC_ISO_LATIN1 PASS_REGS);
if (!t0) {
return 0;
}
ts[0] = Yap_MkApplTerm(Yap_MkFunctor(AtomString, 1), 1, &t0);
}
break;
case WString_tok:
{
} break;
case WString_tok: {
Term t0 = Yap_WCharsToTDQ((wchar_t *)info, cmod PASS_REGS);
if (!t0)
return 0;
ts[0] = Yap_MkApplTerm(Yap_MkFunctor(AtomString, 1), 1, &t0);
}
break;
case BQString_tok:
{
} break;
case BQString_tok: {
Term t0 = Yap_CharsToTBQ((char *)info, cmod, ENC_ISO_LATIN1 PASS_REGS);
ts[0] = Yap_MkApplTerm(Yap_MkFunctor(AtomString, 1), 1, &t0);
}
break;
case WBQString_tok:
{
} break;
case WBQString_tok: {
Term t0 = Yap_WCharsToTBQ((wchar_t *)info, cmod PASS_REGS);
ts[0] = Yap_MkApplTerm(Yap_MkFunctor(AtomString, 1), 1, &t0);
}
break;
case Error_tok:
{
} break;
case Error_tok: {
ts[0] = MkAtomTerm(AtomError);
}
break;
} break;
case eot_tok:
endline = MkIntegerTerm(tok->TokPos);
ts[0] = MkAtomTerm(Yap_LookupAtom("EOT"));
break;
case Ponctuation_tok:
{
case Ponctuation_tok: {
char s[2];
s[1] = '\0';
if ((info) == 'l') {
@ -379,10 +361,10 @@ static Term syntax_error(TokEntry *errtok, int sno, Term cmod) {
Yap_DebugPlWriteln(terr);
}
#endif
return terr;
return NULL;
}
Term Yap_syntax_error(TokEntry *errtok, int sno) {
char * Yap_syntax_error(TokEntry *errtok, int sno) {
return syntax_error(errtok, sno, CurrentModule);
}
@ -790,10 +772,10 @@ static parser_state_t initParser(Term opts, FEnv *fe, REnv *re, int inp_stream,
fe->args = setReadEnv(opts, fe, re, inp_stream);
}
if (fe->args == NULL) {
if (LOCAL_Error_TYPE == DOMAIN_ERROR_READ_OPTION)
if (LOCAL_Error_TYPE == DOMAIN_ERROR_OUT_OF_RANGE)
LOCAL_Error_TYPE = DOMAIN_ERROR_READ_OPTION;
if (LOCAL_Error_TYPE)
Yap_Error(LOCAL_Error_TYPE, LOCAL_Error_Term, NULL);
Yap_Error(LOCAL_Error_TYPE, opts, NULL);
fe->t = 0;
return YAP_PARSING_FINISHED;
;
@ -828,7 +810,6 @@ static parser_state_t scan(REnv *re, FEnv *fe, int inp_stream) {
strncpy(out, "Empty clause", len);
LOCAL_ErrorMessage = out;
LOCAL_Error_TYPE = SYNTAX_ERROR;
LOCAL_Error_Term = TermEof;
return YAP_PARSING_ERROR;
}
return scanEOF(fe, inp_stream);
@ -889,13 +870,14 @@ static parser_state_t parseError(REnv *re, FEnv *fe, int inp_stream) {
LOCAL_Error_TYPE = YAP_NO_ERROR;
return YAP_PARSING_FINISHED;
} else {
Term terr = syntax_error(fe->toklast, inp_stream, fe->cmod);
const char*s = syntax_error(fe->toklast, inp_stream, fe->cmod);
if (ParserErrorStyle == TermError) {
LOCAL_ErrorMessage = NULL;
LOCAL_ErrorMessage = s;
LOCAL_Error_TYPE = SYNTAX_ERROR;
return YAP_PARSING_FINISHED;
// dec-10
} else if (Yap_PrintWarning(terr)) {
} else if (Yap_PrintWarning(MkStringTerm(s))) {
free(s);
LOCAL_Error_TYPE = YAP_NO_ERROR;
return YAP_SCANNING;
}
@ -961,8 +943,7 @@ Term Yap_read_term(int inp_stream, Term opts, int nargs) {
case YAP_PARSING_ERROR:
state = parseError(&re, &fe, inp_stream);
break;
case YAP_PARSING_FINISHED:
{
case YAP_PARSING_FINISHED: {
CACHE_REGS
bool done;
if (fe.reading_clause)
@ -1165,7 +1146,8 @@ static Int read_clause(
/**
* @pred source_location( - _File_ , _Line_ )
*
* unify _File_ and _Line_ wuth the position of the last term read, if the term
* unify _File_ and _Line_ wuth the position of the last term read, if the
*term
* comes from a stream created by opening a file-system path with open/3 and
*friends.>position
* It ignores user_input or

37
os/sig.c
View File

@ -1,7 +1,6 @@
#include "sysbits.h"
#if HAVE_SIGINFO_H
#include <siginfo.h>
#endif
@ -15,7 +14,6 @@
#define SIG_PROLOG_OFFSET 32 /* Start of Prolog signals */
#define SIG_EXCEPTION (SIG_PROLOG_OFFSET + 0)
#ifdef O_ATOMGC
#define SIG_ATOM_GC (SIG_PROLOG_OFFSET + 1)
@ -27,12 +25,11 @@
#define SIG_FREECLAUSES (SIG_PROLOG_OFFSET + 4)
#define SIG_PLABORT (SIG_PROLOG_OFFSET + 5)
static struct signame
{ int sig;
static struct signame {
int sig;
const char *name;
int flags;
} signames[] =
{
} signames[] = {
#ifdef SIGHUP
{SIGHUP, "hup", 0},
#endif
@ -122,7 +119,6 @@ static struct signame
{-1, NULL, 0}};
#if HAVE_SIGACTION
static void my_signal_info(int sig, void *handler) {
struct sigaction sigact;
@ -160,15 +156,13 @@ static void my_signal_info(int sig, void *handler) {
#endif
static void HandleMatherr(int sig, void *sipv, void *uapv) {
CACHE_REGS
LOCAL_matherror = Yap_MathException();
LOCAL_Error_TYPE = Yap_MathException();
/* reset the registers so that we don't have trash in abstract machine */
Yap_external_signal(worker_id, YAP_FPE_SIGNAL);
}
/* SWI emulation */
int Yap_signal_index(const char *name) {
struct signame *sn = signames;
@ -318,10 +312,8 @@ static bool set_fpu_exceptions(Term flag) {
return true;
}
#if !defined(LIGHT) && !_MSC_VER && !defined(__MINGW32__)
static void ReceiveSignal(int s, void *x, void *y) {
CACHE_REGS
LOCAL_PrologMode |= InterruptMode;
@ -412,7 +404,6 @@ static BOOL WINAPI MSCHandleSignal(DWORD dwCtrlType) {
}
#endif
/* wrapper for alarm system call */
#if _MSC_VER || defined(__MINGW32__)
@ -671,7 +662,6 @@ VaxFixFrame(dummy) {
#if defined(_WIN32)
int WINAPI win_yap(HANDLE, DWORD, LPVOID);
int WINAPI win_yap(HANDLE hinst, DWORD reason, LPVOID reserved) {
@ -821,15 +811,7 @@ yap_error_number Yap_MathException__(USES_REGS1) {
set_fpu_exceptions(0);
#endif
return LOCAL_matherror;
}
static Int fpe_error(USES_REGS1) {
Yap_Error(LOCAL_matherror, LOCAL_mathtt, LOCAL_mathstring);
LOCAL_matherror = YAP_NO_ERROR;
LOCAL_mathtt = TermNil;
LOCAL_mathstring = NULL;
return FALSE;
return LOCAL_Error_TYPE;
}
/* SIGINT can cause problems, if caught before full initialization */
@ -865,18 +847,11 @@ void Yap_InitOSSignals(int wid) {
}
}
bool Yap_set_fpu_exceptions(Term flag) {
return set_fpu_exceptions(flag);
}
bool Yap_set_fpu_exceptions(Term flag) { return set_fpu_exceptions(flag); }
void Yap_InitSignalPreds(void) {
CACHE_REGS
Term cm = CurrentModule;
Yap_InitCPred("$fpe_error", 0, fpe_error, 0);
Yap_InitCPred("$alarm", 4, alarm4, SafePredFlag | SyncPredFlag);
CurrentModule = HACKS_MODULE;
Yap_InitCPred("virtual_alarm", 4, virtual_alarm, SafePredFlag | SyncPredFlag);

1
os/sysbits.h
View File

@ -41,7 +41,6 @@
#endif
#endif
#ifdef HAVE_UNISTD_H
#include <unistd.h>
#endif

267
os/time.c
View File

@ -45,16 +45,18 @@ static struct timeval StartOfTimes_sys;
#endif
/* store user time in this variable */
void
Yap_InitTime (int wid)
{
void Yap_InitTime(int wid) {
struct rusage rusage;
#if THREADS
REMOTE_ThreadHandle(wid).start_of_timesp = (struct timeval *)malloc(sizeof(struct timeval));
REMOTE_ThreadHandle(wid).last_timep = (struct timeval *)malloc(sizeof(struct timeval));
REMOTE_ThreadHandle(wid).start_of_times_sysp = (struct timeval *)malloc(sizeof(struct timeval));
REMOTE_ThreadHandle(wid).last_time_sysp = (struct timeval *)malloc(sizeof(struct timeval));
REMOTE_ThreadHandle(wid).start_of_timesp =
(struct timeval *)malloc(sizeof(struct timeval));
REMOTE_ThreadHandle(wid).last_timep =
(struct timeval *)malloc(sizeof(struct timeval));
REMOTE_ThreadHandle(wid).start_of_times_sysp =
(struct timeval *)malloc(sizeof(struct timeval));
REMOTE_ThreadHandle(wid).last_time_sysp =
(struct timeval *)malloc(sizeof(struct timeval));
getrusage(RUSAGE_SELF, &rusage);
(*REMOTE_ThreadHandle(wid).last_timep).tv_sec =
(*REMOTE_ThreadHandle(wid).start_of_timesp).tv_sec =
@ -70,25 +72,14 @@ Yap_InitTime (int wid)
rusage.ru_stime.tv_usec;
#else
getrusage(RUSAGE_SELF, &rusage);
last_time.tv_sec =
StartOfTimes.tv_sec =
rusage.ru_utime.tv_sec;
last_time.tv_usec =
StartOfTimes.tv_usec =
rusage.ru_utime.tv_usec;
last_time_sys.tv_sec =
StartOfTimes_sys.tv_sec =
rusage.ru_stime.tv_sec;
last_time_sys.tv_usec =
StartOfTimes_sys.tv_usec =
rusage.ru_stime.tv_usec;
last_time.tv_sec = StartOfTimes.tv_sec = rusage.ru_utime.tv_sec;
last_time.tv_usec = StartOfTimes.tv_usec = rusage.ru_utime.tv_usec;
last_time_sys.tv_sec = StartOfTimes_sys.tv_sec = rusage.ru_stime.tv_sec;
last_time_sys.tv_usec = StartOfTimes_sys.tv_usec = rusage.ru_stime.tv_usec;
#endif
}
UInt
Yap_cputime ( void )
{
UInt Yap_cputime(void) {
CACHE_REGS
struct rusage rusage;
@ -97,8 +88,7 @@ Yap_cputime ( void )
((rusage.ru_utime.tv_usec - StartOfTimes.tv_usec) / 1000);
}
void Yap_cputime_interval(Int *now,Int *interval)
{
void Yap_cputime_interval(Int *now, Int *interval) {
CACHE_REGS
struct rusage rusage;
@ -111,8 +101,7 @@ void Yap_cputime_interval(Int *now,Int *interval)
last_time.tv_sec = rusage.ru_utime.tv_sec;
}
void Yap_systime_interval(Int *now,Int *interval)
{
void Yap_systime_interval(Int *now, Int *interval) {
CACHE_REGS
struct rusage rusage;
@ -132,7 +121,8 @@ void Yap_systime_interval(Int *now,Int *interval)
/* This is stolen from the Linux kernel.
The problem is that mingw32 does not seem to have acces to div */
#ifndef do_div
#define do_div(n,base) ({ \
#define do_div(n, base) \
({ \
unsigned long __upper, __low, __high, __mod; \
asm("" : "=a"(__low), "=d"(__high) : "A"(n)); \
__upper = __high; \
@ -140,7 +130,9 @@ void Yap_systime_interval(Int *now,Int *interval)
__upper = __high % (base); \
__high = __high / (base); \
} \
asm("divl %2":"=a" (__low), "=d" (__mod):"rm" (base), "0" (__low), "1" (__upper)); \
asm("divl %2" \
: "=a"(__low), "=d"(__mod) \
: "rm"(base), "0"(__low), "1"(__upper)); \
asm("" : "=A"(n) : "a"(__low), "d"(__high)); \
__mod; \
})
@ -148,8 +140,6 @@ void Yap_systime_interval(Int *now,Int *interval)
#endif
#include <time.h>
static FILETIME StartOfTimes, last_time;
@ -159,22 +149,25 @@ static FILETIME StartOfTimes_sys, last_time_sys;
static clock_t TimesStartOfTimes, Times_last_time;
/* store user time in this variable */
void
Yap_InitTime (int wid)
{
void Yap_InitTime(int wid) {
HANDLE hProcess = GetCurrentProcess();
FILETIME CreationTime, ExitTime, KernelTime, UserTime;
if (!GetProcessTimes(hProcess, &CreationTime, &ExitTime, &KernelTime, &UserTime)) {
if (!GetProcessTimes(hProcess, &CreationTime, &ExitTime, &KernelTime,
&UserTime)) {
/* WIN98 */
clock_t t;
t = clock();
Times_last_time = TimesStartOfTimes = t;
} else {
#if THREADS
REMOTE_ThreadHandle(wid).start_of_timesp = (struct _FILETIME *)malloc(sizeof(FILETIME));
REMOTE_ThreadHandle(wid).last_timep = (struct _FILETIME *)malloc(sizeof(FILETIME));
REMOTE_ThreadHandle(wid).start_of_times_sysp = (struct _FILETIME *)malloc(sizeof(FILETIME));
REMOTE_ThreadHandle(wid).last_time_sysp = (struct _FILETIME *)malloc(sizeof(FILETIME));
REMOTE_ThreadHandle(wid).start_of_timesp =
(struct _FILETIME *)malloc(sizeof(FILETIME));
REMOTE_ThreadHandle(wid).last_timep =
(struct _FILETIME *)malloc(sizeof(FILETIME));
REMOTE_ThreadHandle(wid).start_of_times_sysp =
(struct _FILETIME *)malloc(sizeof(FILETIME));
REMOTE_ThreadHandle(wid).last_time_sysp =
(struct _FILETIME *)malloc(sizeof(FILETIME));
(*REMOTE_ThreadHandle(wid).last_timep).dwLowDateTime =
UserTime.dwLowDateTime;
(*REMOTE_ThreadHandle(wid).last_timep).dwHighDateTime =
@ -192,51 +185,38 @@ Yap_InitTime (int wid)
(*REMOTE_ThreadHandle(wid).start_of_times_sysp).dwHighDateTime =
KernelTime.dwHighDateTime;
#else
last_time.dwLowDateTime =
UserTime.dwLowDateTime;
last_time.dwHighDateTime =
UserTime.dwHighDateTime;
StartOfTimes.dwLowDateTime =
UserTime.dwLowDateTime;
StartOfTimes.dwHighDateTime =
UserTime.dwHighDateTime;
last_time_sys.dwLowDateTime =
KernelTime.dwLowDateTime;
last_time_sys.dwHighDateTime =
KernelTime.dwHighDateTime;
StartOfTimes_sys.dwLowDateTime =
KernelTime.dwLowDateTime;
StartOfTimes_sys.dwHighDateTime =
KernelTime.dwHighDateTime;
last_time.dwLowDateTime = UserTime.dwLowDateTime;
last_time.dwHighDateTime = UserTime.dwHighDateTime;
StartOfTimes.dwLowDateTime = UserTime.dwLowDateTime;
StartOfTimes.dwHighDateTime = UserTime.dwHighDateTime;
last_time_sys.dwLowDateTime = KernelTime.dwLowDateTime;
last_time_sys.dwHighDateTime = KernelTime.dwHighDateTime;
StartOfTimes_sys.dwLowDateTime = KernelTime.dwLowDateTime;
StartOfTimes_sys.dwHighDateTime = KernelTime.dwHighDateTime;
#endif
}
}
#ifdef __GNUC__
static unsigned long long int
sub_utime(FILETIME t1, FILETIME t2)
{
static unsigned long long int sub_utime(FILETIME t1, FILETIME t2) {
ULARGE_INTEGER u[2];
memcpy((void *)u, (void *)&t1, sizeof(FILETIME));
memcpy((void *)(u + 1), (void *)&t2, sizeof(FILETIME));
return
u[0].QuadPart - u[1].QuadPart;
return u[0].QuadPart - u[1].QuadPart;
}
#endif
UInt
Yap_cputime ( void )
{
UInt Yap_cputime(void) {
HANDLE hProcess = GetCurrentProcess();
FILETIME CreationTime, ExitTime, KernelTime, UserTime;
if (!GetProcessTimes(hProcess, &CreationTime, &ExitTime, &KernelTime, &UserTime)) {
if (!GetProcessTimes(hProcess, &CreationTime, &ExitTime, &KernelTime,
&UserTime)) {
clock_t t;
t = clock();
return (((t - TimesStartOfTimes) * 1000) / CLOCKS_PER_SEC);
} else {
#ifdef __GNUC__
unsigned long long int t =
sub_utime(UserTime,StartOfTimes);
unsigned long long int t = sub_utime(UserTime, StartOfTimes);
do_div(t, 10000);
return ((Int)t);
#endif
@ -247,11 +227,11 @@ Yap_cputime ( void )
}
}
void Yap_cputime_interval(Int *now,Int *interval)
{
void Yap_cputime_interval(Int *now, Int *interval) {
HANDLE hProcess = GetCurrentProcess();
FILETIME CreationTime, ExitTime, KernelTime, UserTime;
if (!GetProcessTimes(hProcess, &CreationTime, &ExitTime, &KernelTime, &UserTime)) {
if (!GetProcessTimes(hProcess, &CreationTime, &ExitTime, &KernelTime,
&UserTime)) {
clock_t t;
t = clock();
*now = ((t - TimesStartOfTimes) * 1000) / CLOCKS_PER_SEC;
@ -259,10 +239,8 @@ void Yap_cputime_interval(Int *now,Int *interval)
Times_last_time = t;
} else {
#ifdef __GNUC__
unsigned long long int t1 =
sub_utime(UserTime, StartOfTimes);
unsigned long long int t2 =
sub_utime(UserTime, last_time);
unsigned long long int t1 = sub_utime(UserTime, StartOfTimes);
unsigned long long int t2 = sub_utime(UserTime, last_time);
do_div(t1, 10000);
*now = (Int)t1;
do_div(t2, 10000);
@ -279,18 +257,16 @@ void Yap_cputime_interval(Int *now,Int *interval)
}
}
void Yap_systime_interval(Int *now,Int *interval)
{
void Yap_systime_interval(Int *now, Int *interval) {
HANDLE hProcess = GetCurrentProcess();
FILETIME CreationTime, ExitTime, KernelTime, UserTime;
if (!GetProcessTimes(hProcess, &CreationTime, &ExitTime, &KernelTime, &UserTime)) {
if (!GetProcessTimes(hProcess, &CreationTime, &ExitTime, &KernelTime,
&UserTime)) {
*now = *interval = 0; /* not available */
} else {
#ifdef __GNUC__
unsigned long long int t1 =
sub_utime(KernelTime, StartOfTimes_sys);
unsigned long long int t2 =
sub_utime(KernelTime, last_time_sys);
unsigned long long int t1 = sub_utime(KernelTime, StartOfTimes_sys);
unsigned long long int t2 = sub_utime(KernelTime, last_time_sys);
do_div(t1, 10000);
*now = (Int)t1;
do_div(t2, 10000);
@ -332,7 +308,8 @@ void Yap_systime_interval(Int *now,Int *interval)
#define TicksPerSec CLK_TCK
#endif
#if defined(__alpha) || defined(__FreeBSD__) || defined(__linux__) || defined(__DragonFly__)
#if defined(__alpha) || defined(__FreeBSD__) || defined(__linux__) || \
defined(__DragonFly__)
#if HAVE_TIME_H
#include <time.h>
@ -353,25 +330,20 @@ static clock_t StartOfTimes, last_time;
static clock_t StartOfTimes_sys, last_time_sys;
/* store user time in this variable */
static void
InitTime (void)
{
static void InitTime(void) {
struct tms t;
times(&t);
(*REMOTE_ThreadHandle(wid).last_timep) = StartOfTimes = t.tms_utime;
last_time_sys = StartOfTimes_sys = t.tms_stime;
}
UInt
Yap_cputime (void)
{
UInt Yap_cputime(void) {
struct tms t;
times(&t);
return ((t.tms_utime - StartOfTimes) * 1000 / TicksPerSec);
}
void Yap_cputime_interval(Int *now,Int *interval)
{
void Yap_cputime_interval(Int *now, Int *interval) {
struct tms t;
times(&t);
*now = ((t.tms_utime - StartOfTimes) * 1000) / TicksPerSec;
@ -379,8 +351,7 @@ void Yap_cputime_interval(Int *now,Int *interval)
last_time = t.tms_utime;
}
void Yap_systime_interval(Int *now,Int *interval)
{
void Yap_systime_interval(Int *now, Int *interval) {
struct tms t;
times(&t);
*now = ((t.tms_stime - StartOfTimes_sys) * 1000) / TicksPerSec;
@ -401,20 +372,17 @@ static struct timeval StartOfTimes;
static struct timeval last_time;
/* store user time in this variable */
static void
InitTime (int wid)
{
static void InitTime(int wid) {
struct timeval tp;
gettimeofday(&tp, NULL);
(*REMOTE_ThreadHandle(wid).last_timep).tv_sec = (*REMOTE_ThreadHandle.start_of_timesp(wid)).tv_sec = tp.tv_sec;
(*REMOTE_ThreadHandle(wid).last_timep).tv_usec = (*REMOTE_ThreadHandle.start_of_timesp(wid)).tv_usec = tp.tv_usec;
(*REMOTE_ThreadHandle(wid).last_timep).tv_sec =
(*REMOTE_ThreadHandle.start_of_timesp(wid)).tv_sec = tp.tv_sec;
(*REMOTE_ThreadHandle(wid).last_timep).tv_usec =
(*REMOTE_ThreadHandle.start_of_timesp(wid)).tv_usec = tp.tv_usec;
}
UInt
Yap_cputime (void)
{
UInt Yap_cputime(void) {
struct timeval tp;
gettimeofday(&tp, NULL);
@ -426,8 +394,7 @@ Yap_cputime (void)
((tp.tv_usec - StartOfTimes.tv_usec) / 1000);
}
void Yap_cputime_interval(Int *now,Int *interval)
{
void Yap_cputime_interval(Int *now, Int *interval) {
struct timeval tp;
gettimeofday(&tp, NULL);
@ -439,8 +406,7 @@ void Yap_cputime_interval(Int *now,Int *interval)
last_time.tv_sec = tp.tv_sec;
}
void Yap_systime_interval(Int *now,Int *interval)
{
void Yap_systime_interval(Int *now, Int *interval) {
*now = *interval = 0; /* not available */
}
@ -450,16 +416,12 @@ void Yap_systime_interval(Int *now,Int *interval)
/* This code is not working properly. I left it here to help future ports */
#ifdef MPW
#include <files.h>
#include <Events.h>
#include <files.h>
#define TicksPerSec 60.0
static double
real_cputime ()
{
return (((double) TickCount ()) / TicksPerSec);
}
static double real_cputime() { return (((double)TickCount()) / TicksPerSec); }
#endif /* MPW */
@ -469,14 +431,9 @@ real_cputime ()
static long *ptime;
gettime ()
{
*ptime = *(long *) 0x462;
}
gettime() { *ptime = *(long *)0x462; }
static double
real_cputime ()
{
static double real_cputime() {
long thetime;
ptime = &thetime;
xbios(38, gettime);
@ -492,15 +449,9 @@ real_cputime ()
static long *ptime;
static long
readtime ()
{
return (*((long *) 0x4ba));
}
static long readtime() { return (*((long *)0x4ba)); }
static double
real_cputime ()
{
static double real_cputime() {
long time;
time = Supexec(readtime);
@ -518,11 +469,7 @@ real_cputime ()
#define TicksPerSec 60.0
static double
real_cputime ()
{
return (((double) TickCount ()) / TicksPerSec);
}
static double real_cputime() { return (((double)TickCount()) / TicksPerSec); }
#endif /* LIGHT */
@ -540,48 +487,35 @@ uint64_t Yap_StartOfWTimes;
/* since the point YAP was started */
void
Yap_InitWTime (void)
{
Yap_StartOfWTimes = (uint64_t)gethrtime();
}
void Yap_InitWTime(void) { Yap_StartOfWTimes = (uint64_t)gethrtime(); }
/// returns time since Jan 1 1980 in nano-seconds
uint64_t Yap_walltime(uint64_t old)
{
uint64_t Yap_walltime(uint64_t old) {
hrtime_t tp = gethrtime();
/* return time in milliseconds */
return = (uint64_t)tp;
return (uint64_t)tp;
}
#elif HAVE_GETTIMEOFDAY
/* since the point YAP was started */
/* store user time in this variable */
void
Yap_InitWTime (void)
{
void Yap_InitWTime(void) {
struct timeval tp;
gettimeofday(&tp, NULL);
Yap_StartOfWTimes = (uint64_t)tp.tv_sec * 1000000000 + (uint64_t)tp.tv_usec * 1000;
Yap_StartOfWTimes =
(uint64_t)tp.tv_sec * 1000000000 + (uint64_t)tp.tv_usec * 1000;
}
/// returns time in nano-secs since the epoch
uint64_t
Yap_walltime(void)
{
uint64_t Yap_walltime(void) {
struct timeval tp;
gettimeofday(&tp, NULL);
return (uint64_t)tp.tv_sec * 1000000000 + (uint64_t)tp.tv_usec * 1000;
}
#elif defined(_WIN32)
#include <sys/timeb.h>
@ -591,9 +525,7 @@ Yap_walltime(void)
static LARGE_INTEGER Frequency;
/* store user time in this variable */
void
Yap_InitWTime (void)
{
void Yap_InitWTime(void) {
LARGE_INTEGER ElapsedNanoseconds;
QueryPerformanceFrequency(&Frequency);
QueryPerformanceCounter(&ElapsedNanoseconds);
@ -602,11 +534,7 @@ Yap_InitWTime (void)
Yap_StartOfWTimes = (uint64_t)ElapsedNanoseconds.QuadPart;
}
uint64_t
Yap_walltime (void)
{
uint64_t Yap_walltime(void) {
LARGE_INTEGER ElapsedNanoseconds;
QueryPerformanceCounter(&ElapsedNanoseconds);
//
@ -625,33 +553,22 @@ Yap_walltime (void)
#elif HAVE_TIMES
/* store user time in this variable */
void
Yap_InitWTime (void)
{
void Yap_InitWTime(void) {
// start thread 0
REMOTE_LastWTime(0) =
Yap_StartOfWTimes = ((uint64_t)times(NULL))*10000000/TicksPerSec;
REMOTE_LastWTime(0) = Yap_StartOfWTimes =
((uint64_t)times(NULL)) * 10000000 / TicksPerSec;
}
uint64_t
Yap_walltime (void)
{
uint64_t Yap_walltime(void) {
clock_t t;
t = times(NULL);
return = ((uint64_t)times(NULL)) * 10000000 / TicksPerSec;
}
#endif /* HAVE_TIMES */
void
Yap_ReInitWTime (void)
{
Yap_InitWTime();
}
void Yap_ReInitWTime(void) { Yap_InitWTime(); }
void
Yap_InitTimePreds(void)
{
void Yap_InitTimePreds(void) {
/* can only do after heap is initialized */
Yap_InitWTime();
}

27
os/writeterm.c
View File

@ -88,7 +88,6 @@ static char SccsId[] = "%W% %G%";
#endif
#include "iopreds.h"
static Term readFromBuffer(const char *s, Term opts) {
Term rval;
int sno;
@ -291,14 +290,13 @@ end:
/**
*
*/
bool Yap_WriteTerm( int output_stream, Term t, Term opts USES_REGS)
{
bool Yap_WriteTerm(int output_stream, Term t, Term opts USES_REGS) {
xarg *args = Yap_ArgListToVector(opts, write_defs, WRITE_END);
if (args == NULL) {
if (LOCAL_Error_TYPE == DOMAIN_ERROR_OUT_OF_RANGE)
LOCAL_Error_TYPE = DOMAIN_ERROR_WRITE_OPTION;
if (LOCAL_Error_TYPE)
Yap_Error(LOCAL_Error_TYPE, LOCAL_Error_Term, NULL);
Yap_Error(LOCAL_Error_TYPE, opts, NULL);
return false;
}
yhandle_t mySlots = Yap_StartSlots();
@ -343,7 +341,7 @@ static Int write2(USES_REGS1) {
if (LOCAL_Error_TYPE == DOMAIN_ERROR_OUT_OF_RANGE)
LOCAL_Error_TYPE = DOMAIN_ERROR_WRITE_OPTION;
if (LOCAL_Error_TYPE)
Yap_Error(LOCAL_Error_TYPE, LOCAL_Error_Term, NULL);
Yap_Error(LOCAL_Error_TYPE, TermNil, NULL);
return false;
}
mySlots = Yap_StartSlots();
@ -369,7 +367,7 @@ static Int write1(USES_REGS1) {
if (LOCAL_Error_TYPE == DOMAIN_ERROR_OUT_OF_RANGE)
LOCAL_Error_TYPE = DOMAIN_ERROR_WRITE_OPTION;
if (LOCAL_Error_TYPE)
Yap_Error(LOCAL_Error_TYPE, LOCAL_Error_Term, NULL);
Yap_Error(LOCAL_Error_TYPE, TermNil, NULL);
return false;
}
yhandle_t mySlots = Yap_StartSlots();
@ -396,7 +394,7 @@ static Int write_canonical1(USES_REGS1) {
if (LOCAL_Error_TYPE == DOMAIN_ERROR_OUT_OF_RANGE)
LOCAL_Error_TYPE = DOMAIN_ERROR_WRITE_OPTION;
if (LOCAL_Error_TYPE)
Yap_Error(LOCAL_Error_TYPE, LOCAL_Error_Term, NULL);
Yap_Error(LOCAL_Error_TYPE, TermNil, NULL);
return false;
}
yhandle_t mySlots = Yap_StartSlots();
@ -422,7 +420,7 @@ static Int write_canonical(USES_REGS1) {
if (LOCAL_Error_TYPE == DOMAIN_ERROR_OUT_OF_RANGE)
LOCAL_Error_TYPE = DOMAIN_ERROR_WRITE_OPTION;
if (LOCAL_Error_TYPE)
Yap_Error(LOCAL_Error_TYPE, LOCAL_Error_Term, NULL);
Yap_Error(LOCAL_Error_TYPE, TermNil, NULL);
return false;
}
int output_stream = Yap_CheckTextStream(ARG1, Output_Stream_f, "write/2");
@ -452,7 +450,7 @@ static Int writeq1(USES_REGS1) {
if (LOCAL_Error_TYPE == DOMAIN_ERROR_OUT_OF_RANGE)
LOCAL_Error_TYPE = DOMAIN_ERROR_WRITE_OPTION;
if (LOCAL_Error_TYPE)
Yap_Error(LOCAL_Error_TYPE, LOCAL_Error_Term, NULL);
Yap_Error(LOCAL_Error_TYPE, TermNil, NULL);
return false;
}
yhandle_t mySlots = Yap_StartSlots();
@ -482,7 +480,7 @@ static Int writeq(USES_REGS1) {
if (LOCAL_Error_TYPE == DOMAIN_ERROR_OUT_OF_RANGE)
LOCAL_Error_TYPE = DOMAIN_ERROR_WRITE_OPTION;
if (LOCAL_Error_TYPE)
Yap_Error(LOCAL_Error_TYPE, LOCAL_Error_Term, NULL);
Yap_Error(LOCAL_Error_TYPE, TermNil, NULL);
return false;
}
int output_stream = Yap_CheckTextStream(ARG1, Output_Stream_f, "write/2");
@ -512,7 +510,7 @@ static Int print1(USES_REGS1) {
if (LOCAL_Error_TYPE == DOMAIN_ERROR_OUT_OF_RANGE)
LOCAL_Error_TYPE = DOMAIN_ERROR_WRITE_OPTION;
if (LOCAL_Error_TYPE)
Yap_Error(LOCAL_Error_TYPE, LOCAL_Error_Term, NULL);
Yap_Error(LOCAL_Error_TYPE, TermNil, NULL);
return false;
}
yhandle_t mySlots = Yap_StartSlots();
@ -543,7 +541,7 @@ static Int print(USES_REGS1) {
if (LOCAL_Error_TYPE == DOMAIN_ERROR_OUT_OF_RANGE)
LOCAL_Error_TYPE = DOMAIN_ERROR_WRITE_OPTION;
if (LOCAL_Error_TYPE)
Yap_Error(LOCAL_Error_TYPE, LOCAL_Error_Term, NULL);
Yap_Error(LOCAL_Error_TYPE, TermNil, NULL);
return false;
}
int output_stream = Yap_CheckTextStream(ARG1, Output_Stream_f, "write/2");
@ -574,7 +572,7 @@ static Int writeln1(USES_REGS1) {
xarg *args = Yap_ArgListToVector(TermNil, write_defs, WRITE_END);
if (args == NULL) {
if (LOCAL_Error_TYPE)
Yap_Error(LOCAL_Error_TYPE, LOCAL_Error_Term, NULL);
Yap_Error(LOCAL_Error_TYPE, TermNil, NULL);
return false;
}
yhandle_t mySlots = Yap_StartSlots();
@ -598,7 +596,7 @@ static Int writeln(USES_REGS1) {
xarg *args = Yap_ArgListToVector(TermNil, write_defs, WRITE_END);
if (args == NULL) {
if (LOCAL_Error_TYPE)
Yap_Error(LOCAL_Error_TYPE, LOCAL_Error_Term, NULL);
Yap_Error(LOCAL_Error_TYPE, TermNil, NULL);
return false;
}
int output_stream = Yap_CheckTextStream(ARG1, Output_Stream_f, "writeln/2");
@ -676,7 +674,6 @@ static Int dollar_var(USES_REGS1) {
return Yap_unify(tv, ARG2);
}
static Int term_to_string(USES_REGS1) {
Term t2 = Deref(ARG2), rc = false, t1 = Deref(ARG1);
const char *s;

60
packages/python/pandas.yap
View File

@ -1,7 +1,61 @@
%matplotlib inline
import numpy as np
import seaborn as sns
import matplotlib.pyplot as plt
sns.set(style="white", context="talk")
rs = np.random.RandomState(7)
:- use_module( library(python) ).
pos={0:(0,0),
1:(1,0),
2:(0,1),
3:(1,1),
4:(0.1,0.9),
5:(0.3,1.1),
6:(0.9,0.9)
}
:- := import(pandas)).
names={4:'MMM',
5:'XXX',
6:'ZZZ'}
pred2panda(Pred, Obj) :-
def plot1(y10,y20):
def gen(f,f0):
return [f[0],f[1],-f[2]]/max(f,f0)
ax1 = plt.subplot2grid((1,2), (0,0), colspan=2)
ax2 = plt.subplot2grid((1,2), (0,1), colspan=2)
ax3 = plt.subplot2grid((2,2), (2,0), colspan=2, rowspan=2)
xs = ["+-","++","--"]
y1 = gen(y10, y20)
sns.barplot(xs, y1, palette="RdBu_r", ax=ax1)
y2 = gen(y20,y10)
sns.barplot(xs, y2, palette="Set3", ax=ax2)
# Finalize the plot
# sns.despine(bottom=True)
G=nx.Graph()
i=0
G.pos={} # location
G.pop={} # size
lpos={0:(0,0),1:(0,0),2:(0,0),3:(0,0)}
last=len(pos)-1
for i in range(4,len(pos)):
G.pos[i]=pos[i]
G.pop[i]=2000
(x,y) = pos[i]
lpos[i] = (x,y-0.05)
if i > 4:
G.add_edge(i-1,i)
else:
G.add_edge(2,i)
G.add_edge(3,last)
nx.draw_networkx_nodes(G,pos,nodelist=range(4,len(pos)),ax=ax3)
nx.draw_networkx_nodes(G,pos,nodelist=[0,1,2,3],node_color='b',ax=ax3)
nx.draw_networkx_edges(G,pos,alpha=0.5,ax=ax3)
nx.draw_networkx_labels(G,lpos,names,alpha=0.5,ax=ax3)
plt.axis('off')
plt.tight_layout(h_pad=3)
plt.savefig("house_with_colors.png") # save as png
plot1([20,30,10],[30,30,5])

3
packages/python/python.h
View File

@ -39,6 +39,8 @@ extern PyObject *py_F2P;
extern bool python_in_python;
#define PythonReturn PyGILState_Release(gstate) && return
static inline Py_ssize_t get_p_int(PyObject *o, Py_ssize_t def) {
if (o == NULL)
return def;
@ -94,7 +96,6 @@ static inline PyObject *atom_to_python_string(term_t t) {
extern PyObject *compound_to_pyeval(term_t t, functor_t fun);
extern PyObject *compound_to_pytree(term_t t, functor_t fun);
extern PyObject *yap_to_python(YAP_Term t, bool eval);
extern PyObject *term_to_python(term_t t, bool eval);
extern foreign_t python_to_ptr(PyObject *pVal, term_t t);

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

@ -138,9 +138,9 @@ class YAPKernel(KernelBase):
implementation = 'YAP'
implementation_version = release.version
language_info = {
'name': 'python',
'name': 'prolog',
'version': sys.version.split()[0],
'mimetype': 'text/x-python',
'mimetype': 'text/x-prolog',
'codemirror_mode': {
'name': 'prolog',
'version': sys.version_info[0]

34
packages/raptor/raptor_yap.c
View File

@ -15,13 +15,13 @@
* Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
* Boston, MA 02110-1301, USA.
*/
#include <stdio.h>
#include <stdarg.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "raptor_config.h"
#include "YapInterface.h"
#include "raptor_config.h"
#ifdef HAVE_RAPTOR2_RAPTOR2_H
#include "raptor2/raptor2.h"
#else
@ -38,9 +38,7 @@ struct exo_aux {
size_t n;
};
static YAP_Atom
term_load(const raptor_term *term)
{
static YAP_Atom term_load(const raptor_term *term) {
size_t len;
switch (term->type) {
case RAPTOR_TERM_TYPE_LITERAL:
@ -52,11 +50,14 @@ term_load(const raptor_term *term)
return YAP_LookupAtom((const char *)term->value.blank.string);
case RAPTOR_TERM_TYPE_URI:
// fprintf(stderr, "%s,", raptor_uri_as_counted_string(term->value.uri, &len));
return YAP_LookupAtom((const char *)raptor_uri_as_counted_string(term->value.uri, &len));
// fprintf(stderr, "%s,",
// raptor_uri_as_counted_string(term->value.uri, &len));
return YAP_LookupAtom(
(const char *)raptor_uri_as_counted_string(term->value.uri, &len));
case RAPTOR_TERM_TYPE_UNKNOWN:
default:
raptor_log_error_formatted(term->world, RAPTOR_LOG_LEVEL_ERROR, NULL,
"Triple has unsupported term type %d",
term->type);
@ -68,9 +69,7 @@ term_load(const raptor_term *term)
static int so_far = 0;
static void
load_triples(void* user_data, raptor_statement* triple)
{
static void load_triples(void *user_data, raptor_statement *triple) {
struct exo_aux *aux = (struct exo_aux *)user_data;
YAP_Term args[4];
@ -83,9 +82,7 @@ load_triples(void* user_data, raptor_statement* triple)
YAP_AssertTuples(aux->pred, args, so_far++, 1);
}
static void
count_triples(void* user_data, raptor_statement* triple)
{
static void count_triples(void *user_data, raptor_statement *triple) {
unsigned int *count_p = (unsigned int *)user_data;
(*count_p)++;
@ -95,9 +92,7 @@ count_triples(void* user_data, raptor_statement* triple)
// fprintf(stderr, "\n");
}
static YAP_Bool
load(void)
{
static YAP_Bool load(void) {
YAP_Term tfn = YAP_ARG1;
YAP_Term mod = YAP_ARG2;
YAP_Term tfunctor = YAP_ARG3;
@ -160,14 +155,11 @@ load(void)
return TRUE;
}
static inline void
raptor_yap_halt (int exit, void* world)
{
static inline void raptor_yap_halt(int exit, void *world) {
raptor_free_world((raptor_world *)world);
}
void raptor_yap_init (void)
{
void raptor_yap_init(void) {
world = raptor_new_world();
YAP_HaltRegisterHook(raptor_yap_halt, (void *)world);

44
pl/dbload.yap
View File

@ -27,41 +27,16 @@
:- dynamic dbloading/6, dbprocess/2.
dbload_from_stream(R, M0, Type) :-
repeat,
read(R,T),
( T == end_of_file -> !, close_dbload(R, Type);
dbload_count(T, M0),
fail
).
close_dbload(_R, exo) :-
retract(dbloading(Na,Arity,M,T,NaAr,_)),
nb_getval(NaAr,Size),
exo_db_get_space(T, M, Size, Handle),
assertz(dbloading(Na,Arity,M,T,NaAr,Handle)),
nb_setval(NaAr,0),
fail.
close_dbload(R, exo) :-
seek(R, 0, bof, _),
exodb_add_facts(R, _M),
fail.
close_dbload(_R, mega) :-
retract(dbloading(Na,Arity,M,T,NaAr,_)),
nb_getval(NaAr,Size),
dbload_get_space(T, M, Size, Handle),
assertz(dbloading(Na,Arity,M,T,NaAr,Handle)),
nb_setval(NaAr,0),
fail.
close_dbload(R, mega) :-
seek(R, 0, bof, _),
dbload_add_facts(R, _M),
fail.
close_dbload(_, _) :-
retractall(dbloading(_Na,_Arity,_M,_T,_NaAr,_Handle)),
fail.
close_dbload(_, _).
dbload_from_stream(R, M0, rdf, term ) :-
'$lines_in_file'(R, Lines),
'$input_lines'(R, Type, Lines),
dbload_from_stream(R, M0, Type, Storage ) :-
'$lines_in_file'(R, Lines),
'$input_lines'(R, Type, Lines),
'$input_lines'(R, csv, yeLines ) :-
'$process_lines'(R, Lines, Type ),
close(R).
prolog:load_db(Fs) :-
'$current_module'(M0),
@ -199,4 +174,3 @@ clean_up :-
retractall(dbprocess(_,_)),
fail.
clean_up.

5
pl/signals.yap
View File

@ -191,9 +191,8 @@ order of dispatch.
'$continue_signals',
'$hacks':'$stack_dump',
'$execute0'(G,M).
'$do_signal'(sig_fpe, [_M|_G]) :-
'$fpe_error'.
% Unix signals
'$do_signal'(sig_fpe,G) :-
'$signal_handler'(sig_fpe, G)
'$do_signal'(sig_alarm, G) :-
'$signal_handler'(sig_alarm, G).
'$do_signal'(sig_vtalarm, G) :-