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

fixes + win64

This commit is contained in:
Vitor Santos Costa 2016-11-08 01:37:36 -06:00
parent 46a9d52d2d
commit b03e0634c7
56 changed files with 1612 additions and 1529 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
C/adtdefs.c
View File

@ -55,9 +55,8 @@ uint64_t HashFunction(const unsigned char *CHP) {
static Prop
GetFunctorProp(AtomEntry *ae,
arity_t arity) { /* look property list of atom a for kind */
FunctorEntry *pp;
PropEntry *p = RepFunctorProp(ae->PropsOfAE);
PropEntry *p = ae->PropsOfAE;
while (p != NIL) {
if (p->KindOfPE == FunctorProperty &&
RepFunctorProp(p)->ArityOfFE == arity) {

54
C/arith1.c
View File

@ -326,7 +326,7 @@ msb(Int inp USES_REGS) /* calculate the most significant bit for an integer */
Int out = 0;
if (inp < 0) {
return Yap_ArithError(DOMAIN_ERROR_NOT_LESS_THAN_ZERO, MkIntegerTerm(inp),
Yap_ArithError(DOMAIN_ERROR_NOT_LESS_THAN_ZERO, MkIntegerTerm(inp),
"msb/1 received %d", inp);
}
@ -363,7 +363,7 @@ lsb(Int inp USES_REGS) /* calculate the least significant bit for an integer */
Int out = 0;
if (inp < 0) {
return Yap_ArithError(DOMAIN_ERROR_NOT_LESS_THAN_ZERO, MkIntegerTerm(inp),
Yap_ArithError(DOMAIN_ERROR_NOT_LESS_THAN_ZERO, MkIntegerTerm(inp),
"msb/1 received %d", inp);
}
if (inp==0)
@ -387,7 +387,7 @@ popcount(Int inp USES_REGS) /* calculate the least significant bit for an intege
Int c = 0, j = 0, m = ((CELL)1);
if (inp < 0) {
return Yap_ArithError(DOMAIN_ERROR_NOT_LESS_THAN_ZERO, MkIntegerTerm(inp),
Yap_ArithError(DOMAIN_ERROR_NOT_LESS_THAN_ZERO, MkIntegerTerm(inp),
"popcount/1 received %d", inp);
}
if (inp==0)
@ -434,7 +434,7 @@ eval1(Int fi, Term t USES_REGS) {
case long_int_e:
RINT(~IntegerOfTerm(t));
case double_e:
return Yap_ArithError(TYPE_ERROR_INTEGER, t, "\\(%f)", FloatOfTerm(t));
Yap_ArithError(TYPE_ERROR_INTEGER, t, "\\(%f)", FloatOfTerm(t));
case big_int_e:
#ifdef USE_GMP
return Yap_gmp_unot_big(t);
@ -450,7 +450,7 @@ eval1(Int fi, Term t USES_REGS) {
if (dbl >= 0) {
RFLOAT(log(dbl));
} else {
return Yap_ArithError(DOMAIN_ERROR_NOT_LESS_THAN_ZERO, t, "log(%f)", dbl);
Yap_ArithError(EVALUATION_ERROR_UNDEFINED, t, "log(%f)", dbl);
}
}
case op_log10:
@ -459,7 +459,7 @@ eval1(Int fi, Term t USES_REGS) {
if (dbl >= 0) {
RFLOAT(log10(dbl));
} else {
return Yap_ArithError(DOMAIN_ERROR_NOT_LESS_THAN_ZERO, t, "log10(%f)", dbl);
Yap_ArithError(EVALUATION_ERROR_UNDEFINED, t, "log10(%f)", dbl);
}
}
case op_sqrt:
@ -468,7 +468,7 @@ eval1(Int fi, Term t USES_REGS) {
out = sqrt(dbl);
#if HAVE_ISNAN
if (isnan(out)) {
return Yap_ArithError(DOMAIN_ERROR_OUT_OF_RANGE, t, "sqrt(%f)", dbl);
Yap_ArithError(EVALUATION_ERROR_UNDEFINED, t, "sqrt(%f)", dbl);
}
#endif
RFLOAT(out);
@ -517,7 +517,7 @@ eval1(Int fi, Term t USES_REGS) {
out = asin(dbl);
#if HAVE_ISNAN
if (isnan(out)) {
return Yap_ArithError(EVALUATION_ERROR_UNDEFINED, t, "asin(%f)", dbl);
Yap_ArithError(EVALUATION_ERROR_UNDEFINED, t, "asin(%f)", dbl);
}
#endif
RFLOAT(out);
@ -530,7 +530,7 @@ eval1(Int fi, Term t USES_REGS) {
out = acos(dbl);
#if HAVE_ISNAN
if (isnan(out)) {
return Yap_ArithError(EVALUATION_ERROR_UNDEFINED, t, "acos(%f)", dbl);
Yap_ArithError(EVALUATION_ERROR_UNDEFINED, t, "acos(%f)", dbl);
}
#endif
RFLOAT(out);
@ -543,7 +543,7 @@ eval1(Int fi, Term t USES_REGS) {
out = atan(dbl);
#if HAVE_ISNAN
if (isnan(out)) {
return Yap_ArithError(DOMAIN_ERROR_OUT_OF_RANGE, t, "atan(%f)", dbl);
Yap_ArithError(DOMAIN_ERROR_OUT_OF_RANGE, t, "atan(%f)", dbl);
}
#endif
RFLOAT(out);
@ -556,7 +556,7 @@ eval1(Int fi, Term t USES_REGS) {
out = asinh(dbl);
#if HAVE_ISNAN
if (isnan(out)) {
return Yap_ArithError(DOMAIN_ERROR_OUT_OF_RANGE, t, "asinh(%f)", dbl);
Yap_ArithError(DOMAIN_ERROR_OUT_OF_RANGE, t, "asinh(%f)", dbl);
}
#endif
RFLOAT(out);
@ -569,7 +569,7 @@ eval1(Int fi, Term t USES_REGS) {
out = acosh(dbl);
#if HAVE_ISNAN
if (isnan(out)) {
return Yap_ArithError(DOMAIN_ERROR_OUT_OF_RANGE, t, "acosh(%f)", dbl);
Yap_ArithError(DOMAIN_ERROR_OUT_OF_RANGE, t, "acosh(%f)", dbl);
}
#endif
RFLOAT(out);
@ -582,7 +582,7 @@ eval1(Int fi, Term t USES_REGS) {
out = atanh(dbl);
#if HAVE_ISNAN
if (isnan(out)) {
return Yap_ArithError(DOMAIN_ERROR_OUT_OF_RANGE, t, "atanh(%f)", dbl);
Yap_ArithError(DOMAIN_ERROR_OUT_OF_RANGE, t, "atanh(%f)", dbl);
}
#endif
RFLOAT(out);
@ -645,12 +645,12 @@ eval1(Int fi, Term t USES_REGS) {
}
#if HAVE_ISNAN
if (isnan(dbl)) {
return Yap_ArithError(DOMAIN_ERROR_OUT_OF_RANGE, t, "integer(%f)", dbl);
Yap_ArithError(DOMAIN_ERROR_OUT_OF_RANGE, t, "integer(%f)", dbl);
}
#endif
#if HAVE_ISINF
if (isinf(dbl)) {
return Yap_ArithError(EVALUATION_ERROR_INT_OVERFLOW, MkFloatTerm(dbl), "integer\
Yap_ArithError(EVALUATION_ERROR_INT_OVERFLOW, MkFloatTerm(dbl), "integer\
(%f)",dbl);
}
#endif
@ -674,12 +674,12 @@ eval1(Int fi, Term t USES_REGS) {
}
#if HAVE_ISNAN
if (isnan(dbl)) {
return Yap_ArithError(DOMAIN_ERROR_OUT_OF_RANGE, t, "integer(%f)", dbl);
Yap_ArithError(DOMAIN_ERROR_OUT_OF_RANGE, t, "integer(%f)", dbl);
}
#endif
#if HAVE_ISINF
if (isinf(dbl)) {
return Yap_ArithError(EVALUATION_ERROR_INT_OVERFLOW, MkFloatTerm(dbl), "integer\
Yap_ArithError(EVALUATION_ERROR_INT_OVERFLOW, MkFloatTerm(dbl), "integer\
(%f)",dbl);
}
#endif
@ -704,12 +704,12 @@ eval1(Int fi, Term t USES_REGS) {
}
#if HAVE_ISNAN
if (isnan(dbl)) {
return Yap_ArithError(DOMAIN_ERROR_OUT_OF_RANGE, t, "integer(%f)", dbl);
Yap_ArithError(DOMAIN_ERROR_OUT_OF_RANGE, t, "integer(%f)", dbl);
}
#endif
#if HAVE_ISINF
if (isinf(dbl)) {
return Yap_ArithError(EVALUATION_ERROR_INT_OVERFLOW, MkFloatTerm(dbl), "integer\
Yap_ArithError(EVALUATION_ERROR_INT_OVERFLOW, MkFloatTerm(dbl), "integer\
(%f)",dbl);
}
#endif
@ -734,12 +734,12 @@ eval1(Int fi, Term t USES_REGS) {
}
#if HAVE_ISNAN
if (isnan(dbl)) {
return Yap_ArithError(DOMAIN_ERROR_OUT_OF_RANGE, t, "integer(%f)", dbl);
Yap_ArithError(DOMAIN_ERROR_OUT_OF_RANGE, t, "integer(%f)", dbl);
}
#endif
#if HAVE_ISINF
if (isinf(dbl)) {
return Yap_ArithError(EVALUATION_ERROR_INT_OVERFLOW, MkFloatTerm(dbl), "integer (%f)",dbl);
Yap_ArithError(EVALUATION_ERROR_INT_OVERFLOW, MkFloatTerm(dbl), "integer (%f)",dbl);
}
#endif
if (dbl < 0.0)
@ -804,7 +804,7 @@ eval1(Int fi, Term t USES_REGS) {
case long_int_e:
RINT(msb(IntegerOfTerm(t) PASS_REGS));
case double_e:
return Yap_ArithError(TYPE_ERROR_INTEGER, t, "msb(%f)", FloatOfTerm(t));
Yap_ArithError(TYPE_ERROR_INTEGER, t, "msb(%f)", FloatOfTerm(t));
case big_int_e:
#ifdef USE_GMP
return Yap_gmp_msb(t);
@ -817,7 +817,7 @@ eval1(Int fi, Term t USES_REGS) {
case long_int_e:
RINT(lsb(IntegerOfTerm(t) PASS_REGS));
case double_e:
return Yap_ArithError(TYPE_ERROR_INTEGER, t, "lsb(%f)", FloatOfTerm(t));
Yap_ArithError(TYPE_ERROR_INTEGER, t, "lsb(%f)", FloatOfTerm(t));
case big_int_e:
#ifdef USE_GMP
return Yap_gmp_lsb(t);
@ -830,7 +830,7 @@ eval1(Int fi, Term t USES_REGS) {
case long_int_e:
RINT(popcount(IntegerOfTerm(t) PASS_REGS));
case double_e:
return Yap_ArithError(TYPE_ERROR_INTEGER, t, "popcount(%f)", FloatOfTerm(t));
Yap_ArithError(TYPE_ERROR_INTEGER, t, "popcount(%f)", FloatOfTerm(t));
case big_int_e:
#ifdef USE_GMP
return Yap_gmp_popcount(t);
@ -842,7 +842,7 @@ eval1(Int fi, Term t USES_REGS) {
switch (ETypeOfTerm(t)) {
case long_int_e:
if (isoLanguageFlag()) { /* iso */
return Yap_ArithError(TYPE_ERROR_FLOAT, t, "X is float_fractional_part(%f)", IntegerOfTerm(t));
Yap_ArithError(TYPE_ERROR_FLOAT, t, "X is float_fractional_part(%f)", IntegerOfTerm(t));
} else {
RFLOAT(0.0);
}
@ -863,7 +863,7 @@ eval1(Int fi, Term t USES_REGS) {
case op_fintp:
switch (ETypeOfTerm(t)) {
case long_int_e:
return Yap_ArithError(TYPE_ERROR_FLOAT, t, "X is float_integer_part(%f)", IntegerOfTerm(t));
Yap_ArithError(TYPE_ERROR_FLOAT, t, "X is float_integer_part(%f)", IntegerOfTerm(t));
case double_e:
RFLOAT(rint(FloatOfTerm(t)));
break;
@ -901,7 +901,7 @@ eval1(Int fi, Term t USES_REGS) {
case long_int_e:
RINT(Yap_random()*IntegerOfTerm(t));
case double_e:
return Yap_ArithError(TYPE_ERROR_INTEGER, t, "random(%f)", FloatOfTerm(t));
Yap_ArithError(TYPE_ERROR_INTEGER, t, "random(%f)", FloatOfTerm(t));
case big_int_e:
#ifdef USE_GMP
return Yap_gmp_mul_float_big(Yap_random(), t);

54
C/arith2.c
View File

@ -150,7 +150,7 @@ p_mod(Term t1, Term t2 USES_REGS) {
Int mod;
if (i2 == 0)
return Yap_ArithError(EVALUATION_ERROR_ZERO_DIVISOR, t2, "X is " Int_FORMAT " mod 0", i1);
Yap_ArithError(EVALUATION_ERROR_ZERO_DIVISOR, t2, "X is " Int_FORMAT " mod 0", i1);
if (i1 == Int_MIN && i2 == -1) {
return MkIntTerm(0);
}
@ -160,7 +160,7 @@ p_mod(Term t1, Term t2 USES_REGS) {
RINT(mod);
}
case (CELL)double_e:
return Yap_ArithError(TYPE_ERROR_INTEGER, t2, "mod/2");
Yap_ArithError(TYPE_ERROR_INTEGER, t2, "mod/2");
case (CELL)big_int_e:
#ifdef USE_GMP
return Yap_gmp_mod_int_big(IntegerOfTerm(t1), t2);
@ -170,7 +170,7 @@ p_mod(Term t1, Term t2 USES_REGS) {
break;
}
case (CELL)double_e:
return Yap_ArithError(TYPE_ERROR_INTEGER, t1, "mod/2");
Yap_ArithError(TYPE_ERROR_INTEGER, t1, "mod/2");
case (CELL)big_int_e:
#ifdef USE_GMP
switch (ETypeOfTerm(t2)) {
@ -180,14 +180,14 @@ p_mod(Term t1, Term t2 USES_REGS) {
Int i2 = IntegerOfTerm(t2);
if (i2 == 0)
return Yap_ArithError(EVALUATION_ERROR_ZERO_DIVISOR, t2, "X is ... mod 0");
Yap_ArithError(EVALUATION_ERROR_ZERO_DIVISOR, t2, "X is ... mod 0");
return Yap_gmp_mod_big_int(t1, i2);
}
case (CELL)big_int_e:
/* two bignums */
return Yap_gmp_mod_big_big(t1, t2);
case double_e:
return Yap_ArithError(TYPE_ERROR_INTEGER, t2, "mod/2");
Yap_ArithError(TYPE_ERROR_INTEGER, t2, "mod/2");
default:
RERROR();
}
@ -210,12 +210,12 @@ p_div2(Term t1, Term t2 USES_REGS) {
Int res, mod;
if (i2 == 0)
return Yap_ArithError(EVALUATION_ERROR_ZERO_DIVISOR, t2, "X is " Int_FORMAT " div 0", i1);
Yap_ArithError(EVALUATION_ERROR_ZERO_DIVISOR, t2, "X is " Int_FORMAT " div 0", i1);
if (i1 == Int_MIN && i2 == -1) {
#ifdef USE_GMP
return Yap_gmp_add_ints(Int_MAX, 1);
#else
return Yap_ArithError(EVALUATION_ERROR_INT_OVERFLOW, t1,
Yap_ArithError(EVALUATION_ERROR_INT_OVERFLOW, t1,
"// /2 with %d and %d", i1, i2);
#endif
}
@ -226,7 +226,7 @@ p_div2(Term t1, Term t2 USES_REGS) {
RINT(res);
}
case (CELL)double_e:
return Yap_ArithError(TYPE_ERROR_INTEGER, t2, "div/2");
Yap_ArithError(TYPE_ERROR_INTEGER, t2, "div/2");
case (CELL)big_int_e:
#ifdef USE_GMP
return Yap_gmp_div_int_big(IntegerOfTerm(t1), t2);
@ -236,7 +236,7 @@ p_div2(Term t1, Term t2 USES_REGS) {
break;
}
case (CELL)double_e:
return Yap_ArithError(TYPE_ERROR_INTEGER, t2, "div/2");
Yap_ArithError(TYPE_ERROR_INTEGER, t2, "div/2");
case (CELL)big_int_e:
#ifdef USE_GMP
switch (ETypeOfTerm(t2)) {
@ -246,14 +246,14 @@ p_div2(Term t1, Term t2 USES_REGS) {
Int i2 = IntegerOfTerm(t2);
if (i2 == 0)
return Yap_ArithError(EVALUATION_ERROR_ZERO_DIVISOR, t2, "X is ... div 0");
Yap_ArithError(EVALUATION_ERROR_ZERO_DIVISOR, t2, "X is ... div 0");
return Yap_gmp_div2_big_int(t1, i2);
}
case (CELL)big_int_e:
/* two bignums */
return Yap_gmp_div2_big_big(t1, t2);
case double_e:
return Yap_ArithError(TYPE_ERROR_INTEGER, t2, "div/2");
Yap_ArithError(TYPE_ERROR_INTEGER, t2, "div/2");
default:
RERROR();
}
@ -275,14 +275,14 @@ p_rem(Term t1, Term t2 USES_REGS) {
Int i2 = IntegerOfTerm(t2);
if (i2 == 0)
return Yap_ArithError(EVALUATION_ERROR_ZERO_DIVISOR, t2, "X is " Int_FORMAT " rem 0", i1);
Yap_ArithError(EVALUATION_ERROR_ZERO_DIVISOR, t2, "X is " Int_FORMAT " rem 0", i1);
if (i1 == Int_MIN && i2 == -1) {
return MkIntTerm(0);
}
RINT(i1%i2);
}
case (CELL)double_e:
return Yap_ArithError(TYPE_ERROR_INTEGER, t2, "rem/2");
Yap_ArithError(TYPE_ERROR_INTEGER, t2, "rem/2");
case (CELL)big_int_e:
#ifdef USE_GMP
return Yap_gmp_rem_int_big(IntegerOfTerm(t1), t2);
@ -292,19 +292,19 @@ p_rem(Term t1, Term t2 USES_REGS) {
}
break;
case (CELL)double_e:
return Yap_ArithError(TYPE_ERROR_INTEGER, t1, "rem/2");
Yap_ArithError(TYPE_ERROR_INTEGER, t1, "rem/2");
case (CELL)big_int_e:
#ifdef USE_GMP
switch (ETypeOfTerm(t2)) {
case long_int_e:
if (IntegerOfTerm(t2) == 0)
return Yap_ArithError(EVALUATION_ERROR_ZERO_DIVISOR, t2, "X is ... rem 0");
Yap_ArithError(EVALUATION_ERROR_ZERO_DIVISOR, t2, "X is ... rem 0");
return Yap_gmp_rem_big_int(t1, IntegerOfTerm(t2));
case (CELL)big_int_e:
/* two bignums */
return Yap_gmp_rem_big_big(t1, t2);
case double_e:
return Yap_ArithError(TYPE_ERROR_INTEGER, t2, "rem/2");
Yap_ArithError(TYPE_ERROR_INTEGER, t2, "rem/2");
default:
RERROR();
}
@ -320,7 +320,7 @@ p_rdiv(Term t1, Term t2 USES_REGS) {
#ifdef USE_GMP
switch (ETypeOfTerm(t1)) {
case (CELL)double_e:
return Yap_ArithError(TYPE_ERROR_INTEGER, t2, "rdiv/2");
Yap_ArithError(TYPE_ERROR_INTEGER, t2, "rdiv/2");
case (CELL)long_int_e:
switch (ETypeOfTerm(t2)) {
case (CELL)long_int_e:
@ -330,7 +330,7 @@ p_rdiv(Term t1, Term t2 USES_REGS) {
Int i2 = IntegerOfTerm(t2);
if (i2 == 0)
return Yap_ArithError(EVALUATION_ERROR_ZERO_DIVISOR, t2, "X is " Int_FORMAT " rdiv 0", i1);
Yap_ArithError(EVALUATION_ERROR_ZERO_DIVISOR, t2, "X is " Int_FORMAT " rdiv 0", i1);
return Yap_gmq_rdiv_int_int(i1, i2);
}
case (CELL)big_int_e:
@ -344,13 +344,13 @@ p_rdiv(Term t1, Term t2 USES_REGS) {
switch (ETypeOfTerm(t2)) {
case long_int_e:
if (IntegerOfTerm(t2) == 0)
return Yap_ArithError(EVALUATION_ERROR_ZERO_DIVISOR, t2, "X is ... rdiv 0");
Yap_ArithError(EVALUATION_ERROR_ZERO_DIVISOR, t2, "X is ... rdiv 0");
/* I know the term is much larger, so: */
return Yap_gmq_rdiv_big_int(t1, IntegerOfTerm(t2));
case (CELL)big_int_e:
return Yap_gmq_rdiv_big_big(t1, t2);
case double_e:
return Yap_ArithError(TYPE_ERROR_INTEGER, t2, "rdiv/2");
Yap_ArithError(TYPE_ERROR_INTEGER, t2, "rdiv/2");
default:
RERROR();
}
@ -449,7 +449,7 @@ p_xor(Term t1, Term t2 USES_REGS)
/* two integers */
RINT(IntegerOfTerm(t1) ^ IntegerOfTerm(t2));
case double_e:
return Yap_ArithError(TYPE_ERROR_INTEGER, t2, "#/2");
Yap_ArithError(TYPE_ERROR_INTEGER, t2, "#/2");
case big_int_e:
#ifdef USE_GMP
return Yap_gmp_xor_int_big(IntegerOfTerm(t1), t2);
@ -459,7 +459,7 @@ p_xor(Term t1, Term t2 USES_REGS)
}
break;
case double_e:
return Yap_ArithError(TYPE_ERROR_INTEGER, t1, "#/2");
Yap_ArithError(TYPE_ERROR_INTEGER, t1, "#/2");
case big_int_e:
#ifdef USE_GMP
switch (ETypeOfTerm(t2)) {
@ -468,7 +468,7 @@ p_xor(Term t1, Term t2 USES_REGS)
case big_int_e:
return Yap_gmp_xor_big_big(t1, t2);
case double_e:
return Yap_ArithError(TYPE_ERROR_INTEGER, t2, "#/2");
Yap_ArithError(TYPE_ERROR_INTEGER, t2, "#/2");
default:
RERROR();
}
@ -690,7 +690,7 @@ p_exp(Term t1, Term t2 USES_REGS)
Int pow;
if (i2 < 0) {
return Yap_ArithError(DOMAIN_ERROR_NOT_LESS_THAN_ZERO, t2,
Yap_ArithError(DOMAIN_ERROR_NOT_LESS_THAN_ZERO, t2,
"%d ^ %d", i1, i2);
}
pow = ipow(i1,i2);
@ -836,7 +836,7 @@ p_gcd(Term t1, Term t2 USES_REGS)
RINT(gcd(i1,i2 PASS_REGS));
}
case double_e:
return Yap_ArithError(TYPE_ERROR_INTEGER, t2, "gcd/2");
Yap_ArithError(TYPE_ERROR_INTEGER, t2, "gcd/2");
case big_int_e:
#ifdef USE_GMP
return Yap_gmp_gcd_int_big(IntegerOfTerm(t1), t2);
@ -846,7 +846,7 @@ p_gcd(Term t1, Term t2 USES_REGS)
}
break;
case double_e:
return Yap_ArithError(TYPE_ERROR_INTEGER, t1, "gcd/2");
Yap_ArithError(TYPE_ERROR_INTEGER, t1, "gcd/2");
case big_int_e:
#ifdef USE_GMP
switch (ETypeOfTerm(t2)) {
@ -855,7 +855,7 @@ p_gcd(Term t1, Term t2 USES_REGS)
case big_int_e:
return Yap_gmp_gcd_big_big(t1, t2);
case double_e:
return Yap_ArithError(TYPE_ERROR_INTEGER, t2, "gcd/2");
Yap_ArithError(TYPE_ERROR_INTEGER, t2, "gcd/2");
default:
RERROR();
}

1581
C/atomic.c
View File

File diff suppressed because it is too large Load Diff

2
C/cdmgr.c
View File

@ -1453,6 +1453,8 @@ static void addcl_permission_error(AtomEntry *ap, Int Arity, int in_use) {
ti[1] = MkIntegerTerm(Arity);
t = Yap_MkApplTerm(FunctorSlash, 2, ti);
LOCAL_Error_TYPE = PERMISSION_ERROR_MODIFY_STATIC_PROCEDURE;
LOCAL_ErrorMessage = Malloc( 256 );
if (in_use) {
if (Arity == 0)
sprintf(LOCAL_ErrorMessage, "static predicate %s is in use", ap->StrOfAE);

13
C/cmppreds.c
View File

@ -379,7 +379,6 @@ inline static Int compare(Term t1, Term t2) /* compare terms t1 and t2 */
if (IsExtensionFunctor(f))
return 1;
else {
int out;
if (f != FunctorDot)
return strcmp(".", RepAtom(NameOfFunctor(f))->StrOfAE);
else {
@ -596,10 +595,10 @@ inline static Int flt_cmp(Float dif) {
static Int a_cmp(Term t1, Term t2 USES_REGS) {
if (IsVarTerm(t1)) {
Yap_ThrowError( INSTANTIATION_ERROR, t1, "while doing arithmetic comparison" );
Yap_ThrowError( INSTANTIATION_ERROR, t1, 4, "while doing arithmetic comparison" );
}
if (IsVarTerm(t2)) {
Yap_ThrowError( INSTANTIATION_ERROR, t1, "while doing arithmetic comparison" );
Yap_ThrowError( INSTANTIATION_ERROR, t1, 4, "while doing arithmetic comparison" );
}
if (IsFloatTerm(t1) && IsFloatTerm(t2)) {
return flt_cmp(FloatOfTerm(t1) - FloatOfTerm(t2));
@ -622,7 +621,7 @@ static Int a_cmp(Term t1, Term t2 USES_REGS) {
Float f2 = FloatOfTerm(t2);
#if HAVE_ISNAN
if (isnan(f2)) {
Yap_ThrowError( EVALUATION_ERROR_UNDEFINED, t2, "trying to evaluate nan" );
Yap_ThrowError( EVALUATION_ERROR_UNDEFINED, t2, 4, "trying to evaluate nan" );
}
#endif
return flt_cmp(i1 - f2);
@ -637,7 +636,7 @@ static Int a_cmp(Term t1, Term t2 USES_REGS) {
Float f1 = FloatOfTerm(t1);
#if HAVE_ISNAN
if (isnan(f1)) {
Yap_ThrowError( EVALUATION_ERROR_UNDEFINED, t1, "trying to evaluate nan" );
Yap_ThrowError( EVALUATION_ERROR_UNDEFINED, t1, 4, "trying to evaluate nan" );
}
#endif
t2 = Yap_Eval(t2);
@ -653,7 +652,7 @@ static Int a_cmp(Term t1, Term t2 USES_REGS) {
Float f2 = FloatOfTerm(t2);
#if HAVE_ISNAN
if (isnan(f2)) {
Yap_ThrowError( EVALUATION_ERROR_UNDEFINED, t2, "trying to evaluate nan" );
Yap_ThrowError( EVALUATION_ERROR_UNDEFINED, t2, 4, "trying to evaluate nan" );
}
#endif
return flt_cmp(f1 - f2);
@ -675,7 +674,7 @@ static Int a_cmp(Term t1, Term t2 USES_REGS) {
Float f2 = FloatOfTerm(t2);
#if HAVE_ISNAN
if (isnan(f2)) {
Yap_ThrowError( EVALUATION_ERROR_UNDEFINED, t2, "trying to evaluate nan" );
Yap_ThrowError( EVALUATION_ERROR_UNDEFINED, t2, 4, "trying to evaluate nan" );
}
#endif
return Yap_gmp_cmp_big_float(t1, f2);

6
C/compiler.c
View File

@ -1103,16 +1103,14 @@ static void c_bifun(basic_preds Op, Term t1, Term t2, Term t3, Term Goal,
Int i2;
if (!IsIntegerTerm(t2)) {
char s[32];
Yap_ThrowError( TYPE_ERROR_INTEGER, t2, "compiling functor/3");
Yap_Error( TYPE_ERROR_INTEGER, t2, "compiling functor/3");
save_machine_regs();
siglongjmp(cglobs->cint.CompilerBotch, 1);
}
i2 = IntegerOfTerm(t2);
if (i2 < 0) {
char s[32];
Yap_ThrowError(DOMAIN_ERROR_NOT_LESS_THAN_ZERO , t2, "compiling functor/3");
Yap_ThrowError(DOMAIN_ERROR_NOT_LESS_THAN_ZERO , t2,4, "compiling functor/3");
save_machine_regs();
siglongjmp(cglobs->cint.CompilerBotch, 1);
}

9
C/errors.c
View File

@ -311,11 +311,11 @@ yap_error_descriptor_t *Yap_popErrorContext(void) {
}
void Yap_ThrowError__(const char *file, const char *function, int lineno,
yap_error_number type, Term where, ...) {
yap_error_number type, Term where, int code, ...) {
va_list ap;
char tmpbuf[MAXPATHLEN];
va_start(ap, where);
va_start(ap, code);
char *format = va_arg(ap, char *);
if (format != NULL) {
#if HAVE_VSNPRINTF
@ -328,7 +328,7 @@ Yap_Error__(file, function, lineno, type, where, tmpbuf);
} else {
Yap_Error__(file, function, lineno, type, where);
}
siglongjmp(LOCAL_RestartEnv, 2);
siglongjmp(LOCAL_RestartEnv, code);
}
/**
@ -560,8 +560,7 @@ 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_ErrorMessage, (char *)RepAtom(AtomOfTerm(nt[0]))->StrOfAE,
MAX_ERROR_MSG_SIZE);
LOCAL_ErrorMessage = RepAtom(AtomOfTerm(nt[0]))->StrOfAE;
} else {
LOCAL_ErrorMessage =
(char *)RepAtom(NameOfFunctor(FunctorOfTerm(nt[0])))->StrOfAE;

38
C/eval.c
View File

@ -93,7 +93,7 @@ static Term get_matrix_element(Term t1, Term t2 USES_REGS) {
static Term Eval(Term t USES_REGS) {
if (IsVarTerm(t)) {
return Yap_ArithError(INSTANTIATION_ERROR, t, "in arithmetic");
Yap_ArithError(INSTANTIATION_ERROR, t, "in arithmetic");
} else if (IsNumTerm(t)) {
return t;
} else if (IsAtomTerm(t)) {
@ -101,7 +101,7 @@ static Term Eval(Term t USES_REGS) {
Atom name = AtomOfTerm(t);
if (EndOfPAEntr(p = RepExpProp(Yap_GetExpProp(name, 0)))) {
return Yap_ArithError(TYPE_ERROR_EVALUABLE, takeIndicator(t),
Yap_ArithError(TYPE_ERROR_EVALUABLE, takeIndicator(t),
"atom %s in arithmetic expression",
RepAtom(name)->StrOfAE);
}
@ -112,10 +112,10 @@ static Term Eval(Term t USES_REGS) {
const char *s = (const char *)StringOfTerm(t);
if (s[1] == '\0')
return MkIntegerTerm(s[0]);
return Yap_ArithError(TYPE_ERROR_EVALUABLE, t,
Yap_ArithError(TYPE_ERROR_EVALUABLE, t,
"string in arithmetic expression");
} else if ((Atom)fun == AtomFoundVar) {
return Yap_ArithError(TYPE_ERROR_EVALUABLE, TermNil,
Yap_ArithError(TYPE_ERROR_EVALUABLE, TermNil,
"cyclic term in arithmetic expression");
} else {
Int n = ArityOfFunctor(fun);
@ -124,7 +124,7 @@ static Term Eval(Term t USES_REGS) {
Term t1, t2;
if (EndOfPAEntr(p = RepExpProp(Yap_GetExpProp(name, n)))) {
return Yap_ArithError(TYPE_ERROR_EVALUABLE, takeIndicator(t),
Yap_ArithError(TYPE_ERROR_EVALUABLE, takeIndicator(t),
"functor %s/%d for arithmetic expression",
RepAtom(name)->StrOfAE, n);
}
@ -153,7 +153,7 @@ static Term Eval(Term t USES_REGS) {
} /* else if (IsPairTerm(t)) */
{
if (TailOfTerm(t) != TermNil) {
return Yap_ArithError(TYPE_ERROR_EVALUABLE, t,
Yap_ArithError(TYPE_ERROR_EVALUABLE, t,
"string must contain a single character to be "
"evaluated as an arithmetic expression");
}
@ -369,32 +369,6 @@ static Int p_logsum(USES_REGS1) { /* X is Y */
}
}
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];
LOCAL_Error_TYPE = type;
LOCAL_Error_File = file;
LOCAL_Error_Function = function;
LOCAL_Error_Lineno = lineno;
va_start(ap, where);
format = va_arg(ap, char *);
if (format != NULL) {
#if HAVE_VSNPRINTF
(void)vsnprintf(buf, MAX_ERROR_MSG_SIZE, format, ap);
#else
(void)vsprintf(buf, format, ap);
#endif
} else {
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, ...) {
CACHE_REGS

48
C/exec.c
View File

@ -292,7 +292,7 @@ inline static bool do_execute(Term t, Term mod USES_REGS) {
Term t2 = ArgOfTerm(2, t);
if (IsVarTerm(t2))
return CallMetaCall(t, mod PASS_REGS);
if (!CommaCall(t2, mod))
if (1 || !CommaCall(t2, mod))
return CallMetaCall(t, mod PASS_REGS);
Term t1 = ArgOfTerm(1, t);
@ -315,6 +315,9 @@ inline static bool do_execute(Term t, Term mod USES_REGS) {
/* I cannot use the standard macro here because
otherwise I would dereference the argument and
might skip a svar */
if (pen->PredFlags & MetaPredFlag) {
return CallMetaCall(t, mod PASS_REGS);
}
pt = RepAppl(t) + 1;
for (i = 1; i <= arity; i++) {
#if YAPOR_SBA
@ -1441,19 +1444,23 @@ static bool exec_absmi(bool top, yap_reset_t reset_mode USES_REGS) {
LOCAL_PrologMode = UserMode;
P = (yamop *)FAILCODE;
} break;
case 2: {
/* arithmetic exception */
/* must be done here, otherwise siglongjmp will clobber all the
* registers
*/
Yap_Error(LOCAL_Error_TYPE, TermNil, NULL);
/* reset the registers so that we don't have trash in abstract
* machine */
Yap_set_fpu_exceptions(
getAtomicGlobalPrologFlag(ARITHMETIC_EXCEPTIONS_FLAG));
P = (yamop *)FAILCODE;
LOCAL_PrologMode = UserMode;
} break;
case 2: {
/* arithmetic exception */
/* must be done here, otherwise siglongjmp will clobber all the
* registers
*/
Yap_Error(LOCAL_Error_TYPE, TermNil, NULL);
/* reset the registers so that we don't have trash in abstract
* machine */
Yap_set_fpu_exceptions(
getAtomicGlobalPrologFlag(ARITHMETIC_EXCEPTIONS_FLAG));
P = (yamop *)FAILCODE;
LOCAL_PrologMode = UserMode;
} break;
case 4: {
P = (yamop *)FAILCODE;
LOCAL_PrologMode = UserMode;
} break;
case 3: { /* saved state */
LOCAL_CBorder = OldBorder;
return false;
@ -2074,16 +2081,15 @@ static Int jump_env(USES_REGS1) {
Yap_Error(INSTANTIATION_ERROR, t, "throw ball must be bound");
return false;
} else if (IsApplTerm(t) && FunctorOfTerm(t) == FunctorError) {
Term t2;
Term t2, te;
Yap_find_prolog_culprit(PASS_REGS1);
LOCAL_Error_TYPE = ERROR_EVENT;
t = ArgOfTerm(1, t);
if (IsApplTerm(t) && IsAtomTerm((t2 = ArgOfTerm(1, t)))) {
te = ArgOfTerm(1, t);
if (IsApplTerm(te) && IsAtomTerm((t2 = ArgOfTerm(1, te)))) {
LOCAL_ActiveError->errorAsText = AtomOfTerm(t2);
LOCAL_ActiveError->classAsText = NameOfFunctor(FunctorOfTerm(t));
} else if (IsAtomTerm(t)) {
LOCAL_ActiveError->errorAsText = AtomOfTerm(t);
LOCAL_ActiveError->classAsText = NameOfFunctor(FunctorOfTerm(te));
} else if (IsAtomTerm(te)) {
LOCAL_ActiveError->errorAsText = AtomOfTerm(te);
LOCAL_ActiveError->classAsText = NULL;
}
} else {

3
C/globals.c
View File

@ -1654,7 +1654,8 @@ static Int p_nb_queue_close(USES_REGS1) {
return Yap_unify(ARG3, ARG2);
}
out = Yap_unify(ARG3, qp[QUEUE_TAIL]) && Yap_unify(ARG2, qp[QUEUE_HEAD]);
qp[QUEUE_HEAD] = qp[QUEUE_TAIL] = RESET_VARIABLE(qp + QUEUE_TAIL);
RESET_VARIABLE(qp + QUEUE_TAIL);
qp[QUEUE_HEAD] = qp[QUEUE_TAIL] = (CELL)(qp + QUEUE_TAIL);
qp[QUEUE_SIZE] = MkIntTerm(0);
return out;
}

76
C/gmp_support.c
View File

@ -32,7 +32,7 @@ MkBigAndClose(MP_INT *new)
Term t = Yap_MkBigIntTerm(new);
mpz_clear(new);
if (t == TermNil) {
return Yap_ArithError(RESOURCE_ERROR_STACK, t, ">>/2");
Yap_ArithError(RESOURCE_ERROR_STACK, t, ">>/2");
}
return t;
}
@ -43,7 +43,7 @@ MkRatAndClose(MP_RAT *new)
Term t = Yap_MkBigRatTerm(new);
mpq_clear(new);
if (t == TermNil) {
return Yap_ArithError(RESOURCE_ERROR_STACK, t, ">>/2");
Yap_ArithError(RESOURCE_ERROR_STACK, t, ">>/2");
}
return t;
}
@ -243,7 +243,7 @@ Yap_gmp_div_big_int(Term t, Int i)
if (i > 0) {
mpz_tdiv_q_ui(&new, &new, i);
} else if (i == 0) {
return Yap_ArithError(EVALUATION_ERROR_ZERO_DIVISOR, MkIntTerm(0), "// /2");
Yap_ArithError(EVALUATION_ERROR_ZERO_DIVISOR, MkIntTerm(0), "// /2");
} else {
/* we do not handle MIN_INT */
mpz_tdiv_q_ui(&new, &new, -i);
@ -253,7 +253,7 @@ Yap_gmp_div_big_int(Term t, Int i)
if (i > 0) {
mpz_fdiv_q_ui(&new, &new, i);
} else if (i == 0) {
return Yap_ArithError(EVALUATION_ERROR_ZERO_DIVISOR, MkIntTerm(0), "// /2");
Yap_ArithError(EVALUATION_ERROR_ZERO_DIVISOR, MkIntTerm(0), "// /2");
} else {
/* we do not handle MIN_INT */
mpz_fdiv_q_ui(&new, &new, -i);
@ -285,7 +285,7 @@ Yap_gmp_div2_big_int(Term t, Int i)
if (i > 0) {
mpz_fdiv_q_ui(&new, &new, i);
} else if (i == 0) {
return Yap_ArithError(EVALUATION_ERROR_ZERO_DIVISOR, MkIntTerm(0), "// /2");
Yap_ArithError(EVALUATION_ERROR_ZERO_DIVISOR, MkIntTerm(0), "// /2");
} else {
/* we do not handle MIN_INT */
mpz_fdiv_q_ui(&new, &new, -i);
@ -311,7 +311,7 @@ Yap_gmp_and_int_big(Int i, Term t)
CELL *pt = RepAppl(t);
MP_INT *b;
if (pt[1] != BIG_INT) {
return Yap_ArithError(TYPE_ERROR_INTEGER, t, "/\\/2");
Yap_ArithError(TYPE_ERROR_INTEGER, t, "/\\/2");
}
b = Yap_BigIntOfTerm(t);
@ -328,7 +328,7 @@ Yap_gmp_ior_int_big(Int i, Term t)
CELL *pt = RepAppl(t);
MP_INT *b;
if (pt[1] != BIG_INT) {
return Yap_ArithError(TYPE_ERROR_INTEGER, t, "\\/ /2");
Yap_ArithError(TYPE_ERROR_INTEGER, t, "\\/ /2");
}
b = Yap_BigIntOfTerm(t);
@ -367,7 +367,7 @@ Yap_gmp_xor_int_big(Int i, Term t)
CELL *pt = RepAppl(t);
MP_INT *b;
if (pt[1] != BIG_INT) {
return Yap_ArithError(TYPE_ERROR_INTEGER, t, "#/2");
Yap_ArithError(TYPE_ERROR_INTEGER, t, "#/2");
}
b = Yap_BigIntOfTerm(t);
@ -394,7 +394,7 @@ Yap_gmp_sll_big_int(Term t, Int i)
mpz_init(&new);
if (i == Int_MIN) {
CACHE_REGS
return Yap_ArithError(RESOURCE_ERROR_HUGE_INT, MkIntegerTerm(i), "<</2");
Yap_ArithError(RESOURCE_ERROR_HUGE_INT, MkIntegerTerm(i), "<</2");
}
mpz_fdiv_q_2exp(&new, b, -i);
}
@ -628,9 +628,9 @@ Yap_gmp_and_big_big(Term t1, Term t2)
return MkBigAndClose(&new);
} else {
if (pt1[1] != BIG_INT) {
return Yap_ArithError(TYPE_ERROR_INTEGER, t1, "/\\/2");
Yap_ArithError(TYPE_ERROR_INTEGER, t1, "/\\/2");
}
return Yap_ArithError(TYPE_ERROR_INTEGER, t2, "/\\/2");
Yap_ArithError(TYPE_ERROR_INTEGER, t2, "/\\/2");
}
}
@ -649,9 +649,9 @@ Yap_gmp_ior_big_big(Term t1, Term t2)
return MkBigAndClose(&new);
} else {
if (pt1[1] != BIG_INT) {
return Yap_ArithError(TYPE_ERROR_INTEGER, t1, "\\/ /2");
Yap_ArithError(TYPE_ERROR_INTEGER, t1, "\\/ /2");
}
return Yap_ArithError(TYPE_ERROR_INTEGER, t2, "\\/ /2");
Yap_ArithError(TYPE_ERROR_INTEGER, t2, "\\/ /2");
}
}
@ -670,9 +670,9 @@ Yap_gmp_xor_big_big(Term t1, Term t2)
return MkBigAndClose(&new);
} else {
if (pt1[1] != BIG_INT) {
return Yap_ArithError(TYPE_ERROR_INTEGER, t1, "\\/ /2");
Yap_ArithError(TYPE_ERROR_INTEGER, t1, "\\/ /2");
}
return Yap_ArithError(TYPE_ERROR_INTEGER, t2, "\\/ /2");
Yap_ArithError(TYPE_ERROR_INTEGER, t2, "\\/ /2");
}
}
@ -691,9 +691,9 @@ Yap_gmp_mod_big_big(Term t1, Term t2)
return MkBigAndClose(&new);
} else {
if (pt1[1] != BIG_INT) {
return Yap_ArithError(TYPE_ERROR_INTEGER, t1, "mod/2");
Yap_ArithError(TYPE_ERROR_INTEGER, t1, "mod/2");
}
return Yap_ArithError(TYPE_ERROR_INTEGER, t2, "mod/2");
Yap_ArithError(TYPE_ERROR_INTEGER, t2, "mod/2");
}
}
@ -702,7 +702,7 @@ Yap_gmp_mod_big_int(Term t, Int i2)
{
CELL *pt = RepAppl(t);
if (pt[1] != BIG_INT) {
return Yap_ArithError(TYPE_ERROR_INTEGER, t, "mod/2");
Yap_ArithError(TYPE_ERROR_INTEGER, t, "mod/2");
} else {
MP_INT *b = Yap_BigIntOfTerm(t);
MP_INT new;
@ -719,7 +719,7 @@ Yap_gmp_mod_int_big(Int i1, Term t)
CACHE_REGS
CELL *pt = RepAppl(t);
if (pt[1] != BIG_INT) {
return Yap_ArithError(TYPE_ERROR_INTEGER, t, "mod/2");
Yap_ArithError(TYPE_ERROR_INTEGER, t, "mod/2");
} else {
MP_INT *b = Yap_BigIntOfTerm(t);
/* integer is much smaller */
@ -768,9 +768,9 @@ Yap_gmp_rem_big_big(Term t1, Term t2)
return MkBigAndClose(&new);
} else {
if (pt1[1] != BIG_INT) {
return Yap_ArithError(TYPE_ERROR_INTEGER, t1, "rem/2");
Yap_ArithError(TYPE_ERROR_INTEGER, t1, "rem/2");
}
return Yap_ArithError(TYPE_ERROR_INTEGER, t2, "rem/2");
Yap_ArithError(TYPE_ERROR_INTEGER, t2, "rem/2");
}
}
@ -779,7 +779,7 @@ Yap_gmp_rem_big_int(Term t, Int i2)
{
CELL *pt = RepAppl(t);
if (pt[1] != BIG_INT) {
return Yap_ArithError(TYPE_ERROR_INTEGER, t, "rem/2");
Yap_ArithError(TYPE_ERROR_INTEGER, t, "rem/2");
} else {
MP_INT *b = Yap_BigIntOfTerm(t);
MP_INT new;
@ -796,7 +796,7 @@ Yap_gmp_rem_int_big(Int i1, Term t)
CACHE_REGS
CELL *pt = RepAppl(t);
if (pt[1] != BIG_INT) {
return Yap_ArithError(TYPE_ERROR_INTEGER, t, "rem/2");
Yap_ArithError(TYPE_ERROR_INTEGER, t, "rem/2");
} else {
/* integer is much smaller */
return MkIntegerTerm(i1);
@ -818,9 +818,9 @@ Yap_gmp_gcd_big_big(Term t1, Term t2)
return MkBigAndClose(&new);
} else {
if (pt1[1] != BIG_INT) {
return Yap_ArithError(TYPE_ERROR_INTEGER, t1, "gcd/2");
Yap_ArithError(TYPE_ERROR_INTEGER, t1, "gcd/2");
}
return Yap_ArithError(TYPE_ERROR_INTEGER, t2, "gcd/2");
Yap_ArithError(TYPE_ERROR_INTEGER, t2, "gcd/2");
}
}
@ -830,7 +830,7 @@ Yap_gmp_gcd_int_big(Int i, Term t)
CACHE_REGS
CELL *pt = RepAppl(t);
if (pt[1] != BIG_INT) {
return Yap_ArithError(TYPE_ERROR_INTEGER, t, "gcd/2");
Yap_ArithError(TYPE_ERROR_INTEGER, t, "gcd/2");
} else {
/* integer is much smaller */
if (i > 0) {
@ -992,7 +992,7 @@ Yap_gmp_exp_int_big(Int i, Term t)
CACHE_REGS
CELL *pt = RepAppl(t);
if (pt[1] == BIG_INT) {
return Yap_ArithError(RESOURCE_ERROR_HUGE_INT, t, "^/2");
Yap_ArithError(RESOURCE_ERROR_HUGE_INT, t, "^/2");
} else {
MP_INT *b = Yap_BigIntOfTerm(t);
Float dbl = mpz_get_d(b);
@ -1009,7 +1009,7 @@ Yap_gmp_exp_big_big(Term t1, Term t2)
Float dbl1, dbl2;
if (pt1[1] == BIG_INT && pt2[1] == BIG_INT) {
return Yap_ArithError(RESOURCE_ERROR_HUGE_INT, t2, "^/2");
Yap_ArithError(RESOURCE_ERROR_HUGE_INT, t2, "^/2");
} else {
if (pt1[1] != BIG_INT) {
dbl1 = mpz_get_d(Yap_BigIntOfTerm(t1));
@ -1476,7 +1476,7 @@ Yap_gmp_unot_big(Term t)
mpz_com(&new, &new);
return MkBigAndClose(&new);
} else {
return Yap_ArithError(TYPE_ERROR_INTEGER, t, "#/1");
Yap_ArithError(TYPE_ERROR_INTEGER, t, "#/1");
}
}
@ -1571,7 +1571,7 @@ Yap_gmp_float_fractional_part(Term t)
{
CELL *pt = RepAppl(t);
if (pt[1] == BIG_INT) {
return Yap_ArithError(TYPE_ERROR_FLOAT, t, "X is float_fractional_part(%f)", FloatOfTerm(t));
Yap_ArithError(TYPE_ERROR_FLOAT, t, "X is float_fractional_part(%f)", FloatOfTerm(t));
} else {
MP_RAT *b = Yap_BigRatOfTerm(t);
MP_RAT new;
@ -1591,7 +1591,7 @@ Yap_gmp_float_integer_part(Term t)
{
CELL *pt = RepAppl(t);
if (pt[1] == BIG_INT) {
return Yap_ArithError(TYPE_ERROR_FLOAT, t, "X is float_integer_part(%f)", FloatOfTerm(t));
Yap_ArithError(TYPE_ERROR_FLOAT, t, "X is float_integer_part(%f)", FloatOfTerm(t));
} else {
MP_RAT *b = Yap_BigRatOfTerm(t);
MP_INT new;
@ -1624,12 +1624,12 @@ Yap_gmp_lsb(Term t)
if (pt[1] == BIG_INT) {
MP_INT *big = Yap_BigIntOfTerm(t);
if ( mpz_sgn(big) <= 0 ) {
return Yap_ArithError(DOMAIN_ERROR_NOT_LESS_THAN_ZERO, t,
Yap_ArithError(DOMAIN_ERROR_NOT_LESS_THAN_ZERO, t,
"lsb/1 received negative bignum");
}
return MkIntegerTerm(mpz_scan1(big,0));
} else {
return Yap_ArithError(TYPE_ERROR_INTEGER, t, "lsb");
Yap_ArithError(TYPE_ERROR_INTEGER, t, "lsb");
}
}
@ -1641,12 +1641,12 @@ Yap_gmp_msb(Term t)
if (pt[1] == BIG_INT) {
MP_INT *big = Yap_BigIntOfTerm(t);
if ( mpz_sgn(big) <= 0 ) {
return Yap_ArithError(DOMAIN_ERROR_NOT_LESS_THAN_ZERO, t,
Yap_ArithError(DOMAIN_ERROR_NOT_LESS_THAN_ZERO, t,
"msb/1 received negative bignum");
}
return MkIntegerTerm(mpz_sizeinbase(big,2));
} else {
return Yap_ArithError(TYPE_ERROR_INTEGER, t, "popcount");
Yap_ArithError(TYPE_ERROR_INTEGER, t, "popcount");
}
}
@ -1658,17 +1658,17 @@ Yap_gmp_popcount(Term t)
if (pt[1] == BIG_INT) {
MP_INT *big = Yap_BigIntOfTerm(t);
if ( mpz_sgn(big) <= 0 ) {
return Yap_ArithError(DOMAIN_ERROR_NOT_LESS_THAN_ZERO, t,
Yap_ArithError(DOMAIN_ERROR_NOT_LESS_THAN_ZERO, t,
"popcount/1 received negative bignum");
}
return MkIntegerTerm(mpz_popcount(big));
} else {
return Yap_ArithError(TYPE_ERROR_INTEGER, t, "popcount");
Yap_ArithError(TYPE_ERROR_INTEGER, t, "popcount");
}
}
char *
Yap_mpz_to_string(MP_INT *b, char *s, size_t sz, int base)
Yap_mpz_to_string( MP_INT *b, char *s, size_t sz, int base)
{
if (s) {
size_t size = mpz_sizeinbase(b, base);

6
C/grow.c
View File

@ -832,7 +832,7 @@ static_growheap(size_t esize, bool fix_code, struct intermediates *cip, tr_fr_pt
fprintf( stderr, "%% Worker Id %d:\n", worker_id);
#endif
fprintf( stderr, "%% Database Overflow %d\n", LOCAL_heap_overflows);
fprintf( stderr, "%% growing the heap %ld bytes\n", size);
fprintf( stderr, "%% growing the heap " Int_FORMAT " bytes\n", size);
}
/* CreepFlag is set to force heap expansion */
if ( Yap_only_has_signal( YAP_CDOVF_SIGNAL) ) {
@ -976,7 +976,7 @@ static_growglobal(size_t request, CELL **ptr, CELL *hsplit USES_REGS)
fprintf(stderr, "%% Worker Id %d:\n", worker_id);
#endif
fprintf(stderr, "%% %cO %s Overflow %d\n", vb_msg1, vb_msg2, LOCAL_delay_overflows);
fprintf(stderr, "%% %cO growing the stacks %ld bytes\n", vb_msg1, size);
fprintf(stderr, "%% %cO growing the stacks " UInt_FORMAT " bytes\n", vb_msg1, size);
}
ASP -= 256;
YAPEnterCriticalSection();
@ -1794,7 +1794,7 @@ static int do_growtrail(size_t esize, bool contiguous_only, bool in_parser, tr_f
fprintf(stderr, "%% Trail:%8ld cells (%p-%p)\n",
(unsigned long int)(TR-(tr_fr_ptr)LOCAL_TrailBase),LOCAL_TrailBase,TR);
#endif
fprintf(stderr, "%% growing the trail %ld bytes\n", size);
fprintf(stderr, "%% growing the trail " UInt_FORMAT " bytes\n", size);
}
LOCAL_ErrorMessage = NULL;
if (!GLOBAL_AllowTrailExpansion) {

10
C/load_dll.c
View File

@ -45,10 +45,10 @@ Yap_LoadForeignFile(char *file, int flags)
void *ptr= (void *)LoadLibrary(file);
if (!ptr) {
CACHE_REGS
LOCAL_ErrorSay[0]='\0';
LOCAL_ErrorMessage = NULL;
FormatMessage(FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS,
NULL, GetLastError(),
MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), LOCAL_ErrorSay, 256,
MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), LOCAL_ErrorMessage, 256,
NULL);
}
return ptr;
@ -86,13 +86,13 @@ LoadForeign(StringList ofiles, StringList libs,
if (!Yap_findFile(file, NULL, NULL, LOCAL_FileNameBuf, true, YAP_OBJ, true, true) &&
(handle=LoadLibrary(LOCAL_FileNameBuf)) != 0)
{
LOCAL_ErrorSay[0]=~'\0';
LOCAL_ErrorMessage = NULL;
if (*init_proc == NULL)
*init_proc = (YapInitProc)GetProcAddress((HMODULE)handle, proc_name);
} else {
FormatMessage(FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS,
NULL, GetLastError(),
MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), LOCAL_ErrorSay, 256,
MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), LOCAL_ErrorMessage, 256,
NULL);
//fprintf(stderr,"WinError: %s\n", LOCAL_ErrorSay);
}
@ -124,7 +124,7 @@ LoadForeign(StringList ofiles, StringList libs,
}
if(*init_proc == NULL) {
strcpy(LOCAL_ErrorSay,"Could not locate initialization routine");
LOCAL_ErrorMessage = "Could not locate initialization routine";
return LOAD_FAILLED;
}

68
C/modules.c
View File

@ -370,16 +370,57 @@ static Int new_system_module(USES_REGS1) {
}
static Int strip_module(USES_REGS1) {
Term t1 = Deref(ARG1), tmod = CurrentModule;
if (tmod == PROLOG_MODULE) {
tmod = TermProlog;
}
t1 = Yap_StripModule(t1, &tmod);
if (!t1) {
Term t1 = Deref(ARG1), tmod = CurrentModule;
if (tmod == PROLOG_MODULE) {
tmod = TermProlog;
}
t1 = Yap_StripModule(t1, &tmod);
if (!t1) {
Yap_Error(TYPE_ERROR_CALLABLE, t1, "trying to obtain module");
return FALSE;
}
return Yap_unify(ARG3, t1) && Yap_unify(ARG2, tmod);
}
static Int yap_strip_clause(USES_REGS1) {
Functor f;
Term t1 = Deref(ARG1), tmod = LOCAL_SourceModule;
if (tmod == PROLOG_MODULE) {
tmod = TermProlog;
}
t1 = Yap_StripModule(t1, &tmod);
if (IsVarTerm(t1)) {
Yap_Error(INSTANTIATION_ERROR, t1, "trying to obtain module");
return false;
} else if (IsVarTerm(tmod)) {
Yap_Error(INSTANTIATION_ERROR, tmod, "trying to obtain module");
return false;
} else if (IsIntTerm(t1) || (IsApplTerm(t1) && IsExtensionFunctor((f = FunctorOfTerm(t1))))) {
Yap_Error(TYPE_ERROR_CALLABLE, t1, "trying to obtain module");
return FALSE;
}
return Yap_unify(ARG3, t1) && Yap_unify(ARG2, tmod);
return false;
} else if (!IsAtomTerm(tmod)) {
Yap_Error(TYPE_ERROR_ATOM, tmod, "trying to obtain module");
return false;
}
if (f == FunctorAssert || f == FunctorDoubleArrow) {
Term thmod = tmod;
Term th = ArgOfTerm(1, t1);
th = Yap_StripModule(th, &thmod);
if (IsVarTerm(th)) {
Yap_Error(INSTANTIATION_ERROR, t1, "trying to obtain module");
return false;
} else if (IsVarTerm(thmod)) {
Yap_Error(INSTANTIATION_ERROR, thmod, "trying to obtain module");
return false;
} else if (IsIntTerm(th) || (IsApplTerm(th) && IsExtensionFunctor(FunctorOfTerm(t1)))) {
Yap_Error(TYPE_ERROR_CALLABLE, t1, "trying to obtain module");
return false;
}else if (!IsAtomTerm(thmod)) {
Yap_Error(TYPE_ERROR_ATOM, thmod, "trying to obtain module");
return false;
}
}
return Yap_unify(ARG3, t1) && Yap_unify(ARG2, tmod);
}
Term Yap_YapStripModule(Term t, Term *modp) {
@ -564,13 +605,14 @@ void Yap_InitModulesC(void) {
SafePredFlag | SyncPredFlag);
Yap_InitCPred("$change_module", 1, change_module,
SafePredFlag | SyncPredFlag);
Yap_InitCPred("strip_module", 3, strip_module, SafePredFlag | SyncPredFlag);
Yap_InitCPred("strip_module", 3, strip_module, SafePredFlag | SyncPredFlag);
Yap_InitCPred("$yap_strip_module", 3, yap_strip_module, SafePredFlag | SyncPredFlag);
Yap_InitCPred("source_module", 1, source_module, SafePredFlag | SyncPredFlag);
Yap_InitCPred("current_source_module", 2, current_source_module,
SafePredFlag | SyncPredFlag);
Yap_InitCPred("$yap_strip_module", 3, yap_strip_module,
SafePredFlag | SyncPredFlag);
Yap_InitCPred("context_module", 1, context_module, 0);
Yap_InitCPred("$yap_strip_clause", 3, yap_strip_clause,
SafePredFlag | SyncPredFlag);
Yap_InitCPred("context_module", 1, context_module, 0);
Yap_InitCPred("$is_system_module", 1, is_system_module, SafePredFlag);
Yap_InitCPred("$copy_operators", 2, copy_operators, 0);
Yap_InitCPred("new_system_module", 1, new_system_module, SafePredFlag);

34
C/parser.c
View File

@ -168,7 +168,8 @@ static Term ParseArgs(Atom, Term, JMPBUFF *, Term, encoding_t, Term CACHE_TYPE);
static Term ParseList(JMPBUFF *, encoding_t, Term CACHE_TYPE);
static Term ParseTerm(int, JMPBUFF *, encoding_t, Term CACHE_TYPE);
const char *Yap_tokRep(void *tokptr, encoding_t enc);
extern Term Yap_tokRep(void* tokptr);
extern const char * Yap_tokText(void *tokptr);
static void syntax_msg(const char *msg, ...) {
CACHE_REGS
@ -366,6 +367,7 @@ static Term Variables(VarEntry *p, Term l USES_REGS) {
Term Yap_Variables(VarEntry *p, Term l) {
CACHE_REGS
l = Variables(LOCAL_AnonVarTable, l PASS_REGS);
return Variables(p, l PASS_REGS);
}
@ -466,7 +468,7 @@ inline static void checkfor(Term c, JMPBUFF *FailBuff,
encoding_t enc USES_REGS) {
if (LOCAL_tokptr->Tok != Ord(Ponctuation_tok) || LOCAL_tokptr->TokInfo != c) {
char s[1024];
strncpy(s, Yap_tokRep(LOCAL_tokptr, enc), 1023);
strncpy(s, Yap_tokText(LOCAL_tokptr), 1023);
syntax_msg("line %d: expected to find "
"\'%c....................................\', found %s",
LOCAL_tokptr->TokPos, c, s);
@ -654,7 +656,7 @@ loop:
}
} else {
syntax_msg("line %d: looking for symbol ',','|' got symbol '%s'",
LOCAL_tokptr->TokPos, Yap_tokRep(LOCAL_tokptr, enc));
LOCAL_tokptr->TokPos, Yap_tokText(LOCAL_tokptr));
FAIL;
}
return (o);
@ -675,7 +677,7 @@ static Term ParseTerm(int prio, JMPBUFF *FailBuff, encoding_t enc,
NextToken;
/* special rules apply for +1, -2.3, etc... */
if (LOCAL_tokptr->Tok == Number_tok) {
if ((Atom)t == AtomMinus) {
if (t == TermMinus) {
t = LOCAL_tokptr->TokInfo;
if (IsIntTerm(t))
t = MkIntTerm(-IntOfTerm(t));
@ -698,7 +700,7 @@ static Term ParseTerm(int prio, JMPBUFF *FailBuff, encoding_t enc,
if (LOCAL_tokptr->Tok == Name_tok) {
Atom at = AtomOfTerm(LOCAL_tokptr->TokInfo);
#ifndef _MSC_VER
if ((Atom)t == AtomPlus) {
if (t == TermPlus) {
if (at == AtomInf) {
t = MkFloatTerm(INFINITY);
NextToken;
@ -708,7 +710,7 @@ static Term ParseTerm(int prio, JMPBUFF *FailBuff, encoding_t enc,
NextToken;
break;
}
} else if ((Atom)t == AtomMinus) {
} else if (t == TermMinus) {
if (at == AtomInf) {
t = MkFloatTerm(-INFINITY);
NextToken;
@ -764,7 +766,7 @@ static Term ParseTerm(int prio, JMPBUFF *FailBuff, encoding_t enc,
case Error_tok:
syntax_msg("line %d: found ill-formed \"%s\"", LOCAL_tokptr->TokPos,
Yap_tokRep(LOCAL_tokptr, enc));
Yap_tokText(LOCAL_tokptr));
FAIL;
case Ponctuation_tok:
@ -806,7 +808,7 @@ static Term ParseTerm(int prio, JMPBUFF *FailBuff, encoding_t enc,
break;
default:
syntax_msg("line %d: unexpected ponctuation signal %s",
LOCAL_tokptr->TokPos, Yap_tokRep(LOCAL_tokptr, enc));
LOCAL_tokptr->TokPos, Yap_tokRep(LOCAL_tokptr));
FAIL;
}
break;
@ -851,12 +853,12 @@ static Term ParseTerm(int prio, JMPBUFF *FailBuff, encoding_t enc,
t = ParseTerm(GLOBAL_MaxPriority, FailBuff, enc, cmod PASS_REGS);
if (LOCAL_tokptr->Tok != QuasiQuotes_tok) {
syntax_msg("expected to find quasi quotes, got \"%s\"", ,
Yap_tokRep(LOCAL_tokptr, enc));
Yap_tokText(LOCAL_tokptr));
FAIL;
}
if (!(is_quasi_quotation_syntax(t, &at))) {
syntax_msg("bad quasi quotation syntax, at \"%s\"",
Yap_tokRep(LOCAL_tokptr, enc));
Yap_tokText(LOCAL_tokptr));
FAIL;
}
/* Arg 2: the content */
@ -866,7 +868,7 @@ static Term ParseTerm(int prio, JMPBUFF *FailBuff, encoding_t enc,
if (!get_quasi_quotation(Yap_InitSlot(ArgOfTerm(2, tn)), &qq->text,
qq->text + strlen((const char *)qq->text))) {
syntax_msg("could not get quasi quotation, at \"%s\"",
Yap_tokRep(LOCAL_tokptr, enc));
Yap_tokText(LOCAL_tokptr));
FAIL;
}
if (positions) {
@ -878,7 +880,7 @@ static Term ParseTerm(int prio, JMPBUFF *FailBuff, encoding_t enc,
qq->mid.charno + 2, /* end of | token */
PL_INTPTR, qqend - 2)) /* end minus "|}" */
syntax_msg("failed to unify quasi quotation, at \"%s\"",
Yap_tokRep(LOCAL_tokptr, enc));
Yap_tokText(LOCAL_tokptr));
FAIL;
}
@ -898,7 +900,7 @@ static Term ParseTerm(int prio, JMPBUFF *FailBuff, encoding_t enc,
break;
default:
syntax_msg("line %d: expected operator, got \'%s\'", LOCAL_tokptr->TokPos,
Yap_tokRep(LOCAL_tokptr, enc));
Yap_tokText(LOCAL_tokptr));
FAIL;
}
@ -1013,7 +1015,7 @@ static Term ParseTerm(int prio, JMPBUFF *FailBuff, encoding_t enc,
}
if (LOCAL_tokptr->Tok <= Ord(String_tok)) {
syntax_msg("line %d: expected operator, got \'%s\'", LOCAL_tokptr->TokPos,
Yap_tokRep(LOCAL_tokptr, enc));
Yap_tokText(LOCAL_tokptr));
FAIL;
}
break;
@ -1046,7 +1048,11 @@ Term Yap_Parse(UInt prio, encoding_t enc, Term cmod) {
}
if (LOCAL_tokptr != NULL && LOCAL_tokptr->Tok != Ord(eot_tok)) {
LOCAL_Error_TYPE = SYNTAX_ERROR;
if (LOCAL_tokptr->TokNext) {
LOCAL_ErrorMessage = "operator misssing . ";
} else {
LOCAL_ErrorMessage = "term does not end on . ";
}
t = 0;
}
if (t != 0 && LOCAL_Error_TYPE == SYNTAX_ERROR) {

244
C/prim_absmi_insts.h
View File

@ -33,13 +33,13 @@
BEGP(pt0);
deref_body(d0, pt0, plus_vv_unk, plus_vv_nvar);
Yap_AsmError(INSTANTIATION_ERROR);
Yap_AsmError(INSTANTIATION_ERROR, d0);
FAIL();
ENDP(pt0);
BEGP(pt0);
deref_body(d1, pt0, plus_vv_nvar_unk, plus_vv_nvar_nvar);
Yap_AsmError(INSTANTIATION_ERROR);
Yap_AsmError(INSTANTIATION_ERROR, d1);
FAIL();
ENDP(pt0);
ENDD(d1);
@ -67,7 +67,7 @@
BEGP(pt0);
deref_body(d0, pt0, plus_vc_unk, plus_vc_nvar);
Yap_AsmError(INSTANTIATION_ERROR);
Yap_AsmError(INSTANTIATION_ERROR, d0);
FAIL();
ENDP(pt0);
ENDD(d0);
@ -101,13 +101,13 @@
BEGP(pt0);
deref_body(d0, pt0, plus_y_vv_unk, plus_y_vv_nvar);
Yap_AsmError(INSTANTIATION_ERROR);
Yap_AsmError(INSTANTIATION_ERROR, d0);
FAIL();
ENDP(pt0);
BEGP(pt0);
deref_body(d1, pt0, plus_y_vv_nvar_unk, plus_y_vv_nvar_nvar);
Yap_AsmError(INSTANTIATION_ERROR);
Yap_AsmError(INSTANTIATION_ERROR, d1);
FAIL();
ENDP(pt0);
ENDD(d1);
@ -138,7 +138,7 @@
BEGP(pt0);
deref_body(d0, pt0, plus_y_vc_unk, plus_y_vc_nvar);
Yap_AsmError(INSTANTIATION_ERROR);
Yap_AsmError(INSTANTIATION_ERROR, d0);
FAIL();
ENDP(pt0);
ENDD(d0);
@ -169,13 +169,13 @@
BEGP(pt0);
deref_body(d0, pt0, minus_vv_unk, minus_vv_nvar);
Yap_AsmError(INSTANTIATION_ERROR);
Yap_AsmError(INSTANTIATION_ERROR,d0);
FAIL();
ENDP(pt0);
BEGP(pt0);
deref_body(d1, pt0, minus_vv_nvar_unk, minus_vv_nvar_nvar);
Yap_AsmError(INSTANTIATION_ERROR);
Yap_AsmError(INSTANTIATION_ERROR, d0);
FAIL();
ENDP(pt0);
ENDD(d1);
@ -203,7 +203,7 @@
BEGP(pt0);
deref_body(d0, pt0, minus_cv_unk, minus_cv_nvar);
Yap_AsmError(INSTANTIATION_ERROR);
Yap_AsmError(INSTANTIATION_ERROR, d0);
FAIL();
ENDP(pt0);
ENDD(d0);
@ -237,13 +237,13 @@
BEGP(pt0);
deref_body(d0, pt0, minus_y_vv_unk, minus_y_vv_nvar);
Yap_AsmError(INSTANTIATION_ERROR);
Yap_AsmError(INSTANTIATION_ERROR, d0);
FAIL();
ENDP(pt0);
BEGP(pt0);
deref_body(d1, pt0, minus_y_vv_nvar_unk, minus_y_vv_nvar_nvar);
Yap_AsmError(INSTANTIATION_ERROR);
Yap_AsmError(INSTANTIATION_ERROR, d1);
FAIL();
ENDP(pt0);
ENDD(d1);
@ -274,7 +274,7 @@
BEGP(pt0);
deref_body(d0, pt0, minus_y_cv_unk, minus_y_cv_nvar);
Yap_AsmError(INSTANTIATION_ERROR);
Yap_AsmError(INSTANTIATION_ERROR,d0);
FAIL();
ENDP(pt0);
ENDD(d0);
@ -304,13 +304,13 @@
BEGP(pt0);
deref_body(d0, pt0, times_vv_unk, times_vv_nvar);
Yap_AsmError(INSTANTIATION_ERROR);
Yap_AsmError(INSTANTIATION_ERROR,d0);
FAIL();
ENDP(pt0);
BEGP(pt0);
deref_body(d1, pt0, times_vv_nvar_unk, times_vv_nvar_nvar);
Yap_AsmError(INSTANTIATION_ERROR);
Yap_AsmError(INSTANTIATION_ERROR,d1);
FAIL();
ENDP(pt0);
ENDD(d1);
@ -338,7 +338,7 @@
BEGP(pt0);
deref_body(d0, pt0, times_vc_unk, times_vc_nvar);
Yap_AsmError(INSTANTIATION_ERROR);
Yap_AsmError(INSTANTIATION_ERROR,d0);
FAIL();
ENDP(pt0);
ENDD(d0);
@ -372,13 +372,13 @@
BEGP(pt0);
deref_body(d0, pt0, times_y_vv_unk, times_y_vv_nvar);
Yap_AsmError(INSTANTIATION_ERROR);
Yap_AsmError(INSTANTIATION_ERROR,d0);
FAIL();
ENDP(pt0);
BEGP(pt0);
deref_body(d1, pt0, times_y_vv_nvar_unk, times_y_vv_nvar_nvar);
Yap_AsmError(INSTANTIATION_ERROR);
Yap_AsmError(INSTANTIATION_ERROR,d1);
FAIL();
ENDP(pt0);
ENDD(d1);
@ -409,7 +409,7 @@
BEGP(pt0);
deref_body(d0, pt0, times_y_vc_unk, times_y_vc_nvar);
Yap_AsmError(INSTANTIATION_ERROR);
Yap_AsmError(INSTANTIATION_ERROR,d0);
FAIL();
ENDP(pt0);
ENDD(d0);
@ -430,7 +430,7 @@
if (IsIntTerm(d0) && IsIntTerm(d1)) {
Int div = IntOfTerm(d1);
if (div == 0) {
Yap_AsmError(EVALUATION_ERROR_ZERO_DIVISOR);
Yap_AsmError(EVALUATION_ERROR_ZERO_DIVISOR,d1);
}
d0 = MkIntTerm(IntOfTerm(d0) / div);
} else {
@ -444,13 +444,13 @@
BEGP(pt0);
deref_body(d0, pt0, div_vv_unk, div_vv_nvar);
Yap_AsmError(INSTANTIATION_ERROR);
Yap_AsmError(INSTANTIATION_ERROR,d0);
FAIL();
ENDP(pt0);
BEGP(pt0);
deref_body(d1, pt0, div_vv_nvar_unk, div_vv_nvar_nvar);
Yap_AsmError(INSTANTIATION_ERROR);
Yap_AsmError(INSTANTIATION_ERROR,d1);
FAIL();
ENDP(pt0);
ENDD(d1);
@ -478,7 +478,7 @@
BEGP(pt0);
deref_body(d0, pt0, div_vc_unk, div_vc_nvar);
Yap_AsmError(INSTANTIATION_ERROR);
Yap_AsmError(INSTANTIATION_ERROR,d0);
FAIL();
ENDP(pt0);
ENDD(d0);
@ -494,7 +494,7 @@
if (IsIntTerm(d0)) {
Int div = IntOfTerm(d0);
if (div == 0) {
Yap_AsmError(EVALUATION_ERROR_ZERO_DIVISOR);
Yap_AsmError(EVALUATION_ERROR_ZERO_DIVISOR,d0);
FAIL();
}
d0 = MkIntegerTerm(d1 / div);
@ -509,7 +509,7 @@
BEGP(pt0);
deref_body(d0, pt0, div_cv_unk, div_cv_nvar);
Yap_AsmError(INSTANTIATION_ERROR);
Yap_AsmError(INSTANTIATION_ERROR,d0);
FAIL();
ENDP(pt0);
ENDD(d0);
@ -530,7 +530,7 @@
if (IsIntTerm(d0) && IsIntTerm(d1)) {
Int div = IntOfTerm(d1);
if (div == 0) {
Yap_AsmError(EVALUATION_ERROR_ZERO_DIVISOR);
Yap_AsmError(EVALUATION_ERROR_ZERO_DIVISOR, d0);
FAIL();
}
d0 = MkIntTerm(IntOfTerm(d0) / div);
@ -548,13 +548,13 @@
BEGP(pt0);
deref_body(d0, pt0, div_y_vv_unk, div_y_vv_nvar);
Yap_AsmError(INSTANTIATION_ERROR);
Yap_AsmError(INSTANTIATION_ERROR,d0);
FAIL();
ENDP(pt0);
BEGP(pt0);
deref_body(d1, pt0, div_y_vv_nvar_unk, div_y_vv_nvar_nvar);
Yap_AsmError(INSTANTIATION_ERROR);
Yap_AsmError(INSTANTIATION_ERROR,d1);
FAIL();
ENDP(pt0);
ENDD(d1);
@ -585,7 +585,7 @@
BEGP(pt0);
deref_body(d0, pt0, div_y_vc_unk, div_y_vc_nvar);
Yap_AsmError(INSTANTIATION_ERROR);
Yap_AsmError(INSTANTIATION_ERROR,d0);
FAIL();
ENDP(pt0);
ENDD(d0);
@ -601,7 +601,7 @@
if (IsIntTerm(d0)) {
Int div = IntOfTerm(d0);
if (div == 0) {
Yap_AsmError(EVALUATION_ERROR_ZERO_DIVISOR);
Yap_AsmError(EVALUATION_ERROR_ZERO_DIVISOR,d0);
FAIL();
}
d0 = MkIntegerTerm(d1 / div);
@ -651,13 +651,13 @@
BEGP(pt0);
deref_body(d0, pt0, and_vv_unk, and_vv_nvar);
Yap_AsmError(INSTANTIATION_ERROR);
Yap_AsmError(INSTANTIATION_ERROR,d0);
FAIL();
ENDP(pt0);
BEGP(pt0);
deref_body(d1, pt0, and_vv_nvar_unk, and_vv_nvar_nvar);
Yap_AsmError(INSTANTIATION_ERROR);
Yap_AsmError(INSTANTIATION_ERROR,d1);
FAIL();
ENDP(pt0);
ENDD(d1);
@ -719,13 +719,13 @@
BEGP(pt0);
deref_body(d0, pt0, and_y_vv_unk, and_y_vv_nvar);
Yap_AsmError(INSTANTIATION_ERROR);
Yap_AsmError(INSTANTIATION_ERROR,d0);
FAIL();
ENDP(pt0);
BEGP(pt0);
deref_body(d1, pt0, and_y_vv_nvar_unk, and_y_vv_nvar_nvar);
Yap_AsmError(INSTANTIATION_ERROR);
Yap_AsmError(INSTANTIATION_ERROR,d1);
FAIL();
ENDP(pt0);
ENDD(d1);
@ -787,13 +787,13 @@
BEGP(pt0);
deref_body(d0, pt0, or_vv_unk, or_vv_nvar);
Yap_AsmError(INSTANTIATION_ERROR);
Yap_AsmError(INSTANTIATION_ERROR,d0);
FAIL();
ENDP(pt0);
BEGP(pt0);
deref_body(d1, pt0, or_vv_nvar_unk, or_vv_nvar_nvar);
Yap_AsmError(INSTANTIATION_ERROR);
Yap_AsmError(INSTANTIATION_ERROR,d1);
FAIL();
ENDP(pt0);
ENDD(d1);
@ -854,13 +854,13 @@
BEGP(pt0);
deref_body(d0, pt0, or_y_vv_unk, or_y_vv_nvar);
Yap_AsmError(INSTANTIATION_ERROR);
Yap_AsmError(INSTANTIATION_ERROR,d0);
FAIL();
ENDP(pt0);
BEGP(pt0);
deref_body(d1, pt0, or_y_vv_nvar_unk, or_y_vv_nvar_nvar);
Yap_AsmError(INSTANTIATION_ERROR);
Yap_AsmError(INSTANTIATION_ERROR,d1);
FAIL();
ENDP(pt0);
ENDD(d1);
@ -926,13 +926,13 @@
BEGP(pt0);
deref_body(d0, pt0, sll_vv_unk, sll_vv_nvar);
Yap_AsmError(INSTANTIATION_ERROR);
Yap_AsmError(INSTANTIATION_ERROR,d0);
FAIL();
ENDP(pt0);
BEGP(pt0);
deref_body(d1, pt0, sll_vv_nvar_unk, sll_vv_nvar_nvar);
Yap_AsmError(INSTANTIATION_ERROR);
Yap_AsmError(INSTANTIATION_ERROR,d1);
FAIL();
ENDP(pt0);
ENDD(d1);
@ -960,7 +960,7 @@
BEGP(pt0);
deref_body(d0, pt0, sll_vc_unk, sll_vc_nvar);
Yap_AsmError(INSTANTIATION_ERROR);
Yap_AsmError(INSTANTIATION_ERROR,d0);
FAIL();
ENDP(pt0);
ENDD(d0);
@ -991,7 +991,7 @@
BEGP(pt0);
deref_body(d0, pt0, sll_cv_unk, sll_cv_nvar);
Yap_AsmError(INSTANTIATION_ERROR);
Yap_AsmError(INSTANTIATION_ERROR,d0);
FAIL();
ENDP(pt0);
ENDD(d0);
@ -1029,13 +1029,13 @@
BEGP(pt0);
deref_body(d0, pt0, sll_y_vv_unk, sll_y_vv_nvar);
Yap_AsmError(INSTANTIATION_ERROR);
Yap_AsmError(INSTANTIATION_ERROR,d0);
FAIL();
ENDP(pt0);
BEGP(pt0);
deref_body(d1, pt0, sll_y_vv_nvar_unk, sll_y_vv_nvar_nvar);
Yap_AsmError(INSTANTIATION_ERROR);
Yap_AsmError(INSTANTIATION_ERROR,d1);
FAIL();
ENDP(pt0);
ENDD(d1);
@ -1066,7 +1066,7 @@
BEGP(pt0);
deref_body(d0, pt0, sll_y_vc_unk, sll_y_vc_nvar);
Yap_AsmError(INSTANTIATION_ERROR);
Yap_AsmError(INSTANTIATION_ERROR,d0);
FAIL();
ENDP(pt0);
ENDD(d0);
@ -1100,7 +1100,7 @@
BEGP(pt0);
deref_body(d0, pt0, sll_y_cv_unk, sll_y_cv_nvar);
Yap_AsmError(INSTANTIATION_ERROR);
Yap_AsmError(INSTANTIATION_ERROR,d0);
FAIL();
ENDP(pt0);
ENDD(d0);
@ -1135,13 +1135,13 @@
BEGP(pt0);
deref_body(d0, pt0, slr_vv_unk, slr_vv_nvar);
Yap_AsmError(INSTANTIATION_ERROR);
Yap_AsmError(INSTANTIATION_ERROR,d0);
FAIL();
ENDP(pt0);
BEGP(pt0);
deref_body(d1, pt0, slr_vv_nvar_unk, slr_vv_nvar_nvar);
Yap_AsmError(INSTANTIATION_ERROR);
Yap_AsmError(INSTANTIATION_ERROR,d1);
FAIL();
ENDP(pt0);
ENDD(d1);
@ -1169,7 +1169,7 @@
BEGP(pt0);
deref_body(d0, pt0, slr_vc_unk, slr_vc_nvar);
Yap_AsmError(INSTANTIATION_ERROR);
Yap_AsmError(INSTANTIATION_ERROR,d0);
FAIL();
ENDP(pt0);
ENDD(d0);
@ -1200,7 +1200,7 @@
BEGP(pt0);
deref_body(d0, pt0, slr_cv_unk, slr_cv_nvar);
Yap_AsmError(INSTANTIATION_ERROR);
Yap_AsmError(INSTANTIATION_ERROR,d0);
FAIL();
ENDP(pt0);
ENDD(d0);
@ -1238,13 +1238,13 @@
BEGP(pt0);
deref_body(d0, pt0, slr_y_vv_unk, slr_y_vv_nvar);
Yap_AsmError(INSTANTIATION_ERROR);
Yap_AsmError(INSTANTIATION_ERROR,d0);
FAIL();
ENDP(pt0);
BEGP(pt0);
deref_body(d1, pt0, slr_y_vv_nvar_unk, slr_y_vv_nvar_nvar);
Yap_AsmError(INSTANTIATION_ERROR);
Yap_AsmError(INSTANTIATION_ERROR,d1);
FAIL();
ENDP(pt0);
ENDD(d1);
@ -1275,7 +1275,7 @@
BEGP(pt0);
deref_body(d0, pt0, slr_y_vc_unk, slr_y_vc_nvar);
Yap_AsmError(INSTANTIATION_ERROR);
Yap_AsmError(INSTANTIATION_ERROR,d0);
ENDP(pt0);
ENDD(d0);
ENDOp();
@ -1300,7 +1300,7 @@
}
}
if (d0 == 0L) {
Yap_AsmError(LOCAL_Error_TYPE);
Yap_AsmError(LOCAL_Error_TYPE,d0);
FAIL();
}
BEGP(pt0);
@ -1312,7 +1312,7 @@
BEGP(pt0);
deref_body(d0, pt0, slr_y_cv_unk, slr_y_cv_nvar);
Yap_AsmError(INSTANTIATION_ERROR);
Yap_AsmError(INSTANTIATION_ERROR,d0);
FAIL();
ENDP(pt0);
ENDD(d0);
@ -1968,7 +1968,7 @@
} else {
if (IsBigIntTerm(d0))
FAIL();
Yap_AsmError(TYPE_ERROR_INTEGER);
Yap_AsmError(TYPE_ERROR_INTEGER, d0);
FAIL();
}
@ -1984,7 +1984,7 @@
pt0 = RepAppl(d1);
d1 = *pt0;
if (IsExtensionFunctor((Functor)d1)) {
Yap_AsmError(TYPE_ERROR_COMPOUND);
Yap_AsmError(TYPE_ERROR_COMPOUND, AbsAppl(pt0));
FAIL();
}
if ((Int)d0 <= 0 || (Int)d0 > ArityOfFunctor((Functor)d1)) {
@ -2007,7 +2007,7 @@ Yap_AsmError( DOMAIN_ERROR_NOT_LESS_THAN_ZERO );
pt0 = RepPair(d1);
if (d0 != 1 && d0 != 2) {
if ((Int)d0 < 0) {
Yap_AsmError(DOMAIN_ERROR_NOT_LESS_THAN_ZERO);
Yap_AsmError(DOMAIN_ERROR_NOT_LESS_THAN_ZERO, MkIntegerTerm(d0) );
}
FAIL();
}
@ -2016,14 +2016,14 @@ Yap_AsmError( DOMAIN_ERROR_NOT_LESS_THAN_ZERO );
GONext();
ENDP(pt0);
} else {
Yap_AsmError(TYPE_ERROR_COMPOUND);
Yap_AsmError(TYPE_ERROR_COMPOUND, d1);
FAIL();
}
BEGP(pt0);
deref_body(d1, pt0, arg_arg2_unk, arg_arg2_nvar);
saveregs();
Yap_AsmError(INSTANTIATION_ERROR);
Yap_AsmError(INSTANTIATION_ERROR,d1);
;
setregs();
ENDP(pt0);
@ -2033,7 +2033,7 @@ Yap_AsmError( DOMAIN_ERROR_NOT_LESS_THAN_ZERO );
BEGP(pt0);
deref_body(d0, pt0, arg_arg1_unk, arg_arg1_nvar);
saveregs();
Yap_AsmError(INSTANTIATION_ERROR);
Yap_AsmError(INSTANTIATION_ERROR,d0);
;
setregs();
ENDP(pt0);
@ -2068,7 +2068,7 @@ Yap_AsmError( DOMAIN_ERROR_NOT_LESS_THAN_ZERO );
pt0 = RepAppl(d1);
d1 = *pt0;
if (IsExtensionFunctor((Functor)d1)) {
Yap_AsmError(TYPE_ERROR_COMPOUND);
Yap_AsmError(TYPE_ERROR_COMPOUND,XREG(PREG->y_u.xxn.xi));
FAIL();
}
if ((Int)d0 <= 0 || (Int)d0 > ArityOfFunctor((Functor)d1)) {
@ -2092,7 +2092,7 @@ Yap_AsmError( DOMAIN_ERROR_NOT_LESS_THAN_ZERO );
if (d0 != 1 && d0 != 2) {
if ((Int)d0 < 0) {
saveregs();
Yap_AsmError(DOMAIN_ERROR_NOT_LESS_THAN_ZERO);
Yap_AsmError(DOMAIN_ERROR_NOT_LESS_THAN_ZERO, XREG(PREG->y_u.xxn.xi));
}
FAIL();
}
@ -2101,13 +2101,13 @@ Yap_AsmError( DOMAIN_ERROR_NOT_LESS_THAN_ZERO );
GONext();
ENDP(pt0);
} else {
Yap_AsmError(TYPE_ERROR_COMPOUND);
Yap_AsmError(TYPE_ERROR_COMPOUND, XREG(PREG->y_u.xxn.xi));
FAIL();
}
BEGP(pt0);
deref_body(d1, pt0, arg_arg2_vc_unk, arg_arg2_vc_nvar);
Yap_AsmError(INSTANTIATION_ERROR);
Yap_AsmError(INSTANTIATION_ERROR, XREG(PREG->y_u.xxn.xi));
ENDP(pt0);
FAIL();
ENDD(d1);
@ -2138,7 +2138,7 @@ Yap_AsmError( DOMAIN_ERROR_NOT_LESS_THAN_ZERO );
} else {
if (IsBigIntTerm(d0))
FAIL();
Yap_AsmError(TYPE_ERROR_INTEGER);
Yap_AsmError(TYPE_ERROR_INTEGER, XREG(PREG->y_u.yxx.x1));
FAIL();
}
@ -2154,7 +2154,7 @@ Yap_AsmError( DOMAIN_ERROR_NOT_LESS_THAN_ZERO );
pt0 = RepAppl(d1);
d1 = *pt0;
if (IsExtensionFunctor((Functor)d1)) {
Yap_AsmError(TYPE_ERROR_COMPOUND);
Yap_AsmError(TYPE_ERROR_COMPOUND,XREG(PREG->y_u.yxx.x2));
FAIL();
}
if ((Int)d0 <= 0 || (Int)d0 > ArityOfFunctor((Functor)d1)) {
@ -2181,7 +2181,7 @@ Yap_AsmError( DOMAIN_ERROR_NOT_LESS_THAN_ZERO );
if (d0 != 1 && d0 != 2) {
if ((Int)d0 < 0) {
saveregs();
Yap_AsmError(DOMAIN_ERROR_NOT_LESS_THAN_ZERO);
Yap_AsmError(DOMAIN_ERROR_NOT_LESS_THAN_ZERO, YREG[PREG->y_u.yxx.y]);
}
FAIL();
}
@ -2193,20 +2193,20 @@ Yap_AsmError( DOMAIN_ERROR_NOT_LESS_THAN_ZERO );
ENDP(pt1);
ENDP(pt0);
} else {
Yap_AsmError(TYPE_ERROR_COMPOUND);
Yap_AsmError(TYPE_ERROR_COMPOUND, d1);
FAIL();
}
BEGP(pt0);
deref_body(d1, pt0, arg_y_arg2_unk, arg_y_arg2_nvar);
Yap_AsmError(INSTANTIATION_ERROR);
Yap_AsmError(INSTANTIATION_ERROR,d1);
ENDP(pt0);
FAIL();
ENDD(d1);
BEGP(pt0);
deref_body(d0, pt0, arg_y_arg1_unk, arg_y_arg1_nvar);
Yap_AsmError(INSTANTIATION_ERROR);
Yap_AsmError(INSTANTIATION_ERROR,d0);
ENDP(pt0);
FAIL();
ENDD(d0);
@ -2240,7 +2240,7 @@ Yap_AsmError( DOMAIN_ERROR_NOT_LESS_THAN_ZERO );
pt0 = RepAppl(d1);
d1 = *pt0;
if (IsExtensionFunctor((Functor)d1)) {
Yap_AsmError(TYPE_ERROR_COMPOUND);
Yap_AsmError(TYPE_ERROR_COMPOUND, XREG(PREG->y_u.yxn.xi));
FAIL();
}
if ((Int)d0 <= 0 || (Int)d0 > ArityOfFunctor((Functor)d1)) {
@ -2264,7 +2264,7 @@ Yap_AsmError( DOMAIN_ERROR_NOT_LESS_THAN_ZERO );
if (d0 != 1 && d0 != 2) {
if ((Int)d0 < 0) {
saveregs();
Yap_AsmError(DOMAIN_ERROR_NOT_LESS_THAN_ZERO);
Yap_AsmError(DOMAIN_ERROR_NOT_LESS_THAN_ZERO, YREG[PREG->y_u.yxn.y]);
}
FAIL();
}
@ -2276,13 +2276,13 @@ Yap_AsmError( DOMAIN_ERROR_NOT_LESS_THAN_ZERO );
GONext();
ENDP(pt0);
} else {
Yap_AsmError(TYPE_ERROR_COMPOUND);
Yap_AsmError(TYPE_ERROR_COMPOUND,YREG[PREG->y_u.yxn.y]);
FAIL();
}
BEGP(pt0);
deref_body(d1, pt0, arg_y_arg2_vc_unk, arg_y_arg2_vc_nvar);
Yap_AsmError(INSTANTIATION_ERROR);
Yap_AsmError(INSTANTIATION_ERROR,d1);
ENDP(pt0);
FAIL();
ENDD(d1);
@ -2320,15 +2320,15 @@ Yap_AsmError( DOMAIN_ERROR_NOT_LESS_THAN_ZERO );
saveregs();
if (IsBigIntTerm(d1)) {
setregs();
Yap_AsmError(RESOURCE_ERROR_STACK);
Yap_AsmError(RESOURCE_ERROR_STACK,d1);
} else {
setregs();
Yap_AsmError(TYPE_ERROR_INTEGER);
Yap_AsmError(TYPE_ERROR_INTEGER,d1);
}
FAIL();
}
if (!IsAtomicTerm(d0)) {
Yap_AsmError(TYPE_ERROR_ATOM);
Yap_AsmError(TYPE_ERROR_ATOM, d0);
FAIL();
}
/* We made it!!!!! we got in d0 the name, in d1 the arity and
@ -2346,7 +2346,7 @@ Yap_AsmError( DOMAIN_ERROR_NOT_LESS_THAN_ZERO );
} else if ((Int)d1 > 0) {
/* now let's build a compound term */
if (!IsAtomTerm(d0)) {
Yap_AsmError(TYPE_ERROR_ATOM);
Yap_AsmError(TYPE_ERROR_ATOM, d0);
FAIL();
}
BEGP(pt1);
@ -2363,7 +2363,7 @@ Yap_AsmError( DOMAIN_ERROR_NOT_LESS_THAN_ZERO );
if (!Yap_gcl((1 + d1) * sizeof(CELL), 0, YREG,
NEXTOP(NEXTOP(PREG, xxx), Osbpp))) {
setregs();
Yap_AsmError(RESOURCE_ERROR_STACK);
Yap_AsmError(RESOURCE_ERROR_STACK, d1 );
JMPNext();
} else {
setregs();
@ -2387,12 +2387,12 @@ Yap_AsmError( DOMAIN_ERROR_NOT_LESS_THAN_ZERO );
PREG = NEXTOP(NEXTOP(NEXTOP(PREG, xxx), Osbpp), l);
GONext();
} else {
Yap_AsmError(DOMAIN_ERROR_NOT_LESS_THAN_ZERO);
Yap_AsmError(DOMAIN_ERROR_NOT_LESS_THAN_ZERO, MkIntegerTerm(d1));
}
BEGP(pt1);
deref_body(d1, pt1, func2s_unk2, func2s_nvar2);
Yap_AsmError(INSTANTIATION_ERROR);
Yap_AsmError(INSTANTIATION_ERROR,d1);
ENDP(pt1);
/* Oops, third argument was unbound */
FAIL();
@ -2400,7 +2400,7 @@ Yap_AsmError( DOMAIN_ERROR_NOT_LESS_THAN_ZERO );
BEGP(pt1);
deref_body(d0, pt1, func2s_unk, func2s_nvar);
Yap_AsmError(INSTANTIATION_ERROR);
Yap_AsmError(INSTANTIATION_ERROR,d0);
ENDP(pt1);
/* Oops, second argument was unbound too */
FAIL();
@ -2435,10 +2435,10 @@ Yap_AsmError( DOMAIN_ERROR_NOT_LESS_THAN_ZERO );
saveregs();
if (IsBigIntTerm(d1)) {
setregs();
Yap_AsmError(RESOURCE_ERROR_STACK);
Yap_AsmError(RESOURCE_ERROR_STACK, d1);
} else {
setregs();
Yap_AsmError(TYPE_ERROR_INTEGER);
Yap_AsmError(TYPE_ERROR_INTEGER, d1);
}
FAIL();
}
@ -2457,7 +2457,7 @@ Yap_AsmError( DOMAIN_ERROR_NOT_LESS_THAN_ZERO );
} else if ((Int)d1 > 0) {
/* now let's build a compound term */
if (!IsAtomTerm(d0)) {
Yap_AsmError(TYPE_ERROR_ATOM);
Yap_AsmError(TYPE_ERROR_ATOM, d0);
FAIL();
}
BEGP(pt1);
@ -2474,7 +2474,7 @@ Yap_AsmError( DOMAIN_ERROR_NOT_LESS_THAN_ZERO );
if (!Yap_gcl((1 + d1) * sizeof(CELL), 0, YREG,
NEXTOP(NEXTOP(PREG, xxc), Osbpp))) {
setregs();
Yap_AsmError(RESOURCE_ERROR_STACK);
Yap_AsmError(RESOURCE_ERROR_STACK, d1);
JMPNext();
} else {
setregs();
@ -2498,12 +2498,12 @@ Yap_AsmError( DOMAIN_ERROR_NOT_LESS_THAN_ZERO );
PREG = NEXTOP(NEXTOP(NEXTOP(PREG, xxc), Osbpp), l);
GONext();
} else {
Yap_AsmError(DOMAIN_ERROR_NOT_LESS_THAN_ZERO);
Yap_AsmError(DOMAIN_ERROR_NOT_LESS_THAN_ZERO,d1);
}
BEGP(pt1);
deref_body(d1, pt1, func2s_unk2_cv, func2s_nvar2_cv);
Yap_AsmError(INSTANTIATION_ERROR);
Yap_AsmError(INSTANTIATION_ERROR,d1);
ENDP(pt1);
/* Oops, third argument was unbound */
FAIL();
@ -2537,7 +2537,7 @@ Yap_AsmError( DOMAIN_ERROR_NOT_LESS_THAN_ZERO );
BEGD(d1);
d1 = PREG->y_u.xxn.c;
if (!IsAtomicTerm(d0)) {
Yap_AsmError(TYPE_ERROR_ATOM);
Yap_AsmError(TYPE_ERROR_ATOM,d0);
FAIL();
}
/* We made it!!!!! we got in d0 the name, in d1 the arity and
@ -2560,7 +2560,7 @@ Yap_AsmError( DOMAIN_ERROR_NOT_LESS_THAN_ZERO );
GONext();
}
if (!IsAtomTerm(d0)) {
Yap_AsmError(TYPE_ERROR_ATOM);
Yap_AsmError(TYPE_ERROR_ATOM, d0);
FAIL();
}
BEGP(pt1);
@ -2576,7 +2576,7 @@ Yap_AsmError( DOMAIN_ERROR_NOT_LESS_THAN_ZERO );
saveregs();
if (!Yap_gc(0, YREG, NEXTOP(NEXTOP(PREG, xxn), Osbpp))) {
setregs();
Yap_AsmError(RESOURCE_ERROR_STACK);
Yap_AsmError(INSTANTIATION_ERROR,d1);
JMPNext();
} else {
setregs();
@ -2599,7 +2599,7 @@ Yap_AsmError( DOMAIN_ERROR_NOT_LESS_THAN_ZERO );
BEGP(pt1);
deref_body(d0, pt1, func2s_unk_vc, func2s_nvar_vc);
Yap_AsmError(INSTANTIATION_ERROR);
Yap_AsmError(INSTANTIATION_ERROR,d0);
ENDP(pt1);
/* Oops, second argument was unbound too */
FAIL();
@ -2636,15 +2636,15 @@ Yap_AsmError( DOMAIN_ERROR_NOT_LESS_THAN_ZERO );
saveregs();
if (IsBigIntTerm(d1)) {
setregs();
Yap_AsmError(RESOURCE_ERROR_STACK);
Yap_AsmError(RESOURCE_ERROR_STACK, d1);
} else {
setregs();
Yap_AsmError(TYPE_ERROR_INTEGER);
Yap_AsmError(TYPE_ERROR_INTEGER, d1);
}
FAIL();
}
if (!IsAtomicTerm(d0)) {
Yap_AsmError(TYPE_ERROR_ATOM);
Yap_AsmError(TYPE_ERROR_ATOM, d0);
FAIL();
}
/* We made it!!!!! we got in d0 the name, in d1 the arity and
@ -2663,7 +2663,7 @@ Yap_AsmError( DOMAIN_ERROR_NOT_LESS_THAN_ZERO );
} else if ((Int)d1 > 0) {
/* now let's build a compound term */
if (!IsAtomTerm(d0)) {
Yap_AsmError(TYPE_ERROR_ATOM);
Yap_AsmError(TYPE_ERROR_ATOM, d0);
FAIL();
}
BEGP(pt1);
@ -2680,7 +2680,7 @@ Yap_AsmError( DOMAIN_ERROR_NOT_LESS_THAN_ZERO );
if (!Yap_gcl((1 + d1) * sizeof(CELL), 0, YREG,
NEXTOP(NEXTOP(PREG, yxx), Osbpp))) {
setregs();
Yap_AsmError(RESOURCE_ERROR_STACK);
Yap_AsmError(RESOURCE_ERROR_STACK, d1);
JMPNext();
} else {
setregs();
@ -2710,12 +2710,12 @@ Yap_AsmError( DOMAIN_ERROR_NOT_LESS_THAN_ZERO );
ENDP(pt1);
GONext();
} else {
Yap_AsmError(DOMAIN_ERROR_NOT_LESS_THAN_ZERO);
Yap_AsmError(DOMAIN_ERROR_NOT_LESS_THAN_ZERO, MkIntegerTerm(d1));
}
BEGP(pt1);
deref_body(d1, pt1, func2s_y_unk2, func2s_y_nvar2);
Yap_AsmError(INSTANTIATION_ERROR);
Yap_AsmError(INSTANTIATION_ERROR,d1);
ENDP(pt1);
/* Oops, third argument was unbound */
FAIL();
@ -2723,7 +2723,7 @@ Yap_AsmError( DOMAIN_ERROR_NOT_LESS_THAN_ZERO );
BEGP(pt1);
deref_body(d0, pt1, func2s_y_unk, func2s_y_nvar);
Yap_AsmError(INSTANTIATION_ERROR);
Yap_AsmError(INSTANTIATION_ERROR,d0);
ENDP(pt1);
/* Oops, second argument was unbound too */
FAIL();
@ -2756,9 +2756,9 @@ Yap_AsmError( DOMAIN_ERROR_NOT_LESS_THAN_ZERO );
d1 = IntegerOfTerm(d1);
} else {
if (IsBigIntTerm(d1)) {
Yap_AsmError(RESOURCE_ERROR_STACK);
Yap_AsmError(RESOURCE_ERROR_STACK, d1);
} else {
Yap_AsmError(TYPE_ERROR_INTEGER);
Yap_AsmError(TYPE_ERROR_INTEGER, d1);
}
FAIL();
}
@ -2780,7 +2780,7 @@ Yap_AsmError( DOMAIN_ERROR_NOT_LESS_THAN_ZERO );
} else if ((Int)d1 > 0) {
/* now let's build a compound term */
if (!IsAtomTerm(d0)) {
Yap_AsmError(TYPE_ERROR_ATOM);
Yap_AsmError(TYPE_ERROR_ATOM,d0);
FAIL();
}
if (!IsAtomTerm(d0)) {
@ -2797,7 +2797,7 @@ Yap_AsmError( DOMAIN_ERROR_NOT_LESS_THAN_ZERO );
if (!Yap_gcl((1 + d1) * sizeof(CELL), 0, YREG,
NEXTOP(NEXTOP(PREG, yxc), Osbpp))) {
setregs();
Yap_AsmError(RESOURCE_ERROR_STACK);
Yap_AsmError(RESOURCE_ERROR_STACK, d1);
JMPNext();
} else {
setregs();
@ -2827,12 +2827,12 @@ Yap_AsmError( DOMAIN_ERROR_NOT_LESS_THAN_ZERO );
ENDP(pt1);
GONext();
} else {
Yap_AsmError(DOMAIN_ERROR_NOT_LESS_THAN_ZERO);
Yap_AsmError(DOMAIN_ERROR_NOT_LESS_THAN_ZERO, MkIntegerTerm(d1));
}
BEGP(pt1);
deref_body(d1, pt1, func2s_y_unk_cv, func2s_y_nvar_cv);
Yap_AsmError(INSTANTIATION_ERROR);
Yap_AsmError(INSTANTIATION_ERROR,d1);
ENDP(pt1);
/* Oops, third argument was unbound */
FAIL();
@ -2866,7 +2866,7 @@ Yap_AsmError( DOMAIN_ERROR_NOT_LESS_THAN_ZERO );
BEGD(d1);
d1 = PREG->y_u.yxn.c;
if (!IsAtomicTerm(d0)) {
Yap_AsmError(TYPE_ERROR_ATOM);
Yap_AsmError(TYPE_ERROR_ATOM,d0);
FAIL();
}
/* We made it!!!!! we got in d0 the name, in d1 the arity and
@ -2894,12 +2894,12 @@ Yap_AsmError( DOMAIN_ERROR_NOT_LESS_THAN_ZERO );
GONext();
}
if (!IsAtomTerm(d0)) {
Yap_AsmError(TYPE_ERROR_ATOM);
Yap_AsmError(TYPE_ERROR_ATOM,d0);
FAIL();
}
/* now let's build a compound term */
if (!IsAtomTerm(d0)) {
Yap_AsmError(TYPE_ERROR_ATOM);
Yap_AsmError(TYPE_ERROR_ATOM,d0);
FAIL();
}
BEGP(pt1);
@ -2916,7 +2916,7 @@ Yap_AsmError( DOMAIN_ERROR_NOT_LESS_THAN_ZERO );
if (!Yap_gcl((1 + d1) * sizeof(CELL), 0, YREG,
NEXTOP(NEXTOP(PREG, yxn), Osbpp))) {
setregs();
Yap_AsmError(RESOURCE_ERROR_STACK);
Yap_AsmError(RESOURCE_ERROR_STACK, d1);
JMPNext();
} else {
setregs();
@ -2942,7 +2942,7 @@ Yap_AsmError( DOMAIN_ERROR_NOT_LESS_THAN_ZERO );
BEGP(pt1);
deref_body(d0, pt1, func2s_y_unk_vc, func2s_y_nvar_vc);
Yap_AsmError(INSTANTIATION_ERROR);
Yap_AsmError(INSTANTIATION_ERROR,d0);
ENDP(pt1);
/* Oops, second argument was unbound too */
FAIL();
@ -2990,7 +2990,7 @@ Yap_AsmError( DOMAIN_ERROR_NOT_LESS_THAN_ZERO );
BEGP(pt1);
deref_body(d0, pt1, func2f_xx_unk, func2f_xx_nvar);
Yap_AsmError(INSTANTIATION_ERROR);
Yap_AsmError(INSTANTIATION_ERROR,d0);
ENDP(pt1);
/* Oops, second argument was unbound too */
FAIL();
@ -3041,7 +3041,7 @@ Yap_AsmError( DOMAIN_ERROR_NOT_LESS_THAN_ZERO );
BEGP(pt1);
deref_body(d0, pt1, func2f_xy_unk, func2f_xy_nvar);
Yap_AsmError(INSTANTIATION_ERROR);
Yap_AsmError(INSTANTIATION_ERROR,d0);
ENDP(pt1);
/* Oops, second argument was unbound too */
FAIL();
@ -3092,7 +3092,7 @@ Yap_AsmError( DOMAIN_ERROR_NOT_LESS_THAN_ZERO );
BEGP(pt1);
deref_body(d0, pt1, func2f_yx_unk, func2f_yx_nvar);
Yap_AsmError(INSTANTIATION_ERROR);
Yap_AsmError(INSTANTIATION_ERROR,d0);
ENDP(pt1);
/* Oops, second argument was unbound too */
FAIL();
@ -3146,7 +3146,7 @@ Yap_AsmError( DOMAIN_ERROR_NOT_LESS_THAN_ZERO );
BEGP(pt1);
deref_body(d0, pt1, func2f_yy_unk, func2f_yy_nvar);
Yap_AsmError(INSTANTIATION_ERROR);
Yap_AsmError(INSTANTIATION_ERROR,d0);
ENDP(pt1);
/* Oops, second argument was unbound too */
FAIL();
@ -3250,11 +3250,11 @@ Yap_AsmError( DOMAIN_ERROR_NOT_LESS_THAN_ZERO );
if (IsIntTerm(d1))
d1 = IntOfTerm(d1);
else {
Yap_AsmError(TYPE_ERROR_INTEGER);
Yap_AsmError(TYPE_ERROR_INTEGER, d1);
FAIL();
}
if (!IsAtomicTerm(d0)) {
Yap_AsmError(TYPE_ERROR_ATOM);
Yap_AsmError(TYPE_ERROR_ATOM,d0);
FAIL();
} /* We made it!!!!! we got in d0 the name, in d1 the arity and
* in pt0 the variable to bind it to. */
@ -3266,7 +3266,7 @@ Yap_AsmError( DOMAIN_ERROR_NOT_LESS_THAN_ZERO );
} else if ((Int)d1 > 0) {
/* now let's build a compound term */
if (!IsAtomTerm(d0)) {
Yap_AsmError(TYPE_ERROR_ATOM);
Yap_AsmError(TYPE_ERROR_ATOM,d0);
FAIL();
}
BEGP(pt1);
@ -3283,7 +3283,7 @@ Yap_AsmError( DOMAIN_ERROR_NOT_LESS_THAN_ZERO );
if (!Yap_gcl((1 + d1) * sizeof(CELL), 3, YREG,
NEXTOP(NEXTOP(PREG, e), Osbmp))) {
setregs();
Yap_AsmError(RESOURCE_ERROR_STACK);
Yap_AsmError(INSTANTIATION_ERROR,d1);
} else {
setregs();
}
@ -3297,7 +3297,7 @@ Yap_AsmError( DOMAIN_ERROR_NOT_LESS_THAN_ZERO );
HR = pt1;
ENDP(pt1);
} else if ((Int)d1 < 0) {
Yap_AsmError(DOMAIN_ERROR_NOT_LESS_THAN_ZERO);
Yap_AsmError(DOMAIN_ERROR_NOT_LESS_THAN_ZERO, MkIntegerTerm(d1));
FAIL();
}
/* else if arity is 0 just pass d0 through */
@ -3308,7 +3308,7 @@ Yap_AsmError( DOMAIN_ERROR_NOT_LESS_THAN_ZERO );
BEGP(pt1);
deref_body(d1, pt1, func_var_3unk, func_var_3nvar);
Yap_AsmError(INSTANTIATION_ERROR);
Yap_AsmError(INSTANTIATION_ERROR,d1);
ENDP(pt1);
/* Oops, third argument was unbound */
FAIL();
@ -3316,7 +3316,7 @@ Yap_AsmError( DOMAIN_ERROR_NOT_LESS_THAN_ZERO );
BEGP(pt1);
deref_body(d0, pt1, func_var_2unk, func_var_2nvar);
Yap_AsmError(INSTANTIATION_ERROR);
Yap_AsmError(INSTANTIATION_ERROR,d0);
ENDP(pt1);
/* Oops, second argument was unbound too */
FAIL();

263
C/scanner.c
View File

@ -457,6 +457,7 @@ static void Yap_setCurrentSourceLocation(struct stream_desc *s) {
char_kind_t Yap_chtype0[NUMBER_OF_CHARS + 1] = {
EF,
/* nul soh stx etx eot enq ack bel bs ht nl vt np cr so si
*/
BS, BS, BS, BS, BS, BS, BS, BS, BS, BS, BS, BS, BS, BS, BS, BS,
@ -630,18 +631,6 @@ static char *AllocScannerMemory(unsigned int size) {
return AuxSpScan;
}
static void PopScannerMemory(char *block, unsigned int size) {
CACHE_REGS
if (block == LOCAL_ScannerStack - size) {
LOCAL_ScannerStack -= size;
} else if (block == (char *)(LOCAL_ScannerExtraBlocks + 1)) {
struct scanner_extra_alloc *ptr = LOCAL_ScannerExtraBlocks;
LOCAL_ScannerExtraBlocks = ptr->next;
free(ptr);
}
}
char *Yap_AllocScannerMemory(unsigned int size) {
/* I assume memory has been initialized */
return AllocScannerMemory(size);
@ -1111,13 +1100,12 @@ static Term get_num(int *chp, int *chbuffp, StreamDesc *inp_stream, int sign) {
/* given a function getchr scan until we either find the number
or end of file */
Term Yap_scan_num(StreamDesc *inp) {
Term Yap_scan_num(StreamDesc *inp, bool error_on) {
CACHE_REGS
Term out;
int sign = 1;
int ch, cherr;
char *ptr, *mp;
int kind;
char *ptr;
void *old_tr = TR;
InitScannerMemory();
@ -1127,8 +1115,8 @@ Term Yap_scan_num(StreamDesc *inp) {
LOCAL_Error_TYPE = RESOURCE_ERROR_TRAIL;
return 0;
}
#if HAVE_ISWBLANK
while (iswblank(ch = getchr(inp)))
#if HAVE_ISWSPACE
while (iswspace(ch = getchr(inp)))
;
#else
while (isspace(ch = getchr(inp)))
@ -1151,64 +1139,22 @@ Term Yap_scan_num(StreamDesc *inp) {
return 0;
}
out = get_num(&ch, &cherr, inp, sign); /* */
}
if (LOCAL_ErrorMessage != NULL || ch != -1 || cherr) {
CACHE_REGS
char *s = ptr;
int sign = 1;
} else {
out = 0;
if (s[0] == '+') {
s++;
}
if (s[0] == '-') {
s++;
sign = -1;
}
if (strcmp(s, "inf") == 0) {
if (sign > 0) {
out = MkFloatTerm(INFINITY);
} else {
out = MkFloatTerm(-INFINITY);
}
}
if (strcmp(s, "nan") == 0) {
if (sign > 0) {
out = MkFloatTerm(NAN);
} else {
out = MkFloatTerm(-NAN);
}
}
if (out == 0) {
TokEntry *e, *ef;
size_t len = strlen(ptr);
mp = AllocScannerMemory(len + 1);
tokptr->Tok = Ord(kind = String_tok);
tokptr->TokInfo = MkStringTerm(mp);
e = (TokEntry *)AllocScannerMemory(sizeof(TokEntry));
ef = (TokEntry *)AllocScannerMemory(sizeof(TokEntry));
tokptr->TokNext = e;
e->Tok = Error_tok;
if (!LOCAL_ErrorMessage) {
LOCAL_ErrorMessage =
"syntax error while converting from a string to a number";
}
e->TokInfo = MkAtomTerm(Yap_LookupAtom(LOCAL_ErrorMessage));
e->TokPos = GetCurInpPos(inp);
e->TokNext = ef;
ef->Tok = Ord(kind = eot_tok);
ef->TokInfo = TermSyntaxError;
ef->TokPos = GetCurInpPos(inp);
ef->TokNext = NULL;
LOCAL_tokptr = tokptr;
LOCAL_toktide = e;
Yap_JumpToEnv(
Yap_syntax_error(e, inp - GLOBAL_Stream) );
LOCAL_Error_TYPE = SYNTAX_ERROR;
}
}
PopScannerMemory(ptr, 4096);
Yap_clean_tokenizer(old_tr, NULL, NULL);
#if HAVE_ISWSPACE
while (iswspace(ch = getchr(inp)))
;
#else
while (isspace(ch = getchr(inp)))
;
#endif
if (LOCAL_ErrorMessage != NULL || ch != -1 || cherr) {
Yap_clean_tokenizer(old_tr, NULL, NULL);
if (error_on)
Yap_Error(SYNTAX_ERROR, ARG2, "converting number");
return 0;
}
return out;
}
@ -1225,35 +1171,86 @@ Term Yap_scan_num(StreamDesc *inp) {
return l; \
}
const char *Yap_tokRep(void *tokptre, encoding_t encoding) {
CACHE_REGS
TokEntry *tokptr = tokptre;
Term info = tokptr->TokInfo;
size_t length;
UInt flags = 0;
switch (tokptr->Tok) {
case Name_tok:
case Number_tok:
case Ponctuation_tok:
case String_tok:
case BQString_tok:
return Yap_TermToString(info, &length, encoding, flags);
case Var_tok:
{
VarEntry *varinfo = (VarEntry *)info;
varinfo->VarAdr = TermNil;
return RepAtom(varinfo->VarRep)->StrOfAE;
}
case Error_tok:
return "<ERR>";
case eot_tok:
return "<EOT>";
case QuasiQuotes_tok:
return "<QQ>";
}
Term Yap_tokRep(void *tokptre) {
CACHE_REGS
TokEntry *tokptr = tokptre;
Term info = tokptr->TokInfo;
switch (tokptr->Tok) {
case Name_tok:
if (!info) {
info = TermNil;
}
return Yap_MkApplTerm(Yap_MkFunctor(AtomAtom, 1), 1, &info);
case QuasiQuotes_tok:
info = MkAtomTerm(Yap_LookupAtom("<QQ>"));
return Yap_MkApplTerm(Yap_MkFunctor(AtomAtom, 1), 1, &info);
case Number_tok:
return Yap_MkApplTerm(Yap_MkFunctor(AtomAtom, 1), 1, &info);
break;
case Var_tok: {
Term t[2];
VarEntry *varinfo = (VarEntry *)info;
if ((t[0]= varinfo->VarAdr) == TermNil) {
t[0] = varinfo->VarAdr = MkVarTerm();
}
t[1] = MkAtomTerm((Atom)(varinfo->VarRep));
return Yap_MkApplTerm(Yap_MkFunctor(AtomGVar, 2), 2, t);
}
case String_tok:
return Yap_MkApplTerm(Yap_MkFunctor(AtomString, 1), 1, &info);
case BQString_tok:
return Yap_MkApplTerm(Yap_MkFunctor(AtomString, 1), 1, &info);
case Error_tok:
return MkAtomTerm(AtomError);
case eot_tok:
return MkAtomTerm(Yap_LookupAtom("EOT"));
case Ponctuation_tok:
return info;
}
return TermDot;
}
const char * Yap_tokText(void *tokptre) {
CACHE_REGS
TokEntry *tokptr = tokptre;
Term info = tokptr->TokInfo;
switch (tokptr->Tok) {
case eot_tok:
return "EOT";
case Ponctuation_tok:
case Error_tok:
case BQString_tok:
case String_tok:
case Name_tok:
return AtomOfTerm(info)->StrOfAE;
case QuasiQuotes_tok:
return "<QQ>";
case Number_tok:
if (IsIntegerTerm(info)) {
char *s = Malloc(36);
snprintf(s, 35, Int_FORMAT, IntegerOfTerm(info));
return s;
}else if (IsFloatTerm(info)) {
char *s = Malloc( 64);
snprintf(s, 63, "%6g", FloatOfTerm(info));
return s;
} else {
size_t len = Yap_gmp_to_size(info,10);
char *s = Malloc(len+2);
return Yap_gmp_to_string(info,s, len+1,10);
}
break;
case Var_tok:
if (info == 0) return "[]";
return ((Atom)info)->StrOfAE;
}
return ".";
}
static void open_comment(int ch, StreamDesc *inp_stream USES_REGS) {
CELL *h0 = HR;
HR += 5;
@ -1314,6 +1311,7 @@ TokEntry *Yap_tokenizer(struct stream_desc *inp_stream, bool store_comments,
int solo_flag = TRUE;
int32_t ch, och;
struct qq_struct_t *cur_qq = NULL;
int sign = 1;
InitScannerMemory();
LOCAL_VarTable = NULL;
@ -1331,7 +1329,7 @@ TokEntry *Yap_tokenizer(struct stream_desc *inp_stream, bool store_comments,
do {
int quote, isvar;
unsigned char *charp, *mp;
unsigned int len;
size_t len;
unsigned char *TokImage = NULL;
t = (TokEntry *)AllocScannerMemory(sizeof(TokEntry));
@ -1396,8 +1394,8 @@ TokEntry *Yap_tokenizer(struct stream_desc *inp_stream, bool store_comments,
int32_t och = ch;
ch = getchr(inp_stream);
size_t sz = 512;
scan_name:
TokImage = Malloc(sz PASS_REGS);
scan_name:
charp = (unsigned char *)TokImage;
isvar = (chtype(och) != LC);
add_ch_to_buff(och);
@ -1446,13 +1444,16 @@ TokEntry *Yap_tokenizer(struct stream_desc *inp_stream, bool store_comments,
} break;
case NU: {
case NU: {
int cherr;
int cha = ch;
int cha;
sign = 1;
cherr = 0;
scan_number:
cha = ch;
cherr = 0;
CHECK_SPACE();
if ((t->TokInfo = get_num(&cha, &cherr, inp_stream, 1)) == 0L) {
if ((t->TokInfo = get_num(&cha, &cherr, inp_stream, sign)) == 0L) {
if (p) {
p->Tok = eot_tok;
t->TokInfo = TermError;
@ -1479,7 +1480,8 @@ TokEntry *Yap_tokenizer(struct stream_desc *inp_stream, bool store_comments,
case 'e':
case 'E':
och = cherr;
goto scan_name;
TokImage = Malloc(1024 PASS_REGS);
goto scan_name;
break;
case '=':
case '_':
@ -1511,6 +1513,13 @@ TokEntry *Yap_tokenizer(struct stream_desc *inp_stream, bool store_comments,
{
TokEntry *e2;
if (chtype(ch) == NU) {
if (och == '-')
sign = -1;
else
sign = 1;
goto scan_number;
}
t->Tok = Name_tok;
if (ch == '(')
solo_flag = FALSE;
@ -1558,7 +1567,9 @@ TokEntry *Yap_tokenizer(struct stream_desc *inp_stream, bool store_comments,
LOCAL_ErrorMessage = "layout character \n inside quotes";
break;
}
if (ch == EOFCHAR) {
break;
}
if (ch == quote) {
ch = getchrq(inp_stream);
if (ch != quote)
@ -1627,23 +1638,16 @@ TokEntry *Yap_tokenizer(struct stream_desc *inp_stream, bool store_comments,
break;
case SY: {
int pch;
if (ch == '.' && (pch = Yap_peek(inp_stream - GLOBAL_Stream)) &&
(chtype(pch) == BS || chtype(pch) == EF || pch == '%')) {
t->Tok = Ord(kind = eot_tok);
// consume...
if (pch == '%') {
t->TokInfo = TermNewLine;
return l;
if (ch == '.' && (pch = Yap_peek(inp_stream - GLOBAL_Stream)) &&
(chtype(pch) == BS || chtype(pch) == EF || pch == '%')) {
t->Tok = Ord(kind = eot_tok);
// consume...
if (pch == '%') {
t->TokInfo = TermNewLine;
return l;
}
return l;
}
ch = getchr(inp_stream);
if (chtype(ch) == EF) {
mark_eof(inp_stream);
t->TokInfo = TermEof;
} else {
t->TokInfo = TermNewLine;
}
return l;
}
if (ch == '`')
goto quoted_string;
och = ch;
@ -1664,7 +1668,7 @@ TokEntry *Yap_tokenizer(struct stream_desc *inp_stream, bool store_comments,
return l;
}
}
if (och == '/' && ch == '*') {
if (och == '/' && ch == '*') {
if (store_comments) {
CHECK_SPACE();
open_comment('/', inp_stream PASS_REGS);
@ -1721,7 +1725,7 @@ TokEntry *Yap_tokenizer(struct stream_desc *inp_stream, bool store_comments,
return l;
} else {
Atom ae;
size_t sz = 1024;
sz = 1024;
TokImage = Malloc(sz);
charp = TokImage;
add_ch_to_buff(och);
@ -1949,13 +1953,6 @@ TokEntry *Yap_tokenizer(struct stream_desc *inp_stream, bool store_comments,
t->Tok = Ord(kind = eot_tok);
t->TokInfo = TermEof;
}
#if DEBUG
if (GLOBAL_Option[2]) {
static int n;
fprintf(stderr, "[Token %d %s %d]", Ord(kind),
Yap_tokRep(t, inp_stream->encoding), n++);
}
#endif
if (LOCAL_ErrorMessage) {
/* insert an error token to inform the system of what happened */
TokEntry *e = (TokEntry *)AllocScannerMemory(sizeof(TokEntry));

72
C/text.c
View File

@ -206,7 +206,7 @@ static Int SkipListCodes(unsigned char **bufp, Term *l, Term **tailp,
(*atoms)++;
if (*atoms < length) {
*tailp = l;
return -TYPE_ERROR_NUMBER;
return -REPRESENTATION_ERROR_CHARACTER_CODE;
} else {
AtomEntry *ae = RepAtom(AtomOfTerm(hd));
if ((ae->StrOfAE)[1] != '\0') {
@ -219,10 +219,10 @@ static Int SkipListCodes(unsigned char **bufp, Term *l, Term **tailp,
} else if (IsIntegerTerm(hd)) {
ch = IntegerOfTerm(hd);
if (*atoms)
length = -TYPE_ERROR_ATOM;
length = -REPRESENTATION_ERROR_CHARACTER;
else if (ch < 0) {
*tailp = l;
length = -DOMAIN_ERROR_NOT_LESS_THAN_ZERO;
length = -REPRESENTATION_ERROR_CHARACTER_CODE;
} else {
*wide |= ch > 0x80;
}
@ -386,30 +386,34 @@ unsigned char *Yap_readText(seq_tv_t *inp, size_t *lengp) {
// this is a term, extract to a buffer, and representation is wide
// Yap_DebugPlWriteln(inp->val.t);
Atom at = AtomOfTerm(inp->val.t);
if (lengp)
*lengp = strlen_utf8(at->UStrOfAE);
return at->UStrOfAE;
}
if (IsStringTerm(inp->val.t) && inp->type & YAP_STRING_STRING) {
// this is a term, extract to a buffer, and representation is wide
// Yap_DebugPlWriteln(inp->val.t);
return (unsigned char *)UStringOfTerm(inp->val.t);
if (lengp)
*lengp = strlen_utf8(UStringOfTerm(inp->val.t));
return (unsigned char *)UStringOfTerm(inp->val.t);
}
if (((inp->type & (YAP_STRING_CODES | YAP_STRING_ATOMS)) ==
(YAP_STRING_CODES | YAP_STRING_ATOMS)) &&
IsPairOrNilTerm(inp->val.t)) {
// Yap_DebugPlWriteln(inp->val.t);
return inp->val.uc =
return
Yap_ListToBuffer(s0, inp->val.t, inp, &wide, lengp PASS_REGS);
// this is a term, extract to a sfer, and representation is wide
}
if (inp->type & YAP_STRING_CODES && IsPairOrNilTerm(inp->val.t)) {
// Yap_DebugPlWriteln(inp->val.t);
return inp->val.uc = Yap_ListOfCodesToBuffer(s0, inp->val.t, inp, &wide,
return Yap_ListOfCodesToBuffer(s0, inp->val.t, inp, &wide,
lengp PASS_REGS);
// this is a term, extract to a sfer, and representation is wide
}
if (inp->type & YAP_STRING_ATOMS && IsPairOrNilTerm(inp->val.t)) {
// Yap_DebugPlWriteln(inp->val.t);
return inp->val.uc = Yap_ListOfAtomsToBuffer(s0, inp->val.t, inp, &wide,
return Yap_ListOfAtomsToBuffer(s0, inp->val.t, inp, &wide,
lengp PASS_REGS);
// this is a term, extract to a buffer, and representation is wide
}
@ -426,22 +430,23 @@ unsigned char *Yap_readText(seq_tv_t *inp, size_t *lengp) {
AUX_ERROR(inp->val.t, 2 * MaxTmp(PASS_REGS1), s, char);
}
*lengp = strlen(s);
Malloc(*lengp);
return inp->val.uc = (unsigned char *)s;
return (unsigned char *)s;
}
if (inp->type & YAP_STRING_FLOAT && IsFloatTerm(inp->val.t)) {
char *s;
size_t sz = 1024;
// Yap_DebugPlWriteln(inp->val.t);
if (s0)
s = (char *)s0;
{ s = (char *)s0; sz = strlen(s);}
else
s = Malloc(0);
s = Malloc(sz);
if (!s)
AUX_ERROR(inp->val.t, MaxTmp(PASS_REGS1), s, char);
if (!Yap_FormatFloat(FloatOfTerm(inp->val.t), &s, MaxTmp() - 1)) {
AUX_ERROR(inp->val.t, 2 * MaxTmp(PASS_REGS1), s, char);
while (!Yap_FormatFloat(FloatOfTerm(inp->val.t), &s, sz - 1)) {
if (s0) { s = Malloc(sz=1024); s0 = NULL; }
else s = Realloc(s, sz+1024);
}
*lengp = strlen(s);
Malloc(*lengp);
return inp->val.uc = (unsigned char *)s;
}
#if USE_GMP
@ -595,8 +600,7 @@ static Term write_codes(void *s0, seq_tv_t *out, size_t leng USES_REGS) {
unsigned char *s = s0, *lim = s + strlen((char *)s);
unsigned char *cp = s;
wchar_t w[2];
w[1] = '\0';
LOCAL_TERM_ERROR(t, 2 * (lim - s));
while (*cp) {
utf8proc_int32_t chr;
@ -630,8 +634,11 @@ static Term write_codes(void *s0, seq_tv_t *out, size_t leng USES_REGS) {
static Atom write_atom(void *s0, seq_tv_t *out, size_t leng USES_REGS) {
unsigned char *s = s0;
int32_t ch;
if (!leng || strlen_utf8(s0) <= leng) {
return Yap_LookupAtom(s0);
if ( leng == 0) {
return Yap_LookupAtom("");
}
if ( strlen_utf8(s0) <= leng) {
return Yap_LookupAtom(s0);
} else {
size_t n = get_utf8(s, 1, &ch);
unsigned char *buf = Malloc(n + 1);
@ -713,10 +720,10 @@ static size_t write_length(const unsigned char *s0, seq_tv_t *out,
return leng;
}
static Term write_number(unsigned char *s, seq_tv_t *out, int size USES_REGS) {
static Term write_number(unsigned char *s, seq_tv_t *out, int size, bool error_on USES_REGS) {
Term t;
int i = push_text_stack();
t = Yap_StringToNumberTerm((char *)s, &out->enc);
t = Yap_StringToNumberTerm((char *)s, &out->enc, error_on);
pop_text_stack(i);
return t;
}
@ -739,7 +746,7 @@ bool write_Text(unsigned char *inp, seq_tv_t *out, size_t leng USES_REGS) {
return out->val.t != 0;
}
if (out->type & (YAP_STRING_INT | YAP_STRING_FLOAT | YAP_STRING_BIG)) {
if ((out->val.t = write_number(inp, out, leng PASS_REGS)) != 0L) {
if ((out->val.t = write_number(inp, out, leng,!(out->type & YAP_STRING_ATOM) PASS_REGS)) != 0L) {
// Yap_DebugPlWriteln(out->val.t);
return true;
@ -790,7 +797,7 @@ bool write_Text(unsigned char *inp, seq_tv_t *out, size_t leng USES_REGS) {
// Yap_DebugPlWriteln(out->val.t);
return out->val.a != NULL;
case YAP_STRING_INT | YAP_STRING_FLOAT | YAP_STRING_BIG:
out->val.t = write_number(inp, out, leng PASS_REGS);
out->val.t = write_number(inp, out, leng, true PASS_REGS);
// Yap_DebugPlWriteln(out->val.t);
return out->val.t != 0;
default: { return true ; }
@ -898,8 +905,8 @@ static int cmp_Text(const unsigned char *s1, const unsigned char *s2, int l) {
return 0;
}
static unsigned char *concat(int n, unsigned char *sv[] USES_REGS) {
char *buf;
static unsigned char *concat(int n, void *sv[] USES_REGS) {
void *buf;
unsigned char *buf0;
size_t room = 0;
int i;
@ -908,9 +915,14 @@ static unsigned char *concat(int n, unsigned char *sv[] USES_REGS) {
room += strlen((char *)sv[i]);
}
buf = Malloc(room + 1);
buf0 = (unsigned char *)buf;
buf0 = buf;
for (i = 0; i < n; i++) {
#if _WIN32
strcpy(buf, sv[i]);
buf = (char*)buf + strlen(buf);
#else
buf = stpcpy(buf, sv[i]);
#endif
}
return buf0;
}
@ -932,7 +944,7 @@ static void *slice(size_t min, size_t max, unsigned char *buf USES_REGS) {
//
// Out must be an atom or a string
bool Yap_Concat_Text(int tot, seq_tv_t inp[], seq_tv_t *out USES_REGS) {
unsigned char **bufv;
void **bufv;
unsigned char *buf;
int i;
size_t leng;
@ -951,7 +963,7 @@ bool Yap_Concat_Text(int tot, seq_tv_t inp[], seq_tv_t *out USES_REGS) {
bufv[i] = nbuf;
}
buf = concat(tot, bufv PASS_REGS);
bool rc = write_Text(buf, out, 0 PASS_REGS);
bool rc = write_Text(buf, out, strlen_utf8(buf) PASS_REGS);
return rc;
}
@ -1009,7 +1021,7 @@ bool Yap_Splice_Text(int n, size_t cuts[], seq_tv_t *inp,
next = 0;
else
next = cuts[i - 1];
if (cuts[i] == 0)
if (i>0 && cuts[i] == 0)
break;
void *bufi = slice(next, cuts[i], buf PASS_REGS);
if (!write_Text(bufi, outv + i, cuts[i] - next PASS_REGS)) {
@ -1022,7 +1034,7 @@ bool Yap_Splice_Text(int n, size_t cuts[], seq_tv_t *inp,
/**
* Function to convert a generic text term (string, atom, list of codes, list
of
of<
atoms) into a buff
er.
*
@ -1073,7 +1085,7 @@ const char *Yap_TextTermToText(Term t, char *buf, size_t len, encoding_t enc) {
const char *Yap_PredIndicatorToUTF8String(PredEntry *ap) {
CACHE_REGS
Atom at;
arity_t arity;
arity_t arity = 0;
Functor f;
char *s, *smax, *s0;
s = s0 = malloc(1024);

5
C/write.c
View File

@ -565,9 +565,12 @@ static void write_string(const unsigned char *s,
qt = '"';
wrputc(qt, stream);
do {
ptr += get_utf8(ptr, -1, &chr);
int delta;
ptr += (delta = get_utf8(ptr, -1, &chr) );
if (chr == '\0')
break;
if (delta == 0) {chr = *ptr++; }
write_quoted(chr, qt, stream);
} while (TRUE);
wrputc(qt, stream);

23
CMakeLists.txt
View File

@ -8,11 +8,15 @@
project( YAP )
if (ANDROID)
set(YAP_APP_DIR "$CMAKE_SOURCE_DIR/../..")
cmake_policy(VERSION 3.4)
else ()
cmake_minimum_required(VERSION 2.8)
include(CMakeToolsHelpers OPTIONAL)
# cmake_policy(VERSION 3.4)
endif()
set(
CMAKE_MODULE_PATH
@ -43,6 +47,7 @@ include(Model NO_POLICY_SCOPE)
include_directories ( utf8proc packages/myddas packages/myddas/sqlite3 )
if (ANDROID)
include_directories ( packages/myddas/sqlite3/Android/jni/sqlite/nativehelper packages/myddas/sqlite3/Android/jni/sqlite )
endif (ANDROID)
add_definitions(-DUSE_MYDDAS=1 -DMYDDAS_SQLITE3=1)
@ -69,18 +74,12 @@ if (ANDROID)
#
#
set (SWIG_SOURCES ${CMAKE_SOURCE_DIR}/packages/swig/yap.i)
set (SWIG_CXX ${CMAKE_BINARY_DIR}/yap_swig.cpp)
find_host_package (SWIG)
macro_log_feature (SWIG_FOUND "Swig"
"Use SWIG Language Interface "
"http://www.swig.org" ON)
add_custom_command (OUTPUT ${SWIG_CXX}
COMMAND ${SWIG_EXECUTABLE} -c++ -java -package pt.up.yap.lib -outdir ${CMAKE_LIBRARY_OUTPUT_DIRECTORY}/../../../../../src/generated/java -I${CMAKE_SOURCE_DIR}/CXX -o ${SWIG_CXX}
${SWIG_SOURCES}
)
set (SWIG_CXX ${CMAKE_BINARY_DIR}/packages/swig/android/yap_swig.cpp)
add_subdirectory("packages/swig")
ADD_SUBDIRECTORY(os)
ADD_SUBDIRECTORY(OPTYap)
@ -132,7 +131,7 @@ endif (USE_READLINE)
if (ANDROID)
add_dependencies(libYap plmyddas)
add_dependencies(libYap plmyddas swig)
target_link_libraries(libYap android log)

6
CXX/yapa.hh
View File

@ -57,8 +57,10 @@ class YAPAtom {
/// construct new YAPAtom from Atom
YAPAtom( Atom at ) { a = at; }
public:
/// construct new YAPAtom from UTF-8 string
YAPAtom( const char * s) { a = Yap_LookupAtom( s ); }
/// construct new YAPAtom from UTF-8 string
YAPAtom( const char * s) { a = Yap_LookupAtom( s ); }
/// construct new YAPAtom from UTF-8 string
YAPAtom( const wchar_t * s) { CACHE_REGS a = UTF32ToAtom( s PASS_REGS ); }
/// construct new YAPAtom from wide string
//YAPAtom( const wchar_t * s) { a = Yap_LookupMaybeWideAtom( s ); }
/// construct new YAPAtom from max-length string

2
CXX/yapdb.hh
View File

@ -97,7 +97,7 @@ public:
/// Note: Python confuses the 3 constructors,
/// use YAPFunctorFromWideString
inline YAPFunctor(const wchar_t *s, uintptr_t arity) {
f = Yap_MkFunctor(Yap_LookupWideAtom(s), arity);
CACHE_REGS f = Yap_MkFunctor(UTF32ToAtom(s PASS_REGS), arity);
}
~YAPFunctor(){};
/// Getter: extract name of functor as an atom

44
CXX/yapi.cpp
View File

@ -412,31 +412,6 @@ YAPTerm YAPListTerm::car() {
}
}
YAPTerm::YAPTerm(YAPFunctor f, YAPTerm ts[]) {
CACHE_REGS
BACKUP_H();
Functor fun = f.f;
arity_t arity = ArityOfFunctor(fun);
while (HR + arity > ASP - 1024) {
RECOVER_H();
if (!Yap_dogc(0, NULL PASS_REGS)) {
t = TermNil;
}
BACKUP_H();
}
if (fun == FunctorDot) {
t = AbsPair(HR);
HR[0] = ts[0].term();
HR[1] = ts[1].term();
} else {
t = AbsAppl(HR);
*HR++ = (CELL)fun;
for (arity_t i = 0; i < arity; i++) {
HR[i] = ts[i].term();
}
RECOVER_H();
}
}
YAPListTerm::YAPListTerm(YAPTerm ts[], arity_t n) {
CACHE_REGS
@ -519,12 +494,8 @@ bool YAPEngine::call(YAPPredicate ap, YAPTerm ts[]) {
}
return false;
}
// don't forget, on success these l);
if (!result) {
// don't forget, on success these bindings will still be there);
YAP_LeaveGoal(false, &q);
} else {
YAP_LeaveGoal(FALSE, &q);
}
RECOVER_MACHINE_REGS();
return result;
}
@ -595,7 +566,7 @@ Term YAPEngine::fun(Term t) {
BACKUP_MACHINE_REGS();
Term tmod = CurrentModule, *ts = nullptr;
PredEntry *ap ;
arity_t arity = arity;
arity_t arity;
Functor f;
jmp_buf q_env;
Atom name;
@ -612,9 +583,11 @@ Term YAPEngine::fun(Term t) {
} else if (IsAtomTerm(t)) {
name = AtomOfTerm(t);
f = nullptr;
arity = 0;
} else if (IsPairTerm(t)) {
XREGS[1] = ts[0];
XREGS[2] = ts[1];
arity = 2;
name = AtomDot;
f = FunctorDot;
} else {
@ -653,12 +626,11 @@ Term YAPEngine::fun(Term t) {
}
__android_log_print(ANDROID_LOG_INFO, "YAPDroid", "out %d", result);
Term result;
t = Yap_GetFromSlot(q.CurSlot);
Yap_CloseHandles(q.CurSlot);
if (!t) {
YAP_LeaveGoal(false, &q);
result = 0;
t = 0;
}
RECOVER_MACHINE_REGS();
return t;
@ -668,7 +640,7 @@ YAPQuery::YAPQuery(YAPFunctor f, YAPTerm mod, YAPTerm ts[])
: YAPPredicate(f, mod) {
/* ignore flags for now */
BACKUP_MACHINE_REGS();
goal = YAPTerm(f, ts);
goal = YAPApplTerm(f, ts);
vnames = YAPListTerm();
openQuery();
RECOVER_MACHINE_REGS();
@ -677,7 +649,7 @@ YAPQuery::YAPQuery(YAPFunctor f, YAPTerm mod, YAPTerm ts[])
YAPQuery::YAPQuery(YAPFunctor f, YAPTerm ts[]) : YAPPredicate(f) {
/* ignore flags for now */
BACKUP_MACHINE_REGS();
goal = YAPTerm(f, ts);
goal = YAPApplTerm(f, ts);
vnames = YAPListTerm();
openQuery();
RECOVER_MACHINE_REGS();
@ -685,7 +657,7 @@ YAPQuery::YAPQuery(YAPFunctor f, YAPTerm ts[]) : YAPPredicate(f) {
YAPQuery::YAPQuery(YAPPredicate p, YAPTerm ts[]) : YAPPredicate(p.ap) {
BACKUP_MACHINE_REGS();
goal = YAPTerm(YAPFunctor(ap->FunctorOfPred), ts);
goal = YAPApplTerm(YAPFunctor(ap->FunctorOfPred), ts);
vnames = YAPListTerm();
openQuery();
RECOVER_MACHINE_REGS();

8
CXX/yapt.hh
View File

@ -39,12 +39,12 @@ public:
}
/// construct a term out of an integer (if you know object type use
/// YAPIntegerTerm)
YAPTerm(long int num) { mk(MkIntegerTerm(num)); }
/// YAPTerm(long int num) { mk(MkIntegerTerm(num)); }
/// construct a term out of an integer (if you know object type use
/// YAPIntegerTerm)
YAPTerm(double num) { mk(MkFloatTerm(num)); }
/// YAPTerm(double num) { mk(MkFloatTerm(num)); }
/// parse string s and construct a term.
YAPTerm(YAPFunctor f, YAPTerm ts[]);
/// YAPTerm(YAPFunctor f, YAPTerm ts[]);
/// extract the tag of a term, after dereferencing.
YAP_tag_t tag();
/// copy the term ( term copy )
@ -322,8 +322,6 @@ class YAPAtomTerm : public YAPTerm {
// Constructor: receives a C-atom;
YAPAtomTerm(Atom a) { mk(MkAtomTerm(a)); }
YAPAtomTerm(Term t) : YAPTerm(t) { IsAtomTerm(t); }
// Getter for Prolog atom
Term getTerm() { return t; }
public:
// Constructor: receives an atom;

6
H/ATOMS
View File

@ -196,6 +196,7 @@ A Id N "id"
A Ignore N "ignore"
A Inf N "inf"
A Infinity N "infinity"
A Info N "info"
A InitGoal F "$init_goal"
A InitProlog F "$init_prolog"
A InStackExpansion N "in stack expansion"
@ -495,6 +496,7 @@ F Dot6 Dot 6
F Dot7 Dot 7
F Dot8 Dot 8
F Dot9 Dot 9
F DoubleArrow DoubleArrow 2
F DoubleSlash DoubleSlash 2
F EmptySquareBrackets EmptySquareBrackets 2
F Eq Eq 2
@ -523,6 +525,10 @@ F HandleThrow HandleThrow 3
F Hat Hat 2
F I I 2
F Id Id 1
F Info1 Info 1
F Info2 Info 2
F Info3 Info 3
F Info4 Info 4
F Is Is 2
F J J 2
F LastExecuteWithin LastExecuteWithin 1

39
H/YapText.h
View File

@ -40,7 +40,9 @@ extern void Free(void *buf USES_REGS);
extern int push_text_stack( USES_REGS1 );
extern int pop_text_stack( int lvl USES_REGS );
#ifndef min
#define min(x,y) (x<y ? x : y)
#endif
#define MBYTE (1024*1024)
@ -154,12 +156,18 @@ INLINE_ONLY EXTERN inline char_kind_t chtype(Int ch) {
#define __android_log_print(...)
#endif
inline static utf8proc_ssize_t get_utf8(const utf8proc_uint8_t *ptr, size_t n,
INLINE_ONLY inline EXTERN utf8proc_ssize_t get_utf8(const utf8proc_uint8_t *ptr, size_t n,
utf8proc_int32_t *valp);
INLINE_ONLY inline EXTERN utf8proc_ssize_t get_utf8(const utf8proc_uint8_t *ptr, size_t n,
utf8proc_int32_t *valp) {
return utf8proc_iterate(ptr, n, valp);
}
inline static utf8proc_ssize_t put_utf8(utf8proc_uint8_t *ptr,
INLINE_ONLY inline EXTERN utf8proc_ssize_t put_utf8(utf8proc_uint8_t *ptr,
utf8proc_int32_t val);
INLINE_ONLY inline EXTERN utf8proc_ssize_t put_utf8(utf8proc_uint8_t *ptr,
utf8proc_int32_t val) {
return utf8proc_encode_char(val, ptr);
}
@ -286,7 +294,8 @@ inline static int cmpn_utf8(const utf8proc_uint8_t *pt1,
#define SURROGATE_OFFSET \
((uint32_t)0x10000 - (uint32_t)(0xD800 << 10) - (uint32_t)0xDC00)
const char *Yap_tokRep(void*tokptr, encoding_t enc);
extern const char *Yap_tokText(void*tokptr);
extern Term Yap_tokRep(void*tokptr);
// standard strings
@ -670,6 +679,17 @@ static inline Term Yap_AtomicToTDQ(Term t0, Term mod USES_REGS) {
return out.val.t;
}
static inline wchar_t *Yap_AtomToWide(Atom at USES_REGS) {
seq_tv_t inp, out;
inp.val.a = at;
inp.type = YAP_STRING_ATOM;
out.val.uc = NULL;
out.type = YAP_STRING_WCHARS;
if (!Yap_CVT_Text(&inp, &out PASS_REGS))
return NIL;
return out.val.w;
}
static inline Term Yap_AtomicToTBQ(Term t0, Term mod USES_REGS) {
seq_tv_t inp, out;
@ -1362,6 +1382,19 @@ static inline Term Yap_UTF8ToString(const char *s USES_REGS) {
return MkStringTerm(s);
}
static inline Atom UTF32ToAtom(const wchar_t *s USES_REGS) {
seq_tv_t inp, out;
inp.val.w0 = s;
inp.type = YAP_STRING_WCHARS ;
out.type = YAP_STRING_ATOM;
out.max = -1;
if (!Yap_CVT_Text(&inp, &out PASS_REGS))
return 0L;
return out.val.a;
}
static inline Term Yap_WCharsToListOfCodes(const wchar_t *s USES_REGS) {
seq_tv_t inp, out;
inp.val.w0 = s;

4
H/absmi.h
View File

@ -2452,10 +2452,10 @@ extern yamop *headoftrace;
ENDD(d0);
#endif
#define Yap_AsmError(e) \
#define Yap_AsmError(e, d) \
{ \
saveregs(); \
Yap_Error(e, 0, ""); \
Yap_ThrowError(e, d, 4, ""); \
setregs(); \
}

46
H/arith2.h
View File

@ -301,12 +301,12 @@ static Term p_div(Term t1, Term t2 USES_REGS) {
Int i1 = IntegerOfTerm(t1), i2 = IntegerOfTerm(t2);
if (i2 == 0) {
return Yap_ArithError(EVALUATION_ERROR_ZERO_DIVISOR, t2, "// /2");
Yap_ArithError(EVALUATION_ERROR_ZERO_DIVISOR, t2, "// /2");
} else if (i1 == Int_MIN && i2 == -1) {
#ifdef USE_GMP
return Yap_gmp_add_ints(Int_MAX, 1);
#else
return Yap_ArithError(EVALUATION_ERROR_INT_OVERFLOW, t1,
Yap_ArithError(EVALUATION_ERROR_INT_OVERFLOW, t1,
"rem/2 with %d and %d", i1, i2);
#endif
} else {
@ -314,7 +314,7 @@ static Term p_div(Term t1, Term t2 USES_REGS) {
}
}
case double_e:
return Yap_ArithError(TYPE_ERROR_INTEGER, t2, "// /2");
Yap_ArithError(TYPE_ERROR_INTEGER, t2, "// /2");
case big_int_e:
#ifdef USE_GMP
/* dividing a bignum by an integer */
@ -325,7 +325,7 @@ static Term p_div(Term t1, Term t2 USES_REGS) {
}
break;
case double_e:
return Yap_ArithError(TYPE_ERROR_INTEGER, t1, "// /2");
Yap_ArithError(TYPE_ERROR_INTEGER, t1, "// /2");
case big_int_e:
#ifdef USE_GMP
switch (ETypeOfTerm(t2)) {
@ -336,7 +336,7 @@ static Term p_div(Term t1, Term t2 USES_REGS) {
/* two bignums */
return Yap_gmp_div_big_big(t1, t2);
case double_e:
return Yap_ArithError(TYPE_ERROR_INTEGER, t2, "// /2");
Yap_ArithError(TYPE_ERROR_INTEGER, t2, "// /2");
default:
RERROR();
}
@ -355,7 +355,7 @@ static Term p_and(Term t1, Term t2 USES_REGS) {
/* two integers */
RINT(IntegerOfTerm(t1) & IntegerOfTerm(t2));
case double_e:
return Yap_ArithError(TYPE_ERROR_INTEGER, t2, "/\\ /2");
Yap_ArithError(TYPE_ERROR_INTEGER, t2, "/\\ /2");
case big_int_e:
#ifdef USE_GMP
return Yap_gmp_and_int_big(IntegerOfTerm(t1), t2);
@ -365,7 +365,7 @@ static Term p_and(Term t1, Term t2 USES_REGS) {
}
break;
case double_e:
return Yap_ArithError(TYPE_ERROR_INTEGER, t1, "/\\ /2");
Yap_ArithError(TYPE_ERROR_INTEGER, t1, "/\\ /2");
case big_int_e:
#ifdef USE_GMP
switch (ETypeOfTerm(t2)) {
@ -376,7 +376,7 @@ static Term p_and(Term t1, Term t2 USES_REGS) {
/* two bignums */
return Yap_gmp_and_big_big(t1, t2);
case double_e:
return Yap_ArithError(TYPE_ERROR_INTEGER, t2, "/\\ /2");
Yap_ArithError(TYPE_ERROR_INTEGER, t2, "/\\ /2");
default:
RERROR();
}
@ -395,7 +395,7 @@ static Term p_or(Term t1, Term t2 USES_REGS) {
/* two integers */
RINT(IntegerOfTerm(t1) | IntegerOfTerm(t2));
case double_e:
return Yap_ArithError(TYPE_ERROR_INTEGER, t2, "\\/ /2");
Yap_ArithError(TYPE_ERROR_INTEGER, t2, "\\/ /2");
case big_int_e:
#ifdef USE_GMP
return Yap_gmp_ior_int_big(IntegerOfTerm(t1), t2);
@ -405,7 +405,7 @@ static Term p_or(Term t1, Term t2 USES_REGS) {
}
break;
case double_e:
return Yap_ArithError(TYPE_ERROR_INTEGER, t1, "\\/ /2");
Yap_ArithError(TYPE_ERROR_INTEGER, t1, "\\/ /2");
case big_int_e:
#ifdef USE_GMP
switch (ETypeOfTerm(t2)) {
@ -416,7 +416,7 @@ static Term p_or(Term t1, Term t2 USES_REGS) {
/* two bignums */
return Yap_gmp_ior_big_big(t1, t2);
case double_e:
return Yap_ArithError(TYPE_ERROR_INTEGER, t2, "\\/ /2");
Yap_ArithError(TYPE_ERROR_INTEGER, t2, "\\/ /2");
default:
RERROR();
}
@ -438,33 +438,33 @@ static Term p_sll(Term t1, Term t2 USES_REGS) {
if (i2 <= 0) {
if (i2 == Int_MIN) {
return Yap_ArithError(RESOURCE_ERROR_HUGE_INT, t2, ">>/2");
Yap_ArithError(RESOURCE_ERROR_HUGE_INT, t2, ">>/2");
}
RINT(SLR(IntegerOfTerm(t1), -i2));
}
return do_sll(IntegerOfTerm(t1), i2 PASS_REGS);
}
case double_e:
return Yap_ArithError(TYPE_ERROR_INTEGER, t2, "<</2");
Yap_ArithError(TYPE_ERROR_INTEGER, t2, "<</2");
case big_int_e:
#ifdef USE_GMP
return Yap_ArithError(RESOURCE_ERROR_HUGE_INT, t2, "<</2");
Yap_ArithError(RESOURCE_ERROR_HUGE_INT, t2, "<</2");
#endif
default:
RERROR();
}
break;
case double_e:
return Yap_ArithError(TYPE_ERROR_INTEGER, t1, "<< /2");
Yap_ArithError(TYPE_ERROR_INTEGER, t1, "<< /2");
case big_int_e:
#ifdef USE_GMP
switch (ETypeOfTerm(t2)) {
case long_int_e:
return Yap_gmp_sll_big_int(t1, IntegerOfTerm(t2));
case big_int_e:
return Yap_ArithError(RESOURCE_ERROR_HUGE_INT, t2, ">>/2");
Yap_ArithError(RESOURCE_ERROR_HUGE_INT, t2, ">>/2");
case double_e:
return Yap_ArithError(TYPE_ERROR_INTEGER, t2, "<</2");
Yap_ArithError(TYPE_ERROR_INTEGER, t2, "<</2");
default:
RERROR();
}
@ -486,33 +486,33 @@ static Term p_slr(Term t1, Term t2 USES_REGS) {
if (i2 < 0) {
if (i2 == Int_MIN) {
return Yap_ArithError(RESOURCE_ERROR_HUGE_INT, t2, ">>/2");
Yap_ArithError(RESOURCE_ERROR_HUGE_INT, t2, ">>/2");
}
return do_sll(IntegerOfTerm(t1), -i2 PASS_REGS);
}
RINT(SLR(IntegerOfTerm(t1), i2));
}
case double_e:
return Yap_ArithError(TYPE_ERROR_INTEGER, t2, ">>/2");
Yap_ArithError(TYPE_ERROR_INTEGER, t2, ">>/2");
case big_int_e:
#ifdef USE_GMP
return Yap_ArithError(RESOURCE_ERROR_HUGE_INT, t2, ">>/2");
Yap_ArithError(RESOURCE_ERROR_HUGE_INT, t2, ">>/2");
#endif
default:
RERROR();
}
break;
case double_e:
return Yap_ArithError(TYPE_ERROR_INTEGER, t1, ">>/2");
Yap_ArithError(TYPE_ERROR_INTEGER, t1, ">>/2");
case big_int_e:
#ifdef USE_GMP
switch (ETypeOfTerm(t2)) {
case long_int_e:
return Yap_gmp_sll_big_int(t1, -IntegerOfTerm(t2));
case big_int_e:
return Yap_ArithError(RESOURCE_ERROR_HUGE_INT, t2, ">>/2");
Yap_ArithError(RESOURCE_ERROR_HUGE_INT, t2, ">>/2");
case double_e:
return Yap_ArithError(TYPE_ERROR_INTEGER, t2, ">>/2");
Yap_ArithError(TYPE_ERROR_INTEGER, t2, ">>/2");
default:
RERROR();
}

2
H/eval.h
View File

@ -407,7 +407,7 @@ 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__)
Yap_ThrowError__(__FILE__, __FUNCTION__, __LINE__, id, t, 2, __VA_ARGS__)
#define Yap_BinError(id) \
Yap_Error__(__FILE__, __FUNCTION__, __LINE__, id, 0L, "")
#define Yap_AbsmiError(id) \

6
H/generated/iatoms.h
View File

@ -191,6 +191,7 @@
AtomIgnore = Yap_LookupAtom("ignore"); TermIgnore = MkAtomTerm(AtomIgnore);
AtomInf = Yap_LookupAtom("inf"); TermInf = MkAtomTerm(AtomInf);
AtomInfinity = Yap_LookupAtom("infinity"); TermInfinity = MkAtomTerm(AtomInfinity);
AtomInfo = Yap_LookupAtom("info"); TermInfo = MkAtomTerm(AtomInfo);
AtomInitGoal = Yap_FullLookupAtom("$init_goal"); TermInitGoal = MkAtomTerm(AtomInitGoal);
AtomInitProlog = Yap_FullLookupAtom("$init_prolog"); TermInitProlog = MkAtomTerm(AtomInitProlog);
AtomInStackExpansion = Yap_LookupAtom("in stack expansion"); TermInStackExpansion = MkAtomTerm(AtomInStackExpansion);
@ -490,6 +491,7 @@
FunctorDot7 = Yap_MkFunctor(AtomDot,7);
FunctorDot8 = Yap_MkFunctor(AtomDot,8);
FunctorDot9 = Yap_MkFunctor(AtomDot,9);
FunctorDoubleArrow = Yap_MkFunctor(AtomDoubleArrow,2);
FunctorDoubleSlash = Yap_MkFunctor(AtomDoubleSlash,2);
FunctorEmptySquareBrackets = Yap_MkFunctor(AtomEmptySquareBrackets,2);
FunctorEq = Yap_MkFunctor(AtomEq,2);
@ -518,6 +520,10 @@
FunctorHat = Yap_MkFunctor(AtomHat,2);
FunctorI = Yap_MkFunctor(AtomI,2);
FunctorId = Yap_MkFunctor(AtomId,1);
FunctorInfo1 = Yap_MkFunctor(AtomInfo,1);
FunctorInfo2 = Yap_MkFunctor(AtomInfo,2);
FunctorInfo3 = Yap_MkFunctor(AtomInfo,3);
FunctorInfo4 = Yap_MkFunctor(AtomInfo,4);
FunctorIs = Yap_MkFunctor(AtomIs,2);
FunctorJ = Yap_MkFunctor(AtomJ,2);
FunctorLastExecuteWithin = Yap_MkFunctor(AtomLastExecuteWithin,1);

6
H/generated/ratoms.h
View File

@ -191,6 +191,7 @@
AtomIgnore = AtomAdjust(AtomIgnore); TermIgnore = MkAtomTerm(AtomIgnore);
AtomInf = AtomAdjust(AtomInf); TermInf = MkAtomTerm(AtomInf);
AtomInfinity = AtomAdjust(AtomInfinity); TermInfinity = MkAtomTerm(AtomInfinity);
AtomInfo = AtomAdjust(AtomInfo); TermInfo = MkAtomTerm(AtomInfo);
AtomInitGoal = AtomAdjust(AtomInitGoal); TermInitGoal = MkAtomTerm(AtomInitGoal);
AtomInitProlog = AtomAdjust(AtomInitProlog); TermInitProlog = MkAtomTerm(AtomInitProlog);
AtomInStackExpansion = AtomAdjust(AtomInStackExpansion); TermInStackExpansion = MkAtomTerm(AtomInStackExpansion);
@ -490,6 +491,7 @@
FunctorDot7 = FuncAdjust(FunctorDot7);
FunctorDot8 = FuncAdjust(FunctorDot8);
FunctorDot9 = FuncAdjust(FunctorDot9);
FunctorDoubleArrow = FuncAdjust(FunctorDoubleArrow);
FunctorDoubleSlash = FuncAdjust(FunctorDoubleSlash);
FunctorEmptySquareBrackets = FuncAdjust(FunctorEmptySquareBrackets);
FunctorEq = FuncAdjust(FunctorEq);
@ -518,6 +520,10 @@
FunctorHat = FuncAdjust(FunctorHat);
FunctorI = FuncAdjust(FunctorI);
FunctorId = FuncAdjust(FunctorId);
FunctorInfo1 = FuncAdjust(FunctorInfo1);
FunctorInfo2 = FuncAdjust(FunctorInfo2);
FunctorInfo3 = FuncAdjust(FunctorInfo3);
FunctorInfo4 = FuncAdjust(FunctorInfo4);
FunctorIs = FuncAdjust(FunctorIs);
FunctorJ = FuncAdjust(FunctorJ);
FunctorLastExecuteWithin = FuncAdjust(FunctorLastExecuteWithin);

11
H/generated/tatoms.h
View File

@ -191,6 +191,7 @@ EXTERNAL Atom AtomId; EXTERNAL Term TermId;
EXTERNAL Atom AtomIgnore; EXTERNAL Term TermIgnore;
EXTERNAL Atom AtomInf; EXTERNAL Term TermInf;
EXTERNAL Atom AtomInfinity; EXTERNAL Term TermInfinity;
EXTERNAL Atom AtomInfo; EXTERNAL Term TermInfo;
EXTERNAL Atom AtomInitGoal; EXTERNAL Term TermInitGoal;
EXTERNAL Atom AtomInitProlog; EXTERNAL Term TermInitProlog;
EXTERNAL Atom AtomInStackExpansion; EXTERNAL Term TermInStackExpansion;
@ -544,6 +545,8 @@ EXTERNAL Functor FunctorDot8;
EXTERNAL Functor FunctorDot9;
EXTERNAL Functor FunctorDoubleArrow;
EXTERNAL Functor FunctorDoubleSlash;
EXTERNAL Functor FunctorEmptySquareBrackets;
@ -600,6 +603,14 @@ EXTERNAL Functor FunctorI;
EXTERNAL Functor FunctorId;
EXTERNAL Functor FunctorInfo1;
EXTERNAL Functor FunctorInfo2;
EXTERNAL Functor FunctorInfo3;
EXTERNAL Functor FunctorInfo4;
EXTERNAL Functor FunctorIs;
EXTERNAL Functor FunctorJ;

18
Prelims.cmake
View File

@ -141,18 +141,20 @@ if(POLICY CMP0043)
endif(POLICY CMP0043)
if (ANDROID)
set ( prefix ${YAP_APP_DIR}/app/build/generated )
set ( datarootdir ${YAP_APP_DIR}/app/build/generated/assets )
set ( includedir "${prefix}/assets/include")
set ( libpl ${YAP_APP_DIR}/app/build/generated/assets/Yap)
else()
set ( prefix "${CMAKE_INSTALL_PREFIX}")
set ( datarootdir "${prefix}/share")
set ( libpl "${datarootdir}/Yap")
set ( includedir "${prefix}/include")
endif()
set ( exec_prefix "${prefix}")
set ( libdir "${exec_prefix}/lib")
set ( dlls "${exec_prefix}/lib/Yap")
set ( includedir "${prefix}/include")
set ( datarootdir "${prefix}/share")
if (ANDROID)
set ( libpl "${CMAKE_LIBRARY_OUTPUT_DIRECTORY}/../../../../../build/generated/assets/Yap")
else()
set ( libpl "${datarootdir}/Yap")
endif()
set ( datadir "${datarootdir}")
set ( mandir "${datarootdir}/man")
set ( bindir "${exec_prefix}/bin")

1
cmake/Config.cmake
View File

@ -255,6 +255,7 @@ check_function_exists(__builtin_ffsll HAVE___BUILTIN_FFSLL)
check_function_exists(fgetpos HAVE_FGETPOS)
check_function_exists(finite HAVE_FINITE)
check_function_exists(iswblank HAVE_ISWBLANK)
check_function_exists(iswspace HAVE_ISWSPACE)
check_symbol_exists(flsl <string.h> HAVE_FLSL)
check_symbol_exists(flsll <string.h> HAVE_FLSLL)
check_function_exists(fmemopen HAVE_FMEMOPEN)

5
config.h.cmake
View File

@ -586,6 +586,11 @@ function. */
#cmakedefine HAVE_ISWBLANK ${HAVE_ISWBLANK}
#endif
/* Define to 1 if you have the `iswspace' function. */
#ifndef HAVE_ISWSPACE
#cmakedefine HAVE_ISWSPACE ${HAVE_ISWSPACE}
#endif
/* Define to 1 if you have the <Judy.h> header file. */
#ifndef HAVE_JUDY_H
#cmakedefine HAVE_JUDY_H ${HAVE_JUDY_H}

6
include/YapError.h
View File

@ -42,7 +42,7 @@ struct yami *Yap_Error__(const char *file, const char *function, int lineno,
yap_error_number err, YAP_Term wheret, ...);
void Yap_ThrowError__(const char *file, const char *function, int lineno,
yap_error_number err, YAP_Term wheret, ...);
yap_error_number err, YAP_Term wheret, int code, ...) __attribute__ ((noreturn));
#define Yap_NilError(id, ...) \
@ -51,8 +51,8 @@ void Yap_ThrowError__(const char *file, const char *function, int lineno,
#define Yap_Error(id, inp, ...) \
Yap_Error__(__FILE__, __FUNCTION__, __LINE__, id, inp, __VA_ARGS__)
#define Yap_ThrowError(id, inp, ...) \
Yap_ThrowError__(__FILE__, __FUNCTION__, __LINE__, id, inp, __VA_ARGS__)
#define Yap_ThrowError(id, inp, code, ...) \
Yap_ThrowError__(__FILE__, __FUNCTION__, __LINE__, id, inp, code, __VA_ARGS__)
#ifdef YAP_TERM_H
/**

43
library/lineutils.yap
View File

@ -248,6 +248,49 @@ split_within(SplitCodes, DoubleQs, C-SingleQs, Strings, C) -->
split_within(SplitCodes, DoubleQs, SingleQs, [[C|String]|Strings], C) -->
split_within(SplitCodes, DoubleQs, SingleQs, [String|Strings]).
/** @pred split_unquoted(+ _Line_,+ _Separators_,- _Split_)
Unify _Words_ with a set of strings obtained from _Line_ by
using the character codes in _Separators_ as separators, but treat text wi
thin double quotes as a single unit. As an
example, consider:
~~~~~{.prolog}
?- split("Hello * I \"am free\""," *",S).
S = ["Hello","I","am free"] ?
no
~~~~~
*/
split_unquoted(String, SplitCodes, Strings) :-
split_unquoted_at_blank(SplitCodes, Strings, String, []).
split_unquoted_at_blank(SplitCodes, [[0'"|New]|More]) --> %0'"
"\"",
split_quoted(New, More),
split_unquoted_at_blank(SplitCodes, More).
split_unquoted_at_blank(SplitCodes, More) -->
[C],
{ member(C, SplitCodes) }, !,
split_unquoted_at_blank(SplitCodes, More).
split_unquoted_at_blank(SplitCodes, [[C|New]| More]) -->
[C], !,
split_unquoted(SplitCodes, New, More).
split_unquoted_at_blank(_, []) --> [].
split_unquoted(SplitCodes, [], More) -->
[C],
{ member(C, SplitCodes) }, !,
split_unquoted_at_blank(SplitCodes, More).
split_unquoted(SplitCodes, [C|New], Set) -->
[C], !,
split_unquoted(SplitCodes, New, Set).
split_unquoted(_, [], []) --> [].
/** @pred split_quoted(+ _Line_,+ _Separators_, GroupQuotes, SingleQuotes, - _Split_)

4
os/chartypes.c
View File

@ -79,7 +79,7 @@ static char SccsId[] = "%W% %G%";
static Int p_change_type_of_char(USES_REGS1);
Term Yap_StringToNumberTerm(const char *s, encoding_t *encp) {
Term Yap_StringToNumberTerm(const char *s, encoding_t *encp, bool error_on) {
CACHE_REGS
int sno;
Term t;
@ -95,7 +95,7 @@ Term Yap_StringToNumberTerm(const char *s, encoding_t *encp) {
while (*s && isblank(*s) && Yap_wide_chtype(*s) == BS)
s++;
#endif
t = Yap_scan_num(GLOBAL_Stream + sno);
t = Yap_scan_num(GLOBAL_Stream + sno, error_on);
if (LOCAL_Error_TYPE == SYNTAX_ERROR)
LOCAL_Error_TYPE = YAP_NO_ERROR;
Yap_CloseStream(sno);

2
os/iopreds.h
View File

@ -109,7 +109,7 @@ extern void Yap_plwrite(Term, struct stream_desc *, int, int, int);
extern void Yap_WriteAtom(struct stream_desc *s, Atom atom);
extern bool Yap_WriteTerm( int output_stream, Term t, Term opts USES_REGS);
extern Term Yap_scan_num(struct stream_desc *);
extern Term Yap_scan_num(struct stream_desc *, bool);
extern void Yap_DefaultStreamOps(StreamDesc *st);
extern void Yap_PipeOps(StreamDesc *st);

99
os/readterm.c
View File

@ -217,26 +217,26 @@ static const param_t read_defs[] = {READ_DEFS()};
*/
static Term syntax_error(TokEntry *errtok, int sno, Term cmod) {
CACHE_REGS
Term info;
Term startline, errline, endline;
Term tf[4];
Term *tailp = tf + 3;
Term tf[3];
Term tm;
Term *tailp = tf + 2;
CELL *Hi = HR;
TokEntry *tok = LOCAL_tokptr;
Int cline = tok->TokPos;
startline = MkIntegerTerm(cline);
if (errtok != LOCAL_toktide) {
endline = MkIntegerTerm(cline);
if (errtok != LOCAL_toktide) {
errtok = LOCAL_toktide;
}
LOCAL_Error_TYPE = YAP_NO_ERROR;
errline = MkIntegerTerm(errtok->TokPos);
if (LOCAL_ErrorMessage)
tf[0] = MkStringTerm(LOCAL_ErrorMessage);
tm = MkStringTerm(LOCAL_ErrorMessage);
else
tf[0] = MkStringTerm("");
tm = MkStringTerm("syntax error");
while (tok) {
Term ts[2];
if (HR > ASP - 1024) {
errline = MkIntegerTerm(0);
@ -254,57 +254,7 @@ static Term syntax_error(TokEntry *errtok, int sno, Term cmod) {
*tailp = MkPairTerm(MkAtomTerm(AtomError), TermNil);
tailp = RepPair(*tailp) + 1;
}
info = tok->TokInfo;
switch (tok->Tok) {
case Name_tok: {
Term t0[1];
if (info) {
t0[0] = MkAtomTerm((Atom)info);
} else {
t0[0] = TermNil;
}
ts[0] = Yap_MkApplTerm(Yap_MkFunctor(AtomAtom, 1), 1, t0);
} 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 Number_tok:
ts[0] = Yap_MkApplTerm(Yap_MkFunctor(AtomNumber, 1), 1, &info);
break;
case Var_tok: {
Term t[2];
VarEntry *varinfo = (VarEntry *)info;
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: {
ts[0] = Yap_MkApplTerm(Yap_MkFunctor(AtomString, 1), 1, &info);
} break;
case BQString_tok: {
ts[0] = Yap_MkApplTerm(Yap_MkFunctor(AtomString, 1), 1, &info);
} break;
case Error_tok: {
ts[0] = MkAtomTerm(AtomError);
} break;
case eot_tok:
endline = MkIntegerTerm(tok->TokPos);
ts[0] = MkAtomTerm(Yap_LookupAtom("EOT"));
break;
case Ponctuation_tok: {
char s[2];
s[1] = '\0';
if ((info) == 'l') {
s[0] = '(';
} else {
s[0] = (char)info;
}
ts[0] = MkAtomTerm(Yap_LookupAtom(s));
}
}
Term rep = Yap_tokRep(tok );
if (tok->TokNext) {
tok = tok->TokNext;
} else {
@ -312,7 +262,7 @@ static Term syntax_error(TokEntry *errtok, int sno, Term cmod) {
tok = NULL;
break;
}
*tailp = MkPairTerm(ts[0], TermNil);
*tailp = MkPairTerm(rep , TermNil);
tailp = RepPair(*tailp) + 1;
}
{
@ -320,19 +270,18 @@ static Term syntax_error(TokEntry *errtok, int sno, Term cmod) {
t[0] = startline;
t[1] = errline;
t[2] = endline;
tf[1] = Yap_MkApplTerm(Yap_MkFunctor(AtomBetween, 3), 3, t);
tf[0] = Yap_MkApplTerm(Yap_MkFunctor(AtomBetween, 3), 3, t);
}
/* 0: id */
/* 1: strat, error, end line */
/* 0: strat, error, end line */
/*2 msg */
/* file */
tf[2] = Yap_StreamUserName(sno);
/* 1: file */
tf[1] = Yap_StreamUserName(sno);
clean_vars(LOCAL_VarTable);
clean_vars(LOCAL_AnonVarTable);
Term terr = Yap_MkApplTerm(FunctorSyntaxError, 4, tf);
Term terr = Yap_MkApplTerm(FunctorInfo3, 3, tf);
Term tn[2];
tn[0] = Yap_MkApplTerm(FunctorShortSyntaxError, 1, &terr);
tn[1] = TermNil;
tn[0] = Yap_MkApplTerm(FunctorShortSyntaxError, 1, &tm);
tn[1] = terr;
terr = Yap_MkApplTerm(FunctorError, 2, tn);
#if DEBUG
if (Yap_ExecutionMode == YAP_BOOT_MODE) {
@ -401,7 +350,6 @@ static xarg *setReadEnv(Term opts, FEnv *fe, struct renv *re, int inp_stream) {
fe->cmod = PROLOG_MODULE;
if (args[READ_BACKQUOTED_STRING].used) {
if (!setBackQuotesFlag(args[READ_BACKQUOTED_STRING].tvalue)) {
free(args);
return false;
}
}
@ -695,7 +643,7 @@ static parser_state_t scan(REnv *re, FEnv *fe, int inp_stream);
static parser_state_t scanEOF(FEnv *fe, int inp_stream) {
CACHE_REGS
// bool store_comments = false;
TokEntry *tokstart = LOCAL_tokptr;
TokEntry *tokstart = LOCAL_tokptr;
// check for an user abort
if (tokstart != NULL && tokstart->Tok != Ord(eot_tok)) {
/* we got the end of file from an abort */
@ -782,10 +730,11 @@ static parser_state_t scan(REnv *re, FEnv *fe, int inp_stream) {
TokEntry *t = LOCAL_tokptr;
int n = 0;
while (t) {
fprintf(stderr, "[Token %d %s %d]", Ord(t->Tok),
Yap_tokRep(t, ENC_ISO_UTF8), n++);
fprintf(stderr, "[Token %d %s %d]",
Ord(t->Tok),Yap_tokText(t), n++);
t = t->TokNext;
}
fprintf(stderr, "\n");
}
#endif
if (LOCAL_ErrorMessage)
@ -856,14 +805,12 @@ static parser_state_t parseError(REnv *re, FEnv *fe, int inp_stream) {
LOCAL_Error_TYPE = YAP_NO_ERROR;
return YAP_PARSING_FINISHED;
} else {
char *s = syntax_error(fe->toklast, inp_stream, fe->cmod);
Term t = syntax_error(fe->toklast, inp_stream, fe->cmod);
if (ParserErrorStyle == TermError) {
LOCAL_ErrorMessage = s;
LOCAL_ActiveError->errorTerm = Yap_StoreTermInDB( t, 4);
LOCAL_Error_TYPE = SYNTAX_ERROR;
return YAP_PARSING_FINISHED;
// dec-10
} else if (Yap_PrintWarning(MkStringTerm(s))) {
free(s);
} else if (Yap_PrintWarning(t)) {
LOCAL_Error_TYPE = YAP_NO_ERROR;
return YAP_SCANNING;
}

61
os/sysbits.c
View File

@ -1926,34 +1926,8 @@ static HKEY reg_open_key(const wchar_t *which, int create) {
#define MAXREGSTRLEN 1024
static void recover_space(wchar_t *k, Atom At) {
if (At->WStrOfAE != k)
Yap_FreeCodeSpace((char *)k);
}
static wchar_t *WideStringFromAtom(Atom KeyAt USES_REGS) {
if (IsWideAtom(KeyAt)) {
return KeyAt->WStrOfAE;
} else {
int len = strlen(KeyAt->StrOfAE);
int sz = sizeof(wchar_t) * (len + 1);
char *chp = KeyAt->StrOfAE;
wchar_t *kptr, *k;
k = (wchar_t *)Yap_AllocCodeSpace(sz);
while (k == NULL) {
if (!Yap_growheap(false, sz, NULL)) {
Yap_Error(RESOURCE_ERROR_HEAP, MkIntegerTerm(sz),
"generating key in win_registry_get_value/3");
return false;
}
k = (wchar_t *)Yap_AllocCodeSpace(sz);
}
kptr = k;
while ((*kptr++ = *chp++))
;
return k;
}
return Yap_AtomToWide( KeyAt );
}
static Int p_win_registry_get_value(USES_REGS1) {
@ -1965,24 +1939,29 @@ static Int p_win_registry_get_value(USES_REGS1) {
Term Key = Deref(ARG1);
Term Name = Deref(ARG2);
Atom KeyAt, NameAt;
int l = push_text_stack();
if (IsVarTerm(Key)) {
Yap_Error(INSTANTIATION_ERROR, Key,
"argument to win_registry_get_value unbound");
return FALSE;
pop_text_stack(l);
return FALSE;
}
if (!IsAtomTerm(Key)) {
Yap_Error(TYPE_ERROR_ATOM, Key, "argument to win_registry_get_value");
return FALSE;
pop_text_stack(l);
return FALSE;
}
KeyAt = AtomOfTerm(Key);
if (IsVarTerm(Name)) {
Yap_Error(INSTANTIATION_ERROR, Key,
"argument to win_registry_get_value unbound");
return FALSE;
pop_text_stack(l);
return FALSE;
}
if (!IsAtomTerm(Name)) {
Yap_Error(TYPE_ERROR_ATOM, Key, "argument to win_registry_get_value");
pop_text_stack(l);
return FALSE;
}
NameAt = AtomOfTerm(Name);
@ -1990,7 +1969,7 @@ static Int p_win_registry_get_value(USES_REGS1) {
k = WideStringFromAtom(KeyAt PASS_REGS);
if (!(key = reg_open_key(k, FALSE))) {
Yap_Error(EXISTENCE_ERROR_KEY, Key, "argument to win_registry_get_value");
recover_space(k, KeyAt);
pop_text_stack(l);
return FALSE;
}
name = WideStringFromAtom(NameAt PASS_REGS);
@ -1999,26 +1978,22 @@ static Int p_win_registry_get_value(USES_REGS1) {
RegCloseKey(key);
switch (type) {
case REG_SZ:
recover_space(k, KeyAt);
recover_space(name, NameAt);
((wchar_t *)data)[len] = '\0';
return Yap_unify(MkAtomTerm(Yap_LookupMaybeWideAtom((wchar_t *)data)),
ARG3);
Atom at = Yap_NWCharsToAtom((wchar_t *)data, len PASS_REGS);
pop_text_stack(l);
return Yap_unify(MkAtomTerm(at),ARG3);
case REG_DWORD:
recover_space(k, KeyAt);
recover_space(name, NameAt);
{
{
DWORD *d = (DWORD *)data;
pop_text_stack(l);
return Yap_unify(MkIntegerTerm((Int)d[0]), ARG3);
}
default:
recover_space(k, KeyAt);
recover_space(name, NameAt);
return FALSE;
pop_text_stack(l);
return FALSE;
}
}
recover_space(k, KeyAt);
recover_space(name, NameAt);
pop_text_stack(l);
return FALSE;
}

2
os/writeterm.c
View File

@ -224,7 +224,7 @@ static bool write_term(int output_stream, Term t, xarg *args USES_REGS) {
flags |= AttVar_Dots_f;
} else if (ctl != TermIgnore) {
Yap_Error(
DOMAIN_ERROR_OUT_OF_RANGE, ctl,
DOMAIN_ERROR_WRITE_OPTION, ctl,
"write attributes should be one of {dots,ignore,portray,write}");
rc = false;
goto end;

2
os/yapio.h
View File

@ -107,7 +107,7 @@ extern char *Yap_MemStreamBuf(int sno);
extern X_API Term Yap_StringToTerm(const char *s, size_t len, encoding_t *encp,
int prio, Term *bindings_p);
extern Term Yap_StringToNumberTerm(const char *s, encoding_t *encp);
extern Term Yap_StringToNumberTerm(const char *s, encoding_t *encp, bool error_on);
extern int Yap_FormatFloat(Float f, char **s, size_t sz);
extern int Yap_open_buf_read_stream(const char *buf, size_t nchars,
encoding_t *encp, memBufSource src);

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

@ -388,7 +388,7 @@ int simpleNamedBDDtoDot(DdManager *manager, namedvars varmap, DdNode *bdd,
perror(filename);
return -1;
}
const char *vs = varmap.vars;
const char **vs = varmap.vars;
ret = Cudd_DumpDot(manager, 1, f, vs, NULL, fd);
fclose(fd);
return ret;

3
packages/myddas/sqlite3/myddas_sqlite3.c
View File

@ -586,8 +586,7 @@ static Int c_sqlite3_row(USES_REGS1) {
} else if (res == SQLITE_ROW) {
list = arg_list_args;
Term tf;
Term tf = 0;
for (i = 0; i < arity; i++) {
/* convert data types here */
head = HeadOfTerm(list);

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

@ -1,25 +1,21 @@
# This is a CMake example for Python and Java
INCLUDE(UseJava)
# set(ANDROID_SO_OUTDIR ${libdir})
# set(CMAKE_SWIG_OUTDIR ${CMAKE_SOURCE_DIR}/android/yaplib/build/generated/source/pt/up/yap/lib)
#set(CMAKE_SWIG_OUTDIR ${CMAKE_CURRENT_BINARY_DIR}/derived)
set(CMAKE_SWIG_OUTDIR ${YAP_APP_DIR}/app/src/main/java/pt/up/yap/lib )
set ( SWIG_SOURCES ../yap.i )
SET_SOURCE_FILES_PROPERTIES(${SWIG_SOURCES} PROPERTIES CPLUSPLUS ON)
include_directories (
${CMAKE_SOURCE_DIR}/CXX
${JAVA_INCLUDE_DIRS}
${JNI_INCLUDE_DIRS}
)
add_custom_target ( swig ALL
DEPENDS ${SWIG_CXX}
)
add_custom_command (OUTPUT ${SWIG_CXX}
COMMAND ${SWIG} -java -outdir ${CMAKE_CURRENT_BINARY_DIR} -c++ -addextern -I${CMAKE_SOURCE_DIR}/CXX ${SWIG_SOURCES} -o ${SWIG_CXX}
${SWIG_SOURCES}
add_custom_command (OUTPUT ${SWIG_CXX}
COMMAND ${SWIG} -java -outdir ${CMAKE_SWIG_OUTDIR} -c++ -addextern -I${CMAKE_SOURCE_DIR}/CXX -o ${SWIG_CXX}${SWIG_SOURCES}
)

2
pl/atoms.yap
View File

@ -165,8 +165,6 @@ current_atom(A) :- % check
atom(A), !.
current_atom(A) :- % generate
'$current_atom'(A).
current_atom(A) :- % generate
'$current_wide_atom'(A).
string_concat(Xs,At) :-
( var(At) ->

15
pl/boot.yap
View File

@ -1,3 +1,4 @@
/*************************************************************************
* *
* YAP Prolog *
@ -174,7 +175,7 @@ list, since backtracking could not "pass through" the cut.
system_module(_Mod, _SysExps, _Decls).
% new_system_module(Mod).
use_system_module(Module, _SysExps).
use_system_module(_Module, _SysExps).
private(_).
@ -291,8 +292,9 @@ private(_).
'$bootstrap_predicate'(print_message(Context, Msg), _M, _) :- !,
'$early_print_message'(Context, Msg).
'$bootstrap_predicate'(print_message(Context, Msg), _M, _) :- !,
'$early_print_message'(Context, Msg).
'$bootstrap_predicate'(prolog_file_type(A,B), _, prolog_file_type(A,B)) :- !, B = prolog.
'$early_print_message'(Context, Msg).
'$bootstrap_predicate'(prolog_file_type(A,prolog), _, _) :- !,
( A = yap ; A = pl ; A = prolog ).
'$bootstrap_predicate'(file_search_path(_A,_B), _, _ ) :- !, fail.
'$bootstrap_predicate'(meta_predicate(G), M, _) :- !,
strip_module(M:G, M1, G1),
@ -446,7 +448,6 @@ live :-
W1 is W-1,
'$start_orp_threads'(W1).
% Start file for yap
/* I/O predicates */
@ -1428,7 +1429,7 @@ Command = (H --> B) ->
'$check_head_and_body'(MH, M, H, true, P) :-
'$yap_strip_module'(MH,M,H),
error:is_callable(M:H,P).
is_callable(M:H,P).
% term expansion
%
% return two arguments: Expanded0 is the term after "USER" expansion.
@ -1453,8 +1454,8 @@ Command = (H --> B) ->
'$precompile_term'(Term, Term, Term).
'$expand_clause'(InputCl, C1, CO) :-
source_module(SM),
'$yap_strip_module'(SM:InputCl, M, ICl),
source_module(SM),
'$yap_strip_clause'(SM:InputCl, M, ICl),
'$expand_a_clause'( M:ICl, SM, C1, CO),
!.
'$expand_clause'(Cl, Cl, Cl).

5
pl/dbload.yap
View File

@ -29,10 +29,7 @@
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, Type, Lines).
'$input_lines'(R, csv, yeLines ) :-
'$process_lines'(R, Lines, Type ),

2
pl/errors.yap
View File

@ -138,6 +138,8 @@ system_error(Type,Goal,Culprit) :-
throw(error(permission_error(module,redefined,A),B)).
'$process_error'(error(Msg, Where), _) :-
print_message(error,error(Msg, Where)), !.
'$process_error'(error(Msg, Where), _) :-
print_message(error,error(Msg, [g|Where])), !.
'$process_error'(Throw, _) :-
print_message(error,error(unhandled_exception,Throw)).

42
pl/messages.yap
View File

@ -65,6 +65,34 @@ messages that do not produce output but that can be intercepted by hooks.
The next table shows the main predicates and hooks associated to message
handling in YAP:
An error record comsists of An ISO compatible descriptor of the format
error(errror_kind(Culprit,..), Info)
In YAP, the infoo field describes:
- what() more detauls on the event
- input_stream, may be ine of;
- loop_sream
- file()
- none
- prolog_source(_) a record containing file, line, predicate, and clause
that activated the goal, or a list therof. YAP tries to search for the user
code generatinng the error.
- c_source(0), a record containing the line of C-code thhat caused the event. This
is reported under systm debugging mode, or if this is user code.
- stream_source() - a record containg data on the the I/O stream datum causisng the evwnt.
- user_message () - ttext on the event.
@{
*/
@ -210,11 +238,11 @@ compose_message(Term, Level) -->
main_message( Term, Level, LC),
[nl,nl].
location(error(syntax_error(syntax_error(_,between(_,LN,_),FileName,_)),_), _ , _) -->
!,
[ '~a:~d:0 ' - [FileName,LN] ] .
location(error(syntax_error(_),info(between(_,LN,_), FileName, _)), _ , _) -->
!,
[ '~a:~d:~d ' - [FileName,LN,0] ] .
location(error(style_check(style_check(_,LN,FileName,_ ) ),_), _ , _) -->
% { stream_position_data( line_count, LN) },
!,
[ '~a:~d:0 ' - [FileName,LN] ] .
location( error(_,Term), Level, LC ) -->
@ -231,7 +259,7 @@ location( error(_,Term), Level, LC ) -->
%message(loaded(Past,AbsoluteFileName,user,Msec,Bytes), Prefix, Suffix) :- !,
main_message(error(Msg,Info), _, _) --> {var(Info)}, !,
[ ' error: uninstantiated message ~w~n.' - [Msg], nl ].
main_message( error(syntax_error(syntax_error(Msg,between(L0,LM,LF),_Stream,Term)),_), Level, LC ) -->
main_message( error(syntax_error(Msg),info(between(L0,LM,LF),_Stream,Term)), Level, LC ) -->
!,
[' ~a: syntax error ~s' - [Level,Msg]],
[nl],
@ -602,7 +630,7 @@ list_of_preds([P|L]) -->
list_of_preds(L).
syntax_error_term(between(_I,_J,_L),LTaL,LC) -->
['error found at line ~d to line ~d' - [_I,_L], nl ],
['term between lines ~d and ~d' - [_I,_L], nl ],
syntax_error_tokens(LTaL, LC).
syntax_error_tokens([], _LC) --> [].
@ -615,7 +643,7 @@ syntax_error_token(atom(A), _LC) --> !,
syntax_error_token(number(N), _LC) --> !,
[ '~w' - [N] ].
syntax_error_token(var(_,S), _LC) --> !,
[ '~s' - [S] ].
[ '~a' - [S] ].
syntax_error_token(string(S), _LC) --> !,
[ '`~s`' - [S] ].
syntax_error_token(error, _LC) --> !,

6
pl/meta.yap
View File

@ -284,14 +284,14 @@ meta_predicate declaration
nonvar(G),
G = (A = B),
!.
'$expand_goals'(\+A,\+A1,(AO-> false;true),HM,SM,BM,HVars) :- !,
'$expand_goals'(\+A,\+A1,('$current_choice_point'(CP),AO,'$$cut_by'(CP)-> false;true),HM,SM,BM,HVars) :- !,
'$expand_goals'(A,A1,AO,HM,SM,BM,HVars).
'$expand_goals'(once(A),once(A1),
('$current_choice_point'(CP),AO,'$$cut_by'(CP)),HM,SM,BM,HVars) :- !,
'$expand_goals'(A,A1,AO0,HM,SM,BM,HVars),
'$clean_cuts'(AO0, CP, AO).
'$expand_goals'(ignore(A),ignore(A1),
(AO -> true ; true),HM,SM,BM,HVars) :- !,
('$current_choice_point'(CP),AO,'$$cut_by'(CP)-> true ; true),HM,SM,BM,HVars) :- !,
'$expand_goals'(A,A1,AO0,HM,SM,BM,HVars),
'$clean_cuts'(AO0, AO).
'$expand_goals'(forall(A,B),forall(A1,B1),
@ -299,7 +299,7 @@ meta_predicate declaration
'$expand_goals'(A,A1,AO0,HM,SM,BM,HVars),
'$expand_goals'(B,B1,BO,HM,SM,BM,HVars),
'$clean_cuts'(AO0, AO).
'$expand_goals'(not(A),not(A1),(AO -> fail; true),HM,SM,BM,HVars) :- !,
'$expand_goals'(not(A),not(A1),('$current_choice_point'(CP),AO,'$$cut_by'(CP) -> fail; true),HM,SM,BM,HVars) :- !,
'$expand_goals'(A,A1,AO,HM,SM,BM,HVars).
'$expand_goals'(if(A,B,C),if(A1,B1,C1),
('$current_choicepoint'(DCP),AO,yap_hacks:cut_at(DCP),BO; CO),HM,SM,BM,HVars) :- !,

4
pl/modules.yap
View File

@ -338,8 +338,8 @@ system_module(Mod) :-
'$pred_exists'(Pred, Mod),
!.
'$continue_imported'(FM,Mod,FPred,Pred) :-
recorded('$import','$import'(IM,Mod,IPred,Pred,_,_),_), !,
'$continue_imported'(FM, IM, FPred, IPred).
recorded('$import','$import'(IM,Mod,IPred,Pred,_,_),_),
'$continue_imported'(FM, IM, FPred, IPred), !.
'$continue_imported'(FM,Mod,FPred,Pred) :-
prolog:'$parent_module'(Mod,IM),
'$continue_imported'(FM, IM, FPred, Pred).

1
pl/preddyns.yap
View File

@ -51,6 +51,7 @@ assert(Clause) :-
'$assert'(Clause, assertz, _).
'$assert'(Clause, Where, R) :-
'$yap_strip_clause'(Clause, _, _Clause0),
'$expand_clause'(Clause,C0,C),
'$$compile'(C, Where, C0, R).

2
pl/signals.yap
View File

@ -192,7 +192,7 @@ order of dispatch.
'$hacks':'$stack_dump',
'$execute0'(G,M).
'$do_signal'(sig_fpe,G) :-
'$signal_handler'(sig_fpe, G)
'$signal_handler'(sig_fpe, G).
'$do_signal'(sig_alarm, G) :-
'$signal_handler'(sig_alarm, G).
'$do_signal'(sig_vtalarm, G) :-