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

Stasinos noticed that _YAP_ breaks C standard: use Yap_ instead. 

git-svn-id: https://yap.svn.sf.net/svnroot/yap/trunk@691 b08c6af1-5177-4d33-ba66-4b1c6b8b522a
This commit is contained in:
vsc 2002-11-18 18:18:05 +00:00
parent 212c64f782
commit d7f80ea1ad
77 changed files with 6703 additions and 6703 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

812
C/absmi.c
View File

File diff suppressed because it is too large Load Diff

86
C/adtdefs.c
View File

@ -61,7 +61,7 @@ InlinedUnlockedMkFunctor(AtomEntry *ae, unsigned int arity)
if (p0 != NIL) { if (p0 != NIL) {
return ((Functor) RepProp(p0)); return ((Functor) RepProp(p0));
} }
p = (FunctorEntry *) _YAP_AllocAtomSpace(sizeof(*p)); p = (FunctorEntry *) Yap_AllocAtomSpace(sizeof(*p));
p->KindOfPE = FunctorProperty; p->KindOfPE = FunctorProperty;
p->NameOfFE = AbsAtom(ae); p->NameOfFE = AbsAtom(ae);
p->ArityOfFE = arity; p->ArityOfFE = arity;
@ -73,14 +73,14 @@ InlinedUnlockedMkFunctor(AtomEntry *ae, unsigned int arity)
} }
Functor Functor
_YAP_UnlockedMkFunctor(AtomEntry *ae, unsigned int arity) Yap_UnlockedMkFunctor(AtomEntry *ae, unsigned int arity)
{ {
return(InlinedUnlockedMkFunctor(ae, arity)); return(InlinedUnlockedMkFunctor(ae, arity));
} }
/* vsc: We must guarantee that IsVarTerm(functor) returns true! */ /* vsc: We must guarantee that IsVarTerm(functor) returns true! */
Functor Functor
_YAP_MkFunctor(Atom ap, unsigned int arity) Yap_MkFunctor(Atom ap, unsigned int arity)
{ {
AtomEntry *ae = RepAtom(ap); AtomEntry *ae = RepAtom(ap);
Functor f; Functor f;
@ -93,7 +93,7 @@ _YAP_MkFunctor(Atom ap, unsigned int arity)
/* vsc: We must guarantee that IsVarTerm(functor) returns true! */ /* vsc: We must guarantee that IsVarTerm(functor) returns true! */
void void
_YAP_MkFunctorWithAddress(Atom ap, unsigned int arity, FunctorEntry *p) Yap_MkFunctorWithAddress(Atom ap, unsigned int arity, FunctorEntry *p)
{ {
AtomEntry *ae = RepAtom(ap); AtomEntry *ae = RepAtom(ap);
@ -160,7 +160,7 @@ LookupAtom(char *atom)
return(a); return(a);
} }
/* add new atom to start of chain */ /* add new atom to start of chain */
ae = (AtomEntry *) _YAP_AllocAtomSpace((sizeof *ae) + strlen(atom)); ae = (AtomEntry *) Yap_AllocAtomSpace((sizeof *ae) + strlen(atom));
a = AbsAtom(ae); a = AbsAtom(ae);
ae->NextOfAE = HashChain[hash].Entry; ae->NextOfAE = HashChain[hash].Entry;
HashChain[hash].Entry = a; HashChain[hash].Entry = a;
@ -173,13 +173,13 @@ LookupAtom(char *atom)
} }
Atom Atom
_YAP_LookupAtom(char *atom) Yap_LookupAtom(char *atom)
{ /* lookup atom in atom table */ { /* lookup atom in atom table */
return(LookupAtom(atom)); return(LookupAtom(atom));
} }
Atom Atom
_YAP_FullLookupAtom(char *atom) Yap_FullLookupAtom(char *atom)
{ /* lookup atom in atom table */ { /* lookup atom in atom table */
Atom t; Atom t;
@ -190,7 +190,7 @@ _YAP_FullLookupAtom(char *atom)
} }
void void
_YAP_LookupAtomWithAddress(char *atom, AtomEntry *ae) Yap_LookupAtomWithAddress(char *atom, AtomEntry *ae)
{ /* lookup atom in atom table */ { /* lookup atom in atom table */
register CELL hash; register CELL hash;
register unsigned char *p; register unsigned char *p;
@ -204,7 +204,7 @@ _YAP_LookupAtomWithAddress(char *atom, AtomEntry *ae)
a = HashChain[hash].Entry; a = HashChain[hash].Entry;
/* search atom in chain */ /* search atom in chain */
if (SearchAtom(p, a) != NIL) { if (SearchAtom(p, a) != NIL) {
_YAP_Error(FATAL_ERROR,TermNil,"repeated initialisation for atom %s", ae); Yap_Error(FATAL_ERROR,TermNil,"repeated initialisation for atom %s", ae);
WRITE_UNLOCK(HashChain[hash].AERWLock); WRITE_UNLOCK(HashChain[hash].AERWLock);
return; return;
} }
@ -218,7 +218,7 @@ _YAP_LookupAtomWithAddress(char *atom, AtomEntry *ae)
} }
void void
_YAP_ReleaseAtom(Atom atom) Yap_ReleaseAtom(Atom atom)
{ /* Releases an atom from the hash chain */ { /* Releases an atom from the hash chain */
register Int hash; register Int hash;
register unsigned char *p; register unsigned char *p;
@ -257,7 +257,7 @@ GetAPropHavingLock(AtomEntry *ae, PropFlags kind)
} }
Prop Prop
_YAP_GetAPropHavingLock(AtomEntry *ae, PropFlags kind) Yap_GetAPropHavingLock(AtomEntry *ae, PropFlags kind)
{ /* look property list of atom a for kind */ { /* look property list of atom a for kind */
return (GetAPropHavingLock(ae,kind)); return (GetAPropHavingLock(ae,kind));
} }
@ -275,7 +275,7 @@ GetAProp(Atom a, PropFlags kind)
} }
Prop Prop
_YAP_GetAProp(Atom a, PropFlags kind) Yap_GetAProp(Atom a, PropFlags kind)
{ /* look property list of atom a for kind */ { /* look property list of atom a for kind */
return GetAProp(a,kind); return GetAProp(a,kind);
} }
@ -299,7 +299,7 @@ GetPredPropByAtomHavingLock(AtomEntry* ae, SMALLUNSGN cur_mod)
} }
Prop Prop
_YAP_GetPredPropByAtom(Atom at, SMALLUNSGN cur_mod) Yap_GetPredPropByAtom(Atom at, SMALLUNSGN cur_mod)
/* get predicate entry for ap/arity; create it if neccessary. */ /* get predicate entry for ap/arity; create it if neccessary. */
{ {
Prop p0; Prop p0;
@ -332,7 +332,7 @@ GetPredPropByFuncHavingLock(Functor f, SMALLUNSGN cur_mod)
} }
Prop Prop
_YAP_GetPredPropByFunc(Functor f, SMALLUNSGN cur_mod) Yap_GetPredPropByFunc(Functor f, SMALLUNSGN cur_mod)
/* get predicate entry for ap/arity; */ /* get predicate entry for ap/arity; */
{ {
Prop p0; Prop p0;
@ -344,7 +344,7 @@ _YAP_GetPredPropByFunc(Functor f, SMALLUNSGN cur_mod)
} }
Prop Prop
_YAP_GetPredPropHavingLock(Atom ap, unsigned int arity, SMALLUNSGN mod) Yap_GetPredPropHavingLock(Atom ap, unsigned int arity, SMALLUNSGN mod)
/* get predicate entry for ap/arity; */ /* get predicate entry for ap/arity; */
{ {
Prop p0; Prop p0;
@ -363,7 +363,7 @@ _YAP_GetPredPropHavingLock(Atom ap, unsigned int arity, SMALLUNSGN mod)
/* get expression entry for at/arity; */ /* get expression entry for at/arity; */
Prop Prop
_YAP_GetExpProp(Atom at, unsigned int arity) Yap_GetExpProp(Atom at, unsigned int arity)
{ {
Prop p0; Prop p0;
AtomEntry *ae = RepAtom(at); AtomEntry *ae = RepAtom(at);
@ -379,7 +379,7 @@ _YAP_GetExpProp(Atom at, unsigned int arity)
/* get expression entry for at/arity, at is already locked; */ /* get expression entry for at/arity, at is already locked; */
Prop Prop
_YAP_GetExpPropHavingLock(AtomEntry *ae, unsigned int arity) Yap_GetExpPropHavingLock(AtomEntry *ae, unsigned int arity)
{ {
Prop p0; Prop p0;
ExpEntry *p; ExpEntry *p;
@ -391,10 +391,10 @@ _YAP_GetExpPropHavingLock(AtomEntry *ae, unsigned int arity)
} }
Prop Prop
_YAP_NewPredPropByFunctor(FunctorEntry *fe, SMALLUNSGN cur_mod) Yap_NewPredPropByFunctor(FunctorEntry *fe, SMALLUNSGN cur_mod)
{ {
Prop p0; Prop p0;
PredEntry *p = (PredEntry *) _YAP_AllocAtomSpace(sizeof(*p)); PredEntry *p = (PredEntry *) Yap_AllocAtomSpace(sizeof(*p));
/* printf("entering %s:%s/%d\n", RepAtom(AtomOfTerm(ModuleName[cur_mod]))->StrOfAE, RepAtom(fe->NameOfFE)->StrOfAE, fe->ArityOfFE); */ /* printf("entering %s:%s/%d\n", RepAtom(AtomOfTerm(ModuleName[cur_mod]))->StrOfAE, RepAtom(fe->NameOfFE)->StrOfAE, fe->ArityOfFE); */
@ -426,10 +426,10 @@ _YAP_NewPredPropByFunctor(FunctorEntry *fe, SMALLUNSGN cur_mod)
} }
Prop Prop
_YAP_NewPredPropByAtom(AtomEntry *ae, SMALLUNSGN cur_mod) Yap_NewPredPropByAtom(AtomEntry *ae, SMALLUNSGN cur_mod)
{ {
Prop p0; Prop p0;
PredEntry *p = (PredEntry *) _YAP_AllocAtomSpace(sizeof(*p)); PredEntry *p = (PredEntry *) Yap_AllocAtomSpace(sizeof(*p));
/* Printf("entering %s:%s/0\n", RepAtom(AtomOfTerm(ModuleName[cur_mod]))->StrOfAE, ae->StrOfAE); */ /* Printf("entering %s:%s/0\n", RepAtom(AtomOfTerm(ModuleName[cur_mod]))->StrOfAE, ae->StrOfAE); */
@ -461,7 +461,7 @@ _YAP_NewPredPropByAtom(AtomEntry *ae, SMALLUNSGN cur_mod)
} }
Term Term
_YAP_GetValue(Atom a) Yap_GetValue(Atom a)
{ {
Prop p0 = GetAProp(a, ValProperty); Prop p0 = GetAProp(a, ValProperty);
Term out; Term out;
@ -479,7 +479,7 @@ _YAP_GetValue(Atom a)
} }
#ifdef USE_GMP #ifdef USE_GMP
else { else {
out = _YAP_MkBigIntTerm(_YAP_BigIntOfTerm(out)); out = Yap_MkBigIntTerm(Yap_BigIntOfTerm(out));
} }
#endif #endif
} }
@ -488,7 +488,7 @@ _YAP_GetValue(Atom a)
} }
void void
_YAP_PutValue(Atom a, Term v) Yap_PutValue(Atom a, Term v)
{ {
AtomEntry *ae = RepAtom(a); AtomEntry *ae = RepAtom(a);
Prop p0; Prop p0;
@ -502,7 +502,7 @@ _YAP_PutValue(Atom a, Term v)
WRITE_LOCK(p->VRWLock); WRITE_LOCK(p->VRWLock);
WRITE_UNLOCK(ae->ARWLock); WRITE_UNLOCK(ae->ARWLock);
} else { } else {
p = (ValEntry *) _YAP_AllocAtomSpace(sizeof(ValEntry)); p = (ValEntry *) Yap_AllocAtomSpace(sizeof(ValEntry));
p->NextOfPE = RepAtom(a)->PropsOfAE; p->NextOfPE = RepAtom(a)->PropsOfAE;
RepAtom(a)->PropsOfAE = AbsValProp(p); RepAtom(a)->PropsOfAE = AbsValProp(p);
p->KindOfPE = ValProperty; p->KindOfPE = ValProperty;
@ -528,9 +528,9 @@ _YAP_PutValue(Atom a, Term v)
pt = RepAppl(t0); pt = RepAppl(t0);
} else { } else {
if (IsApplTerm(t0)) { if (IsApplTerm(t0)) {
_YAP_FreeCodeSpace((char *) (RepAppl(t0))); Yap_FreeCodeSpace((char *) (RepAppl(t0)));
} }
pt = (CELL *) _YAP_AllocAtomSpace(sizeof(CELL)*(1 + 2*sizeof(Float)/sizeof(CELL))); pt = (CELL *) Yap_AllocAtomSpace(sizeof(CELL)*(1 + 2*sizeof(Float)/sizeof(CELL)));
p->ValueOfVE = AbsAppl(pt); p->ValueOfVE = AbsAppl(pt);
pt[0] = (CELL)FunctorDouble; pt[0] = (CELL)FunctorDouble;
} }
@ -547,9 +547,9 @@ _YAP_PutValue(Atom a, Term v)
pt = RepAppl(t0); pt = RepAppl(t0);
} else { } else {
if (IsApplTerm(t0)) { if (IsApplTerm(t0)) {
_YAP_FreeCodeSpace((char *) (RepAppl(t0))); Yap_FreeCodeSpace((char *) (RepAppl(t0)));
} }
pt = (CELL *) _YAP_AllocAtomSpace(2*sizeof(CELL)); pt = (CELL *) Yap_AllocAtomSpace(2*sizeof(CELL));
p->ValueOfVE = AbsAppl(pt); p->ValueOfVE = AbsAppl(pt);
pt[0] = (CELL)FunctorLongInt; pt[0] = (CELL)FunctorLongInt;
} }
@ -560,9 +560,9 @@ _YAP_PutValue(Atom a, Term v)
Int sz = Int sz =
sizeof(MP_INT)+sizeof(CELL)+ sizeof(MP_INT)+sizeof(CELL)+
(((MP_INT *)(ap+1))->_mp_alloc*sizeof(mp_limb_t)); (((MP_INT *)(ap+1))->_mp_alloc*sizeof(mp_limb_t));
CELL *pt = (CELL *) _YAP_AllocAtomSpace(sz); CELL *pt = (CELL *) Yap_AllocAtomSpace(sz);
if (IsApplTerm(t0)) { if (IsApplTerm(t0)) {
_YAP_FreeCodeSpace((char *) RepAppl(t0)); Yap_FreeCodeSpace((char *) RepAppl(t0));
} }
memcpy((void *)pt, (void *)ap, sz); memcpy((void *)pt, (void *)ap, sz);
p->ValueOfVE = AbsAppl(pt); p->ValueOfVE = AbsAppl(pt);
@ -570,7 +570,7 @@ _YAP_PutValue(Atom a, Term v)
} else { } else {
if (IsApplTerm(t0)) { if (IsApplTerm(t0)) {
/* recover space */ /* recover space */
_YAP_FreeCodeSpace((char *) (RepAppl(p->ValueOfVE))); Yap_FreeCodeSpace((char *) (RepAppl(p->ValueOfVE)));
} }
p->ValueOfVE = v; p->ValueOfVE = v;
} }
@ -578,7 +578,7 @@ _YAP_PutValue(Atom a, Term v)
} }
Term Term
_YAP_StringToList(char *s) Yap_StringToList(char *s)
{ {
register Term t; register Term t;
register unsigned char *cp = (unsigned char *)s + strlen(s); register unsigned char *cp = (unsigned char *)s + strlen(s);
@ -591,7 +591,7 @@ _YAP_StringToList(char *s)
} }
Term Term
_YAP_StringToListOfAtoms(char *s) Yap_StringToListOfAtoms(char *s)
{ {
register Term t; register Term t;
char so[2]; char so[2];
@ -607,7 +607,7 @@ _YAP_StringToListOfAtoms(char *s)
} }
Term Term
_YAP_ArrayToList(register Term *tp, int nof) Yap_ArrayToList(register Term *tp, int nof)
{ {
register Term *pt = tp + nof; register Term *pt = tp + nof;
register Term t; register Term t;
@ -626,7 +626,7 @@ _YAP_ArrayToList(register Term *tp, int nof)
} }
int int
_YAP_GetName(char *s, UInt max, Term t) Yap_GetName(char *s, UInt max, Term t)
{ {
register Term Head; register Term Head;
register Int i; register Int i;
@ -643,7 +643,7 @@ _YAP_GetName(char *s, UInt max, Term t)
*s++ = i; *s++ = i;
t = TailOfTerm(t); t = TailOfTerm(t);
if (--max == 0) { if (--max == 0) {
_YAP_Error(FATAL_ERROR,t,"not enough space for GetName"); Yap_Error(FATAL_ERROR,t,"not enough space for GetName");
} }
} }
*s = '\0'; *s = '\0';
@ -685,7 +685,7 @@ ArgsOfSFTerm(Term t)
#endif #endif
long long
_YAP_NewSlots(int n) Yap_NewSlots(int n)
{ {
Int old_slots = IntOfTerm(ASP[0]), oldn = n; Int old_slots = IntOfTerm(ASP[0]), oldn = n;
while (n > 0) { while (n > 0) {
@ -698,7 +698,7 @@ _YAP_NewSlots(int n)
} }
long long
_YAP_InitSlot(Term t) Yap_InitSlot(Term t)
{ {
Int old_slots = IntOfTerm(ASP[0]); Int old_slots = IntOfTerm(ASP[0]);
*ASP = t; *ASP = t;
@ -708,7 +708,7 @@ _YAP_InitSlot(Term t)
} }
void void
_YAP_RecoverSlots(int n) Yap_RecoverSlots(int n)
{ {
Int old_slots = IntOfTerm(ASP[0]); Int old_slots = IntOfTerm(ASP[0]);
ASP += n; ASP += n;
@ -716,19 +716,19 @@ _YAP_RecoverSlots(int n)
} }
Term Term
_YAP_GetFromSlot(long slot) Yap_GetFromSlot(long slot)
{ {
return(Deref(LCL0[slot])); return(Deref(LCL0[slot]));
} }
Term * Term *
_YAP_AddressFromSlot(long slot) Yap_AddressFromSlot(long slot)
{ {
return(LCL0+slot); return(LCL0+slot);
} }
void void
_YAP_PutInSlot(long slot, Term t) Yap_PutInSlot(long slot, Term t)
{ {
LCL0[slot] = t; LCL0[slot] = t;
} }

40
C/agc.c
View File

@ -25,7 +25,7 @@ static char SccsId[] = "@(#)agc.c 1.3 3/15/90";
#ifdef DEBUG #ifdef DEBUG
/* #define DEBUG_RESTORE2 1 */ /* #define DEBUG_RESTORE2 1 */
#define errout _YAP_stderr #define errout Yap_stderr
#endif #endif
STATIC_PROTO(void RestoreEntries, (PropEntry *)); STATIC_PROTO(void RestoreEntries, (PropEntry *));
@ -227,7 +227,7 @@ mark_trail(void)
pt = (CELL *)TR; pt = (CELL *)TR;
/* moving the trail is simple */ /* moving the trail is simple */
while (pt != (CELL *)_YAP_TrailBase) { while (pt != (CELL *)Yap_TrailBase) {
register CELL reg = pt[-1]; register CELL reg = pt[-1];
pt--; pt--;
if (!IsVarTerm(reg)) { if (!IsVarTerm(reg)) {
@ -266,7 +266,7 @@ mark_global(void)
* to clean the global now that functors are just variables pointing to * to clean the global now that functors are just variables pointing to
* the code * the code
*/ */
pt = CellPtr(_YAP_GlobalBase); pt = CellPtr(Yap_GlobalBase);
while (pt < H) { while (pt < H) {
register CELL reg; register CELL reg;
@ -343,8 +343,8 @@ clean_atoms(void)
#endif #endif
*patm = at->NextOfAE; *patm = at->NextOfAE;
atm = at->NextOfAE; atm = at->NextOfAE;
agc_collected += _YAP_SizeOfBlock((char *)at); agc_collected += Yap_SizeOfBlock((char *)at);
_YAP_FreeCodeSpace((char *)at); Yap_FreeCodeSpace((char *)at);
} }
} }
HashPtr++; HashPtr++;
@ -362,8 +362,8 @@ clean_atoms(void)
#endif #endif
*patm = at->NextOfAE; *patm = at->NextOfAE;
atm = at->NextOfAE; atm = at->NextOfAE;
agc_collected += _YAP_SizeOfBlock((char *)at); agc_collected += Yap_SizeOfBlock((char *)at);
_YAP_FreeCodeSpace((char *)at); Yap_FreeCodeSpace((char *)at);
} }
} }
} }
@ -371,38 +371,38 @@ clean_atoms(void)
static void static void
atom_gc(void) atom_gc(void)
{ {
int gc_verbose = _YAP_is_gc_verbose(); int gc_verbose = Yap_is_gc_verbose();
int gc_trace = 0; int gc_trace = 0;
Int time_start, agc_time; Int time_start, agc_time;
if (_YAP_GetValue(AtomGcTrace) != TermNil) if (Yap_GetValue(AtomGcTrace) != TermNil)
gc_trace = 1; gc_trace = 1;
agc_calls++; agc_calls++;
agc_collected = 0; agc_collected = 0;
if (gc_trace) { if (gc_trace) {
fprintf(_YAP_stderr, "[agc]\n"); fprintf(Yap_stderr, "[agc]\n");
} else if (gc_verbose) { } else if (gc_verbose) {
fprintf(_YAP_stderr, "[AGC] Start of atom garbage collection %d:\n", agc_calls); fprintf(Yap_stderr, "[AGC] Start of atom garbage collection %d:\n", agc_calls);
} }
time_start = _YAP_cputime(); time_start = Yap_cputime();
/* get the number of active registers */ /* get the number of active registers */
YAPEnterCriticalSection(); YAPEnterCriticalSection();
mark_stacks(); mark_stacks();
mark_atoms(); mark_atoms();
clean_atoms(); clean_atoms();
YAPLeaveCriticalSection(); YAPLeaveCriticalSection();
agc_time = _YAP_cputime()-time_start; agc_time = Yap_cputime()-time_start;
tot_agc_time += agc_time; tot_agc_time += agc_time;
tot_agc_recovered += agc_collected; tot_agc_recovered += agc_collected;
if (gc_verbose) { if (gc_verbose) {
fprintf(_YAP_stderr, "[AGC] collected %d bytes.\n", agc_collected); fprintf(Yap_stderr, "[AGC] collected %d bytes.\n", agc_collected);
fprintf(_YAP_stderr, "[AGC] GC %d took %g sec, total of %g sec doing GC so far.\n", agc_calls, (double)agc_time/1000, (double)tot_agc_time/1000); fprintf(Yap_stderr, "[AGC] GC %d took %g sec, total of %g sec doing GC so far.\n", agc_calls, (double)agc_time/1000, (double)tot_agc_time/1000);
} }
} }
void void
_YAP_atom_gc(void) Yap_atom_gc(void)
{ {
atom_gc(); atom_gc();
} }
@ -423,13 +423,13 @@ p_inform_agc(void)
Term tt = MkIntegerTerm(agc_calls); Term tt = MkIntegerTerm(agc_calls);
Term ts = MkIntegerTerm(tot_agc_recovered); Term ts = MkIntegerTerm(tot_agc_recovered);
return(_YAP_unify(tn, ARG2) && _YAP_unify(tt, ARG1) && _YAP_unify(ts, ARG3)); return(Yap_unify(tn, ARG2) && Yap_unify(tt, ARG1) && Yap_unify(ts, ARG3));
} }
void void
_YAP_init_agc(void) Yap_init_agc(void)
{ {
_YAP_InitCPred("$atom_gc", 0, p_atom_gc, 0); Yap_InitCPred("$atom_gc", 0, p_atom_gc, 0);
_YAP_InitCPred("$inform_agc", 3, p_inform_agc, 0); Yap_InitCPred("$inform_agc", 3, p_inform_agc, 0);
} }

216
C/alloc.c
View File

@ -12,7 +12,7 @@
* Last rev: * * Last rev: *
* mods: * * mods: *
* comments: allocating space * * comments: allocating space *
* version:$Id: alloc.c,v 1.27 2002-11-11 17:37:52 vsc Exp $ * * version:$Id: alloc.c,v 1.28 2002-11-18 17:56:30 vsc Exp $ *
*************************************************************************/ *************************************************************************/
#ifdef SCCS #ifdef SCCS
static char SccsId[] = "%W% %G%"; static char SccsId[] = "%W% %G%";
@ -76,7 +76,7 @@ STATIC_PROTO(void AddToFreeList, (BlockHeader *));
/* Yap workspace management */ /* Yap workspace management */
int int
_YAP_SizeOfBlock(CODEADDR p) Yap_SizeOfBlock(CODEADDR p)
{ {
BlockHeader *b = (BlockHeader *) (p - sizeof(YAP_SEG_SIZE)); BlockHeader *b = (BlockHeader *) (p - sizeof(YAP_SEG_SIZE));
YAP_SEG_SIZE s = (b->b_size) & ~InUseFlag; YAP_SEG_SIZE s = (b->b_size) & ~InUseFlag;
@ -155,10 +155,10 @@ FreeBlock(BlockHeader *b)
sp = &(b->b_size) + (b->b_size & ~InUseFlag); sp = &(b->b_size) + (b->b_size & ~InUseFlag);
if (*sp != b->b_size) { if (*sp != b->b_size) {
#if !SHORT_INTS #if !SHORT_INTS
fprintf(_YAP_stderr, "** sanity check failed in FreeBlock %p %x %x\n", fprintf(Yap_stderr, "** sanity check failed in FreeBlock %p %x %x\n",
b, b->b_size, Unsigned(*sp)); b, b->b_size, Unsigned(*sp));
#else #else
fprintf(_YAP_stderr, "** sanity check failed in FreeBlock %p %lx %lx\n", fprintf(Yap_stderr, "** sanity check failed in FreeBlock %p %lx %lx\n",
b, b->b_size, *sp); b, b->b_size, *sp);
#endif #endif
return; return;
@ -265,7 +265,7 @@ AllocHeap(unsigned int size)
HeapUsed += size * sizeof(CELL) + sizeof(YAP_SEG_SIZE); HeapUsed += size * sizeof(CELL) + sizeof(YAP_SEG_SIZE);
#ifdef YAPOR #ifdef YAPOR
if (HeapTop > Addr(_YAP_GlobalBase) - MinHeapGap) { if (HeapTop > Addr(Yap_GlobalBase) - MinHeapGap) {
abort_optyap("No heap left in function AllocHeap"); abort_optyap("No heap left in function AllocHeap");
} }
#else #else
@ -278,7 +278,7 @@ AllocHeap(unsigned int size)
UNLOCK(HeapTopLock); UNLOCK(HeapTopLock);
} }
/* we destroyed the stack */ /* we destroyed the stack */
_YAP_Error(SYSTEM_ERROR, TermNil, "Stack Crashed against Heap..."); Yap_Error(SYSTEM_ERROR, TermNil, "Stack Crashed against Heap...");
return(NULL); return(NULL);
} else { } else {
if (HeapTop + size * sizeof(CELL) + sizeof(YAP_SEG_SIZE) < Addr(AuxSp)) { if (HeapTop + size * sizeof(CELL) + sizeof(YAP_SEG_SIZE) < Addr(AuxSp)) {
@ -320,7 +320,7 @@ AllocHeap(unsigned int size)
/* If you need to dinamically allocate space from the heap, this is /* If you need to dinamically allocate space from the heap, this is
* the macro you should use */ * the macro you should use */
ADDR ADDR
_YAP_PreAllocCodeSpace(void) Yap_PreAllocCodeSpace(void)
{ {
LOCK(HeapTopLock); LOCK(HeapTopLock);
HEAPTOP_OWN(worker_id); HEAPTOP_OWN(worker_id);
@ -331,7 +331,7 @@ _YAP_PreAllocCodeSpace(void)
/* Grabbing the HeapTop is an excellent idea for a sequential system, /* Grabbing the HeapTop is an excellent idea for a sequential system,
but does work as well in parallel systems. Anyway, this will do for now */ but does work as well in parallel systems. Anyway, this will do for now */
void void
_YAP_ReleasePreAllocCodeSpace(ADDR ptr) Yap_ReleasePreAllocCodeSpace(ADDR ptr)
{ {
HEAPTOP_DISOWN(worker_id); HEAPTOP_DISOWN(worker_id);
UNLOCK(HeapTopLock); UNLOCK(HeapTopLock);
@ -349,19 +349,19 @@ FreeCodeSpace(char *p)
/* If you need to dinamically allocate space from the heap, this is /* If you need to dinamically allocate space from the heap, this is
* the macro you should use */ * the macro you should use */
void void
_YAP_FreeCodeSpace(char *p) Yap_FreeCodeSpace(char *p)
{ {
FreeCodeSpace(p); FreeCodeSpace(p);
} }
char * char *
_YAP_AllocAtomSpace(unsigned int size) Yap_AllocAtomSpace(unsigned int size)
{ {
return (AllocHeap(size)); return (AllocHeap(size));
} }
void void
_YAP_FreeAtomSpace(char *p) Yap_FreeAtomSpace(char *p)
{ {
FreeCodeSpace(p); FreeCodeSpace(p);
} }
@ -375,7 +375,7 @@ AllocCodeSpace(unsigned int size)
} }
char * char *
_YAP_AllocCodeSpace(unsigned int size) Yap_AllocCodeSpace(unsigned int size)
{ {
return AllocCodeSpace(size); return AllocCodeSpace(size);
} }
@ -393,7 +393,7 @@ _YAP_AllocCodeSpace(unsigned int size)
/* functions: */ /* functions: */
/* void *InitWorkSpace(int s) - initial workspace allocation */ /* void *InitWorkSpace(int s) - initial workspace allocation */
/* int ExtendWorkSpace(int s) - extend workspace */ /* int ExtendWorkSpace(int s) - extend workspace */
/* int _YAP_FreeWorkSpace() - release workspace */ /* int Yap_FreeWorkSpace() - release workspace */
/************************************************************************/ /************************************************************************/
#if defined(_WIN32) #if defined(_WIN32)
@ -410,21 +410,21 @@ static int
ExtendWorkSpace(Int s) ExtendWorkSpace(Int s)
{ {
LPVOID b; LPVOID b;
prolog_exec_mode OldPrologMode = _YAP_PrologMode; prolog_exec_mode OldPrologMode = Yap_PrologMode;
_YAP_PrologMode = ExtendStackMode; Yap_PrologMode = ExtendStackMode;
s = ((s-1)/_YAP_page_size+1)*_YAP_page_size; s = ((s-1)/Yap_page_size+1)*Yap_page_size;
b = VirtualAlloc(brk, s, MEM_COMMIT, PAGE_READWRITE); b = VirtualAlloc(brk, s, MEM_COMMIT, PAGE_READWRITE);
if (b) { if (b) {
brk = (LPVOID) ((Int) brk + s); brk = (LPVOID) ((Int) brk + s);
_YAP_PrologMode = OldPrologMode; Yap_PrologMode = OldPrologMode;
return TRUE; return TRUE;
} }
_YAP_ErrorMessage = _YAP_ErrorSay; Yap_ErrorMessage = Yap_ErrorSay;
snprintf4(_YAP_ErrorMessage, MAX_ERROR_MSG_SIZE, snprintf4(Yap_ErrorMessage, MAX_ERROR_MSG_SIZE,
"VirtualAlloc could not commit %ld bytes", "VirtualAlloc could not commit %ld bytes",
(long int)s); (long int)s);
_YAP_PrologMode = OldPrologMode; Yap_PrologMode = OldPrologMode;
return FALSE; return FALSE;
} }
@ -435,12 +435,12 @@ InitWorkSpace(Int s)
LPVOID b; LPVOID b;
GetSystemInfo(&si); GetSystemInfo(&si);
_YAP_page_size = si.dwPageSize; Yap_page_size = si.dwPageSize;
b = VirtualAlloc(BASE_ADDRESS, MAX_WORKSPACE, MEM_RESERVE, PAGE_NOACCESS); b = VirtualAlloc(BASE_ADDRESS, MAX_WORKSPACE, MEM_RESERVE, PAGE_NOACCESS);
if (b==NULL) { if (b==NULL) {
b = VirtualAlloc(0x0, MAX_WORKSPACE, MEM_RESERVE, PAGE_NOACCESS); b = VirtualAlloc(0x0, MAX_WORKSPACE, MEM_RESERVE, PAGE_NOACCESS);
if (b == NULL) { if (b == NULL) {
_YAP_Error(FATAL_ERROR,TermNil,"VirtualAlloc failed"); Yap_Error(FATAL_ERROR,TermNil,"VirtualAlloc failed");
return(0); return(0);
} }
fprintf(stderr,"[ Warning: YAP reserving space at variable address %p ]\n", b); fprintf(stderr,"[ Warning: YAP reserving space at variable address %p ]\n", b);
@ -450,13 +450,13 @@ InitWorkSpace(Int s)
if (ExtendWorkSpace(s)) { if (ExtendWorkSpace(s)) {
return BASE_ADDRESS; return BASE_ADDRESS;
} else { } else {
_YAP_Error(FATAL_ERROR,TermNil,"VirtualAlloc Failed"); Yap_Error(FATAL_ERROR,TermNil,"VirtualAlloc Failed");
return(0); return(0);
} }
} }
int int
_YAP_FreeWorkSpace(void) Yap_FreeWorkSpace(void)
{ {
return TRUE; return TRUE;
} }
@ -496,14 +496,14 @@ InitWorkSpace(Int s)
a = mmap(((void *)MMAP_ADDR), (size_t) s, PROT_READ | PROT_WRITE | PROT_EXEC, a = mmap(((void *)MMAP_ADDR), (size_t) s, PROT_READ | PROT_WRITE | PROT_EXEC,
MAP_PRIVATE | MAP_ANONYMOUS | MAP_FIXED, -1, 0); MAP_PRIVATE | MAP_ANONYMOUS | MAP_FIXED, -1, 0);
if (a != (MALLOC_T)MMAP_ADDR) { if (a != (MALLOC_T)MMAP_ADDR) {
_YAP_Error(FATAL_ERROR, TermNil, "mmap could not map ANON at %p, got %p", (void *)MMAP_ADDR, a); Yap_Error(FATAL_ERROR, TermNil, "mmap could not map ANON at %p, got %p", (void *)MMAP_ADDR, a);
return(NULL); return(NULL);
} }
#elif defined(__APPLE__) #elif defined(__APPLE__)
a = mmap(((void *)MMAP_ADDR), (size_t) s, PROT_READ | PROT_WRITE | PROT_EXEC, a = mmap(((void *)MMAP_ADDR), (size_t) s, PROT_READ | PROT_WRITE | PROT_EXEC,
MAP_PRIVATE | MAP_ANON | MAP_FIXED, -1, 0); MAP_PRIVATE | MAP_ANON | MAP_FIXED, -1, 0);
if (a != (MALLOC_T)MMAP_ADDR) { if (a != (MALLOC_T)MMAP_ADDR) {
_YAP_Error(FATAL_ERROR, TermNil, "mmap could not map ANON at %p, got %p", (void *)MMAP_ADDR,a ); Yap_Error(FATAL_ERROR, TermNil, "mmap could not map ANON at %p, got %p", (void *)MMAP_ADDR,a );
return(NULL); return(NULL);
} }
#else #else
@ -514,9 +514,9 @@ InitWorkSpace(Int s)
strncpy(file,"/tmp/YAP.TMPXXXXXX", 256); strncpy(file,"/tmp/YAP.TMPXXXXXX", 256);
if (mkstemp(file) == -1) { if (mkstemp(file) == -1) {
#if HAVE_STRERROR #if HAVE_STRERROR
_YAP_Error(FATAL_ERROR, TermNil, "mkstemp could not create temporary file %s (%s)", file, strerror(errno)); Yap_Error(FATAL_ERROR, TermNil, "mkstemp could not create temporary file %s (%s)", file, strerror(errno));
#else #else
_YAP_Error(FATAL_ERROR, TermNil, "mkstemp could not create temporary file %s", file); Yap_Error(FATAL_ERROR, TermNil, "mkstemp could not create temporary file %s", file);
#endif #endif
return NULL; return NULL;
} }
@ -531,21 +531,21 @@ InitWorkSpace(Int s)
#endif /* HAVE_MKSTEMP */ #endif /* HAVE_MKSTEMP */
fd = open(file, O_CREAT|O_RDWR); fd = open(file, O_CREAT|O_RDWR);
if (fd < 0) { if (fd < 0) {
_YAP_Error(FATAL_ERROR, TermNil, "mmap could not open %s", file); Yap_Error(FATAL_ERROR, TermNil, "mmap could not open %s", file);
return NULL; return NULL;
} }
if (lseek(fd, s, SEEK_SET) < 0) { if (lseek(fd, s, SEEK_SET) < 0) {
_YAP_Error(FATAL_ERROR, TermNil, "mmap could not lseek in mmapped file %s", file); Yap_Error(FATAL_ERROR, TermNil, "mmap could not lseek in mmapped file %s", file);
close(fd); close(fd);
return FALSE; return FALSE;
} }
if (write(fd, "", 1) < 0) { if (write(fd, "", 1) < 0) {
_YAP_Error(FATAL_ERROR, TermNil, "mmap could not write in mmapped file %s", file); Yap_Error(FATAL_ERROR, TermNil, "mmap could not write in mmapped file %s", file);
close(fd); close(fd);
return NULL; return NULL;
} }
if (unlink(file) < 0) { if (unlink(file) < 0) {
_YAP_Error(FATAL_ERROR,TermNil, "mmap could not unlink mmapped file %s", file); Yap_Error(FATAL_ERROR,TermNil, "mmap could not unlink mmapped file %s", file);
close(fd); close(fd);
return NULL; return NULL;
} }
@ -554,7 +554,7 @@ InitWorkSpace(Int s)
a = mmap(((void *)MMAP_ADDR), (size_t) s, PROT_READ | PROT_WRITE | PROT_EXEC, a = mmap(((void *)MMAP_ADDR), (size_t) s, PROT_READ | PROT_WRITE | PROT_EXEC,
MAP_PRIVATE | MAP_FIXED, fd, 0); MAP_PRIVATE | MAP_FIXED, fd, 0);
if (a != (MALLOC_T)MMAP_ADDR) { if (a != (MALLOC_T)MMAP_ADDR) {
_YAP_Error(FATAL_ERROR, TermNil, "mmap could not map at %p, got %p", (void *)MMAP_ADDR, a); Yap_Error(FATAL_ERROR, TermNil, "mmap could not map at %p, got %p", (void *)MMAP_ADDR, a);
return NULL; return NULL;
} }
#else #else
@ -562,11 +562,11 @@ InitWorkSpace(Int s)
MAP_PRIVATE, fd, 0); MAP_PRIVATE, fd, 0);
if ((CELL)a & YAP_PROTECTED_MASK) { if ((CELL)a & YAP_PROTECTED_MASK) {
close(fd); close(fd);
_YAP_Error(FATAL_ERROR, TermNil, "mmapped address %p collides with YAP tags", a); Yap_Error(FATAL_ERROR, TermNil, "mmapped address %p collides with YAP tags", a);
return NULL; return NULL;
} }
if (close(fd) == -1) { if (close(fd) == -1) {
_YAP_Error(FATAL_ERROR, TermNil, "while closing mmaped file"); Yap_Error(FATAL_ERROR, TermNil, "while closing mmaped file");
return NULL; return NULL;
} }
#endif #endif
@ -578,7 +578,7 @@ InitWorkSpace(Int s)
(a == (MALLOC_T) - 1) (a == (MALLOC_T) - 1)
#endif #endif
{ {
_YAP_Error(FATAL_ERROR, TermNil, "mmap cannot allocate memory ***"); Yap_Error(FATAL_ERROR, TermNil, "mmap cannot allocate memory ***");
return(NULL); return(NULL);
} }
WorkSpaceTop = (char *) a + s; WorkSpaceTop = (char *) a + s;
@ -594,36 +594,36 @@ ExtendWorkSpace(Int s)
#else #else
MALLOC_T a; MALLOC_T a;
prolog_exec_mode OldPrologMode = _YAP_PrologMode; prolog_exec_mode OldPrologMode = Yap_PrologMode;
#if defined(_AIX) || defined(__hpux) #if defined(_AIX) || defined(__hpux)
_YAP_PrologMode = ExtendStackMode; Yap_PrologMode = ExtendStackMode;
a = mmap(WorkSpaceTop, (size_t) s, PROT_READ | PROT_WRITE | PROT_EXEC, a = mmap(WorkSpaceTop, (size_t) s, PROT_READ | PROT_WRITE | PROT_EXEC,
MAP_PRIVATE | MAP_ANONYMOUS, -1, 0); MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
#elif defined(__APPLE__) #elif defined(__APPLE__)
_YAP_PrologMode = ExtendStackMode; Yap_PrologMode = ExtendStackMode;
a = mmap(WorkSpaceTop, (size_t) s, PROT_READ | PROT_WRITE | PROT_EXEC, a = mmap(WorkSpaceTop, (size_t) s, PROT_READ | PROT_WRITE | PROT_EXEC,
MAP_PRIVATE | MAP_ANON | MAP_FIXED, -1, 0); MAP_PRIVATE | MAP_ANON | MAP_FIXED, -1, 0);
#else #else
int fd; int fd;
_YAP_PrologMode = ExtendStackMode; Yap_PrologMode = ExtendStackMode;
fd = open("/dev/zero", O_RDWR); fd = open("/dev/zero", O_RDWR);
if (fd < 0) { if (fd < 0) {
#if HAVE_MKSTEMP #if HAVE_MKSTEMP
char file[256]; char file[256];
strncpy(file,"/tmp/YAP.TMPXXXXXX",256); strncpy(file,"/tmp/YAP.TMPXXXXXX",256);
if (mkstemp(file) == -1) { if (mkstemp(file) == -1) {
_YAP_ErrorMessage = _YAP_ErrorSay; Yap_ErrorMessage = Yap_ErrorSay;
#if HAVE_STRERROR #if HAVE_STRERROR
snprintf5(_YAP_ErrorMessage, MAX_ERROR_MSG_SIZE, snprintf5(Yap_ErrorMessage, MAX_ERROR_MSG_SIZE,
"mkstemp could not create temporary file %s (%s)", "mkstemp could not create temporary file %s (%s)",
file, strerror(errno)); file, strerror(errno));
#else #else
snprintf4(_YAP_ErrorMessage, MAX_ERROR_MSG_SIZE, snprintf4(Yap_ErrorMessage, MAX_ERROR_MSG_SIZE,
"mkstemp could not create temporary file %s", file); "mkstemp could not create temporary file %s", file);
#endif /* HAVE_STRERROR */ #endif /* HAVE_STRERROR */
_YAP_PrologMode = OldPrologMode; Yap_PrologMode = OldPrologMode;
return FALSE; return FALSE;
} }
#else #else
@ -637,33 +637,33 @@ ExtendWorkSpace(Int s)
#endif /* HAVE_MKSTEMP */ #endif /* HAVE_MKSTEMP */
fd = open(file, O_CREAT|O_RDWR); fd = open(file, O_CREAT|O_RDWR);
if (fd < 0) { if (fd < 0) {
_YAP_ErrorMessage = _YAP_ErrorSay; Yap_ErrorMessage = Yap_ErrorSay;
snprintf4(_YAP_ErrorMessage, MAX_ERROR_MSG_SIZE, snprintf4(Yap_ErrorMessage, MAX_ERROR_MSG_SIZE,
"mmap could not open %s", file); "mmap could not open %s", file);
_YAP_PrologMode = OldPrologMode; Yap_PrologMode = OldPrologMode;
return FALSE; return FALSE;
} }
if (lseek(fd, s, SEEK_SET) < 0) { if (lseek(fd, s, SEEK_SET) < 0) {
_YAP_ErrorMessage = _YAP_ErrorSay; Yap_ErrorMessage = Yap_ErrorSay;
snprintf4(_YAP_ErrorMessage, MAX_ERROR_MSG_SIZE, snprintf4(Yap_ErrorMessage, MAX_ERROR_MSG_SIZE,
"mmap could not lseek in mmapped file %s", file); "mmap could not lseek in mmapped file %s", file);
_YAP_PrologMode = OldPrologMode; Yap_PrologMode = OldPrologMode;
close(fd); close(fd);
return FALSE; return FALSE;
} }
if (write(fd, "", 1) < 0) { if (write(fd, "", 1) < 0) {
_YAP_ErrorMessage = _YAP_ErrorSay; Yap_ErrorMessage = Yap_ErrorSay;
snprintf4(_YAP_ErrorMessage, MAX_ERROR_MSG_SIZE, snprintf4(Yap_ErrorMessage, MAX_ERROR_MSG_SIZE,
"mmap could not write in mmapped file %s", file); "mmap could not write in mmapped file %s", file);
_YAP_PrologMode = OldPrologMode; Yap_PrologMode = OldPrologMode;
close(fd); close(fd);
return FALSE; return FALSE;
} }
if (unlink(file) < 0) { if (unlink(file) < 0) {
_YAP_ErrorMessage = _YAP_ErrorSay; Yap_ErrorMessage = Yap_ErrorSay;
snprintf4(_YAP_ErrorMessage, MAX_ERROR_MSG_SIZE, snprintf4(Yap_ErrorMessage, MAX_ERROR_MSG_SIZE,
"mmap could not unlink mmapped file %s", file); "mmap could not unlink mmapped file %s", file);
_YAP_PrologMode = OldPrologMode; Yap_PrologMode = OldPrologMode;
close(fd); close(fd);
return FALSE; return FALSE;
} }
@ -676,46 +676,46 @@ ExtendWorkSpace(Int s)
#endif #endif
, fd, 0); , fd, 0);
if (close(fd) == -1) { if (close(fd) == -1) {
_YAP_ErrorMessage = _YAP_ErrorSay; Yap_ErrorMessage = Yap_ErrorSay;
#if HAVE_STRERROR #if HAVE_STRERROR
snprintf4(_YAP_ErrorMessage, MAX_ERROR_MSG_SIZE, snprintf4(Yap_ErrorMessage, MAX_ERROR_MSG_SIZE,
"mmap could not close file (%s) ]\n", strerror(errno)); "mmap could not close file (%s) ]\n", strerror(errno));
#else #else
snprintf3(_YAP_ErrorMessage, MAX_ERROR_MSG_SIZE, snprintf3(Yap_ErrorMessage, MAX_ERROR_MSG_SIZE,
"mmap could not close file ]\n"); "mmap could not close file ]\n");
#endif #endif
_YAP_PrologMode = OldPrologMode; Yap_PrologMode = OldPrologMode;
return FALSE; return FALSE;
} }
#endif #endif
if (a == (MALLOC_T) - 1) { if (a == (MALLOC_T) - 1) {
_YAP_ErrorMessage = _YAP_ErrorSay; Yap_ErrorMessage = Yap_ErrorSay;
#if HAVE_STRERROR #if HAVE_STRERROR
snprintf5(_YAP_ErrorMessage, MAX_ERROR_MSG_SIZE, snprintf5(Yap_ErrorMessage, MAX_ERROR_MSG_SIZE,
"could not allocate %d bytes (%s)", (int)s, strerror(errno)); "could not allocate %d bytes (%s)", (int)s, strerror(errno));
#else #else
snprintf4(_YAP_ErrorMessage, MAX_ERROR_MSG_SIZE, snprintf4(Yap_ErrorMessage, MAX_ERROR_MSG_SIZE,
"could not allocate %d bytes", (int)s); "could not allocate %d bytes", (int)s);
#endif #endif
_YAP_PrologMode = OldPrologMode; Yap_PrologMode = OldPrologMode;
return FALSE; return FALSE;
} }
if (a != WorkSpaceTop) { if (a != WorkSpaceTop) {
_YAP_ErrorMessage = _YAP_ErrorSay; Yap_ErrorMessage = Yap_ErrorSay;
snprintf5(_YAP_ErrorMessage, MAX_ERROR_MSG_SIZE, snprintf5(Yap_ErrorMessage, MAX_ERROR_MSG_SIZE,
"mmap could not grow memory at %p, got %p", WorkSpaceTop, a ); "mmap could not grow memory at %p, got %p", WorkSpaceTop, a );
_YAP_PrologMode = OldPrologMode; Yap_PrologMode = OldPrologMode;
return FALSE; return FALSE;
} }
WorkSpaceTop = (char *) a + s; WorkSpaceTop = (char *) a + s;
_YAP_PrologMode = OldPrologMode; Yap_PrologMode = OldPrologMode;
return TRUE; return TRUE;
#endif /* YAPOR */ #endif /* YAPOR */
} }
int int
_YAP_FreeWorkSpace(void) Yap_FreeWorkSpace(void)
{ {
return 1; return 1;
} }
@ -740,15 +740,15 @@ InitWorkSpace(Int s)
/* mapping heap area */ /* mapping heap area */
if((shm_id = shmget(IPC_PRIVATE, (size_t)s, SHM_R|SHM_W)) == -1) { if((shm_id = shmget(IPC_PRIVATE, (size_t)s, SHM_R|SHM_W)) == -1) {
_YAP_Error(FATAL_ERROR, TermNil, "could not shmget %d bytes", s); Yap_Error(FATAL_ERROR, TermNil, "could not shmget %d bytes", s);
return(NULL); return(NULL);
} }
if((ptr = (MALLOC_T)shmat(shm_id, (void *) MMAP_ADDR, 0)) == (MALLOC_T) -1) { if((ptr = (MALLOC_T)shmat(shm_id, (void *) MMAP_ADDR, 0)) == (MALLOC_T) -1) {
_YAP_Error(FATAL_ERROR, TermNil, "could not shmat at %p", MMAP_ADDR); Yap_Error(FATAL_ERROR, TermNil, "could not shmat at %p", MMAP_ADDR);
return(NULL); return(NULL);
} }
if (shmctl(shm_id, IPC_RMID, 0) != 0) { if (shmctl(shm_id, IPC_RMID, 0) != 0) {
_YAP_Error(FATAL_ERROR, TermNil, "could not remove shm segment", shm_id); Yap_Error(FATAL_ERROR, TermNil, "could not remove shm segment", shm_id);
return(NULL); return(NULL);
} }
WorkSpaceTop = (char *) ptr + s; WorkSpaceTop = (char *) ptr + s;
@ -765,22 +765,22 @@ ExtendWorkSpace(Int s)
PrologMode = ExtendStackMode; PrologMode = ExtendStackMode;
/* mapping heap area */ /* mapping heap area */
if((shm_id = shmget(IPC_PRIVATE, (size_t)s, SHM_R|SHM_W)) == -1) { if((shm_id = shmget(IPC_PRIVATE, (size_t)s, SHM_R|SHM_W)) == -1) {
_YAP_ErrorMessage = _YAP_ErrorSay; Yap_ErrorMessage = Yap_ErrorSay;
snprintf4(_YAP_ErrorMessage, MAX_ERROR_MSG_SIZE, snprintf4(Yap_ErrorMessage, MAX_ERROR_MSG_SIZE,
"could not shmget %d bytes", s); "could not shmget %d bytes", s);
PrologMode = OldPrologMode; PrologMode = OldPrologMode;
return(FALSE); return(FALSE);
} }
if((ptr = (MALLOC_T)shmat(shm_id, WorkSpaceTop, 0)) == (MALLOC_T) -1) { if((ptr = (MALLOC_T)shmat(shm_id, WorkSpaceTop, 0)) == (MALLOC_T) -1) {
_YAP_ErrorMessage = _YAP_ErrorSay; Yap_ErrorMessage = Yap_ErrorSay;
snprintf4(_YAP_ErrorMessage, MAX_ERROR_MSG_SIZE, snprintf4(Yap_ErrorMessage, MAX_ERROR_MSG_SIZE,
"could not shmat at %p", MMAP_ADDR); "could not shmat at %p", MMAP_ADDR);
PrologMode = OldPrologMode; PrologMode = OldPrologMode;
return(FALSE); return(FALSE);
} }
if (shmctl(shm_id, IPC_RMID, 0) != 0) { if (shmctl(shm_id, IPC_RMID, 0) != 0) {
_YAP_ErrorMessage = _YAP_ErrorSay; Yap_ErrorMessage = Yap_ErrorSay;
snprintf4(_YAP_ErrorMessage, MAX_ERROR_MSG_SIZE, snprintf4(Yap_ErrorMessage, MAX_ERROR_MSG_SIZE,
"could not remove shm segment", shm_id); "could not remove shm segment", shm_id);
PrologMode = OldPrologMode; PrologMode = OldPrologMode;
return(FALSE); return(FALSE);
@ -791,7 +791,7 @@ ExtendWorkSpace(Int s)
} }
int int
_YAP_FreeWorkSpace(void) Yap_FreeWorkSpace(void)
{ {
return TRUE; return TRUE;
} }
@ -825,7 +825,7 @@ InitWorkSpace(Int s)
MALLOC_T ptr = (MALLOC_T)sbrk(s); MALLOC_T ptr = (MALLOC_T)sbrk(s);
if (ptr == ((MALLOC_T) - 1)) { if (ptr == ((MALLOC_T) - 1)) {
_YAP_Error(FATAL_ERROR, TermNil, "could not allocate %d bytes", s); Yap_Error(FATAL_ERROR, TermNil, "could not allocate %d bytes", s);
return(NULL); return(NULL);
} }
return(ptr); return(ptr);
@ -839,8 +839,8 @@ ExtendWorkSpace(Int s)
PrologMode = ExtendStackMode; PrologMode = ExtendStackMode;
if (ptr == ((MALLOC_T) - 1)) { if (ptr == ((MALLOC_T) - 1)) {
_YAP_ErrorMessage = _YAP_ErrorSay; Yap_ErrorMessage = Yap_ErrorSay;
snprintf4(_YAP_ErrorMessage, MAX_ERROR_MSG_SIZE, snprintf4(Yap_ErrorMessage, MAX_ERROR_MSG_SIZE,
"could not expand stacks over %d bytes", s); "could not expand stacks over %d bytes", s);
PrologMode = OldPrologMode; PrologMode = OldPrologMode;
return(FALSE); return(FALSE);
@ -850,7 +850,7 @@ ExtendWorkSpace(Int s)
} }
int int
_YAP_FreeWorkSpace(void) Yap_FreeWorkSpace(void)
{ {
return TRUE; return TRUE;
} }
@ -885,7 +885,7 @@ free(MALLOC_T ptr)
} }
if (!ptr) if (!ptr)
return; return;
if ((char *) ptr < _YAP_HeapBase || (char *) ptr > HeapTop) if ((char *) ptr < Yap_HeapBase || (char *) ptr > HeapTop)
return; return;
if (!(b->b_size & InUseFlag)) if (!(b->b_size & InUseFlag))
return; return;
@ -955,7 +955,7 @@ InitWorkSpace(Int s)
total_space = s; total_space = s;
if (ptr == NULL) { if (ptr == NULL) {
_YAP_Error(FATAL_ERROR, TermNil, "could not allocate %d bytes", s); Yap_Error(FATAL_ERROR, TermNil, "could not allocate %d bytes", s);
return(NULL); return(NULL);
} }
return(ptr); return(ptr);
@ -970,24 +970,24 @@ ExtendWorkSpace(Int s)
PrologMode = ExtendStackMode; PrologMode = ExtendStackMode;
total_space += s; total_space += s;
if (total_space < MAX_SPACE) return(TRUE); if (total_space < MAX_SPACE) return(TRUE);
ptr = (MALLOC_T)realloc((void *)_YAP_HeapBase, total_space); ptr = (MALLOC_T)realloc((void *)Yap_HeapBase, total_space);
if (ptr == NULL) { if (ptr == NULL) {
_YAP_ErrorMessage = _YAP_ErrorSay; Yap_ErrorMessage = Yap_ErrorSay;
snprintf4(_YAP_ErrorMessage, MAX_ERROR_MSG_SIZE, snprintf4(Yap_ErrorMessage, MAX_ERROR_MSG_SIZE,
"could not allocate %d bytes", s); "could not allocate %d bytes", s);
PrologMode = OldPrologMode; PrologMode = OldPrologMode;
return(FALSE); return(FALSE);
} }
if (ptr != (MALLOC_T)_YAP_HeapBase) { if (ptr != (MALLOC_T)Yap_HeapBase) {
_YAP_ErrorMessage = _YAP_ErrorSay; Yap_ErrorMessage = Yap_ErrorSay;
snprintf4(_YAP_ErrorMessage, MAX_ERROR_MSG_SIZE, snprintf4(Yap_ErrorMessage, MAX_ERROR_MSG_SIZE,
"could not expand contiguous stacks %d bytes", s); "could not expand contiguous stacks %d bytes", s);
PrologMode = OldPrologMode; PrologMode = OldPrologMode;
return(FALSE); return(FALSE);
} }
if ((CELL)ptr & MBIT) { if ((CELL)ptr & MBIT) {
_YAP_ErrorMessage = _YAP_ErrorSay; Yap_ErrorMessage = Yap_ErrorSay;
snprintf5(_YAP_ErrorMessage, MAX_ERROR_MSG_SIZE, snprintf5(Yap_ErrorMessage, MAX_ERROR_MSG_SIZE,
"memory at %p conflicts with MBIT %lx", ptr, (unsigned long)MBIT); "memory at %p conflicts with MBIT %lx", ptr, (unsigned long)MBIT);
PrologMode = OldPrologMode; PrologMode = OldPrologMode;
return(FALSE); return(FALSE);
@ -997,7 +997,7 @@ ExtendWorkSpace(Int s)
} }
int int
_YAP_FreeWorkSpace(void) Yap_FreeWorkSpace(void)
{ {
return TRUE; return TRUE;
} }
@ -1007,13 +1007,13 @@ static void
InitHeap(void *heap_addr) InitHeap(void *heap_addr)
{ {
/* allocate space */ /* allocate space */
_YAP_HeapBase = heap_addr; Yap_HeapBase = heap_addr;
/* reserve space for specially allocated functors and atoms so that /* reserve space for specially allocated functors and atoms so that
their values can be known statically */ their values can be known statically */
HeapTop = _YAP_HeapBase + AdjustSize(sizeof(all_heap_codes)); HeapTop = Yap_HeapBase + AdjustSize(sizeof(all_heap_codes));
HeapMax = HeapUsed = HeapTop-_YAP_HeapBase; HeapMax = HeapUsed = HeapTop-Yap_HeapBase;
*((YAP_SEG_SIZE *) HeapTop) = InUseFlag; *((YAP_SEG_SIZE *) HeapTop) = InUseFlag;
HeapTop = HeapTop + sizeof(YAP_SEG_SIZE); HeapTop = HeapTop + sizeof(YAP_SEG_SIZE);
@ -1039,13 +1039,13 @@ InitHeap(void *heap_addr)
} }
void void
_YAP_InitHeap(void *heap_addr) Yap_InitHeap(void *heap_addr)
{ {
InitHeap(heap_addr); InitHeap(heap_addr);
} }
void void
_YAP_InitMemory(int Trail, int Heap, int Stack) Yap_InitMemory(int Trail, int Heap, int Stack)
{ {
Int pm, sa, ta; Int pm, sa, ta;
@ -1060,12 +1060,12 @@ _YAP_InitMemory(int Trail, int Heap, int Stack)
InitHeap(InitWorkSpace(pm)); InitHeap(InitWorkSpace(pm));
_YAP_TrailTop = _YAP_HeapBase + pm; Yap_TrailTop = Yap_HeapBase + pm;
_YAP_LocalBase = _YAP_TrailTop - ta; Yap_LocalBase = Yap_TrailTop - ta;
_YAP_TrailBase = _YAP_LocalBase + sizeof(CELL); Yap_TrailBase = Yap_LocalBase + sizeof(CELL);
_YAP_GlobalBase = _YAP_LocalBase - sa; Yap_GlobalBase = Yap_LocalBase - sa;
AuxTop = _YAP_GlobalBase - CellSize; /* avoid confusions while AuxTop = Yap_GlobalBase - CellSize; /* avoid confusions while
* * restoring */ * * restoring */
AuxSp = (CELL *) AuxTop; AuxSp = (CELL *) AuxTop;
@ -1073,12 +1073,12 @@ _YAP_InitMemory(int Trail, int Heap, int Stack)
#if SIZEOF_INT_P!=SIZEOF_INT #if SIZEOF_INT_P!=SIZEOF_INT
if (output_msg) { if (output_msg) {
fprintf(stderr, "HeapBase = %p GlobalBase = %p\n LocalBase = %p TrailTop = %p\n", fprintf(stderr, "HeapBase = %p GlobalBase = %p\n LocalBase = %p TrailTop = %p\n",
_YAP_HeapBase, _YAP_GlobalBase, _YAP_LocalBase, _YAP_TrailTop); Yap_HeapBase, Yap_GlobalBase, Yap_LocalBase, Yap_TrailTop);
#else #else
if (output_msg) { if (output_msg) {
fprintf(stderr, "HeapBase = %x GlobalBase = %x\n LocalBase = %x TrailTop = %x\n", fprintf(stderr, "HeapBase = %x GlobalBase = %x\n LocalBase = %x TrailTop = %x\n",
(UInt) _YAP_HeapBase, (UInt) _YAP_GlobalBase, (UInt) Yap_HeapBase, (UInt) Yap_GlobalBase,
(UInt) _YAP_LocalBase, (UInt) _YAP_TrailTop); (UInt) Yap_LocalBase, (UInt) Yap_TrailTop);
#endif #endif
#if !SHORT_INTS #if !SHORT_INTS
@ -1094,7 +1094,7 @@ _YAP_InitMemory(int Trail, int Heap, int Stack)
} }
int int
_YAP_ExtendWorkSpace(Int s) Yap_ExtendWorkSpace(Int s)
{ {
return ExtendWorkSpace(s); return ExtendWorkSpace(s);
} }

108
C/amasm.c
View File

@ -297,8 +297,8 @@ DumpOpCodes(void)
while (i < 30) { while (i < 30) {
for (j = i; j <= _std_top; j += 25) for (j = i; j <= _std_top; j += 25)
fprintf(_YAP_stderr, "%5d %6lx", j, absmadr(j)); fprintf(Yap_stderr, "%5d %6lx", j, absmadr(j));
fputc('\n',_YAP_stderr); fputc('\n',Yap_stderr);
++i; ++i;
} }
} }
@ -317,7 +317,7 @@ opcode(op_numbers op)
} }
OPCODE OPCODE
_YAP_opcode(op_numbers op) Yap_opcode(op_numbers op)
{ {
return (opcode(op)); return (opcode(op));
} }
@ -731,15 +731,15 @@ a_p(op_numbers opcode)
break; break;
default: default:
op = _p_equal; /* just to make some compilers happy */ op = _p_equal; /* just to make some compilers happy */
_YAP_Error(SYSTEM_ERROR, TermNil, "internal assembler error for built-in (%d)", (Flags & 0x7f)); Yap_Error(SYSTEM_ERROR, TermNil, "internal assembler error for built-in (%d)", (Flags & 0x7f));
save_machine_regs(); save_machine_regs();
longjmp(_YAP_CompilerBotch, 1); longjmp(Yap_CompilerBotch, 1);
} }
a_e(op); a_e(op);
if (!comit_ok) { if (!comit_ok) {
_YAP_Error(SYSTEM_ERROR, TermNil,"internal assembler error for commit"); Yap_Error(SYSTEM_ERROR, TermNil,"internal assembler error for commit");
save_machine_regs(); save_machine_regs();
longjmp(_YAP_CompilerBotch, 1); longjmp(Yap_CompilerBotch, 1);
} }
return; return;
} }
@ -748,10 +748,10 @@ a_p(op_numbers opcode)
if (!comit_ok && (Flags & TestPredFlag)) { if (!comit_ok && (Flags & TestPredFlag)) {
if (pass_no) { if (pass_no) {
if (Flags & UserCPredFlag) { if (Flags & UserCPredFlag) {
_YAP_Error(SYSTEM_ERROR, TermNil, Yap_Error(SYSTEM_ERROR, TermNil,
"user defined predicate cannot be a test predicate"); "user defined predicate cannot be a test predicate");
save_machine_regs(); save_machine_regs();
longjmp(_YAP_CompilerBotch, 1); longjmp(Yap_CompilerBotch, 1);
} else } else
code_p->opc = emit_op(_call_c_wfail); code_p->opc = emit_op(_call_c_wfail);
code_p->u.sdl.s = code_p->u.sdl.s =
@ -796,9 +796,9 @@ a_p(op_numbers opcode)
GONEXT(sla); GONEXT(sla);
} }
if (!comit_ok) { if (!comit_ok) {
_YAP_Error(SYSTEM_ERROR, TermNil, "internal assembler error for commit"); Yap_Error(SYSTEM_ERROR, TermNil, "internal assembler error for commit");
save_machine_regs(); save_machine_regs();
longjmp(_YAP_CompilerBotch,1); longjmp(Yap_CompilerBotch,1);
} }
return; return;
} }
@ -838,9 +838,9 @@ a_p(op_numbers opcode)
GONEXT(l); GONEXT(l);
} }
if (!comit_ok) { if (!comit_ok) {
_YAP_Error(SYSTEM_ERROR, TermNil, "internal assembler error for commit"); Yap_Error(SYSTEM_ERROR, TermNil, "internal assembler error for commit");
save_machine_regs(); save_machine_regs();
longjmp(_YAP_CompilerBotch,1); longjmp(Yap_CompilerBotch,1);
} }
} }
@ -862,7 +862,7 @@ a_empty_call(void)
code_p->opc = emit_op(_fcall); code_p->opc = emit_op(_fcall);
} }
if (pass_no) { if (pass_no) {
PredEntry *pe = RepPredProp(_YAP_GetPredPropByAtom(AtomTrue,0)); PredEntry *pe = RepPredProp(Yap_GetPredPropByAtom(AtomTrue,0));
code_p->u.sla.s = emit_count(-Signed(RealEnvSize) - CELLSIZE * code_p->u.sla.s = emit_count(-Signed(RealEnvSize) - CELLSIZE *
cpc->rnd2); cpc->rnd2);
code_p->u.sla.l = emit_a((CELL)&(pe->StateOfPred)); code_p->u.sla.l = emit_a((CELL)&(pe->StateOfPred));
@ -906,7 +906,7 @@ compile_cmp_flags(char *s)
if (strcmp(s,">") == 0) return(GT_OK_IN_CMP); if (strcmp(s,">") == 0) return(GT_OK_IN_CMP);
if (strcmp(s,"=:=") == 0) return(EQ_OK_IN_CMP); if (strcmp(s,"=:=") == 0) return(EQ_OK_IN_CMP);
if (strcmp(s,"=\\=") == 0) return(GT_OK_IN_CMP|LT_OK_IN_CMP); if (strcmp(s,"=\\=") == 0) return(GT_OK_IN_CMP|LT_OK_IN_CMP);
_YAP_Error(SYSTEM_ERROR, x1_arg, "internal assembler error in flags for %s", s); Yap_Error(SYSTEM_ERROR, x1_arg, "internal assembler error in flags for %s", s);
return(0); return(0);
} }
@ -1189,7 +1189,7 @@ a_either(op_numbers opcode, CELL opr, CELL lab)
#endif /* YAPOR */ #endif /* YAPOR */
{ {
if (pass_no) { if (pass_no) {
Prop fe = _YAP_GetPredPropByAtom(AtomTrue,0); Prop fe = Yap_GetPredPropByAtom(AtomTrue,0);
code_p->opc = emit_op(opcode); code_p->opc = emit_op(opcode);
code_p->u.sla.s = emit_count(opr); code_p->u.sla.s = emit_count(opr);
code_p->u.sla.l = emit_a(lab); code_p->u.sla.l = emit_a(lab);
@ -1712,40 +1712,40 @@ a_f2(int var)
if (pass_no) { if (pass_no) {
switch (opc) { switch (opc) {
case _plus: case _plus:
_YAP_Error(SYSTEM_ERROR, x1_arg, "internal assembler error CX for +/2"); Yap_Error(SYSTEM_ERROR, x1_arg, "internal assembler error CX for +/2");
save_machine_regs(); save_machine_regs();
longjmp(_YAP_CompilerBotch, 1); longjmp(Yap_CompilerBotch, 1);
break; break;
case _minus: case _minus:
code_p->opc = emit_op(_p_minus_y_cv); code_p->opc = emit_op(_p_minus_y_cv);
break; break;
case _times: case _times:
_YAP_Error(SYSTEM_ERROR, x1_arg, "internal assembler error CX for */2"); Yap_Error(SYSTEM_ERROR, x1_arg, "internal assembler error CX for */2");
save_machine_regs(); save_machine_regs();
longjmp(_YAP_CompilerBotch, 1); longjmp(Yap_CompilerBotch, 1);
break; break;
case _div: case _div:
code_p->opc = emit_op(_p_div_y_cv); code_p->opc = emit_op(_p_div_y_cv);
break; break;
case _and: case _and:
_YAP_Error(SYSTEM_ERROR, x1_arg, "internal assembler error CX for /\\/2"); Yap_Error(SYSTEM_ERROR, x1_arg, "internal assembler error CX for /\\/2");
save_machine_regs(); save_machine_regs();
longjmp(_YAP_CompilerBotch, 1); longjmp(Yap_CompilerBotch, 1);
break; break;
case _or: case _or:
_YAP_Error(SYSTEM_ERROR, x1_arg, "internal assembler error CX for \\//2"); Yap_Error(SYSTEM_ERROR, x1_arg, "internal assembler error CX for \\//2");
save_machine_regs(); save_machine_regs();
longjmp(_YAP_CompilerBotch, 1); longjmp(Yap_CompilerBotch, 1);
break; break;
case _sll: case _sll:
code_p->opc = emit_op(_p_sll_y_cv); code_p->opc = emit_op(_p_sll_y_cv);
save_machine_regs(); save_machine_regs();
longjmp(_YAP_CompilerBotch, 1); longjmp(Yap_CompilerBotch, 1);
break; break;
case _slr: case _slr:
code_p->opc = emit_op(_p_slr_y_cv); code_p->opc = emit_op(_p_slr_y_cv);
save_machine_regs(); save_machine_regs();
longjmp(_YAP_CompilerBotch, 1); longjmp(Yap_CompilerBotch, 1);
break; break;
case _arg: case _arg:
code_p->opc = emit_op(_p_arg_y_cv); code_p->opc = emit_op(_p_arg_y_cv);
@ -1767,9 +1767,9 @@ a_f2(int var)
code_p->opc = emit_op(_p_plus_y_vc); code_p->opc = emit_op(_p_plus_y_vc);
break; break;
case _minus: case _minus:
_YAP_Error(SYSTEM_ERROR, x2_arg, "internal assembler error XC for -/2"); Yap_Error(SYSTEM_ERROR, x2_arg, "internal assembler error XC for -/2");
save_machine_regs(); save_machine_regs();
longjmp(_YAP_CompilerBotch, 1); longjmp(Yap_CompilerBotch, 1);
break; break;
case _times: case _times:
code_p->opc = emit_op(_p_times_y_vc); code_p->opc = emit_op(_p_times_y_vc);
@ -1790,9 +1790,9 @@ a_f2(int var)
code_p->opc = emit_op(_p_slr_y_vc); code_p->opc = emit_op(_p_slr_y_vc);
break; break;
case _arg: case _arg:
_YAP_Error(SYSTEM_ERROR, x2_arg, "internal assembler error for arg/3"); Yap_Error(SYSTEM_ERROR, x2_arg, "internal assembler error for arg/3");
save_machine_regs(); save_machine_regs();
longjmp(_YAP_CompilerBotch, 1); longjmp(Yap_CompilerBotch, 1);
break; break;
case _functor: case _functor:
code_p->opc = emit_op(_p_func2s_y_vc); code_p->opc = emit_op(_p_func2s_y_vc);
@ -1851,30 +1851,30 @@ a_f2(int var)
if (pass_no) { if (pass_no) {
switch (opc) { switch (opc) {
case _plus: case _plus:
_YAP_Error(SYSTEM_ERROR, x1_arg, "internal assembler error CX for +/2"); Yap_Error(SYSTEM_ERROR, x1_arg, "internal assembler error CX for +/2");
save_machine_regs(); save_machine_regs();
longjmp(_YAP_CompilerBotch, 1); longjmp(Yap_CompilerBotch, 1);
break; break;
case _minus: case _minus:
code_p->opc = emit_op(_p_minus_cv); code_p->opc = emit_op(_p_minus_cv);
break; break;
case _times: case _times:
_YAP_Error(SYSTEM_ERROR, x1_arg, "internal assembler error CX for */2"); Yap_Error(SYSTEM_ERROR, x1_arg, "internal assembler error CX for */2");
save_machine_regs(); save_machine_regs();
longjmp(_YAP_CompilerBotch, 1); longjmp(Yap_CompilerBotch, 1);
break; break;
case _div: case _div:
code_p->opc = emit_op(_p_div_cv); code_p->opc = emit_op(_p_div_cv);
break; break;
case _and: case _and:
_YAP_Error(SYSTEM_ERROR, x1_arg, "internal assembler error CX for /\\/2"); Yap_Error(SYSTEM_ERROR, x1_arg, "internal assembler error CX for /\\/2");
save_machine_regs(); save_machine_regs();
longjmp(_YAP_CompilerBotch, 1); longjmp(Yap_CompilerBotch, 1);
break; break;
case _or: case _or:
_YAP_Error(SYSTEM_ERROR, x1_arg, "internal assembler error CX for \\//2"); Yap_Error(SYSTEM_ERROR, x1_arg, "internal assembler error CX for \\//2");
save_machine_regs(); save_machine_regs();
longjmp(_YAP_CompilerBotch, 1); longjmp(Yap_CompilerBotch, 1);
break; break;
case _sll: case _sll:
code_p->opc = emit_op(_p_sll_cv); code_p->opc = emit_op(_p_sll_cv);
@ -1902,9 +1902,9 @@ a_f2(int var)
code_p->opc = emit_op(_p_plus_vc); code_p->opc = emit_op(_p_plus_vc);
break; break;
case _minus: case _minus:
_YAP_Error(SYSTEM_ERROR, x2_arg, "internal assembler error XC for -/2"); Yap_Error(SYSTEM_ERROR, x2_arg, "internal assembler error XC for -/2");
save_machine_regs(); save_machine_regs();
longjmp(_YAP_CompilerBotch, 1); longjmp(Yap_CompilerBotch, 1);
break; break;
case _times: case _times:
code_p->opc = emit_op(_p_times_vc); code_p->opc = emit_op(_p_times_vc);
@ -1925,9 +1925,9 @@ a_f2(int var)
code_p->opc = emit_op(_p_slr_vc); code_p->opc = emit_op(_p_slr_vc);
break; break;
case _arg: case _arg:
_YAP_Error(SYSTEM_ERROR, x2_arg, "internal assembler error for arg/3"); Yap_Error(SYSTEM_ERROR, x2_arg, "internal assembler error for arg/3");
save_machine_regs(); save_machine_regs();
longjmp(_YAP_CompilerBotch, 1); longjmp(Yap_CompilerBotch, 1);
break; break;
case _functor: case _functor:
code_p->opc = emit_op(_p_func2s_vc); code_p->opc = emit_op(_p_func2s_vc);
@ -1985,7 +1985,7 @@ do_pass(void)
cl_p->ClFlags |= HasBlobsMask; cl_p->ClFlags |= HasBlobsMask;
} }
cl_p->u2.ClExt = NULL; cl_p->u2.ClExt = NULL;
cl_p->Owner = _YAP_ConsultingFile(); cl_p->Owner = Yap_ConsultingFile();
} }
code_p = (yamop *)(cl_p->ClCode); code_p = (yamop *)(cl_p->ClCode);
IPredArity = cpc->rnd2; /* number of args */ IPredArity = cpc->rnd2; /* number of args */
@ -2396,7 +2396,7 @@ do_pass(void)
if (!pass_no) { if (!pass_no) {
if (CellPtr(label_offset+cpc->rnd1) > ASP-256) { if (CellPtr(label_offset+cpc->rnd1) > ASP-256) {
save_machine_regs(); save_machine_regs();
longjmp(_YAP_CompilerBotch,3); longjmp(Yap_CompilerBotch,3);
} }
if ( (char *)(label_offset+cpc->rnd1) > freep) if ( (char *)(label_offset+cpc->rnd1) > freep)
@ -2545,9 +2545,9 @@ do_pass(void)
break; break;
case fetch_args_for_bccall: case fetch_args_for_bccall:
if (cpc->nextInst->op != bccall_op) { if (cpc->nextInst->op != bccall_op) {
_YAP_Error(SYSTEM_ERROR, TermNil, "compiling binary test", (int) cpc->op); Yap_Error(SYSTEM_ERROR, TermNil, "compiling binary test", (int) cpc->op);
save_machine_regs(); save_machine_regs();
longjmp(_YAP_CompilerBotch, 1); longjmp(Yap_CompilerBotch, 1);
} }
a_bfunc(cpc->nextInst->rnd2); a_bfunc(cpc->nextInst->rnd2);
break; break;
@ -2566,9 +2566,9 @@ do_pass(void)
case name_op: case name_op:
break; break;
default: default:
_YAP_Error(SYSTEM_ERROR, TermNil, "instruction %d found while assembling", (int) cpc->op); Yap_Error(SYSTEM_ERROR, TermNil, "instruction %d found while assembling", (int) cpc->op);
save_machine_regs(); save_machine_regs();
longjmp(_YAP_CompilerBotch, 1); longjmp(Yap_CompilerBotch, 1);
} }
cpc = cpc->nextInst; cpc = cpc->nextInst;
} }
@ -2577,7 +2577,7 @@ do_pass(void)
} }
CODEADDR CODEADDR
_YAP_assemble(int mode) Yap_assemble(int mode)
{ {
/* /*
* the assembly proccess is done in two passes: 1 - a first pass * the assembly proccess is done in two passes: 1 - a first pass
@ -2594,8 +2594,8 @@ _YAP_assemble(int mode)
asm_error = FALSE; asm_error = FALSE;
do_pass(); do_pass();
if (asm_error) { if (asm_error) {
_YAP_Error_TYPE = SYSTEM_ERROR; Yap_Error_TYPE = SYSTEM_ERROR;
_YAP_ErrorMessage = "internal assembler error"; Yap_ErrorMessage = "internal assembler error";
return (NIL); return (NIL);
} }
pass_no = 1; pass_no = 1;
@ -2610,9 +2610,9 @@ _YAP_assemble(int mode)
#else #else
size = (CELL)code_p; size = (CELL)code_p;
#endif #endif
while ((code_addr = (CODEADDR) _YAP_AllocCodeSpace(size)) == NULL) { while ((code_addr = (CODEADDR) Yap_AllocCodeSpace(size)) == NULL) {
if (!_YAP_growheap(TRUE)) { if (!Yap_growheap(TRUE)) {
_YAP_Error_TYPE = SYSTEM_ERROR; Yap_Error_TYPE = SYSTEM_ERROR;
return (NIL); return (NIL);
} }
} }

686
C/analyst.c
View File

File diff suppressed because it is too large Load Diff

26
C/arith0.c
View File

@ -68,12 +68,12 @@ static E_FUNC
p_inf(E_ARGS) p_inf(E_ARGS)
{ {
#ifdef _MSC_VER /* Microsoft's Visual C++ Compiler */ #ifdef _MSC_VER /* Microsoft's Visual C++ Compiler */
_YAP_Error(TYPE_ERROR_EVALUABLE, TermNil, "evaluating infinity"); Yap_Error(TYPE_ERROR_EVALUABLE, TermNil, "evaluating infinity");
P = (yamop *)FAILCODE; P = (yamop *)FAILCODE;
RERROR(); RERROR();
#else #else
if (yap_flags[LANGUAGE_MODE_FLAG] == 1) {/* iso */ if (yap_flags[LANGUAGE_MODE_FLAG] == 1) {/* iso */
_YAP_Error(TYPE_ERROR_EVALUABLE, TermNil, "evaluating infinity"); Yap_Error(TYPE_ERROR_EVALUABLE, TermNil, "evaluating infinity");
P = (yamop *)FAILCODE; P = (yamop *)FAILCODE;
RERROR(); RERROR();
} else { } else {
@ -91,12 +91,12 @@ static E_FUNC
p_nan(E_ARGS) p_nan(E_ARGS)
{ {
#ifdef _MSC_VER /* Microsoft's Visual C++ Compiler */ #ifdef _MSC_VER /* Microsoft's Visual C++ Compiler */
_YAP_Error(TYPE_ERROR_EVALUABLE, TermNil, "evaluating infinity"); Yap_Error(TYPE_ERROR_EVALUABLE, TermNil, "evaluating infinity");
P = (yamop *)FAILCODE; P = (yamop *)FAILCODE;
RERROR(); RERROR();
#else #else
if (yap_flags[LANGUAGE_MODE_FLAG] == 1) {/* iso */ if (yap_flags[LANGUAGE_MODE_FLAG] == 1) {/* iso */
_YAP_Error(TYPE_ERROR_EVALUABLE, TermNil, "evaluating not-a-number"); Yap_Error(TYPE_ERROR_EVALUABLE, TermNil, "evaluating not-a-number");
P = (yamop *)FAILCODE; P = (yamop *)FAILCODE;
RERROR(); RERROR();
} else { } else {
@ -108,13 +108,13 @@ p_nan(E_ARGS)
static E_FUNC static E_FUNC
p_random(E_ARGS) p_random(E_ARGS)
{ {
RFLOAT(_YAP_random()); RFLOAT(Yap_random());
} }
static E_FUNC static E_FUNC
p_cputime(E_ARGS) p_cputime(E_ARGS)
{ {
RFLOAT((Float)_YAP_cputime()/1000.0); RFLOAT((Float)Yap_cputime()/1000.0);
} }
static E_FUNC static E_FUNC
@ -204,19 +204,19 @@ static InitConstEntry InitConstTab[] = {
}; };
void void
_YAP_InitConstExps(void) Yap_InitConstExps(void)
{ {
unsigned int i; unsigned int i;
ExpEntry *p; ExpEntry *p;
for (i = 0; i < sizeof(InitConstTab)/sizeof(InitConstEntry); ++i) { for (i = 0; i < sizeof(InitConstTab)/sizeof(InitConstEntry); ++i) {
AtomEntry *ae = RepAtom(_YAP_LookupAtom(InitConstTab[i].OpName)); AtomEntry *ae = RepAtom(Yap_LookupAtom(InitConstTab[i].OpName));
WRITE_LOCK(ae->ARWLock); WRITE_LOCK(ae->ARWLock);
if (_YAP_GetExpPropHavingLock(ae, 0)) { if (Yap_GetExpPropHavingLock(ae, 0)) {
WRITE_UNLOCK(ae->ARWLock); WRITE_UNLOCK(ae->ARWLock);
break; break;
} }
p = (ExpEntry *) _YAP_AllocAtomSpace(sizeof(ExpEntry)); p = (ExpEntry *) Yap_AllocAtomSpace(sizeof(ExpEntry));
p->KindOfPE = ExpProperty; p->KindOfPE = ExpProperty;
p->ArityOfEE = 0; p->ArityOfEE = 0;
p->ENoOfEE = 0; p->ENoOfEE = 0;
@ -229,16 +229,16 @@ _YAP_InitConstExps(void)
/* This routine is called from Restore to make sure we have the same arithmetic operators */ /* This routine is called from Restore to make sure we have the same arithmetic operators */
int int
_YAP_ReInitConstExps(void) Yap_ReInitConstExps(void)
{ {
unsigned int i; unsigned int i;
Prop p; Prop p;
for (i = 0; i < sizeof(InitConstTab)/sizeof(InitConstEntry); ++i) { for (i = 0; i < sizeof(InitConstTab)/sizeof(InitConstEntry); ++i) {
AtomEntry *ae = RepAtom(_YAP_FullLookupAtom(InitConstTab[i].OpName)); AtomEntry *ae = RepAtom(Yap_FullLookupAtom(InitConstTab[i].OpName));
WRITE_LOCK(ae->ARWLock); WRITE_LOCK(ae->ARWLock);
if ((p = _YAP_GetExpPropHavingLock(ae, 0)) == NULL) { if ((p = Yap_GetExpPropHavingLock(ae, 0)) == NULL) {
WRITE_UNLOCK(ae->ARWLock); WRITE_UNLOCK(ae->ARWLock);
return(FALSE); return(FALSE);
} }

406
C/arith1.c
View File

File diff suppressed because it is too large Load Diff

312
C/arith2.c
View File

@ -37,7 +37,7 @@ static char SccsId[] = "%W% %G%";
#define RBIG(v) (o)->big = v; return(big_int_e) #define RBIG(v) (o)->big = v; return(big_int_e)
#define RERROR() return(db_ref_e) #define RERROR() return(db_ref_e)
#define ArithIEval(t,v) _YAP_Eval(t,v) #define ArithIEval(t,v) Yap_Eval(t,v)
inline static Functor inline static Functor
AritFunctorOfTerm(Term t) { AritFunctorOfTerm(Term t) {
@ -64,7 +64,7 @@ EvalToTerm(blob_type f, union arith_ret *res)
return(MkFloatTerm(res->dbl)); return(MkFloatTerm(res->dbl));
#ifdef USE_GMP #ifdef USE_GMP
case big_int_e: case big_int_e:
return(_YAP_MkBigIntTerm(res->big)); return(Yap_MkBigIntTerm(res->big));
#endif #endif
default: default:
return(TermNil); return(TermNil);
@ -104,7 +104,7 @@ p_mod(Term t1, Term t2 E_ARGS)
RINT(IntegerOfTerm(t1) % i2); RINT(IntegerOfTerm(t1) % i2);
} }
case (CELL)double_e: case (CELL)double_e:
_YAP_Error(TYPE_ERROR_INTEGER, t2, "mod/2"); Yap_Error(TYPE_ERROR_INTEGER, t2, "mod/2");
/* make GCC happy */ /* make GCC happy */
P = (yamop *)FAILCODE; P = (yamop *)FAILCODE;
RERROR(); RERROR();
@ -117,11 +117,11 @@ p_mod(Term t1, Term t2 E_ARGS)
/* we've got a full term, need to evaluate it first */ /* we've got a full term, need to evaluate it first */
v1.Int = IntegerOfTerm(t1); v1.Int = IntegerOfTerm(t1);
bt1 = long_int_e; bt1 = long_int_e;
bt2 = _YAP_Eval(t2, &v2); bt2 = Yap_Eval(t2, &v2);
} }
break; break;
case (CELL)double_e: case (CELL)double_e:
_YAP_Error(TYPE_ERROR_INTEGER, t1, "mod/2"); Yap_Error(TYPE_ERROR_INTEGER, t1, "mod/2");
P = (yamop *)FAILCODE; P = (yamop *)FAILCODE;
RERROR(); RERROR();
#ifdef USE_GMP #ifdef USE_GMP
@ -133,50 +133,50 @@ p_mod(Term t1, Term t2 E_ARGS)
/* modulo between bignum and integer */ /* modulo between bignum and integer */
{ {
Int i2 = IntegerOfTerm(t2); Int i2 = IntegerOfTerm(t2);
MP_INT *l1 = _YAP_BigIntOfTerm(t1); MP_INT *l1 = Yap_BigIntOfTerm(t1);
if (i2 > 0) { if (i2 > 0) {
MP_INT *new = _YAP_PreAllocBigNum(); MP_INT *new = Yap_PreAllocBigNum();
Int r = mpz_mod_ui(new, l1, i2); Int r = mpz_mod_ui(new, l1, i2);
_YAP_CleanBigNum(); Yap_CleanBigNum();
RINT((mpz_sgn(l1) ? r : -r)); RINT((mpz_sgn(l1) ? r : -r));
} else if (i2 == 0) { } else if (i2 == 0) {
goto zero_divisor; goto zero_divisor;
} else { } else {
MP_INT *new = _YAP_PreAllocBigNum(); MP_INT *new = Yap_PreAllocBigNum();
Int r = mpz_mod_ui(new, l1, -i2); Int r = mpz_mod_ui(new, l1, -i2);
_YAP_CleanBigNum(); Yap_CleanBigNum();
RINT((mpz_sgn(l1) ? r : -r)); RINT((mpz_sgn(l1) ? r : -r));
} }
} }
case (CELL)big_int_e: case (CELL)big_int_e:
/* two bignums */ /* two bignums */
{ {
MP_INT *new = _YAP_PreAllocBigNum(); MP_INT *new = Yap_PreAllocBigNum();
mpz_mod(new, _YAP_BigIntOfTerm(t1), _YAP_BigIntOfTerm(t2)); mpz_mod(new, Yap_BigIntOfTerm(t1), Yap_BigIntOfTerm(t2));
RBIG(new); RBIG(new);
} }
case double_e: case double_e:
_YAP_Error(TYPE_ERROR_INTEGER, t2, "mod/2"); Yap_Error(TYPE_ERROR_INTEGER, t2, "mod/2");
/* make GCC happy */ /* make GCC happy */
P = (yamop *)FAILCODE; P = (yamop *)FAILCODE;
RERROR(); RERROR();
default: default:
/* we've got a full term, need to evaluate it first */ /* we've got a full term, need to evaluate it first */
v1.big = _YAP_BigIntOfTerm(t1); v1.big = Yap_BigIntOfTerm(t1);
bt1 = big_int_e; bt1 = big_int_e;
bt2 = _YAP_Eval(t2, &v2); bt2 = Yap_Eval(t2, &v2);
break; break;
} }
#endif #endif
default: default:
/* we've got a full term, need to evaluate it first */ /* we've got a full term, need to evaluate it first */
bt1 = _YAP_Eval(t1, &v1); bt1 = Yap_Eval(t1, &v1);
/* don't know anything about second */ /* don't know anything about second */
bt2 = _YAP_Eval(t2, &v2); bt2 = Yap_Eval(t2, &v2);
} }
/* second case, no need no evaluation */ /* second case, no need no evaluation */
switch (bt1) { switch (bt1) {
@ -187,7 +187,7 @@ p_mod(Term t1, Term t2 E_ARGS)
if (v2.Int == 0) goto zero_divisor; if (v2.Int == 0) goto zero_divisor;
RINT(v1.Int % v2.Int); RINT(v1.Int % v2.Int);
case double_e: case double_e:
_YAP_Error(TYPE_ERROR_INTEGER, MkFloatTerm(v2.dbl), "mod/2"); Yap_Error(TYPE_ERROR_INTEGER, MkFloatTerm(v2.dbl), "mod/2");
/* make GCC happy */ /* make GCC happy */
P = (yamop *)FAILCODE; P = (yamop *)FAILCODE;
RERROR(); RERROR();
@ -197,11 +197,11 @@ p_mod(Term t1, Term t2 E_ARGS)
RINT(v1.Int); RINT(v1.Int);
#endif #endif
default: default:
/* _YAP_Error */ /* Yap_Error */
RERROR(); RERROR();
} }
case double_e: case double_e:
_YAP_Error(TYPE_ERROR_INTEGER, MkFloatTerm(v1.dbl), "mod/2"); Yap_Error(TYPE_ERROR_INTEGER, MkFloatTerm(v1.dbl), "mod/2");
P = (yamop *)FAILCODE; P = (yamop *)FAILCODE;
RERROR(); RERROR();
#ifdef USE_GMP #ifdef USE_GMP
@ -210,30 +210,30 @@ p_mod(Term t1, Term t2 E_ARGS)
case long_int_e: case long_int_e:
/* big mod integer */ /* big mod integer */
if (v2.Int > 0) { if (v2.Int > 0) {
MP_INT *new = _YAP_PreAllocBigNum(); MP_INT *new = Yap_PreAllocBigNum();
Int r = mpz_mod_ui(new, v1.big, v2.Int); Int r = mpz_mod_ui(new, v1.big, v2.Int);
_YAP_CleanBigNum(); Yap_CleanBigNum();
RINT((mpz_sgn(v1.big) ? r : -r)); RINT((mpz_sgn(v1.big) ? r : -r));
} else if (v2.Int == 0) { } else if (v2.Int == 0) {
goto zero_divisor; goto zero_divisor;
} else { } else {
MP_INT *new = _YAP_PreAllocBigNum(); MP_INT *new = Yap_PreAllocBigNum();
Int r = mpz_mod_ui(new, v1.big, -v2.Int); Int r = mpz_mod_ui(new, v1.big, -v2.Int);
_YAP_CleanBigNum(); Yap_CleanBigNum();
RINT((mpz_sgn(v1.big) ? r : -r)); RINT((mpz_sgn(v1.big) ? r : -r));
} }
case double_e: case double_e:
/* big // float */ /* big // float */
_YAP_Error(TYPE_ERROR_INTEGER, MkFloatTerm(v2.dbl), "mod/2"); Yap_Error(TYPE_ERROR_INTEGER, MkFloatTerm(v2.dbl), "mod/2");
/* make GCC happy */ /* make GCC happy */
P = (yamop *)FAILCODE; P = (yamop *)FAILCODE;
RERROR(); RERROR();
case (CELL)big_int_e: case (CELL)big_int_e:
/* big * big */ /* big * big */
{ {
MP_INT *new = _YAP_PreAllocBigNum(); MP_INT *new = Yap_PreAllocBigNum();
mpz_mod(new, v1.big, v2.big); mpz_mod(new, v1.big, v2.big);
RBIG(new); RBIG(new);
@ -248,7 +248,7 @@ p_mod(Term t1, Term t2 E_ARGS)
RERROR(); RERROR();
} }
zero_divisor: zero_divisor:
_YAP_Error(EVALUATION_ERROR_ZERO_DIVISOR, t2, "X is mod 0"); Yap_Error(EVALUATION_ERROR_ZERO_DIVISOR, t2, "X is mod 0");
/* make GCC happy */ /* make GCC happy */
P = (yamop *)FAILCODE; P = (yamop *)FAILCODE;
RERROR(); RERROR();
@ -264,14 +264,14 @@ fdiv_bigint(MP_INT *b1,MP_INT *b2)
mpf_t f1,f2; mpf_t f1,f2;
Float res; Float res;
_YAP_PreAllocBigNum(); Yap_PreAllocBigNum();
mpf_init(f1); mpf_init(f1);
mpf_init(f2); mpf_init(f2);
mpf_set_z(f1, b1); mpf_set_z(f1, b1);
mpf_set_z(f2, b2); mpf_set_z(f2, b2);
mpf_div(f1, f1, f2); mpf_div(f1, f1, f2);
res = mpf_get_d(f1); res = mpf_get_d(f1);
_YAP_CleanBigNum(); Yap_CleanBigNum();
return(res); return(res);
} else { } else {
return(f1/f2); return(f1/f2);
@ -312,7 +312,7 @@ p_fdiv(Term t1, Term t2 E_ARGS)
case (CELL)big_int_e: case (CELL)big_int_e:
{ {
Int i1 = IntegerOfTerm(t1); Int i1 = IntegerOfTerm(t1);
Float f2 = mpz_get_d(_YAP_BigIntOfTerm(t2)); Float f2 = mpz_get_d(Yap_BigIntOfTerm(t2));
RFLOAT(i1/f2); RFLOAT(i1/f2);
} }
#endif #endif
@ -320,7 +320,7 @@ p_fdiv(Term t1, Term t2 E_ARGS)
/* we've got a full term, need to evaluate it first */ /* we've got a full term, need to evaluate it first */
v1.Int = IntegerOfTerm(t1); v1.Int = IntegerOfTerm(t1);
bt1 = long_int_e; bt1 = long_int_e;
bt2 = _YAP_Eval(t2, &v2); bt2 = Yap_Eval(t2, &v2);
} }
break; break;
case double_e: case double_e:
@ -341,14 +341,14 @@ p_fdiv(Term t1, Term t2 E_ARGS)
#ifdef USE_GMP #ifdef USE_GMP
case big_int_e: case big_int_e:
{ {
RFLOAT(FloatOfTerm(t1)/mpz_get_d(_YAP_BigIntOfTerm(t2))); RFLOAT(FloatOfTerm(t1)/mpz_get_d(Yap_BigIntOfTerm(t2)));
} }
#endif #endif
default: default:
/* we've got a full term, need to evaluate it first */ /* we've got a full term, need to evaluate it first */
v1.dbl = FloatOfTerm(t1); v1.dbl = FloatOfTerm(t1);
bt1 = double_e; bt1 = double_e;
bt2 = _YAP_Eval(t2, &v2); bt2 = Yap_Eval(t2, &v2);
} }
break; break;
#ifdef USE_GMP #ifdef USE_GMP
@ -359,30 +359,30 @@ p_fdiv(Term t1, Term t2 E_ARGS)
case long_int_e: case long_int_e:
{ {
Int i = IntegerOfTerm(t2); Int i = IntegerOfTerm(t2);
RFLOAT(mpz_get_d(_YAP_BigIntOfTerm(t1))/(Float)i); RFLOAT(mpz_get_d(Yap_BigIntOfTerm(t1))/(Float)i);
} }
case big_int_e: case big_int_e:
/* two bignums*/ /* two bignums*/
RFLOAT(fdiv_bigint(_YAP_BigIntOfTerm(t1),_YAP_BigIntOfTerm(t2))); RFLOAT(fdiv_bigint(Yap_BigIntOfTerm(t1),Yap_BigIntOfTerm(t2)));
// RFLOAT(mpz_get_d(_YAP_BigIntOfTerm(t1))/mpz_get_d(_YAP_BigIntOfTerm(t2))); // RFLOAT(mpz_get_d(Yap_BigIntOfTerm(t1))/mpz_get_d(Yap_BigIntOfTerm(t2)));
case double_e: case double_e:
{ {
Float dbl = FloatOfTerm(t2); Float dbl = FloatOfTerm(t2);
RFLOAT(mpz_get_d(_YAP_BigIntOfTerm(t1))/dbl); RFLOAT(mpz_get_d(Yap_BigIntOfTerm(t1))/dbl);
} }
default: default:
/* we've got a full term, need to evaluate it first */ /* we've got a full term, need to evaluate it first */
v1.big = _YAP_BigIntOfTerm(t1); v1.big = Yap_BigIntOfTerm(t1);
bt1 = big_int_e; bt1 = big_int_e;
bt2 = _YAP_Eval(t2, &v2); bt2 = Yap_Eval(t2, &v2);
break; break;
} }
#endif #endif
default: default:
/* we've got a full term, need to evaluate it first */ /* we've got a full term, need to evaluate it first */
bt1 = _YAP_Eval(t1, &v1); bt1 = Yap_Eval(t1, &v1);
/* don't know anything about second */ /* don't know anything about second */
bt2 = _YAP_Eval(t2, &v2); bt2 = Yap_Eval(t2, &v2);
} }
/* second case, no need no evaluation */ /* second case, no need no evaluation */
switch (bt1) { switch (bt1) {
@ -400,7 +400,7 @@ p_fdiv(Term t1, Term t2 E_ARGS)
RFLOAT(v1.Int/mpz_get_d(v2.big)); RFLOAT(v1.Int/mpz_get_d(v2.big));
#endif #endif
default: default:
/* _YAP_Error */ /* Yap_Error */
RERROR(); RERROR();
} }
case double_e: case double_e:
@ -447,7 +447,7 @@ p_fdiv(Term t1, Term t2 E_ARGS)
static void static void
mpz_xor(MP_INT *new, MP_INT *r1, MP_INT *r2) mpz_xor(MP_INT *new, MP_INT *r1, MP_INT *r2)
{ {
MP_INT *n2 = _YAP_PreAllocBigNum(), *n3 = _YAP_PreAllocBigNum(); MP_INT *n2 = Yap_PreAllocBigNum(), *n3 = Yap_PreAllocBigNum();
mpz_ior(new, r1, r2); mpz_ior(new, r1, r2);
mpz_com(n2, r1); mpz_com(n2, r1);
@ -455,7 +455,7 @@ mpz_xor(MP_INT *new, MP_INT *r1, MP_INT *r2)
mpz_com(n3, r2); mpz_com(n3, r2);
mpz_and(n3, n3, new); mpz_and(n3, n3, new);
mpz_ior(new, n2, n3); mpz_ior(new, n2, n3);
_YAP_CleanBigNum(); Yap_CleanBigNum();
} }
#endif #endif
#endif #endif
@ -479,16 +479,16 @@ p_xor(Term t1, Term t2 E_ARGS)
/* two integers */ /* two integers */
RINT(IntegerOfTerm(t1) ^ IntegerOfTerm(t2)); RINT(IntegerOfTerm(t1) ^ IntegerOfTerm(t2));
case double_e: case double_e:
_YAP_Error(TYPE_ERROR_INTEGER, t2, "#/2"); Yap_Error(TYPE_ERROR_INTEGER, t2, "#/2");
P = (yamop *)FAILCODE; P = (yamop *)FAILCODE;
RERROR(); RERROR();
#ifdef USE_GMP #ifdef USE_GMP
case big_int_e: case big_int_e:
{ {
MP_INT *new = _YAP_PreAllocBigNum(); MP_INT *new = Yap_PreAllocBigNum();
mpz_set_si(new,IntOfTerm(t1)); mpz_set_si(new,IntOfTerm(t1));
mpz_xor(new, new, _YAP_BigIntOfTerm(t2)); mpz_xor(new, new, Yap_BigIntOfTerm(t2));
RBIG(new); RBIG(new);
} }
#endif #endif
@ -496,11 +496,11 @@ p_xor(Term t1, Term t2 E_ARGS)
/* we've got a full term, need to evaluate it first */ /* we've got a full term, need to evaluate it first */
v1.Int = IntegerOfTerm(t1); v1.Int = IntegerOfTerm(t1);
bt1 = long_int_e; bt1 = long_int_e;
bt2 = _YAP_Eval(t2, &v2); bt2 = Yap_Eval(t2, &v2);
} }
break; break;
case double_e: case double_e:
_YAP_Error(TYPE_ERROR_INTEGER, t1, "#/2"); Yap_Error(TYPE_ERROR_INTEGER, t1, "#/2");
P = (yamop *)FAILCODE; P = (yamop *)FAILCODE;
RERROR(); RERROR();
#ifdef USE_GMP #ifdef USE_GMP
@ -510,38 +510,38 @@ p_xor(Term t1, Term t2 E_ARGS)
switch (BlobOfFunctor(f2)) { switch (BlobOfFunctor(f2)) {
case long_int_e: case long_int_e:
{ {
MP_INT *new = _YAP_PreAllocBigNum(); MP_INT *new = Yap_PreAllocBigNum();
mpz_set_si(new,IntOfTerm(t2)); mpz_set_si(new,IntOfTerm(t2));
mpz_xor(new, _YAP_BigIntOfTerm(t1), new); mpz_xor(new, Yap_BigIntOfTerm(t1), new);
RBIG(new); RBIG(new);
} }
case big_int_e: case big_int_e:
/* two bignums */ /* two bignums */
{ {
MP_INT *new = _YAP_PreAllocBigNum(); MP_INT *new = Yap_PreAllocBigNum();
mpz_xor(new, _YAP_BigIntOfTerm(t1), _YAP_BigIntOfTerm(t2)); mpz_xor(new, Yap_BigIntOfTerm(t1), Yap_BigIntOfTerm(t2));
RBIG(new); RBIG(new);
} }
case double_e: case double_e:
_YAP_Error(TYPE_ERROR_INTEGER, t2, "#/2"); Yap_Error(TYPE_ERROR_INTEGER, t2, "#/2");
/* make GCC happy */ /* make GCC happy */
P = (yamop *)FAILCODE; P = (yamop *)FAILCODE;
RERROR(); RERROR();
default: default:
/* we've got a full term, need to evaluate it first */ /* we've got a full term, need to evaluate it first */
v1.big = _YAP_BigIntOfTerm(t1); v1.big = Yap_BigIntOfTerm(t1);
bt1 = big_int_e; bt1 = big_int_e;
bt2 = _YAP_Eval(t2, &v2); bt2 = Yap_Eval(t2, &v2);
break; break;
} }
#endif #endif
default: default:
/* we've got a full term, need to evaluate it first */ /* we've got a full term, need to evaluate it first */
bt1 = _YAP_Eval(t1, &v1); bt1 = Yap_Eval(t1, &v1);
/* don't know anything about second */ /* don't know anything about second */
bt2 = _YAP_Eval(t2, &v2); bt2 = Yap_Eval(t2, &v2);
} }
/* second case, no need no evaluation */ /* second case, no need no evaluation */
switch (bt1) { switch (bt1) {
@ -550,14 +550,14 @@ p_xor(Term t1, Term t2 E_ARGS)
case long_int_e: case long_int_e:
RINT(v1.Int ^ v2.Int); RINT(v1.Int ^ v2.Int);
case double_e: case double_e:
_YAP_Error(TYPE_ERROR_INTEGER, MkFloatTerm(v2.dbl), "#/2"); Yap_Error(TYPE_ERROR_INTEGER, MkFloatTerm(v2.dbl), "#/2");
/* make GCC happy */ /* make GCC happy */
P = (yamop *)FAILCODE; P = (yamop *)FAILCODE;
RERROR(); RERROR();
#ifdef USE_GMP #ifdef USE_GMP
case big_int_e: case big_int_e:
{ {
MP_INT *new = _YAP_PreAllocBigNum(); MP_INT *new = Yap_PreAllocBigNum();
mpz_set_si(new,v1.Int); mpz_set_si(new,v1.Int);
mpz_xor(new, new, v2.big); mpz_xor(new, new, v2.big);
@ -565,11 +565,11 @@ p_xor(Term t1, Term t2 E_ARGS)
} }
#endif #endif
default: default:
/* _YAP_Error */ /* Yap_Error */
RERROR(); RERROR();
} }
case double_e: case double_e:
_YAP_Error(TYPE_ERROR_INTEGER, MkFloatTerm(v1.dbl), "#/2"); Yap_Error(TYPE_ERROR_INTEGER, MkFloatTerm(v1.dbl), "#/2");
P = (yamop *)FAILCODE; P = (yamop *)FAILCODE;
RERROR(); RERROR();
#ifdef USE_GMP #ifdef USE_GMP
@ -578,7 +578,7 @@ p_xor(Term t1, Term t2 E_ARGS)
case long_int_e: case long_int_e:
/* anding a bignum with an integer is easy */ /* anding a bignum with an integer is easy */
{ {
MP_INT *new = _YAP_PreAllocBigNum(); MP_INT *new = Yap_PreAllocBigNum();
mpz_set_si(new,v2.Int); mpz_set_si(new,v2.Int);
mpz_xor(new, v1.big, new); mpz_xor(new, v1.big, new);
@ -586,14 +586,14 @@ p_xor(Term t1, Term t2 E_ARGS)
} }
case double_e: case double_e:
/* big // float */ /* big // float */
_YAP_Error(TYPE_ERROR_INTEGER, MkFloatTerm(v2.dbl), "\\/ /2"); Yap_Error(TYPE_ERROR_INTEGER, MkFloatTerm(v2.dbl), "\\/ /2");
/* make GCC happy */ /* make GCC happy */
P = (yamop *)FAILCODE; P = (yamop *)FAILCODE;
RERROR(); RERROR();
case big_int_e: case big_int_e:
/* big * big */ /* big * big */
{ {
MP_INT *new = _YAP_PreAllocBigNum(); MP_INT *new = Yap_PreAllocBigNum();
mpz_xor(new, v1.big, v2.big); mpz_xor(new, v1.big, v2.big);
RBIG(new); RBIG(new);
@ -642,7 +642,7 @@ p_atan2(Term t1, Term t2 E_ARGS)
case big_int_e: case big_int_e:
{ {
Int i1 = IntegerOfTerm(t1); Int i1 = IntegerOfTerm(t1);
Float f2 = mpz_get_d(_YAP_BigIntOfTerm(t2)); Float f2 = mpz_get_d(Yap_BigIntOfTerm(t2));
RFLOAT(atan2(i1,f2)); RFLOAT(atan2(i1,f2));
} }
#endif #endif
@ -650,7 +650,7 @@ p_atan2(Term t1, Term t2 E_ARGS)
/* we've got a full term, need to evaluate it first */ /* we've got a full term, need to evaluate it first */
v1.Int = IntegerOfTerm(t1); v1.Int = IntegerOfTerm(t1);
bt1 = long_int_e; bt1 = long_int_e;
bt2 = _YAP_Eval(t2, &v2); bt2 = Yap_Eval(t2, &v2);
} }
break; break;
case double_e: case double_e:
@ -671,14 +671,14 @@ p_atan2(Term t1, Term t2 E_ARGS)
#ifdef USE_GMP #ifdef USE_GMP
case big_int_e: case big_int_e:
{ {
RFLOAT(atan2(FloatOfTerm(t1),mpz_get_d(_YAP_BigIntOfTerm(t2)))); RFLOAT(atan2(FloatOfTerm(t1),mpz_get_d(Yap_BigIntOfTerm(t2))));
} }
#endif #endif
default: default:
/* we've got a full term, need to evaluate it first */ /* we've got a full term, need to evaluate it first */
v1.dbl = FloatOfTerm(t1); v1.dbl = FloatOfTerm(t1);
bt1 = double_e; bt1 = double_e;
bt2 = _YAP_Eval(t2, &v2); bt2 = Yap_Eval(t2, &v2);
} }
break; break;
#ifdef USE_GMP #ifdef USE_GMP
@ -689,29 +689,29 @@ p_atan2(Term t1, Term t2 E_ARGS)
case long_int_e: case long_int_e:
{ {
Int i = IntegerOfTerm(t2); Int i = IntegerOfTerm(t2);
RFLOAT(atan2(mpz_get_d(_YAP_BigIntOfTerm(t1)),i)); RFLOAT(atan2(mpz_get_d(Yap_BigIntOfTerm(t1)),i));
} }
case big_int_e: case big_int_e:
/* two bignums */ /* two bignums */
RFLOAT(atan2(mpz_get_d(_YAP_BigIntOfTerm(t1)),mpz_get_d(_YAP_BigIntOfTerm(t2)))); RFLOAT(atan2(mpz_get_d(Yap_BigIntOfTerm(t1)),mpz_get_d(Yap_BigIntOfTerm(t2))));
case double_e: case double_e:
{ {
Float dbl = FloatOfTerm(t2); Float dbl = FloatOfTerm(t2);
RFLOAT(atan2(mpz_get_d(_YAP_BigIntOfTerm(t1)),dbl)); RFLOAT(atan2(mpz_get_d(Yap_BigIntOfTerm(t1)),dbl));
} }
default: default:
/* we've got a full term, need to evaluate it first */ /* we've got a full term, need to evaluate it first */
v1.big = _YAP_BigIntOfTerm(t1); v1.big = Yap_BigIntOfTerm(t1);
bt1 = big_int_e; bt1 = big_int_e;
bt2 = _YAP_Eval(t2, &v2); bt2 = Yap_Eval(t2, &v2);
break; break;
} }
#endif #endif
default: default:
/* we've got a full term, need to evaluate it first */ /* we've got a full term, need to evaluate it first */
bt1 = _YAP_Eval(t1, &v1); bt1 = Yap_Eval(t1, &v1);
/* don't know anything about second */ /* don't know anything about second */
bt2 = _YAP_Eval(t2, &v2); bt2 = Yap_Eval(t2, &v2);
} }
/* second case, no need no evaluation */ /* second case, no need no evaluation */
switch (bt1) { switch (bt1) {
@ -729,7 +729,7 @@ p_atan2(Term t1, Term t2 E_ARGS)
RFLOAT(atan2(v1.Int,mpz_get_d(v2.big))); RFLOAT(atan2(v1.Int,mpz_get_d(v2.big)));
#endif #endif
default: default:
/* _YAP_Error */ /* Yap_Error */
RERROR(); RERROR();
} }
case double_e: case double_e:
@ -804,7 +804,7 @@ p_power(Term t1, Term t2 E_ARGS)
case big_int_e: case big_int_e:
{ {
Int i1 = IntegerOfTerm(t1); Int i1 = IntegerOfTerm(t1);
Float f2 = mpz_get_d(_YAP_BigIntOfTerm(t2)); Float f2 = mpz_get_d(Yap_BigIntOfTerm(t2));
RFLOAT(pow(i1,f2)); RFLOAT(pow(i1,f2));
} }
#endif #endif
@ -812,7 +812,7 @@ p_power(Term t1, Term t2 E_ARGS)
/* we've got a full term, need to evaluate it first */ /* we've got a full term, need to evaluate it first */
v1.Int = IntegerOfTerm(t1); v1.Int = IntegerOfTerm(t1);
bt1 = long_int_e; bt1 = long_int_e;
bt2 = _YAP_Eval(t2, &v2); bt2 = Yap_Eval(t2, &v2);
} }
break; break;
case double_e: case double_e:
@ -833,14 +833,14 @@ p_power(Term t1, Term t2 E_ARGS)
#ifdef USE_GMP #ifdef USE_GMP
case big_int_e: case big_int_e:
{ {
RFLOAT(pow(FloatOfTerm(t1),mpz_get_d(_YAP_BigIntOfTerm(t2)))); RFLOAT(pow(FloatOfTerm(t1),mpz_get_d(Yap_BigIntOfTerm(t2))));
} }
#endif #endif
default: default:
/* we've got a full term, need to evaluate it first */ /* we've got a full term, need to evaluate it first */
v1.dbl = FloatOfTerm(t1); v1.dbl = FloatOfTerm(t1);
bt1 = double_e; bt1 = double_e;
bt2 = _YAP_Eval(t2, &v2); bt2 = Yap_Eval(t2, &v2);
} }
break; break;
#ifdef USE_GMP #ifdef USE_GMP
@ -851,29 +851,29 @@ p_power(Term t1, Term t2 E_ARGS)
case long_int_e: case long_int_e:
{ {
Int i = IntegerOfTerm(t2); Int i = IntegerOfTerm(t2);
RFLOAT(pow(mpz_get_d(_YAP_BigIntOfTerm(t1)),i)); RFLOAT(pow(mpz_get_d(Yap_BigIntOfTerm(t1)),i));
} }
case big_int_e: case big_int_e:
/* two bignums */ /* two bignums */
RFLOAT(pow(mpz_get_d(_YAP_BigIntOfTerm(t1)),mpz_get_d(_YAP_BigIntOfTerm(t2)))); RFLOAT(pow(mpz_get_d(Yap_BigIntOfTerm(t1)),mpz_get_d(Yap_BigIntOfTerm(t2))));
case double_e: case double_e:
{ {
Float dbl = FloatOfTerm(t2); Float dbl = FloatOfTerm(t2);
RFLOAT(pow(mpz_get_d(_YAP_BigIntOfTerm(t1)),dbl)); RFLOAT(pow(mpz_get_d(Yap_BigIntOfTerm(t1)),dbl));
} }
default: default:
/* we've got a full term, need to evaluate it first */ /* we've got a full term, need to evaluate it first */
v1.big = _YAP_BigIntOfTerm(t1); v1.big = Yap_BigIntOfTerm(t1);
bt1 = big_int_e; bt1 = big_int_e;
bt2 = _YAP_Eval(t2, &v2); bt2 = Yap_Eval(t2, &v2);
break; break;
} }
#endif #endif
default: default:
/* we've got a full term, need to evaluate it first */ /* we've got a full term, need to evaluate it first */
bt1 = _YAP_Eval(t1, &v1); bt1 = Yap_Eval(t1, &v1);
/* don't know anything about second */ /* don't know anything about second */
bt2 = _YAP_Eval(t2, &v2); bt2 = Yap_Eval(t2, &v2);
} }
/* second case, no need no evaluation */ /* second case, no need no evaluation */
switch (bt1) { switch (bt1) {
@ -891,7 +891,7 @@ p_power(Term t1, Term t2 E_ARGS)
RFLOAT(pow(v1.Int,mpz_get_d(v2.big))); RFLOAT(pow(v1.Int,mpz_get_d(v2.big)));
#endif #endif
default: default:
/* _YAP_Error */ /* Yap_Error */
RERROR(); RERROR();
} }
case double_e: case double_e:
@ -947,7 +947,7 @@ gcd(Int m11,Int m21)
} }
if (m11<0 || m21<0) { /* overflow? */ if (m11<0 || m21<0) { /* overflow? */
/* Oflow = 1; */ /* Oflow = 1; */
_YAP_Error(EVALUATION_ERROR_INT_OVERFLOW, MkIntegerTerm(m11), Yap_Error(EVALUATION_ERROR_INT_OVERFLOW, MkIntegerTerm(m11),
"gcd/2 with %d and %d", m11, m21); "gcd/2 with %d and %d", m11, m21);
P = (yamop *)FAILCODE; P = (yamop *)FAILCODE;
return(1); return(1);
@ -969,7 +969,7 @@ Int gcdmult(Int m11,Int m21,Int *pm11) /* *pm11 gets multiplier of m11 */
} }
if (m11<0 || m21<0) { /* overflow? */ if (m11<0 || m21<0) { /* overflow? */
/* Oflow = 1; */ /* Oflow = 1; */
_YAP_Error(EVALUATION_ERROR_INT_OVERFLOW, MkIntegerTerm(m11), Yap_Error(EVALUATION_ERROR_INT_OVERFLOW, MkIntegerTerm(m11),
"gcdmult/2 with %d and %d", m11, m21); "gcdmult/2 with %d and %d", m11, m21);
P = (yamop *)FAILCODE; P = (yamop *)FAILCODE;
return(1); return(1);
@ -1007,7 +1007,7 @@ p_gcd(Term t1, Term t2 E_ARGS)
RINT(gcd(i1,i2)); RINT(gcd(i1,i2));
} }
case double_e: case double_e:
_YAP_Error(TYPE_ERROR_INTEGER, t2, "gcd/2"); Yap_Error(TYPE_ERROR_INTEGER, t2, "gcd/2");
/* make GCC happy */ /* make GCC happy */
P = (yamop *)FAILCODE; P = (yamop *)FAILCODE;
RERROR(); RERROR();
@ -1018,14 +1018,14 @@ p_gcd(Term t1, Term t2 E_ARGS)
Int i = IntegerOfTerm(t1); Int i = IntegerOfTerm(t1);
if (i > 0) { if (i > 0) {
RINT(mpz_gcd_ui(NULL,_YAP_BigIntOfTerm(t2),i)); RINT(mpz_gcd_ui(NULL,Yap_BigIntOfTerm(t2),i));
} else if (i == 0) { } else if (i == 0) {
MP_INT *new = _YAP_PreAllocBigNum(); MP_INT *new = Yap_PreAllocBigNum();
mpz_abs(new, _YAP_BigIntOfTerm(t2)); mpz_abs(new, Yap_BigIntOfTerm(t2));
RBIG(new); RBIG(new);
} else { } else {
RINT(mpz_gcd_ui(NULL,_YAP_BigIntOfTerm(t2),-i)); RINT(mpz_gcd_ui(NULL,Yap_BigIntOfTerm(t2),-i));
} }
} }
#endif #endif
@ -1033,11 +1033,11 @@ p_gcd(Term t1, Term t2 E_ARGS)
/* we've got a full term, need to evaluate it first */ /* we've got a full term, need to evaluate it first */
v1.Int = IntegerOfTerm(t1); v1.Int = IntegerOfTerm(t1);
bt1 = long_int_e; bt1 = long_int_e;
bt2 = _YAP_Eval(t2, &v2); bt2 = Yap_Eval(t2, &v2);
} }
break; break;
case double_e: case double_e:
_YAP_Error(TYPE_ERROR_INTEGER, t1, "gcd/2"); Yap_Error(TYPE_ERROR_INTEGER, t1, "gcd/2");
P = (yamop *)FAILCODE; P = (yamop *)FAILCODE;
RERROR(); RERROR();
#ifdef USE_GMP #ifdef USE_GMP
@ -1051,42 +1051,42 @@ p_gcd(Term t1, Term t2 E_ARGS)
Int i = IntegerOfTerm(t2); Int i = IntegerOfTerm(t2);
if (i > 0) { if (i > 0) {
RINT(mpz_gcd_ui(NULL,_YAP_BigIntOfTerm(t1),i)); RINT(mpz_gcd_ui(NULL,Yap_BigIntOfTerm(t1),i));
} else if (i == 0) { } else if (i == 0) {
MP_INT *new = _YAP_PreAllocBigNum(); MP_INT *new = Yap_PreAllocBigNum();
mpz_abs(new, _YAP_BigIntOfTerm(t1)); mpz_abs(new, Yap_BigIntOfTerm(t1));
RBIG(new); RBIG(new);
} else { } else {
RINT(mpz_gcd_ui(NULL,_YAP_BigIntOfTerm(t1),-i)); RINT(mpz_gcd_ui(NULL,Yap_BigIntOfTerm(t1),-i));
} }
} }
case big_int_e: case big_int_e:
/* two bignums */ /* two bignums */
{ {
MP_INT *new = _YAP_PreAllocBigNum(); MP_INT *new = Yap_PreAllocBigNum();
mpz_gcd(new, _YAP_BigIntOfTerm(t1), _YAP_BigIntOfTerm(t2)); mpz_gcd(new, Yap_BigIntOfTerm(t1), Yap_BigIntOfTerm(t2));
RBIG(new); RBIG(new);
} }
case double_e: case double_e:
_YAP_Error(TYPE_ERROR_INTEGER, t2, "gcd/2"); Yap_Error(TYPE_ERROR_INTEGER, t2, "gcd/2");
/* make GCC happy */ /* make GCC happy */
P = (yamop *)FAILCODE; P = (yamop *)FAILCODE;
RERROR(); RERROR();
default: default:
/* we've got a full term, need to evaluate it first */ /* we've got a full term, need to evaluate it first */
v1.big = _YAP_BigIntOfTerm(t1); v1.big = Yap_BigIntOfTerm(t1);
bt1 = big_int_e; bt1 = big_int_e;
bt2 = _YAP_Eval(t2, &v2); bt2 = Yap_Eval(t2, &v2);
break; break;
} }
#endif #endif
default: default:
/* we've got a full term, need to evaluate it first */ /* we've got a full term, need to evaluate it first */
bt1 = _YAP_Eval(t1, &v1); bt1 = Yap_Eval(t1, &v1);
/* don't know anything about second */ /* don't know anything about second */
bt2 = _YAP_Eval(t2, &v2); bt2 = Yap_Eval(t2, &v2);
} }
/* second case, no need no evaluation */ /* second case, no need no evaluation */
switch (bt1) { switch (bt1) {
@ -1102,7 +1102,7 @@ p_gcd(Term t1, Term t2 E_ARGS)
RINT(gcd(i1,i2)); RINT(gcd(i1,i2));
} }
case double_e: case double_e:
_YAP_Error(TYPE_ERROR_INTEGER, MkFloatTerm(v2.dbl), "gcd/2"); Yap_Error(TYPE_ERROR_INTEGER, MkFloatTerm(v2.dbl), "gcd/2");
/* make GCC happy */ /* make GCC happy */
P = (yamop *)FAILCODE; P = (yamop *)FAILCODE;
RERROR(); RERROR();
@ -1112,7 +1112,7 @@ p_gcd(Term t1, Term t2 E_ARGS)
if (v1.Int > 0) { if (v1.Int > 0) {
RINT(mpz_gcd_ui(NULL,v2.big,v1.Int)); RINT(mpz_gcd_ui(NULL,v2.big,v1.Int));
} else if (v1.Int == 0) { } else if (v1.Int == 0) {
MP_INT *new = _YAP_PreAllocBigNum(); MP_INT *new = Yap_PreAllocBigNum();
mpz_abs(new, v2.big); mpz_abs(new, v2.big);
RBIG(new); RBIG(new);
@ -1122,11 +1122,11 @@ p_gcd(Term t1, Term t2 E_ARGS)
} }
#endif #endif
default: default:
/* _YAP_Error */ /* Yap_Error */
RERROR(); RERROR();
} }
case double_e: case double_e:
_YAP_Error(TYPE_ERROR_INTEGER, MkFloatTerm(v1.dbl), "gcd/2"); Yap_Error(TYPE_ERROR_INTEGER, MkFloatTerm(v1.dbl), "gcd/2");
P = (yamop *)FAILCODE; P = (yamop *)FAILCODE;
RERROR(); RERROR();
#ifdef USE_GMP #ifdef USE_GMP
@ -1138,7 +1138,7 @@ p_gcd(Term t1, Term t2 E_ARGS)
if (v2.Int > 0) { if (v2.Int > 0) {
RINT(mpz_gcd_ui(NULL,v1.big,v2.Int)); RINT(mpz_gcd_ui(NULL,v1.big,v2.Int));
} else if (v2.Int == 0) { } else if (v2.Int == 0) {
MP_INT *new = _YAP_PreAllocBigNum(); MP_INT *new = Yap_PreAllocBigNum();
mpz_abs(new, v1.big); mpz_abs(new, v1.big);
RBIG(new); RBIG(new);
@ -1148,13 +1148,13 @@ p_gcd(Term t1, Term t2 E_ARGS)
} }
case double_e: case double_e:
/* big // float */ /* big // float */
_YAP_Error(TYPE_ERROR_INTEGER, MkFloatTerm(v2.dbl), "gcd/2"); Yap_Error(TYPE_ERROR_INTEGER, MkFloatTerm(v2.dbl), "gcd/2");
/* make GCC happy */ /* make GCC happy */
P = (yamop *)FAILCODE; P = (yamop *)FAILCODE;
RERROR(); RERROR();
case big_int_e: case big_int_e:
if (v2.Int > 0) { if (v2.Int > 0) {
MP_INT *new = _YAP_PreAllocBigNum(); MP_INT *new = Yap_PreAllocBigNum();
mpz_gcd(new, v1.big, v2.big); mpz_gcd(new, v1.big, v2.big);
RBIG(new); RBIG(new);
} }
@ -1204,7 +1204,7 @@ p_min(Term t1, Term t2 E_ARGS)
case big_int_e: case big_int_e:
{ {
Int i = IntegerOfTerm(t1); Int i = IntegerOfTerm(t1);
MP_INT *b = _YAP_BigIntOfTerm(t2); MP_INT *b = Yap_BigIntOfTerm(t2);
if (mpz_cmp_si(b,i) < 0) { if (mpz_cmp_si(b,i) < 0) {
RBIG(b); RBIG(b);
@ -1216,7 +1216,7 @@ p_min(Term t1, Term t2 E_ARGS)
/* we've got a full term, need to evaluate it first */ /* we've got a full term, need to evaluate it first */
v1.Int = IntegerOfTerm(t1); v1.Int = IntegerOfTerm(t1);
bt1 = long_int_e; bt1 = long_int_e;
bt2 = _YAP_Eval(t2, &v2); bt2 = Yap_Eval(t2, &v2);
} }
break; break;
case double_e: case double_e:
@ -1246,7 +1246,7 @@ p_min(Term t1, Term t2 E_ARGS)
case big_int_e: case big_int_e:
{ {
Float fl1 = FloatOfTerm(t1); Float fl1 = FloatOfTerm(t1);
Float fl2 = mpz_get_d(_YAP_BigIntOfTerm(t2)); Float fl2 = mpz_get_d(Yap_BigIntOfTerm(t2));
if (fl1 <= fl2) { if (fl1 <= fl2) {
RFLOAT(fl1); RFLOAT(fl1);
} }
@ -1257,7 +1257,7 @@ p_min(Term t1, Term t2 E_ARGS)
/* we've got a full term, need to evaluate it first */ /* we've got a full term, need to evaluate it first */
v1.dbl = FloatOfTerm(t1); v1.dbl = FloatOfTerm(t1);
bt1 = double_e; bt1 = double_e;
bt2 = _YAP_Eval(t2, &v2); bt2 = Yap_Eval(t2, &v2);
} }
break; break;
#ifdef USE_GMP #ifdef USE_GMP
@ -1268,7 +1268,7 @@ p_min(Term t1, Term t2 E_ARGS)
case long_int_e: case long_int_e:
{ {
Int i = IntegerOfTerm(t2); Int i = IntegerOfTerm(t2);
MP_INT *b = _YAP_BigIntOfTerm(t1); MP_INT *b = Yap_BigIntOfTerm(t1);
if (mpz_cmp_si(b,i) < 0) { if (mpz_cmp_si(b,i) < 0) {
RBIG(b); RBIG(b);
@ -1278,8 +1278,8 @@ p_min(Term t1, Term t2 E_ARGS)
case big_int_e: case big_int_e:
/* two bignums */ /* two bignums */
{ {
MP_INT *b1 = _YAP_BigIntOfTerm(t1); MP_INT *b1 = Yap_BigIntOfTerm(t1);
MP_INT *b2 = _YAP_BigIntOfTerm(t2); MP_INT *b2 = Yap_BigIntOfTerm(t2);
if (mpz_cmp(b1,b2) < 0) { if (mpz_cmp(b1,b2) < 0) {
RBIG(b1); RBIG(b1);
@ -1289,7 +1289,7 @@ p_min(Term t1, Term t2 E_ARGS)
case double_e: case double_e:
{ {
Float fl1 = FloatOfTerm(t2); Float fl1 = FloatOfTerm(t2);
Float fl2 = mpz_get_d(_YAP_BigIntOfTerm(t1)); Float fl2 = mpz_get_d(Yap_BigIntOfTerm(t1));
if (fl1 <= fl2) { if (fl1 <= fl2) {
RFLOAT(fl1); RFLOAT(fl1);
} }
@ -1297,17 +1297,17 @@ p_min(Term t1, Term t2 E_ARGS)
} }
default: default:
/* we've got a full term, need to evaluate it first */ /* we've got a full term, need to evaluate it first */
v1.big = _YAP_BigIntOfTerm(t1); v1.big = Yap_BigIntOfTerm(t1);
bt1 = big_int_e; bt1 = big_int_e;
bt2 = _YAP_Eval(t2, &v2); bt2 = Yap_Eval(t2, &v2);
break; break;
} }
#endif #endif
default: default:
/* we've got a full term, need to evaluate it first */ /* we've got a full term, need to evaluate it first */
bt1 = _YAP_Eval(t1, &v1); bt1 = Yap_Eval(t1, &v1);
/* don't know anything about second */ /* don't know anything about second */
bt2 = _YAP_Eval(t2, &v2); bt2 = Yap_Eval(t2, &v2);
} }
/* second case, no need no evaluation */ /* second case, no need no evaluation */
switch (bt1) { switch (bt1) {
@ -1335,7 +1335,7 @@ p_min(Term t1, Term t2 E_ARGS)
} }
#endif #endif
default: default:
/* _YAP_Error */ /* Yap_Error */
RERROR(); RERROR();
} }
case double_e: case double_e:
@ -1443,7 +1443,7 @@ p_max(Term t1, Term t2 E_ARGS)
case big_int_e: case big_int_e:
{ {
Int i = IntegerOfTerm(t1); Int i = IntegerOfTerm(t1);
MP_INT *b = _YAP_BigIntOfTerm(t2); MP_INT *b = Yap_BigIntOfTerm(t2);
if (mpz_cmp_si(b,i) > 0) { if (mpz_cmp_si(b,i) > 0) {
RBIG(b); RBIG(b);
@ -1455,7 +1455,7 @@ p_max(Term t1, Term t2 E_ARGS)
/* we've got a full term, need to evaluate it first */ /* we've got a full term, need to evaluate it first */
v1.Int = IntegerOfTerm(t1); v1.Int = IntegerOfTerm(t1);
bt1 = long_int_e; bt1 = long_int_e;
bt2 = _YAP_Eval(t2, &v2); bt2 = Yap_Eval(t2, &v2);
} }
break; break;
case double_e: case double_e:
@ -1485,7 +1485,7 @@ p_max(Term t1, Term t2 E_ARGS)
case big_int_e: case big_int_e:
{ {
Float fl1 = FloatOfTerm(t1); Float fl1 = FloatOfTerm(t1);
Float fl2 = mpz_get_d(_YAP_BigIntOfTerm(t2)); Float fl2 = mpz_get_d(Yap_BigIntOfTerm(t2));
if (fl1 >= fl2) { if (fl1 >= fl2) {
RFLOAT(fl1); RFLOAT(fl1);
} }
@ -1496,7 +1496,7 @@ p_max(Term t1, Term t2 E_ARGS)
/* we've got a full term, need to evaluate it first */ /* we've got a full term, need to evaluate it first */
v1.dbl = FloatOfTerm(t1); v1.dbl = FloatOfTerm(t1);
bt1 = double_e; bt1 = double_e;
bt2 = _YAP_Eval(t2, &v2); bt2 = Yap_Eval(t2, &v2);
} }
break; break;
#ifdef USE_GMP #ifdef USE_GMP
@ -1507,7 +1507,7 @@ p_max(Term t1, Term t2 E_ARGS)
case long_int_e: case long_int_e:
{ {
Int i = IntegerOfTerm(t2); Int i = IntegerOfTerm(t2);
MP_INT *b = _YAP_BigIntOfTerm(t1); MP_INT *b = Yap_BigIntOfTerm(t1);
if (mpz_cmp_si(b,i) > 0) { if (mpz_cmp_si(b,i) > 0) {
RBIG(b); RBIG(b);
@ -1517,8 +1517,8 @@ p_max(Term t1, Term t2 E_ARGS)
case big_int_e: case big_int_e:
/* two bignums */ /* two bignums */
{ {
MP_INT *b1 = _YAP_BigIntOfTerm(t1); MP_INT *b1 = Yap_BigIntOfTerm(t1);
MP_INT *b2 = _YAP_BigIntOfTerm(t2); MP_INT *b2 = Yap_BigIntOfTerm(t2);
if (mpz_cmp(b1,b2) > 0) { if (mpz_cmp(b1,b2) > 0) {
RBIG(b1); RBIG(b1);
@ -1528,7 +1528,7 @@ p_max(Term t1, Term t2 E_ARGS)
case double_e: case double_e:
{ {
Float fl1 = FloatOfTerm(t2); Float fl1 = FloatOfTerm(t2);
Float fl2 = mpz_get_d(_YAP_BigIntOfTerm(t1)); Float fl2 = mpz_get_d(Yap_BigIntOfTerm(t1));
if (fl1 >= fl2) { if (fl1 >= fl2) {
RFLOAT(fl1); RFLOAT(fl1);
} }
@ -1536,17 +1536,17 @@ p_max(Term t1, Term t2 E_ARGS)
} }
default: default:
/* we've got a full term, need to evaluate it first */ /* we've got a full term, need to evaluate it first */
v1.big = _YAP_BigIntOfTerm(t1); v1.big = Yap_BigIntOfTerm(t1);
bt1 = big_int_e; bt1 = big_int_e;
bt2 = _YAP_Eval(t2, &v2); bt2 = Yap_Eval(t2, &v2);
break; break;
} }
#endif #endif
default: default:
/* we've got a full term, need to evaluate it first */ /* we've got a full term, need to evaluate it first */
bt1 = _YAP_Eval(t1, &v1); bt1 = Yap_Eval(t1, &v1);
/* don't know anything about second */ /* don't know anything about second */
bt2 = _YAP_Eval(t2, &v2); bt2 = Yap_Eval(t2, &v2);
} }
/* second case, no need no evaluation */ /* second case, no need no evaluation */
switch (bt1) { switch (bt1) {
@ -1574,7 +1574,7 @@ p_max(Term t1, Term t2 E_ARGS)
} }
#endif #endif
default: default:
/* _YAP_Error */ /* Yap_Error */
RERROR(); RERROR();
} }
case double_e: case double_e:
@ -1681,50 +1681,50 @@ p_binary_is(void)
blob_type f; blob_type f;
if (IsVarTerm(t)) { if (IsVarTerm(t)) {
_YAP_Error(INSTANTIATION_ERROR,t, "X is Y"); Yap_Error(INSTANTIATION_ERROR,t, "X is Y");
return(FALSE); return(FALSE);
} }
if (IsIntTerm(t)) { if (IsIntTerm(t)) {
blob_type f = InitBinTab[IntOfTerm(t)].f(Deref(ARG3),Deref(ARG4),&res); blob_type f = InitBinTab[IntOfTerm(t)].f(Deref(ARG3),Deref(ARG4),&res);
return (_YAP_unify_constant(ARG1,EvalToTerm(f,&res))); return (Yap_unify_constant(ARG1,EvalToTerm(f,&res)));
} }
if (IsAtomTerm(t)) { if (IsAtomTerm(t)) {
Atom name = AtomOfTerm(t); Atom name = AtomOfTerm(t);
ExpEntry *p; ExpEntry *p;
if (EndOfPAEntr(p = RepExpProp(_YAP_GetExpProp(name, 2)))) { if (EndOfPAEntr(p = RepExpProp(Yap_GetExpProp(name, 2)))) {
Term ti[2]; Term ti[2];
/* error */ /* error */
ti[0] = t; ti[0] = t;
ti[1] = MkIntTerm(2); ti[1] = MkIntTerm(2);
t = _YAP_MkApplTerm(_YAP_MkFunctor(_YAP_LookupAtom("/"),2), 2, ti); t = Yap_MkApplTerm(Yap_MkFunctor(Yap_LookupAtom("/"),2), 2, ti);
_YAP_Error(TYPE_ERROR_EVALUABLE, t, Yap_Error(TYPE_ERROR_EVALUABLE, t,
"functor %s/%d for arithmetic expression", "functor %s/%d for arithmetic expression",
RepAtom(name)->StrOfAE,2); RepAtom(name)->StrOfAE,2);
P = (yamop *)FAILCODE; P = (yamop *)FAILCODE;
return(FALSE); return(FALSE);
} }
f = p->FOfEE.binary(Deref(ARG3),Deref(ARG4),&res); f = p->FOfEE.binary(Deref(ARG3),Deref(ARG4),&res);
return (_YAP_unify_constant(ARG1,EvalToTerm(f,&res))); return (Yap_unify_constant(ARG1,EvalToTerm(f,&res)));
} }
return(FALSE); return(FALSE);
} }
void void
_YAP_InitBinaryExps(void) Yap_InitBinaryExps(void)
{ {
unsigned int i; unsigned int i;
ExpEntry *p; ExpEntry *p;
for (i = 0; i < sizeof(InitBinTab)/sizeof(InitBinEntry); ++i) { for (i = 0; i < sizeof(InitBinTab)/sizeof(InitBinEntry); ++i) {
AtomEntry *ae = RepAtom(_YAP_LookupAtom(InitBinTab[i].OpName)); AtomEntry *ae = RepAtom(Yap_LookupAtom(InitBinTab[i].OpName));
WRITE_LOCK(ae->ARWLock); WRITE_LOCK(ae->ARWLock);
if (_YAP_GetExpPropHavingLock(ae, 2)) { if (Yap_GetExpPropHavingLock(ae, 2)) {
WRITE_UNLOCK(ae->ARWLock); WRITE_UNLOCK(ae->ARWLock);
break; break;
} }
p = (ExpEntry *) _YAP_AllocAtomSpace(sizeof(ExpEntry)); p = (ExpEntry *) Yap_AllocAtomSpace(sizeof(ExpEntry));
p->KindOfPE = ExpProperty; p->KindOfPE = ExpProperty;
p->ArityOfEE = 2; p->ArityOfEE = 2;
p->ENoOfEE = 2; p->ENoOfEE = 2;
@ -1733,21 +1733,21 @@ _YAP_InitBinaryExps(void)
ae->PropsOfAE = AbsExpProp(p); ae->PropsOfAE = AbsExpProp(p);
WRITE_UNLOCK(ae->ARWLock); WRITE_UNLOCK(ae->ARWLock);
} }
_YAP_InitCPred("is", 4, p_binary_is, TestPredFlag | SafePredFlag); Yap_InitCPred("is", 4, p_binary_is, TestPredFlag | SafePredFlag);
} }
/* This routine is called from Restore to make sure we have the same arithmetic operators */ /* This routine is called from Restore to make sure we have the same arithmetic operators */
int int
_YAP_ReInitBinaryExps(void) Yap_ReInitBinaryExps(void)
{ {
unsigned int i; unsigned int i;
Prop p; Prop p;
for (i = 0; i < sizeof(InitBinTab)/sizeof(InitBinEntry); ++i) { for (i = 0; i < sizeof(InitBinTab)/sizeof(InitBinEntry); ++i) {
AtomEntry *ae = RepAtom(_YAP_FullLookupAtom(InitBinTab[i].OpName)); AtomEntry *ae = RepAtom(Yap_FullLookupAtom(InitBinTab[i].OpName));
WRITE_LOCK(ae->ARWLock); WRITE_LOCK(ae->ARWLock);
if ((p = _YAP_GetExpPropHavingLock(ae, 2)) == NULL) { if ((p = Yap_GetExpPropHavingLock(ae, 2)) == NULL) {
WRITE_UNLOCK(ae->ARWLock); WRITE_UNLOCK(ae->ARWLock);
return(FALSE); return(FALSE);
} }

260
C/arrays.c
View File

@ -173,7 +173,7 @@ AccessNamedArray(Atom a, Int indx)
READ_LOCK(ptr->ArRWLock); READ_LOCK(ptr->ArRWLock);
if (-(pp->ArrayEArity) <= indx || indx < 0) { if (-(pp->ArrayEArity) <= indx || indx < 0) {
/* _YAP_Error(DOMAIN_ERROR_ARRAY_OVERFLOW, MkIntegerTerm(indx), "access_array");*/ /* Yap_Error(DOMAIN_ERROR_ARRAY_OVERFLOW, MkIntegerTerm(indx), "access_array");*/
READ_UNLOCK(ptr->ArRWLock); READ_UNLOCK(ptr->ArRWLock);
P = (yamop *)FAILCODE; P = (yamop *)FAILCODE;
return(MkAtomTerm(AtomFoundVar)); return(MkAtomTerm(AtomFoundVar));
@ -259,7 +259,7 @@ AccessNamedArray(Atom a, Int indx)
READ_UNLOCK(ptr->ArRWLock); READ_UNLOCK(ptr->ArRWLock);
if (ref != NULL) { if (ref != NULL) {
TRef = _YAP_FetchTermFromDB(ref,3); TRef = Yap_FetchTermFromDB(ref,3);
} else { } else {
P = (yamop *)FAILCODE; P = (yamop *)FAILCODE;
TRef = TermNil; TRef = TermNil;
@ -273,7 +273,7 @@ AccessNamedArray(Atom a, Int indx)
} }
} }
else { else {
_YAP_Error(EXISTENCE_ERROR_ARRAY,MkAtomTerm(a),"named array"); Yap_Error(EXISTENCE_ERROR_ARRAY,MkAtomTerm(a),"named array");
return (TermNil); return (TermNil);
} }
@ -291,22 +291,22 @@ p_access_array(void)
union arith_ret v; union arith_ret v;
if (IsIntTerm(ti)) if (IsIntTerm(ti))
indx = IntOfTerm(ti); indx = IntOfTerm(ti);
else if (_YAP_Eval(ti, &v) == long_int_e) else if (Yap_Eval(ti, &v) == long_int_e)
indx = v.Int; indx = v.Int;
else { else {
_YAP_Error(TYPE_ERROR_INTEGER,ti,"access_array"); Yap_Error(TYPE_ERROR_INTEGER,ti,"access_array");
return (FALSE); return (FALSE);
} }
} }
else { else {
_YAP_Error(INSTANTIATION_ERROR,ti,"access_array"); Yap_Error(INSTANTIATION_ERROR,ti,"access_array");
return (TermNil); return (TermNil);
} }
if (IsNonVarTerm(t)) { if (IsNonVarTerm(t)) {
if (IsApplTerm(t)) { if (IsApplTerm(t)) {
if (indx >= ArityOfFunctor(FunctorOfTerm(t)) || indx < 0) { if (indx >= ArityOfFunctor(FunctorOfTerm(t)) || indx < 0) {
/* _YAP_Error(DOMAIN_ERROR_ARRAY_OVERFLOW, MkIntegerTerm(indx), "access_array");*/ /* Yap_Error(DOMAIN_ERROR_ARRAY_OVERFLOW, MkIntegerTerm(indx), "access_array");*/
P = (yamop *)FAILCODE; P = (yamop *)FAILCODE;
return(FALSE); return(FALSE);
} }
@ -317,14 +317,14 @@ p_access_array(void)
return(FALSE); return(FALSE);
} }
} else { } else {
_YAP_Error(TYPE_ERROR_ARRAY,t,"access_array"); Yap_Error(TYPE_ERROR_ARRAY,t,"access_array");
return(FALSE); return(FALSE);
} }
} else { } else {
_YAP_Error(INSTANTIATION_ERROR,t,"access_array"); Yap_Error(INSTANTIATION_ERROR,t,"access_array");
return(FALSE); return(FALSE);
} }
return (_YAP_unify(tf, ARG3)); return (Yap_unify(tf, ARG3));
} }
static Int static Int
@ -337,35 +337,35 @@ p_array_arg(void)
union arith_ret v; union arith_ret v;
if (IsIntTerm(ti)) if (IsIntTerm(ti))
indx = IntOfTerm(ti); indx = IntOfTerm(ti);
else if (_YAP_Eval(ti, &v) == long_int_e) else if (Yap_Eval(ti, &v) == long_int_e)
indx = v.Int; indx = v.Int;
else { else {
_YAP_Error(TYPE_ERROR_INTEGER,ti,"array_arg"); Yap_Error(TYPE_ERROR_INTEGER,ti,"array_arg");
return (FALSE); return (FALSE);
} }
} }
else { else {
_YAP_Error(INSTANTIATION_ERROR,ti,"array_arg"); Yap_Error(INSTANTIATION_ERROR,ti,"array_arg");
return (FALSE); return (FALSE);
} }
t = Deref(ARG2); t = Deref(ARG2);
if (IsNonVarTerm(t)) { if (IsNonVarTerm(t)) {
if (IsApplTerm(t)) { if (IsApplTerm(t)) {
return (_YAP_unify(((RepAppl(t))[indx + 1]), ARG1)); return (Yap_unify(((RepAppl(t))[indx + 1]), ARG1));
} }
else if (IsAtomTerm(t)) { else if (IsAtomTerm(t)) {
Term tf = AccessNamedArray(AtomOfTerm(t), indx); Term tf = AccessNamedArray(AtomOfTerm(t), indx);
if (tf == MkAtomTerm(AtomFoundVar)) { if (tf == MkAtomTerm(AtomFoundVar)) {
return(FALSE); return(FALSE);
} }
return (_YAP_unify(tf, ARG1)); return (Yap_unify(tf, ARG1));
} }
else else
_YAP_Error(TYPE_ERROR_ARRAY,t,"array_arg"); Yap_Error(TYPE_ERROR_ARRAY,t,"array_arg");
} }
else else
_YAP_Error(INSTANTIATION_ERROR,t,"array_arg"); Yap_Error(INSTANTIATION_ERROR,t,"array_arg");
return (FALSE); return (FALSE);
@ -382,7 +382,7 @@ InitNamedArray(ArrayEntry * p, Int dim)
/* place terms in reverse order */ /* place terms in reverse order */
Bind_Global(&(p->ValueOfVE),AbsAppl(H)); Bind_Global(&(p->ValueOfVE),AbsAppl(H));
tp = H; tp = H;
tp[0] = (CELL)_YAP_MkFunctor(AtomArray, dim); tp[0] = (CELL)Yap_MkFunctor(AtomArray, dim);
tp++; tp++;
p->ArrayEArity = dim; p->ArrayEArity = dim;
/* Initialise the array as a set of variables */ /* Initialise the array as a set of variables */
@ -399,7 +399,7 @@ CreateNamedArray(PropEntry * pp, Int dim, AtomEntry *ae)
{ {
ArrayEntry *p; ArrayEntry *p;
p = (ArrayEntry *) _YAP_AllocAtomSpace(sizeof(*p)); p = (ArrayEntry *) Yap_AllocAtomSpace(sizeof(*p));
p->KindOfPE = ArrayProperty; p->KindOfPE = ArrayProperty;
p->NextOfPE = ae->PropsOfAE; p->NextOfPE = ae->PropsOfAE;
INIT_RWLOCK(p->ArRWLock); INIT_RWLOCK(p->ArRWLock);
@ -439,10 +439,10 @@ AllocateStaticArraySpace(StaticArrayEntry *p, static_array_types atype, Int arra
asize = array_size*sizeof(DBRef); asize = array_size*sizeof(DBRef);
break; break;
} }
while ((p->ValueOfVE.floats = (Float *) _YAP_AllocAtomSpace(asize) ) == NULL) { while ((p->ValueOfVE.floats = (Float *) Yap_AllocAtomSpace(asize) ) == NULL) {
YAPLeaveCriticalSection(); YAPLeaveCriticalSection();
if (!_YAP_growheap(FALSE)) { if (!Yap_growheap(FALSE)) {
_YAP_Error(SYSTEM_ERROR, TermNil, _YAP_ErrorMessage); Yap_Error(SYSTEM_ERROR, TermNil, Yap_ErrorMessage);
return; return;
} }
YAPEnterCriticalSection(); YAPEnterCriticalSection();
@ -454,7 +454,7 @@ static void
CreateStaticArray(AtomEntry *ae, Int dim, static_array_types type, CODEADDR start_addr, StaticArrayEntry *p) CreateStaticArray(AtomEntry *ae, Int dim, static_array_types type, CODEADDR start_addr, StaticArrayEntry *p)
{ {
if (EndOfPAEntr(p)) { if (EndOfPAEntr(p)) {
p = (StaticArrayEntry *) _YAP_AllocAtomSpace(sizeof(*p)); p = (StaticArrayEntry *) Yap_AllocAtomSpace(sizeof(*p));
p->KindOfPE = ArrayProperty; p->KindOfPE = ArrayProperty;
p->NextOfPE = ae->PropsOfAE; p->NextOfPE = ae->PropsOfAE;
INIT_RWLOCK(p->ArRWLock); INIT_RWLOCK(p->ArRWLock);
@ -520,7 +520,7 @@ ResizeStaticArray(StaticArrayEntry *pp, Int dim)
return; return;
pp->ArrayEArity = -dim; pp->ArrayEArity = -dim;
#if HAVE_MMAP #if HAVE_MMAP
if (pp->ValueOfVE.chars < (char *)_YAP_HeapBase || if (pp->ValueOfVE.chars < (char *)Yap_HeapBase ||
pp->ValueOfVE.chars > (char *)HeapTop) { pp->ValueOfVE.chars > (char *)HeapTop) {
ResizeMmappedArray(pp, dim, (void *)(pp->ValueOfVE.chars)); ResizeMmappedArray(pp, dim, (void *)(pp->ValueOfVE.chars));
return; return;
@ -595,10 +595,10 @@ p_create_array(void)
union arith_ret v; union arith_ret v;
if (IsIntTerm(ti)) if (IsIntTerm(ti))
size = IntOfTerm(ti); size = IntOfTerm(ti);
else if (_YAP_Eval(ti, &v) == long_int_e) else if (Yap_Eval(ti, &v) == long_int_e)
size = v.Int; size = v.Int;
else { else {
_YAP_Error(TYPE_ERROR_INTEGER,ti,"create_array"); Yap_Error(TYPE_ERROR_INTEGER,ti,"create_array");
return (FALSE); return (FALSE);
} }
} }
@ -607,15 +607,15 @@ p_create_array(void)
/* Create an anonymous array */ /* Create an anonymous array */
Functor farray; Functor farray;
farray = _YAP_MkFunctor(AtomArray, size); farray = Yap_MkFunctor(AtomArray, size);
if (H+1+size > ASP-1024) { if (H+1+size > ASP-1024) {
if (!_YAP_gc(2, ENV, P)) { if (!Yap_gc(2, ENV, P)) {
_YAP_Error(OUT_OF_STACK_ERROR,TermNil,_YAP_ErrorMessage); Yap_Error(OUT_OF_STACK_ERROR,TermNil,Yap_ErrorMessage);
return(FALSE); return(FALSE);
} else { } else {
if (H+1+size > ASP-1024) { if (H+1+size > ASP-1024) {
if (!_YAP_growstack( sizeof(CELL) * (size+1-(H-ASP-1024)))) { if (!Yap_growstack( sizeof(CELL) * (size+1-(H-ASP-1024)))) {
_YAP_Error(SYSTEM_ERROR, TermNil, _YAP_ErrorMessage); Yap_Error(SYSTEM_ERROR, TermNil, Yap_ErrorMessage);
return FALSE; return FALSE;
} }
} }
@ -628,7 +628,7 @@ p_create_array(void)
RESET_VARIABLE(H); RESET_VARIABLE(H);
H++; H++;
} }
return (_YAP_unify(t, ARG1)); return (Yap_unify(t, ARG1));
} }
else if (IsAtomTerm(t)) { else if (IsAtomTerm(t)) {
/* Create a named array */ /* Create a named array */
@ -642,8 +642,8 @@ p_create_array(void)
if (EndOfPAEntr(pp)) { if (EndOfPAEntr(pp)) {
if (H+1+size > ASP-1024) { if (H+1+size > ASP-1024) {
WRITE_UNLOCK(ae->ARWLock); WRITE_UNLOCK(ae->ARWLock);
if (!_YAP_gc(2, ENV, P)) { if (!Yap_gc(2, ENV, P)) {
_YAP_Error(OUT_OF_STACK_ERROR,TermNil,_YAP_ErrorMessage); Yap_Error(OUT_OF_STACK_ERROR,TermNil,Yap_ErrorMessage);
return(FALSE); return(FALSE);
} else } else
goto restart; goto restart;
@ -656,12 +656,12 @@ p_create_array(void)
WRITE_UNLOCK(ae->ARWLock); WRITE_UNLOCK(ae->ARWLock);
if (!IsVarTerm(app->ValueOfVE) || !IsUnboundVar(app->ValueOfVE)) if (!IsVarTerm(app->ValueOfVE) || !IsUnboundVar(app->ValueOfVE))
_YAP_Error(PERMISSION_ERROR_CREATE_ARRAY,t,"create_array", Yap_Error(PERMISSION_ERROR_CREATE_ARRAY,t,"create_array",
ae->StrOfAE); ae->StrOfAE);
else { else {
if (H+1+size > ASP-1024) { if (H+1+size > ASP-1024) {
if (!_YAP_gc(2, ENV, P)) { if (!Yap_gc(2, ENV, P)) {
_YAP_Error(OUT_OF_STACK_ERROR,TermNil,_YAP_ErrorMessage); Yap_Error(OUT_OF_STACK_ERROR,TermNil,Yap_ErrorMessage);
return(FALSE); return(FALSE);
} else } else
goto restart; goto restart;
@ -685,23 +685,23 @@ p_create_static_array(void)
static_array_types props; static_array_types props;
if (IsVarTerm(ti)) { if (IsVarTerm(ti)) {
_YAP_Error(INSTANTIATION_ERROR,ti,"create static array"); Yap_Error(INSTANTIATION_ERROR,ti,"create static array");
return (FALSE); return (FALSE);
} else if (IsIntTerm(ti)) } else if (IsIntTerm(ti))
size = IntOfTerm(ti); size = IntOfTerm(ti);
else { else {
union arith_ret v; union arith_ret v;
if (_YAP_Eval(ti, &v) == long_int_e) { if (Yap_Eval(ti, &v) == long_int_e) {
size = v.Int; size = v.Int;
} }
else { else {
_YAP_Error(TYPE_ERROR_INTEGER,ti,"create static array"); Yap_Error(TYPE_ERROR_INTEGER,ti,"create static array");
return (FALSE); return (FALSE);
} }
} }
if (IsVarTerm(tprops)) { if (IsVarTerm(tprops)) {
_YAP_Error(INSTANTIATION_ERROR,tprops,"create static array"); Yap_Error(INSTANTIATION_ERROR,tprops,"create static array");
return (FALSE); return (FALSE);
} else if (IsAtomTerm(tprops)) { } else if (IsAtomTerm(tprops)) {
char *atname = RepAtom(AtomOfTerm(tprops))->StrOfAE; char *atname = RepAtom(AtomOfTerm(tprops))->StrOfAE;
@ -722,16 +722,16 @@ p_create_static_array(void)
else if (!strcmp(atname, "term")) else if (!strcmp(atname, "term"))
props = array_of_terms; props = array_of_terms;
else { else {
_YAP_Error(DOMAIN_ERROR_ARRAY_TYPE,tprops,"create static array"); Yap_Error(DOMAIN_ERROR_ARRAY_TYPE,tprops,"create static array");
return(FALSE); return(FALSE);
} }
} else { } else {
_YAP_Error(TYPE_ERROR_ATOM,tprops,"create static array"); Yap_Error(TYPE_ERROR_ATOM,tprops,"create static array");
return (FALSE); return (FALSE);
} }
if (IsVarTerm(t)) { if (IsVarTerm(t)) {
_YAP_Error(INSTANTIATION_ERROR,t,"create static array"); Yap_Error(INSTANTIATION_ERROR,t,"create static array");
return (FALSE); return (FALSE);
} }
else if (IsAtomTerm(t)) { else if (IsAtomTerm(t)) {
@ -754,15 +754,15 @@ p_create_static_array(void)
CreateStaticArray(ae, size, props, NULL, pp); CreateStaticArray(ae, size, props, NULL, pp);
return (TRUE); return (TRUE);
} else { } else {
_YAP_Error(PERMISSION_ERROR_CREATE_ARRAY,t,"cannot create static array over dynamic array"); Yap_Error(PERMISSION_ERROR_CREATE_ARRAY,t,"cannot create static array over dynamic array");
return (FALSE); return (FALSE);
} }
} else { } else {
_YAP_Error(PERMISSION_ERROR_CREATE_ARRAY,t,"cannot create static array over static array"); Yap_Error(PERMISSION_ERROR_CREATE_ARRAY,t,"cannot create static array over static array");
return (FALSE); return (FALSE);
} }
} }
_YAP_Error(TYPE_ERROR_ATOM,t,"create static array"); Yap_Error(TYPE_ERROR_ATOM,t,"create static array");
return (FALSE); return (FALSE);
} }
@ -806,23 +806,23 @@ p_resize_static_array(void)
Int size; Int size;
if (IsVarTerm(ti)) { if (IsVarTerm(ti)) {
_YAP_Error(INSTANTIATION_ERROR,ti,"resize a static array"); Yap_Error(INSTANTIATION_ERROR,ti,"resize a static array");
return (FALSE); return (FALSE);
} else if (IsIntTerm(ti)) } else if (IsIntTerm(ti))
size = IntOfTerm(ti); size = IntOfTerm(ti);
else { else {
union arith_ret v; union arith_ret v;
if (_YAP_Eval(ti, &v) == long_int_e) { if (Yap_Eval(ti, &v) == long_int_e) {
size = v.Int; size = v.Int;
} }
else { else {
_YAP_Error(TYPE_ERROR_INTEGER,ti,"resize a static array"); Yap_Error(TYPE_ERROR_INTEGER,ti,"resize a static array");
return (FALSE); return (FALSE);
} }
} }
if (IsVarTerm(t)) { if (IsVarTerm(t)) {
_YAP_Error(INSTANTIATION_ERROR,t,"resize a static array"); Yap_Error(INSTANTIATION_ERROR,t,"resize a static array");
return (FALSE); return (FALSE);
} }
else if (IsAtomTerm(t)) { else if (IsAtomTerm(t)) {
@ -833,15 +833,15 @@ p_resize_static_array(void)
while (!EndOfPAEntr(pp) && pp->KindOfPE != ArrayProperty) while (!EndOfPAEntr(pp) && pp->KindOfPE != ArrayProperty)
pp = RepStaticArrayProp(pp->NextOfPE); pp = RepStaticArrayProp(pp->NextOfPE);
if (EndOfPAEntr(pp) || pp->ValueOfVE.ints == NULL) { if (EndOfPAEntr(pp) || pp->ValueOfVE.ints == NULL) {
_YAP_Error(PERMISSION_ERROR_RESIZE_ARRAY,t,"resize a static array"); Yap_Error(PERMISSION_ERROR_RESIZE_ARRAY,t,"resize a static array");
return(FALSE); return(FALSE);
} else { } else {
Int osize = - pp->ArrayEArity; Int osize = - pp->ArrayEArity;
ResizeStaticArray(pp, size); ResizeStaticArray(pp, size);
return(_YAP_unify(ARG2,MkIntegerTerm(osize))); return(Yap_unify(ARG2,MkIntegerTerm(osize)));
} }
} else { } else {
_YAP_Error(TYPE_ERROR_ATOM,t,"resize a static array"); Yap_Error(TYPE_ERROR_ATOM,t,"resize a static array");
return (FALSE); return (FALSE);
} }
} }
@ -854,7 +854,7 @@ p_close_static_array(void)
Term t = Deref(ARG1); Term t = Deref(ARG1);
if (IsVarTerm(t)) { if (IsVarTerm(t)) {
_YAP_Error(INSTANTIATION_ERROR,t,"close static array"); Yap_Error(INSTANTIATION_ERROR,t,"close static array");
return (FALSE); return (FALSE);
} }
else if (IsAtomTerm(t)) { else if (IsAtomTerm(t)) {
@ -873,12 +873,12 @@ p_close_static_array(void)
StaticArrayEntry *ptr = (StaticArrayEntry *)pp; StaticArrayEntry *ptr = (StaticArrayEntry *)pp;
if (ptr->ValueOfVE.ints != NULL) { if (ptr->ValueOfVE.ints != NULL) {
#if HAVE_MMAP #if HAVE_MMAP
if (ptr->ValueOfVE.chars < (char *)_YAP_HeapBase || if (ptr->ValueOfVE.chars < (char *)Yap_HeapBase ||
ptr->ValueOfVE.chars > (char *)HeapTop) { ptr->ValueOfVE.chars > (char *)HeapTop) {
return(CloseMmappedArray(ptr, (void *)ptr->ValueOfVE.chars)); return(CloseMmappedArray(ptr, (void *)ptr->ValueOfVE.chars));
} }
#endif #endif
_YAP_FreeAtomSpace((char *)(ptr->ValueOfVE.ints)); Yap_FreeAtomSpace((char *)(ptr->ValueOfVE.ints));
ptr->ValueOfVE.ints = NULL; ptr->ValueOfVE.ints = NULL;
ptr->ArrayEArity = 0; ptr->ArrayEArity = 0;
return(TRUE); return(TRUE);
@ -887,7 +887,7 @@ p_close_static_array(void)
} }
} }
} else { } else {
_YAP_Error(TYPE_ERROR_ATOM,t,"close static array"); Yap_Error(TYPE_ERROR_ATOM,t,"close static array");
return (FALSE); return (FALSE);
} }
} }
@ -932,21 +932,21 @@ CloseMmappedArray(StaticArrayEntry *pp, void *area)
optr = ptr; optr = ptr;
} }
if (ptr == NULL) { if (ptr == NULL) {
_YAP_Error(SYSTEM_ERROR,ARG1,"close_mmapped_array (array chain incoherent)", strerror(errno)); Yap_Error(SYSTEM_ERROR,ARG1,"close_mmapped_array (array chain incoherent)", strerror(errno));
return(FALSE); return(FALSE);
} }
if (munmap(ptr->start, ptr->size) == -1) { if (munmap(ptr->start, ptr->size) == -1) {
_YAP_Error(SYSTEM_ERROR,ARG1,"close_mmapped_array (munmap: %s)", strerror(errno)); Yap_Error(SYSTEM_ERROR,ARG1,"close_mmapped_array (munmap: %s)", strerror(errno));
return(FALSE); return(FALSE);
} }
optr->next = ptr->next; optr->next = ptr->next;
pp->ValueOfVE.ints = NULL; pp->ValueOfVE.ints = NULL;
pp->ArrayEArity = 0; pp->ArrayEArity = 0;
if (close(ptr->fd) < 0) { if (close(ptr->fd) < 0) {
_YAP_Error(SYSTEM_ERROR,ARG1,"close_mmapped_array (close: %s)", strerror(errno)); Yap_Error(SYSTEM_ERROR,ARG1,"close_mmapped_array (close: %s)", strerror(errno));
return(FALSE); return(FALSE);
} }
_YAP_FreeAtomSpace((char *)ptr); Yap_FreeAtomSpace((char *)ptr);
return(TRUE); return(TRUE);
} }
@ -966,24 +966,24 @@ ResizeMmappedArray(StaticArrayEntry *pp, Int dim, void *area)
and last we initialise again and last we initialise again
*/ */
if (munmap(ptr->start, ptr->size) == -1) { if (munmap(ptr->start, ptr->size) == -1) {
_YAP_Error(SYSTEM_ERROR,ARG1,"resize_mmapped_array (munmap: %s)", strerror(errno)); Yap_Error(SYSTEM_ERROR,ARG1,"resize_mmapped_array (munmap: %s)", strerror(errno));
return; return;
} }
total_size = (ptr->size / ptr->items)*dim; total_size = (ptr->size / ptr->items)*dim;
if (ftruncate(ptr->fd, total_size) < 0) { if (ftruncate(ptr->fd, total_size) < 0) {
_YAP_Error(SYSTEM_ERROR,ARG1,"resize_mmapped_array (ftruncate: %s)", strerror(errno)); Yap_Error(SYSTEM_ERROR,ARG1,"resize_mmapped_array (ftruncate: %s)", strerror(errno));
return; return;
} }
if (lseek(ptr->fd, total_size-1, SEEK_SET) < 0) { if (lseek(ptr->fd, total_size-1, SEEK_SET) < 0) {
_YAP_Error(SYSTEM_ERROR,ARG1,"resize_mmapped_array (lseek: %s)", strerror(errno)); Yap_Error(SYSTEM_ERROR,ARG1,"resize_mmapped_array (lseek: %s)", strerror(errno));
return; return;
} }
if (write(ptr->fd, "", 1) < 0) { if (write(ptr->fd, "", 1) < 0) {
_YAP_Error(SYSTEM_ERROR,ARG1,"resize_mmapped_array (write: %s)", strerror(errno)); Yap_Error(SYSTEM_ERROR,ARG1,"resize_mmapped_array (write: %s)", strerror(errno));
return; return;
} }
if ((ptr->start = (void *)mmap(0, (size_t) total_size, PROT_READ | PROT_WRITE, MAP_SHARED, ptr->fd, 0)) == (void *) - 1) { if ((ptr->start = (void *)mmap(0, (size_t) total_size, PROT_READ | PROT_WRITE, MAP_SHARED, ptr->fd, 0)) == (void *) - 1) {
_YAP_Error(SYSTEM_ERROR,ARG1,"resize_mmapped_array (mmap: %s)", strerror(errno)); Yap_Error(SYSTEM_ERROR,ARG1,"resize_mmapped_array (mmap: %s)", strerror(errno));
return; return;
} }
ptr->size = total_size; ptr->size = total_size;
@ -1009,23 +1009,23 @@ p_create_mmapped_array(void)
int fd; int fd;
if (IsVarTerm(ti)) { if (IsVarTerm(ti)) {
_YAP_Error(INSTANTIATION_ERROR,ti,"create_mmapped_array"); Yap_Error(INSTANTIATION_ERROR,ti,"create_mmapped_array");
return (FALSE); return (FALSE);
} else if (IsIntTerm(ti)) } else if (IsIntTerm(ti))
size = IntOfTerm(ti); size = IntOfTerm(ti);
else { else {
union arith_ret v; union arith_ret v;
if (_YAP_Eval(ti, &v) == long_int_e) { if (Yap_Eval(ti, &v) == long_int_e) {
size = v.Int; size = v.Int;
} }
else { else {
_YAP_Error(TYPE_ERROR_INTEGER,ti,"create_mmapped_array"); Yap_Error(TYPE_ERROR_INTEGER,ti,"create_mmapped_array");
return (FALSE); return (FALSE);
} }
} }
if (IsVarTerm(tprops)) { if (IsVarTerm(tprops)) {
_YAP_Error(INSTANTIATION_ERROR,tprops,"create_mmapped_array"); Yap_Error(INSTANTIATION_ERROR,tprops,"create_mmapped_array");
return (FALSE); return (FALSE);
} else if (IsAtomTerm(tprops)) { } else if (IsAtomTerm(tprops)) {
char *atname = RepAtom(AtomOfTerm(tprops))->StrOfAE; char *atname = RepAtom(AtomOfTerm(tprops))->StrOfAE;
@ -1051,16 +1051,16 @@ p_create_mmapped_array(void)
props = array_of_uchars; props = array_of_uchars;
total_size = size*sizeof(unsigned char); total_size = size*sizeof(unsigned char);
} else { } else {
_YAP_Error(DOMAIN_ERROR_ARRAY_TYPE,tprops,"create_mmapped_array"); Yap_Error(DOMAIN_ERROR_ARRAY_TYPE,tprops,"create_mmapped_array");
return(FALSE); return(FALSE);
} }
} else { } else {
_YAP_Error(TYPE_ERROR_ATOM,tprops,"create_mmapped_array"); Yap_Error(TYPE_ERROR_ATOM,tprops,"create_mmapped_array");
return (FALSE); return (FALSE);
} }
if (IsVarTerm(tfile)) { if (IsVarTerm(tfile)) {
_YAP_Error(INSTANTIATION_ERROR,tfile,"create_mmapped_array"); Yap_Error(INSTANTIATION_ERROR,tfile,"create_mmapped_array");
return (FALSE); return (FALSE);
} else if (IsAtomTerm(tfile)) { } else if (IsAtomTerm(tfile)) {
char *filename = RepAtom(AtomOfTerm(tfile))->StrOfAE; char *filename = RepAtom(AtomOfTerm(tfile))->StrOfAE;
@ -1068,26 +1068,26 @@ p_create_mmapped_array(void)
fd = open(filename, O_RDWR|O_CREAT, S_IRUSR|S_IWUSR); fd = open(filename, O_RDWR|O_CREAT, S_IRUSR|S_IWUSR);
if (fd == -1) { if (fd == -1) {
_YAP_Error(SYSTEM_ERROR,ARG1,"create_mmapped_array (open: %s)", strerror(errno)); Yap_Error(SYSTEM_ERROR,ARG1,"create_mmapped_array (open: %s)", strerror(errno));
return(FALSE); return(FALSE);
} }
if (lseek(fd, total_size-1, SEEK_SET) < 0) if (lseek(fd, total_size-1, SEEK_SET) < 0)
_YAP_Error(SYSTEM_ERROR,tfile,"create_mmapped_array (lseek: %s)", strerror(errno)); Yap_Error(SYSTEM_ERROR,tfile,"create_mmapped_array (lseek: %s)", strerror(errno));
if (write(fd, "", 1) < 0) if (write(fd, "", 1) < 0)
_YAP_Error(SYSTEM_ERROR,tfile,"create_mmapped_array (write: %s)", strerror(errno)); Yap_Error(SYSTEM_ERROR,tfile,"create_mmapped_array (write: %s)", strerror(errno));
/* /*
if (ftruncate(fd, total_size) < 0) if (ftruncate(fd, total_size) < 0)
_YAP_Error(SYSTEM_ERROR,tfile,"create_mmapped_array"); Yap_Error(SYSTEM_ERROR,tfile,"create_mmapped_array");
*/ */
if ((array_addr = (CODEADDR)mmap(0, (size_t) total_size, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0)) == (CODEADDR) - 1) if ((array_addr = (CODEADDR)mmap(0, (size_t) total_size, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0)) == (CODEADDR) - 1)
_YAP_Error(SYSTEM_ERROR,tfile,"create_mmapped_array (mmap: %s)", strerror(errno)); Yap_Error(SYSTEM_ERROR,tfile,"create_mmapped_array (mmap: %s)", strerror(errno));
} else { } else {
_YAP_Error(TYPE_ERROR_ATOM,tfile,"create_mmapped_array"); Yap_Error(TYPE_ERROR_ATOM,tfile,"create_mmapped_array");
return (FALSE); return (FALSE);
} }
if (IsVarTerm(t)) { if (IsVarTerm(t)) {
_YAP_Error(INSTANTIATION_ERROR,t,"create_mmapped_array"); Yap_Error(INSTANTIATION_ERROR,t,"create_mmapped_array");
return (FALSE); return (FALSE);
} }
else if (IsAtomTerm(t)) { else if (IsAtomTerm(t)) {
@ -1106,7 +1106,7 @@ p_create_mmapped_array(void)
mmap_array_block *ptr; mmap_array_block *ptr;
CreateStaticArray(ae, size, props, array_addr, pp); CreateStaticArray(ae, size, props, array_addr, pp);
ptr = (mmap_array_block *)_YAP_AllocAtomSpace(sizeof(mmap_array_block)); ptr = (mmap_array_block *)Yap_AllocAtomSpace(sizeof(mmap_array_block));
ptr->name = AbsAtom(ae); ptr->name = AbsAtom(ae);
ptr->size = total_size; ptr->size = total_size;
ptr->items = size; ptr->items = size;
@ -1118,15 +1118,15 @@ p_create_mmapped_array(void)
} else { } else {
WRITE_UNLOCK(pp->ArRWLock); WRITE_UNLOCK(pp->ArRWLock);
WRITE_UNLOCK(ae->ARWLock); WRITE_UNLOCK(ae->ARWLock);
_YAP_Error(DOMAIN_ERROR_ARRAY_TYPE,t,"create_mmapped_array", ae->StrOfAE); Yap_Error(DOMAIN_ERROR_ARRAY_TYPE,t,"create_mmapped_array", ae->StrOfAE);
return(FALSE); return(FALSE);
} }
} else { } else {
_YAP_Error(TYPE_ERROR_ATOM,t,"create_mmapped_array"); Yap_Error(TYPE_ERROR_ATOM,t,"create_mmapped_array");
return (FALSE); return (FALSE);
} }
#else #else
_YAP_Error(SYSTEM_ERROR,ARG1,"create_mmapped_array (mmap)"); Yap_Error(SYSTEM_ERROR,ARG1,"create_mmapped_array (mmap)");
return (FALSE); return (FALSE);
#endif #endif
} }
@ -1139,7 +1139,7 @@ replace_array_references_complex(register CELL *pt0,
Term Var) Term Var)
{ {
register CELL **to_visit = (CELL **) _YAP_PreAllocCodeSpace(); register CELL **to_visit = (CELL **) Yap_PreAllocCodeSpace();
CELL **to_visit_base = to_visit; CELL **to_visit_base = to_visit;
loop: loop:
@ -1235,7 +1235,7 @@ loop:
} }
Bind_Global(PtrOfTerm(Var), TermNil); Bind_Global(PtrOfTerm(Var), TermNil);
_YAP_ReleasePreAllocCodeSpace((ADDR)to_visit); Yap_ReleasePreAllocCodeSpace((ADDR)to_visit);
} }
/* /*
@ -1285,7 +1285,7 @@ p_array_references(void)
Term t1 = HeadOfTerm(t); Term t1 = HeadOfTerm(t);
Term t2 = TailOfTerm(t); Term t2 = TailOfTerm(t);
return (_YAP_unify(t1, ARG2) && _YAP_unify(t2, ARG3)); return (Yap_unify(t1, ARG2) && Yap_unify(t2, ARG3));
} }
static Int static Int
@ -1301,22 +1301,22 @@ p_assign_static(void)
indx = IntOfTerm(t2); indx = IntOfTerm(t2);
else { else {
union arith_ret v; union arith_ret v;
if (_YAP_Eval(t2, &v) == long_int_e) { if (Yap_Eval(t2, &v) == long_int_e) {
indx = v.Int; indx = v.Int;
} else { } else {
_YAP_Error(TYPE_ERROR_INTEGER,t2,"update_array"); Yap_Error(TYPE_ERROR_INTEGER,t2,"update_array");
return (FALSE); return (FALSE);
} }
} }
} else { } else {
_YAP_Error(INSTANTIATION_ERROR,t2,"update_array"); Yap_Error(INSTANTIATION_ERROR,t2,"update_array");
return (FALSE); return (FALSE);
} }
t3 = Deref(ARG3); t3 = Deref(ARG3);
t1 = Deref(ARG1); t1 = Deref(ARG1);
if (IsVarTerm(t1)) { if (IsVarTerm(t1)) {
_YAP_Error(INSTANTIATION_ERROR,t1,"update_array"); Yap_Error(INSTANTIATION_ERROR,t1,"update_array");
return(FALSE); return(FALSE);
} }
if (!IsAtomTerm(t1)) { if (!IsAtomTerm(t1)) {
@ -1325,11 +1325,11 @@ p_assign_static(void)
Functor f = FunctorOfTerm(t1); Functor f = FunctorOfTerm(t1);
/* store the terms to visit */ /* store the terms to visit */
if (IsExtensionFunctor(f)) { if (IsExtensionFunctor(f)) {
_YAP_Error(TYPE_ERROR_ARRAY,t1,"update_array"); Yap_Error(TYPE_ERROR_ARRAY,t1,"update_array");
return(FALSE); return(FALSE);
} }
if (indx > 0 && indx > ArityOfFunctor(f)) { if (indx > 0 && indx > ArityOfFunctor(f)) {
_YAP_Error(DOMAIN_ERROR_ARRAY_OVERFLOW,t2,"update_array"); Yap_Error(DOMAIN_ERROR_ARRAY_OVERFLOW,t2,"update_array");
return(FALSE); return(FALSE);
} }
ptr = RepAppl(t1)+indx+1; ptr = RepAppl(t1)+indx+1;
@ -1337,11 +1337,11 @@ p_assign_static(void)
MaBind(ptr, t3); MaBind(ptr, t3);
return(TRUE); return(TRUE);
#else #else
_YAP_Error(SYSTEM_ERROR,t2,"update_array"); Yap_Error(SYSTEM_ERROR,t2,"update_array");
return(FALSE); return(FALSE);
#endif #endif
} else { } else {
_YAP_Error(TYPE_ERROR_ATOM,t1,"update_array"); Yap_Error(TYPE_ERROR_ATOM,t1,"update_array");
return(FALSE); return(FALSE);
} }
} }
@ -1356,7 +1356,7 @@ p_assign_static(void)
} }
if (EndOfPAEntr(ptr)) { if (EndOfPAEntr(ptr)) {
_YAP_Error(EXISTENCE_ERROR_ARRAY,t1,"assign_static %s", RepAtom(AtomOfTerm(t1))->StrOfAE); Yap_Error(EXISTENCE_ERROR_ARRAY,t1,"assign_static %s", RepAtom(AtomOfTerm(t1))->StrOfAE);
return(FALSE); return(FALSE);
} }
@ -1365,7 +1365,7 @@ p_assign_static(void)
ArrayEntry *pp = (ArrayEntry *)ptr; ArrayEntry *pp = (ArrayEntry *)ptr;
CELL *pt; CELL *pt;
if (indx < 0 || indx >= pp->ArrayEArity) { if (indx < 0 || indx >= pp->ArrayEArity) {
_YAP_Error(DOMAIN_ERROR_ARRAY_OVERFLOW,t2,"assign_static"); Yap_Error(DOMAIN_ERROR_ARRAY_OVERFLOW,t2,"assign_static");
READ_UNLOCK(((ArrayEntry *)ptr)->ArRWLock); READ_UNLOCK(((ArrayEntry *)ptr)->ArRWLock);
return(FALSE); return(FALSE);
} }
@ -1376,7 +1376,7 @@ p_assign_static(void)
MaBind(pt, t3); MaBind(pt, t3);
return(TRUE); return(TRUE);
#else #else
_YAP_Error(SYSTEM_ERROR,t2,"update_array"); Yap_Error(SYSTEM_ERROR,t2,"update_array");
return(FALSE); return(FALSE);
#endif #endif
} }
@ -1384,12 +1384,12 @@ p_assign_static(void)
/* a static array */ /* a static array */
if (IsVarTerm(t3)) { if (IsVarTerm(t3)) {
WRITE_UNLOCK(ptr->ArRWLock); WRITE_UNLOCK(ptr->ArRWLock);
_YAP_Error(INSTANTIATION_ERROR,t3,"assign_static"); Yap_Error(INSTANTIATION_ERROR,t3,"assign_static");
return (FALSE); return (FALSE);
} }
if (indx < 0 || indx >= - ptr->ArrayEArity) { if (indx < 0 || indx >= - ptr->ArrayEArity) {
WRITE_UNLOCK(ptr->ArRWLock); WRITE_UNLOCK(ptr->ArRWLock);
_YAP_Error(DOMAIN_ERROR_ARRAY_OVERFLOW,t2,"assign_static"); Yap_Error(DOMAIN_ERROR_ARRAY_OVERFLOW,t2,"assign_static");
return(FALSE); return(FALSE);
} }
switch (ptr->ArrayType) { switch (ptr->ArrayType) {
@ -1400,11 +1400,11 @@ p_assign_static(void)
if (IsIntTerm(t3)) if (IsIntTerm(t3))
i = IntOfTerm(t3); i = IntOfTerm(t3);
else if (_YAP_Eval(t3, &v) == long_int_e) else if (Yap_Eval(t3, &v) == long_int_e)
i = v.Int; i = v.Int;
else { else {
WRITE_UNLOCK(ptr->ArRWLock); WRITE_UNLOCK(ptr->ArRWLock);
_YAP_Error(TYPE_ERROR_INTEGER,t3,"assign_static"); Yap_Error(TYPE_ERROR_INTEGER,t3,"assign_static");
return (FALSE); return (FALSE);
} }
ptr->ValueOfVE.ints[indx]= i; ptr->ValueOfVE.ints[indx]= i;
@ -1418,15 +1418,15 @@ p_assign_static(void)
if (IsIntTerm(t3)) if (IsIntTerm(t3))
i = IntOfTerm(t3); i = IntOfTerm(t3);
else if (_YAP_Eval(t3, &v) == long_int_e) else if (Yap_Eval(t3, &v) == long_int_e)
i = v.Int; i = v.Int;
else { else {
_YAP_Error(TYPE_ERROR_INTEGER,t3,"assign_static"); Yap_Error(TYPE_ERROR_INTEGER,t3,"assign_static");
return (FALSE); return (FALSE);
} }
if (i > 127 || i < -128) { if (i > 127 || i < -128) {
WRITE_UNLOCK(ptr->ArRWLock); WRITE_UNLOCK(ptr->ArRWLock);
_YAP_Error(TYPE_ERROR_BYTE,t3,"assign_static"); Yap_Error(TYPE_ERROR_BYTE,t3,"assign_static");
return (FALSE); return (FALSE);
} }
ptr->ValueOfVE.chars[indx]= i; ptr->ValueOfVE.chars[indx]= i;
@ -1440,16 +1440,16 @@ p_assign_static(void)
if (IsIntTerm(t3)) if (IsIntTerm(t3))
i = IntOfTerm(t3); i = IntOfTerm(t3);
else if (_YAP_Eval(t3, &v) == long_int_e) else if (Yap_Eval(t3, &v) == long_int_e)
i = v.Int; i = v.Int;
else { else {
WRITE_UNLOCK(ptr->ArRWLock); WRITE_UNLOCK(ptr->ArRWLock);
_YAP_Error(TYPE_ERROR_INTEGER,t3,"assign_static"); Yap_Error(TYPE_ERROR_INTEGER,t3,"assign_static");
return (FALSE); return (FALSE);
} }
if (i > 255 || i < 0) { if (i > 255 || i < 0) {
WRITE_UNLOCK(ptr->ArRWLock); WRITE_UNLOCK(ptr->ArRWLock);
_YAP_Error(TYPE_ERROR_UBYTE,t3,"assign_static"); Yap_Error(TYPE_ERROR_UBYTE,t3,"assign_static");
return (FALSE); return (FALSE);
} }
ptr->ValueOfVE.chars[indx]= i; ptr->ValueOfVE.chars[indx]= i;
@ -1463,11 +1463,11 @@ p_assign_static(void)
if (IsFloatTerm(t3)) if (IsFloatTerm(t3))
f = FloatOfTerm(t3); f = FloatOfTerm(t3);
else if (_YAP_Eval(t3, &v) == double_e) else if (Yap_Eval(t3, &v) == double_e)
f = v.dbl; f = v.dbl;
else { else {
WRITE_UNLOCK(ptr->ArRWLock); WRITE_UNLOCK(ptr->ArRWLock);
_YAP_Error(TYPE_ERROR_FLOAT,t3,"assign_static"); Yap_Error(TYPE_ERROR_FLOAT,t3,"assign_static");
return (FALSE); return (FALSE);
} }
ptr->ValueOfVE.floats[indx]= f; ptr->ValueOfVE.floats[indx]= f;
@ -1482,7 +1482,7 @@ p_assign_static(void)
r = IntegerOfTerm(t3); r = IntegerOfTerm(t3);
else { else {
WRITE_UNLOCK(ptr->ArRWLock); WRITE_UNLOCK(ptr->ArRWLock);
_YAP_Error(TYPE_ERROR_PTR,t3,"assign_static"); Yap_Error(TYPE_ERROR_PTR,t3,"assign_static");
return (FALSE); return (FALSE);
} }
ptr->ValueOfVE.ptrs[indx]= (AtomEntry *)r; ptr->ValueOfVE.ptrs[indx]= (AtomEntry *)r;
@ -1493,7 +1493,7 @@ p_assign_static(void)
{ {
if (!IsAtomTerm(t3)) { if (!IsAtomTerm(t3)) {
WRITE_UNLOCK(ptr->ArRWLock); WRITE_UNLOCK(ptr->ArRWLock);
_YAP_Error(TYPE_ERROR_ATOM,t3,"assign_static"); Yap_Error(TYPE_ERROR_ATOM,t3,"assign_static");
return (FALSE); return (FALSE);
} }
ptr->ValueOfVE.atoms[indx]= t3; ptr->ValueOfVE.atoms[indx]= t3;
@ -1507,7 +1507,7 @@ p_assign_static(void)
if (!IsDBRefTerm(t3)) { if (!IsDBRefTerm(t3)) {
WRITE_UNLOCK(ptr->ArRWLock); WRITE_UNLOCK(ptr->ArRWLock);
_YAP_Error(TYPE_ERROR_DBREF,t3,"assign_static"); Yap_Error(TYPE_ERROR_DBREF,t3,"assign_static");
return (FALSE); return (FALSE);
} }
ptr->ValueOfVE.dbrefs[indx]= t3; ptr->ValueOfVE.dbrefs[indx]= t3;
@ -1523,9 +1523,9 @@ p_assign_static(void)
DBRef ref = ptr->ValueOfVE.terms[indx]; DBRef ref = ptr->ValueOfVE.terms[indx];
if (ref != NULL) { if (ref != NULL) {
_YAP_ReleaseTermFromDB(ref); Yap_ReleaseTermFromDB(ref);
} }
ptr->ValueOfVE.terms[indx] = _YAP_StoreTermInDB(3,3); ptr->ValueOfVE.terms[indx] = Yap_StoreTermInDB(3,3);
if (ptr->ValueOfVE.terms[indx] == NULL){ if (ptr->ValueOfVE.terms[indx] == NULL){
WRITE_UNLOCK(ptr->ArRWLock); WRITE_UNLOCK(ptr->ArRWLock);
return(FALSE); return(FALSE);
@ -1564,20 +1564,20 @@ p_sync_mmapped_arrays(void)
} }
void void
_YAP_InitArrayPreds(void) Yap_InitArrayPreds(void)
{ {
_YAP_InitCPred("$create_array", 2, p_create_array, SyncPredFlag); Yap_InitCPred("$create_array", 2, p_create_array, SyncPredFlag);
_YAP_InitCPred("$array_references", 3, p_array_references, SafePredFlag); Yap_InitCPred("$array_references", 3, p_array_references, SafePredFlag);
_YAP_InitCPred("$array_arg", 3, p_array_arg, SafePredFlag); Yap_InitCPred("$array_arg", 3, p_array_arg, SafePredFlag);
_YAP_InitCPred("static_array", 3, p_create_static_array, SafePredFlag|SyncPredFlag); Yap_InitCPred("static_array", 3, p_create_static_array, SafePredFlag|SyncPredFlag);
_YAP_InitCPred("resize_static_array", 3, p_resize_static_array, SafePredFlag|SyncPredFlag); Yap_InitCPred("resize_static_array", 3, p_resize_static_array, SafePredFlag|SyncPredFlag);
_YAP_InitCPred("mmapped_array", 4, p_create_mmapped_array, SafePredFlag|SyncPredFlag); Yap_InitCPred("mmapped_array", 4, p_create_mmapped_array, SafePredFlag|SyncPredFlag);
_YAP_InitCPred("update_array", 3, p_assign_static, SafePredFlag); Yap_InitCPred("update_array", 3, p_assign_static, SafePredFlag);
_YAP_InitCPred("array_element", 3, p_access_array, 0); Yap_InitCPred("array_element", 3, p_access_array, 0);
_YAP_InitCPred("close_static_array", 1, p_close_static_array, SafePredFlag); Yap_InitCPred("close_static_array", 1, p_close_static_array, SafePredFlag);
_YAP_InitCPred("$sync_mmapped_arrays", 0, p_sync_mmapped_arrays, SafePredFlag); Yap_InitCPred("$sync_mmapped_arrays", 0, p_sync_mmapped_arrays, SafePredFlag);
_YAP_InitCPred("$compile_array_refs", 0, p_compile_array_refs, SafePredFlag); Yap_InitCPred("$compile_array_refs", 0, p_compile_array_refs, SafePredFlag);
_YAP_InitCPred("$array_refs_compiled", 0, p_array_refs_compiled, SafePredFlag); Yap_InitCPred("$array_refs_compiled", 0, p_array_refs_compiled, SafePredFlag);
_YAP_InitCPred("$has_static_array", 1, p_has_static_array, TestPredFlag|SafePredFlag); Yap_InitCPred("$has_static_array", 1, p_has_static_array, TestPredFlag|SafePredFlag);
} }

114
C/attvar.c
View File

@ -44,15 +44,15 @@ AddToQueue(attvar_record *attv)
t[0] = (CELL)&(attv->Done); t[0] = (CELL)&(attv->Done);
t[1] = attv->Value; t[1] = attv->Value;
/* follow the chain */ /* follow the chain */
WGs = (sus_record *)_YAP_ReadTimedVar(WokenGoals); WGs = (sus_record *)Yap_ReadTimedVar(WokenGoals);
new = (sus_record *)H; new = (sus_record *)H;
H = (CELL *)(new+1); H = (CELL *)(new+1);
new->NR = (sus_record *)(&(new->NR)); new->NR = (sus_record *)(&(new->NR));
new->SG = _YAP_MkApplTerm(FunctorAttGoal, 2, t); new->SG = Yap_MkApplTerm(FunctorAttGoal, 2, t);
new->NS = new; new->NS = new;
if ((Term)WGs == TermNil) { if ((Term)WGs == TermNil) {
_YAP_UpdateTimedVar(WokenGoals, (CELL)new); Yap_UpdateTimedVar(WokenGoals, (CELL)new);
/* from now on, we have to start waking up goals */ /* from now on, we have to start waking up goals */
if (CreepFlag != Unsigned(LCL0) - Unsigned(H0)) if (CreepFlag != Unsigned(LCL0) - Unsigned(H0))
CreepFlag = Unsigned(LCL0); CreepFlag = Unsigned(LCL0);
@ -71,7 +71,7 @@ AddFailToQueue(void)
sus_record *new; sus_record *new;
/* follow the chain */ /* follow the chain */
WGs = (sus_record *)_YAP_ReadTimedVar(WokenGoals); WGs = (sus_record *)Yap_ReadTimedVar(WokenGoals);
new = (sus_record *)H; new = (sus_record *)H;
H = (CELL *)(new+1); H = (CELL *)(new+1);
new->NR = (sus_record *)(&(new->NR)); new->NR = (sus_record *)(&(new->NR));
@ -79,7 +79,7 @@ AddFailToQueue(void)
new->NS = new; new->NS = new;
if ((Term)WGs == TermNil) { if ((Term)WGs == TermNil) {
_YAP_UpdateTimedVar(WokenGoals, (CELL)new); Yap_UpdateTimedVar(WokenGoals, (CELL)new);
/* from now on, we have to start waking up goals */ /* from now on, we have to start waking up goals */
if (CreepFlag != Unsigned(LCL0) - Unsigned(H0)) if (CreepFlag != Unsigned(LCL0) - Unsigned(H0))
CreepFlag = Unsigned(LCL0); CreepFlag = Unsigned(LCL0);
@ -101,13 +101,13 @@ CopyAttVar(CELL *orig, CELL ***to_visit_ptr, CELL *res)
Int j; Int j;
/* add a new attributed variable */ /* add a new attributed variable */
newv = (attvar_record *)_YAP_ReadTimedVar(DelayedVars); newv = (attvar_record *)Yap_ReadTimedVar(DelayedVars);
if (H0 - (CELL *)newv < 1024+(2*NUM_OF_ATTS)) if (H0 - (CELL *)newv < 1024+(2*NUM_OF_ATTS))
return(FALSE); return(FALSE);
RESET_VARIABLE(&(newv->Done)); RESET_VARIABLE(&(newv->Done));
newv->sus_id = attvars_ext; newv->sus_id = attvars_ext;
RESET_VARIABLE(&(newv->Value)); RESET_VARIABLE(&(newv->Value));
newv->NS = _YAP_UpdateTimedVar(AttsMutableList, (CELL)&(newv->Done)); newv->NS = Yap_UpdateTimedVar(AttsMutableList, (CELL)&(newv->Done));
for (j = 0; j < NUM_OF_ATTS; j++) { for (j = 0; j < NUM_OF_ATTS; j++) {
Term t = Deref(attv->Atts[2*j+1]); Term t = Deref(attv->Atts[2*j+1]);
newv->Atts[2*j] = time; newv->Atts[2*j] = time;
@ -135,7 +135,7 @@ CopyAttVar(CELL *orig, CELL ***to_visit_ptr, CELL *res)
} }
*to_visit_ptr = to_visit; *to_visit_ptr = to_visit;
*res = (CELL)&(newv->Done); *res = (CELL)&(newv->Done);
_YAP_UpdateTimedVar(DelayedVars, (CELL)(newv->Atts+2*j)); Yap_UpdateTimedVar(DelayedVars, (CELL)(newv->Atts+2*j));
return(TRUE); return(TRUE);
} }
@ -177,14 +177,14 @@ WakeAttVar(CELL* pt1, CELL reg2)
/* binding two suspended variables, be careful */ /* binding two suspended variables, be careful */
if (susp2->sus_id != attvars_ext) { if (susp2->sus_id != attvars_ext) {
/* joining two different kinds of suspensions */ /* joining two different kinds of suspensions */
_YAP_Error(SYSTEM_ERROR, TermNil, "joining two different suspensions not implemented"); Yap_Error(SYSTEM_ERROR, TermNil, "joining two different suspensions not implemented");
return; return;
} }
if (susp2 >= attv) { if (susp2 >= attv) {
if (susp2 == attv) return; if (susp2 == attv) return;
if (!IsVarTerm(susp2->Value) || !IsUnboundVar(susp2->Value)) { if (!IsVarTerm(susp2->Value) || !IsUnboundVar(susp2->Value)) {
/* oops, our goal is on the queue to be woken */ /* oops, our goal is on the queue to be woken */
if (!_YAP_unify(susp2->Value, (CELL)pt1)) { if (!Yap_unify(susp2->Value, (CELL)pt1)) {
AddFailToQueue(); AddFailToQueue();
} }
} }
@ -199,7 +199,7 @@ WakeAttVar(CELL* pt1, CELL reg2)
} }
if (!IsVarTerm(attv->Value) || !IsUnboundVar(attv->Value)) { if (!IsVarTerm(attv->Value) || !IsUnboundVar(attv->Value)) {
/* oops, our goal is on the queue to be woken */ /* oops, our goal is on the queue to be woken */
if (!_YAP_unify(attv->Value, reg2)) { if (!Yap_unify(attv->Value, reg2)) {
AddFailToQueue(); AddFailToQueue();
} }
return; return;
@ -221,17 +221,17 @@ mark_attvar(CELL *orig)
register attvar_record *attv = (attvar_record *)orig; register attvar_record *attv = (attvar_record *)orig;
Int i; Int i;
_YAP_mark_external_reference(&(attv->Value)); Yap_mark_external_reference(&(attv->Value));
_YAP_mark_external_reference(&(attv->Done)); Yap_mark_external_reference(&(attv->Done));
for (i = 0; i < NUM_OF_ATTS; i++) { for (i = 0; i < NUM_OF_ATTS; i++) {
_YAP_mark_external_reference(attv->Atts+2*i+1); Yap_mark_external_reference(attv->Atts+2*i+1);
} }
} }
#if FROZEN_STACKS #if FROZEN_STACKS
static Term static Term
CurrentTime(void) { CurrentTime(void) {
return(MkIntegerTerm(TR-(tr_fr_ptr)_YAP_TrailBase)); return(MkIntegerTerm(TR-(tr_fr_ptr)Yap_TrailBase));
} }
#endif #endif
@ -244,7 +244,7 @@ InitVarTime(void) {
/* so we just init a TR cell that will not harm anyone */ /* so we just init a TR cell that will not harm anyone */
Bind((CELL *)(TR+1),AbsAppl(H-1)); Bind((CELL *)(TR+1),AbsAppl(H-1));
} }
return(MkIntegerTerm(B->cp_tr-(tr_fr_ptr)_YAP_TrailBase)); return(MkIntegerTerm(B->cp_tr-(tr_fr_ptr)Yap_TrailBase));
#else #else
Term t = (CELL)H; Term t = (CELL)H;
*H++ = TermFoundVar; *H++ = TermFoundVar;
@ -256,7 +256,7 @@ static Int
PutAtt(attvar_record *attv, Int i, Term tatt) { PutAtt(attvar_record *attv, Int i, Term tatt) {
Int pos = i*2; Int pos = i*2;
#if FROZEN_STACKS #if FROZEN_STACKS
tr_fr_ptr timestmp = (tr_fr_ptr)_YAP_TrailBase+IntegerOfTerm(attv->Atts[pos]); tr_fr_ptr timestmp = (tr_fr_ptr)Yap_TrailBase+IntegerOfTerm(attv->Atts[pos]);
if (B->cp_tr <= timestmp if (B->cp_tr <= timestmp
&& timestmp <= TR) { && timestmp <= TR) {
#if defined(SBA) #if defined(SBA)
@ -297,7 +297,7 @@ RmAtt(attvar_record *attv, Int i) {
Int pos = i *2; Int pos = i *2;
if (!IsVarTerm(attv->Atts[pos+1])) { if (!IsVarTerm(attv->Atts[pos+1])) {
#if FROZEN_STACKS #if FROZEN_STACKS
tr_fr_ptr timestmp = (tr_fr_ptr)_YAP_TrailBase+IntegerOfTerm(attv->Atts[pos]); tr_fr_ptr timestmp = (tr_fr_ptr)Yap_TrailBase+IntegerOfTerm(attv->Atts[pos]);
if (B->cp_tr <= timestmp if (B->cp_tr <= timestmp
&& timestmp <= TR) { && timestmp <= TR) {
RESET_VARIABLE(attv->Atts+(pos+1)); RESET_VARIABLE(attv->Atts+(pos+1));
@ -344,13 +344,13 @@ BuildNewAttVar(Term t, Int i, Term tatt)
Term time; Term time;
int j; int j;
attvar_record *attv = (attvar_record *)_YAP_ReadTimedVar(DelayedVars); attvar_record *attv = (attvar_record *)Yap_ReadTimedVar(DelayedVars);
if (H0 - (CELL *)attv < 1024+(2*NUM_OF_ATTS)) { if (H0 - (CELL *)attv < 1024+(2*NUM_OF_ATTS)) {
H[0] = t; H[0] = t;
H[1] = tatt; H[1] = tatt;
H += 2; H += 2;
if (!_YAP_growglobal(NULL)) { if (!Yap_growglobal(NULL)) {
_YAP_Error(SYSTEM_ERROR, t, _YAP_ErrorMessage); Yap_Error(SYSTEM_ERROR, t, Yap_ErrorMessage);
return FALSE; return FALSE;
} }
H -= 2; H -= 2;
@ -365,9 +365,9 @@ BuildNewAttVar(Term t, Int i, Term tatt)
attv->Atts[2*j] = time; attv->Atts[2*j] = time;
RESET_VARIABLE(attv->Atts+2*j+1); RESET_VARIABLE(attv->Atts+2*j+1);
} }
attv->NS = _YAP_UpdateTimedVar(AttsMutableList, (CELL)&(attv->Done)); attv->NS = Yap_UpdateTimedVar(AttsMutableList, (CELL)&(attv->Done));
Bind((CELL *)t,(CELL)attv); Bind((CELL *)t,(CELL)attv);
_YAP_UpdateTimedVar(DelayedVars,(CELL)(attv->Atts+2*j)); Yap_UpdateTimedVar(DelayedVars,(CELL)(attv->Atts+2*j));
/* if i < 0 then we have the list of arguments */ /* if i < 0 then we have the list of arguments */
if (i < 0) { if (i < 0) {
Int j = 0; Int j = 0;
@ -408,7 +408,7 @@ BindAttVar(attvar_record *attv) {
Bind_Global(&(attv->Done), attv->Value); Bind_Global(&(attv->Done), attv->Value);
return(TRUE); return(TRUE);
} else { } else {
_YAP_Error(SYSTEM_ERROR,(CELL)&(attv->Done),"attvar was bound when set"); Yap_Error(SYSTEM_ERROR,(CELL)&(attv->Done),"attvar was bound when set");
return(FALSE); return(FALSE);
} }
} }
@ -437,8 +437,8 @@ AllAttVars(Term t) {
} }
Term Term
_YAP_CurrentAttVars(void) { Yap_CurrentAttVars(void) {
return(AllAttVars(_YAP_ReadTimedVar(AttsMutableList))); return(AllAttVars(Yap_ReadTimedVar(AttsMutableList)));
} }
@ -453,14 +453,14 @@ p_put_att(void) {
exts id = (exts)attv->sus_id; exts id = (exts)attv->sus_id;
if (id != attvars_ext) { if (id != attvars_ext) {
_YAP_Error(TYPE_ERROR_VARIABLE,inp,"put_attributes/2"); Yap_Error(TYPE_ERROR_VARIABLE,inp,"put_attributes/2");
return(FALSE); return(FALSE);
} }
return(PutAtt(attv, IntegerOfTerm(Deref(ARG2)), Deref(ARG3))); return(PutAtt(attv, IntegerOfTerm(Deref(ARG2)), Deref(ARG3)));
} }
return(BuildNewAttVar(inp, IntegerOfTerm(Deref(ARG2)), Deref(ARG3))); return(BuildNewAttVar(inp, IntegerOfTerm(Deref(ARG2)), Deref(ARG3)));
} else { } else {
_YAP_Error(TYPE_ERROR_VARIABLE,inp,"put_attributes/2"); Yap_Error(TYPE_ERROR_VARIABLE,inp,"put_attributes/2");
return(FALSE); return(FALSE);
} }
} }
@ -476,14 +476,14 @@ p_rm_att(void) {
exts id = (exts)attv->sus_id; exts id = (exts)attv->sus_id;
if (id != attvars_ext) { if (id != attvars_ext) {
_YAP_Error(TYPE_ERROR_VARIABLE,inp,"delete_attribute/2"); Yap_Error(TYPE_ERROR_VARIABLE,inp,"delete_attribute/2");
return(FALSE); return(FALSE);
} }
return(RmAtt(attv, IntegerOfTerm(Deref(ARG2)))); return(RmAtt(attv, IntegerOfTerm(Deref(ARG2))));
} }
return(TRUE); return(TRUE);
} else { } else {
_YAP_Error(TYPE_ERROR_VARIABLE,inp,"delete_attribute/2"); Yap_Error(TYPE_ERROR_VARIABLE,inp,"delete_attribute/2");
return(FALSE); return(FALSE);
} }
} }
@ -500,16 +500,16 @@ p_get_att(void) {
exts id = (exts)attv->sus_id; exts id = (exts)attv->sus_id;
if (id != attvars_ext) { if (id != attvars_ext) {
_YAP_Error(TYPE_ERROR_VARIABLE,inp,"get_att/2"); Yap_Error(TYPE_ERROR_VARIABLE,inp,"get_att/2");
return(FALSE); return(FALSE);
} }
out = GetAtt(attv,IntegerOfTerm(Deref(ARG2))); out = GetAtt(attv,IntegerOfTerm(Deref(ARG2)));
return(!IsVarTerm(out) && _YAP_unify(ARG3,out)); return(!IsVarTerm(out) && Yap_unify(ARG3,out));
} }
/* _YAP_Error(INSTANTIATION_ERROR,inp,"get_att/2");*/ /* Yap_Error(INSTANTIATION_ERROR,inp,"get_att/2");*/
return(FALSE); return(FALSE);
} else { } else {
_YAP_Error(TYPE_ERROR_VARIABLE,inp,"get_att/2"); Yap_Error(TYPE_ERROR_VARIABLE,inp,"get_att/2");
return(FALSE); return(FALSE);
} }
} }
@ -525,14 +525,14 @@ p_free_att(void) {
exts id = (exts)attv->sus_id; exts id = (exts)attv->sus_id;
if (id != attvars_ext) { if (id != attvars_ext) {
_YAP_Error(TYPE_ERROR_VARIABLE,inp,"get_att/2"); Yap_Error(TYPE_ERROR_VARIABLE,inp,"get_att/2");
return(FALSE); return(FALSE);
} }
return(FreeAtt(attv,IntegerOfTerm(Deref(ARG2)))); return(FreeAtt(attv,IntegerOfTerm(Deref(ARG2))));
} }
return(TRUE); return(TRUE);
} else { } else {
_YAP_Error(TYPE_ERROR_VARIABLE,inp,"free_att/2"); Yap_Error(TYPE_ERROR_VARIABLE,inp,"free_att/2");
return(FALSE); return(FALSE);
} }
} }
@ -548,14 +548,14 @@ p_bind_attvar(void) {
exts id = (exts)attv->sus_id; exts id = (exts)attv->sus_id;
if (id != attvars_ext) { if (id != attvars_ext) {
_YAP_Error(TYPE_ERROR_VARIABLE,inp,"get_att/2"); Yap_Error(TYPE_ERROR_VARIABLE,inp,"get_att/2");
return(FALSE); return(FALSE);
} }
return(BindAttVar(attv)); return(BindAttVar(attv));
} }
return(TRUE); return(TRUE);
} else { } else {
_YAP_Error(TYPE_ERROR_VARIABLE,inp,"bind_att/2"); Yap_Error(TYPE_ERROR_VARIABLE,inp,"bind_att/2");
return(FALSE); return(FALSE);
} }
} }
@ -571,14 +571,14 @@ p_get_all_atts(void) {
exts id = (exts)(attv->sus_id); exts id = (exts)(attv->sus_id);
if (id != attvars_ext) { if (id != attvars_ext) {
_YAP_Error(TYPE_ERROR_VARIABLE,inp,"get_att/2"); Yap_Error(TYPE_ERROR_VARIABLE,inp,"get_att/2");
return(FALSE); return(FALSE);
} }
return(_YAP_unify(ARG2,GetAllAtts(attv))); return(Yap_unify(ARG2,GetAllAtts(attv)));
} }
return(TRUE); return(TRUE);
} else { } else {
_YAP_Error(TYPE_ERROR_VARIABLE,inp,"get_att/2"); Yap_Error(TYPE_ERROR_VARIABLE,inp,"get_att/2");
return(FALSE); return(FALSE);
} }
} }
@ -588,21 +588,21 @@ p_inc_atts(void)
{ {
Term t = MkIntegerTerm(NUM_OF_ATTS); Term t = MkIntegerTerm(NUM_OF_ATTS);
NUM_OF_ATTS++; NUM_OF_ATTS++;
return(_YAP_unify(ARG1,t)); return(Yap_unify(ARG1,t));
} }
static Int static Int
p_n_atts(void) p_n_atts(void)
{ {
Term t = MkIntegerTerm(NUM_OF_ATTS); Term t = MkIntegerTerm(NUM_OF_ATTS);
return(_YAP_unify(ARG1,t)); return(Yap_unify(ARG1,t));
} }
static Int static Int
p_all_attvars(void) p_all_attvars(void)
{ {
Term t = _YAP_ReadTimedVar(AttsMutableList); Term t = Yap_ReadTimedVar(AttsMutableList);
return(_YAP_unify(ARG1,AllAttVars(t))); return(Yap_unify(ARG1,AllAttVars(t)));
} }
static Int static Int
@ -625,24 +625,24 @@ p_attvar_bound(void)
!IsUnboundVar(((attvar_record *)VarOfTerm(t))->Done)); !IsUnboundVar(((attvar_record *)VarOfTerm(t))->Done));
} }
void _YAP_InitAttVarPreds(void) void Yap_InitAttVarPreds(void)
{ {
attas[attvars_ext].bind_op = WakeAttVar; attas[attvars_ext].bind_op = WakeAttVar;
attas[attvars_ext].copy_term_op = CopyAttVar; attas[attvars_ext].copy_term_op = CopyAttVar;
attas[attvars_ext].to_term_op = AttVarToTerm; attas[attvars_ext].to_term_op = AttVarToTerm;
attas[attvars_ext].term_to_op = TermToAttVar; attas[attvars_ext].term_to_op = TermToAttVar;
attas[attvars_ext].mark_op = mark_attvar; attas[attvars_ext].mark_op = mark_attvar;
_YAP_InitCPred("get_att", 3, p_get_att, SafePredFlag); Yap_InitCPred("get_att", 3, p_get_att, SafePredFlag);
_YAP_InitCPred("get_all_atts", 2, p_get_all_atts, SafePredFlag); Yap_InitCPred("get_all_atts", 2, p_get_all_atts, SafePredFlag);
_YAP_InitCPred("free_att", 2, p_free_att, SafePredFlag); Yap_InitCPred("free_att", 2, p_free_att, SafePredFlag);
_YAP_InitCPred("put_att", 3, p_put_att, 0); Yap_InitCPred("put_att", 3, p_put_att, 0);
_YAP_InitCPred("rm_att", 2, p_rm_att, SafePredFlag); Yap_InitCPred("rm_att", 2, p_rm_att, SafePredFlag);
_YAP_InitCPred("inc_n_of_atts", 1, p_inc_atts, SafePredFlag); Yap_InitCPred("inc_n_of_atts", 1, p_inc_atts, SafePredFlag);
_YAP_InitCPred("n_of_atts", 1, p_n_atts, SafePredFlag); Yap_InitCPred("n_of_atts", 1, p_n_atts, SafePredFlag);
_YAP_InitCPred("bind_attvar", 1, p_bind_attvar, SafePredFlag); Yap_InitCPred("bind_attvar", 1, p_bind_attvar, SafePredFlag);
_YAP_InitCPred("all_attvars", 1, p_all_attvars, SafePredFlag); Yap_InitCPred("all_attvars", 1, p_all_attvars, SafePredFlag);
_YAP_InitCPred("$is_att_variable", 1, p_is_attvar, SafePredFlag|TestPredFlag); Yap_InitCPred("$is_att_variable", 1, p_is_attvar, SafePredFlag|TestPredFlag);
_YAP_InitCPred("$att_bound", 1, p_attvar_bound, SafePredFlag|TestPredFlag); Yap_InitCPred("$att_bound", 1, p_attvar_bound, SafePredFlag|TestPredFlag);
} }
#endif /* COROUTINING */ #endif /* COROUTINING */

72
C/bb.c
View File

@ -38,10 +38,10 @@ PutBBProp(AtomEntry *ae, SMALLUNSGN mod) /* get BBentry for at; */
p = RepBBProp(p0 = p->NextOfPE); p = RepBBProp(p0 = p->NextOfPE);
} }
if (p0 == NIL) { if (p0 == NIL) {
p = (BBProp)_YAP_AllocAtomSpace(sizeof(*p)); p = (BBProp)Yap_AllocAtomSpace(sizeof(*p));
if (p == NULL) { if (p == NULL) {
WRITE_UNLOCK(ae->ARWLock); WRITE_UNLOCK(ae->ARWLock);
_YAP_Error(SYSTEM_ERROR,ARG1,"could not allocate space in bb_put/2"); Yap_Error(SYSTEM_ERROR,ARG1,"could not allocate space in bb_put/2");
return(NULL); return(NULL);
} }
p->NextOfPE = ae->PropsOfAE; p->NextOfPE = ae->PropsOfAE;
@ -64,7 +64,7 @@ PutIntBBProp(Int key, SMALLUNSGN mod) /* get BBentry for at; */
UInt hash_key; UInt hash_key;
if (INT_BB_KEYS == NULL) { if (INT_BB_KEYS == NULL) {
INT_BB_KEYS = (Prop *)_YAP_AllocCodeSpace(sizeof(Prop)*INT_BB_KEYS_SIZE); INT_BB_KEYS = (Prop *)Yap_AllocCodeSpace(sizeof(Prop)*INT_BB_KEYS_SIZE);
if (INT_BB_KEYS != NULL) { if (INT_BB_KEYS != NULL) {
UInt i = 0; UInt i = 0;
Prop *pp = INT_BB_KEYS; Prop *pp = INT_BB_KEYS;
@ -73,7 +73,7 @@ PutIntBBProp(Int key, SMALLUNSGN mod) /* get BBentry for at; */
pp++; pp++;
} }
} else { } else {
_YAP_Error(SYSTEM_ERROR,ARG1,"could not allocate space in bb_put/2"); Yap_Error(SYSTEM_ERROR,ARG1,"could not allocate space in bb_put/2");
return(NULL); return(NULL);
} }
} }
@ -87,10 +87,10 @@ PutIntBBProp(Int key, SMALLUNSGN mod) /* get BBentry for at; */
} }
if (p0 == NIL) { if (p0 == NIL) {
YAPEnterCriticalSection(); YAPEnterCriticalSection();
p = (BBProp)_YAP_AllocAtomSpace(sizeof(*p)); p = (BBProp)Yap_AllocAtomSpace(sizeof(*p));
if (p == NULL) { if (p == NULL) {
YAPLeaveCriticalSection(); YAPLeaveCriticalSection();
_YAP_Error(SYSTEM_ERROR,ARG1,"could not allocate space in bb_put/2"); Yap_Error(SYSTEM_ERROR,ARG1,"could not allocate space in bb_put/2");
return(NULL); return(NULL);
} }
p->ModuleOfBB = mod; p->ModuleOfBB = mod;
@ -157,10 +157,10 @@ resize_bb_int_keys(UInt new_size) {
YAPLeaveCriticalSection(); YAPLeaveCriticalSection();
return(TRUE); return(TRUE);
} }
new = (Prop *)_YAP_AllocCodeSpace(sizeof(Prop)*new_size); new = (Prop *)Yap_AllocCodeSpace(sizeof(Prop)*new_size);
if (new == NULL) { if (new == NULL) {
YAPLeaveCriticalSection(); YAPLeaveCriticalSection();
_YAP_Error(SYSTEM_ERROR,ARG1,"could not allocate space"); Yap_Error(SYSTEM_ERROR,ARG1,"could not allocate space");
return(FALSE); return(FALSE);
} }
for (i = 0; i < new_size; i++) { for (i = 0; i < new_size; i++) {
@ -179,7 +179,7 @@ resize_bb_int_keys(UInt new_size) {
} }
} }
} }
_YAP_FreeCodeSpace((char *)INT_BB_KEYS); Yap_FreeCodeSpace((char *)INT_BB_KEYS);
INT_BB_KEYS = new; INT_BB_KEYS = new;
INT_BB_KEYS_SIZE = new_size; INT_BB_KEYS_SIZE = new_size;
YAPLeaveCriticalSection(); YAPLeaveCriticalSection();
@ -193,7 +193,7 @@ AddBBProp(Term t1, char *msg, SMALLUNSGN mod)
restart: restart:
if (IsVarTerm(t1)) { if (IsVarTerm(t1)) {
_YAP_Error(INSTANTIATION_ERROR, t1, msg); Yap_Error(INSTANTIATION_ERROR, t1, msg);
return(NULL); return(NULL);
} if (IsAtomTerm(t1)) { } if (IsAtomTerm(t1)) {
p = PutBBProp(RepAtom(AtomOfTerm(t1)), mod); p = PutBBProp(RepAtom(AtomOfTerm(t1)), mod);
@ -203,14 +203,14 @@ AddBBProp(Term t1, char *msg, SMALLUNSGN mod)
Term tmod = ArgOfTerm(1, t1); Term tmod = ArgOfTerm(1, t1);
if (!IsVarTerm(tmod) ) { if (!IsVarTerm(tmod) ) {
t1 = ArgOfTerm(2, t1); t1 = ArgOfTerm(2, t1);
mod = _YAP_LookupModule(tmod); mod = Yap_LookupModule(tmod);
goto restart; goto restart;
} else { } else {
_YAP_Error(INSTANTIATION_ERROR, t1, msg); Yap_Error(INSTANTIATION_ERROR, t1, msg);
return(NULL); return(NULL);
} }
} else { } else {
_YAP_Error(TYPE_ERROR_ATOM, t1, msg); Yap_Error(TYPE_ERROR_ATOM, t1, msg);
return(NULL); return(NULL);
} }
return(p); return(p);
@ -223,7 +223,7 @@ FetchBBProp(Term t1, char *msg, SMALLUNSGN mod)
restart: restart:
if (IsVarTerm(t1)) { if (IsVarTerm(t1)) {
_YAP_Error(INSTANTIATION_ERROR, t1, msg); Yap_Error(INSTANTIATION_ERROR, t1, msg);
return(NULL); return(NULL);
} if (IsAtomTerm(t1)) { } if (IsAtomTerm(t1)) {
p = GetBBProp(RepAtom(AtomOfTerm(t1)), mod); p = GetBBProp(RepAtom(AtomOfTerm(t1)), mod);
@ -232,15 +232,15 @@ FetchBBProp(Term t1, char *msg, SMALLUNSGN mod)
} else if (IsApplTerm(t1) && FunctorOfTerm(t1) == FunctorModule) { } else if (IsApplTerm(t1) && FunctorOfTerm(t1) == FunctorModule) {
Term tmod = ArgOfTerm(1, t1); Term tmod = ArgOfTerm(1, t1);
if (!IsVarTerm(tmod) ) { if (!IsVarTerm(tmod) ) {
mod = _YAP_LookupModule(tmod); mod = Yap_LookupModule(tmod);
t1 = ArgOfTerm(2, t1); t1 = ArgOfTerm(2, t1);
goto restart; goto restart;
} else { } else {
_YAP_Error(INSTANTIATION_ERROR, t1, msg); Yap_Error(INSTANTIATION_ERROR, t1, msg);
return(NULL); return(NULL);
} }
} else { } else {
_YAP_Error(TYPE_ERROR_ATOM, t1, msg); Yap_Error(TYPE_ERROR_ATOM, t1, msg);
return(NULL); return(NULL);
} }
return(p); return(p);
@ -255,9 +255,9 @@ p_bb_put(void)
return(FALSE); return(FALSE);
WRITE_LOCK(p->BBRWLock); WRITE_LOCK(p->BBRWLock);
if (p->Element != NULL) { if (p->Element != NULL) {
_YAP_ReleaseTermFromDB(p->Element); Yap_ReleaseTermFromDB(p->Element);
} }
p->Element = _YAP_StoreTermInDB(2,2); p->Element = Yap_StoreTermInDB(2,2);
WRITE_UNLOCK(p->BBRWLock); WRITE_UNLOCK(p->BBRWLock);
return(p->Element != NULL); return(p->Element != NULL);
} }
@ -271,9 +271,9 @@ p_bb_get(void)
if (p == NULL || p->Element == NULL) if (p == NULL || p->Element == NULL)
return(FALSE); return(FALSE);
READ_LOCK(p->BBRWLock); READ_LOCK(p->BBRWLock);
out = _YAP_FetchTermFromDB(p->Element,3); out = Yap_FetchTermFromDB(p->Element,3);
READ_UNLOCK(p->BBRWLock); READ_UNLOCK(p->BBRWLock);
return(_YAP_unify(ARG2,out)); return(Yap_unify(ARG2,out));
} }
static Int static Int
@ -286,12 +286,12 @@ p_bb_delete(void)
p = FetchBBProp(t1, "bb_delete/2", CurrentModule); p = FetchBBProp(t1, "bb_delete/2", CurrentModule);
if (p == NULL || p->Element == NULL) if (p == NULL || p->Element == NULL)
return(FALSE); return(FALSE);
out = _YAP_FetchTermFromDB(p->Element,3); out = Yap_FetchTermFromDB(p->Element,3);
WRITE_LOCK(p->BBRWLock); WRITE_LOCK(p->BBRWLock);
_YAP_ReleaseTermFromDB(p->Element); Yap_ReleaseTermFromDB(p->Element);
p->Element = NULL; p->Element = NULL;
WRITE_UNLOCK(p->BBRWLock); WRITE_UNLOCK(p->BBRWLock);
return(_YAP_unify(ARG2,out)); return(Yap_unify(ARG2,out));
} }
static Int static Int
@ -305,14 +305,14 @@ p_bb_update(void)
if (p == NULL || p->Element == NULL) if (p == NULL || p->Element == NULL)
return(FALSE); return(FALSE);
WRITE_LOCK(p->BBRWLock); WRITE_LOCK(p->BBRWLock);
out = _YAP_FetchTermFromDB(p->Element,3); out = Yap_FetchTermFromDB(p->Element,3);
if (!_YAP_unify(ARG2,out)) { if (!Yap_unify(ARG2,out)) {
WRITE_UNLOCK(p->BBRWLock); WRITE_UNLOCK(p->BBRWLock);
return(FALSE); return(FALSE);
} }
_YAP_ReleaseTermFromDB(p->Element); Yap_ReleaseTermFromDB(p->Element);
p->Element = _YAP_StoreTermInDB(3,3); p->Element = Yap_StoreTermInDB(3,3);
WRITE_UNLOCK(p->BBRWLock); WRITE_UNLOCK(p->BBRWLock);
return(p->Element != NULL); return(p->Element != NULL);
} }
@ -322,22 +322,22 @@ p_resize_bb_int_keys(void)
{ {
Term t1 = Deref(ARG1); Term t1 = Deref(ARG1);
if (IsVarTerm(t1)) { if (IsVarTerm(t1)) {
return(_YAP_unify(ARG1,MkIntegerTerm((Int)INT_BB_KEYS_SIZE))); return(Yap_unify(ARG1,MkIntegerTerm((Int)INT_BB_KEYS_SIZE)));
} }
if (!IsIntegerTerm(t1)) { if (!IsIntegerTerm(t1)) {
_YAP_Error(TYPE_ERROR_INTEGER, t1, "yap_flag(resize_bb_int_keys,T)"); Yap_Error(TYPE_ERROR_INTEGER, t1, "yap_flag(resize_bb_int_keys,T)");
return(FALSE); return(FALSE);
} }
return(resize_bb_int_keys(IntegerOfTerm(t1))); return(resize_bb_int_keys(IntegerOfTerm(t1)));
} }
void void
_YAP_InitBBPreds(void) Yap_InitBBPreds(void)
{ {
_YAP_InitCPred("bb_put", 2, p_bb_put, 0); Yap_InitCPred("bb_put", 2, p_bb_put, 0);
_YAP_InitCPred("bb_get", 2, p_bb_get, 0); Yap_InitCPred("bb_get", 2, p_bb_get, 0);
_YAP_InitCPred("bb_delete", 2, p_bb_delete, 0); Yap_InitCPred("bb_delete", 2, p_bb_delete, 0);
_YAP_InitCPred("bb_update", 3, p_bb_update, 0); Yap_InitCPred("bb_update", 3, p_bb_update, 0);
_YAP_InitCPred("$resize_bb_int_keys", 1, p_resize_bb_int_keys, SafePredFlag|SyncPredFlag); Yap_InitCPred("$resize_bb_int_keys", 1, p_resize_bb_int_keys, SafePredFlag|SyncPredFlag);
} }

18
C/bignum.c
View File

@ -35,7 +35,7 @@ static char SccsId[] = "%W% %G%";
static CELL *pre_alloc_base = NULL, *alloc_ptr; static CELL *pre_alloc_base = NULL, *alloc_ptr;
MP_INT * MP_INT *
_YAP_PreAllocBigNum(void) Yap_PreAllocBigNum(void)
{ {
MP_INT *ret; MP_INT *ret;
@ -54,14 +54,14 @@ _YAP_PreAllocBigNum(void)
} }
void void
_YAP_CleanBigNum(void) Yap_CleanBigNum(void)
{ {
H = pre_alloc_base; H = pre_alloc_base;
pre_alloc_base = NULL; pre_alloc_base = NULL;
} }
MP_INT * MP_INT *
_YAP_InitBigNum(Int in) Yap_InitBigNum(Int in)
{ {
MP_INT *ret; MP_INT *ret;
@ -99,7 +99,7 @@ AllocBigNumSpace(size_t size)
alloc_ptr[0] = size; alloc_ptr[0] = size;
alloc_ptr += size+1; alloc_ptr += size+1;
if (alloc_ptr > ASP-1024) if (alloc_ptr > ASP-1024)
_YAP_Error(SYSTEM_ERROR,TermNil,"no space for bignum"); Yap_Error(SYSTEM_ERROR,TermNil,"no space for bignum");
return(ret); return(ret);
} }
@ -117,7 +117,7 @@ ReAllocBigNumSpace(void *optr, size_t osize, size_t size)
alloc_ptr += (size-osize); alloc_ptr += (size-osize);
((CELL *)optr)[-1] = size; ((CELL *)optr)[-1] = size;
if (alloc_ptr > ASP-1024) if (alloc_ptr > ASP-1024)
_YAP_Error(SYSTEM_ERROR,TermNil,"no space for bignum"); Yap_Error(SYSTEM_ERROR,TermNil,"no space for bignum");
return(optr); return(optr);
} }
out = AllocBigNumSpace(size); out = AllocBigNumSpace(size);
@ -154,7 +154,7 @@ FreeBigNumSpace(void *optr, size_t size)
pre_alloc_base; pre_alloc_base;
*/ */
Term Term
_YAP_MkBigIntTerm(MP_INT *big) Yap_MkBigIntTerm(MP_INT *big)
{ {
CELL *new = (CELL *)(big+1); CELL *new = (CELL *)(big+1);
Int nlimbs = (big->_mp_alloc)*(sizeof(mp_limb_t)/CellSize); Int nlimbs = (big->_mp_alloc)*(sizeof(mp_limb_t)/CellSize);
@ -198,7 +198,7 @@ _YAP_MkBigIntTerm(MP_INT *big)
} }
MP_INT * MP_INT *
_YAP_BigIntOfTerm(Term t) Yap_BigIntOfTerm(Term t)
{ {
MP_INT *new = (MP_INT *)(RepAppl(t)+1); MP_INT *new = (MP_INT *)(RepAppl(t)+1);
@ -220,7 +220,7 @@ p_is_bignum(void)
} }
void void
_YAP_InitBigNums(void) Yap_InitBigNums(void)
{ {
#ifdef USE_GMP #ifdef USE_GMP
/* YAP style memory allocation */ /* YAP style memory allocation */
@ -229,5 +229,5 @@ _YAP_InitBigNums(void)
ReAllocBigNumSpace, ReAllocBigNumSpace,
FreeBigNumSpace); FreeBigNumSpace);
#endif #endif
_YAP_InitCPred("$bignum", 1, p_is_bignum, SafePredFlag); Yap_InitCPred("$bignum", 1, p_is_bignum, SafePredFlag);
} }

142
C/c_interface.c
View File

@ -262,7 +262,7 @@ YAP_AtomName(Atom a)
X_API Atom X_API Atom
YAP_LookupAtom(char *c) YAP_LookupAtom(char *c)
{ {
return(_YAP_LookupAtom(c)); return(Yap_LookupAtom(c));
} }
X_API Atom X_API Atom
@ -270,7 +270,7 @@ YAP_FullLookupAtom(char *c)
{ {
Atom at; Atom at;
at = _YAP_FullLookupAtom(c); at = Yap_FullLookupAtom(c);
return(at); return(at);
} }
@ -304,7 +304,7 @@ YAP_MkNewPairTerm()
Term t; Term t;
BACKUP_H(); BACKUP_H();
t = _YAP_MkNewPairTerm(); t = Yap_MkNewPairTerm();
RECOVER_H(); RECOVER_H();
return(t); return(t);
@ -328,7 +328,7 @@ YAP_MkApplTerm(Functor f,unsigned long int arity, Term args[])
Term t; Term t;
BACKUP_H(); BACKUP_H();
t = _YAP_MkApplTerm(f, arity, args); t = Yap_MkApplTerm(f, arity, args);
RECOVER_H(); RECOVER_H();
return(t); return(t);
@ -340,7 +340,7 @@ YAP_MkNewApplTerm(Functor f,unsigned long int arity)
Term t; Term t;
BACKUP_H(); BACKUP_H();
t = _YAP_MkNewApplTerm(f, arity); t = Yap_MkNewApplTerm(f, arity);
RECOVER_H(); RECOVER_H();
return(t); return(t);
@ -364,7 +364,7 @@ YAP_ArgOfTerm(Int n, Term t)
X_API Functor X_API Functor
YAP_MkFunctor(Atom a, Int n) YAP_MkFunctor(Atom a, Int n)
{ {
return (_YAP_MkFunctor(a, n)); return (Yap_MkFunctor(a, n));
} }
X_API Atom X_API Atom
@ -422,7 +422,7 @@ YAP_Unify(Term t1, Term t2)
Int out; Int out;
BACKUP_MACHINE_REGS(); BACKUP_MACHINE_REGS();
out = _YAP_unify(t1, t2); out = Yap_unify(t1, t2);
RECOVER_MACHINE_REGS(); RECOVER_MACHINE_REGS();
return(out); return(out);
@ -431,37 +431,37 @@ YAP_Unify(Term t1, Term t2)
X_API long X_API long
YAP_NewSlots(int n) YAP_NewSlots(int n)
{ {
return _YAP_NewSlots(n); return Yap_NewSlots(n);
} }
X_API long X_API long
YAP_InitSlot(Term t) YAP_InitSlot(Term t)
{ {
return _YAP_InitSlot(t); return Yap_InitSlot(t);
} }
X_API void X_API void
YAP_RecoverSlots(int n) YAP_RecoverSlots(int n)
{ {
_YAP_RecoverSlots(n); Yap_RecoverSlots(n);
} }
X_API Term X_API Term
YAP_GetFromSlot(long slot) YAP_GetFromSlot(long slot)
{ {
return _YAP_GetFromSlot(slot); return Yap_GetFromSlot(slot);
} }
X_API Term * X_API Term *
YAP_AddressFromSlot(long slot) YAP_AddressFromSlot(long slot)
{ {
return _YAP_AddressFromSlot(slot); return Yap_AddressFromSlot(slot);
} }
X_API void X_API void
YAP_PutInSlot(long slot, Term t) YAP_PutInSlot(long slot, Term t)
{ {
_YAP_PutInSlot(slot, t); Yap_PutInSlot(slot, t);
} }
@ -573,10 +573,10 @@ YAP_CallProlog(Term t)
Term tmod = ArgOfTerm(1,t); Term tmod = ArgOfTerm(1,t);
if (IsVarTerm(tmod)) return(FALSE); if (IsVarTerm(tmod)) return(FALSE);
if (!IsAtomTerm(tmod)) return(FALSE); if (!IsAtomTerm(tmod)) return(FALSE);
mod = _YAP_LookupModule(tmod); mod = Yap_LookupModule(tmod);
t = ArgOfTerm(2,t); t = ArgOfTerm(2,t);
} }
out = _YAP_execute_goal(t, 0, mod); out = Yap_execute_goal(t, 0, mod);
RECOVER_MACHINE_REGS(); RECOVER_MACHINE_REGS();
return(out); return(out);
} }
@ -587,9 +587,9 @@ YAP_AllocSpaceFromYap(unsigned int size)
void *ptr; void *ptr;
BACKUP_MACHINE_REGS(); BACKUP_MACHINE_REGS();
if ((ptr = _YAP_AllocCodeSpace(size)) == NULL) { if ((ptr = Yap_AllocCodeSpace(size)) == NULL) {
if (!_YAP_growheap(FALSE)) { if (!Yap_growheap(FALSE)) {
_YAP_Error(SYSTEM_ERROR, TermNil, _YAP_ErrorMessage); Yap_Error(SYSTEM_ERROR, TermNil, Yap_ErrorMessage);
return(NULL); return(NULL);
} }
} }
@ -601,7 +601,7 @@ YAP_AllocSpaceFromYap(unsigned int size)
X_API void X_API void
YAP_FreeSpaceFromYap(void *ptr) YAP_FreeSpaceFromYap(void *ptr)
{ {
_YAP_FreeCodeSpace(ptr); Yap_FreeCodeSpace(ptr);
} }
/* copy a string to a buffer */ /* copy a string to a buffer */
@ -616,15 +616,15 @@ YAP_StringToBuffer(Term t, char *buf, unsigned int bufsize)
Head = HeadOfTerm(t); Head = HeadOfTerm(t);
if (IsVarTerm(Head)) { if (IsVarTerm(Head)) {
_YAP_Error(INSTANTIATION_ERROR,Head,"user defined procedure"); Yap_Error(INSTANTIATION_ERROR,Head,"user defined procedure");
return(FALSE); return(FALSE);
} else if (!IsIntTerm(Head)) { } else if (!IsIntTerm(Head)) {
_YAP_Error(REPRESENTATION_ERROR_CHARACTER_CODE,Head,"user defined procedure"); Yap_Error(REPRESENTATION_ERROR_CHARACTER_CODE,Head,"user defined procedure");
return(FALSE); return(FALSE);
} }
i = IntOfTerm(Head); i = IntOfTerm(Head);
if (i < 0 || i > 255) { if (i < 0 || i > 255) {
_YAP_Error(REPRESENTATION_ERROR_CHARACTER_CODE,Head,"user defined procedure"); Yap_Error(REPRESENTATION_ERROR_CHARACTER_CODE,Head,"user defined procedure");
return(FALSE); return(FALSE);
} }
buf[j++] = i; buf[j++] = i;
@ -634,10 +634,10 @@ YAP_StringToBuffer(Term t, char *buf, unsigned int bufsize)
} }
t = TailOfTerm(t); t = TailOfTerm(t);
if (IsVarTerm(t)) { if (IsVarTerm(t)) {
_YAP_Error(INSTANTIATION_ERROR,t,"user defined procedure"); Yap_Error(INSTANTIATION_ERROR,t,"user defined procedure");
return(FALSE); return(FALSE);
} else if (!IsPairTerm(t) && t != TermNil) { } else if (!IsPairTerm(t) && t != TermNil) {
_YAP_Error(TYPE_ERROR_LIST, t, "user defined procedure"); Yap_Error(TYPE_ERROR_LIST, t, "user defined procedure");
return(FALSE); return(FALSE);
} }
} }
@ -653,7 +653,7 @@ YAP_BufferToString(char *s)
Term t; Term t;
BACKUP_H(); BACKUP_H();
t = _YAP_StringToList(s); t = Yap_StringToList(s);
RECOVER_H(); RECOVER_H();
return(t); return(t);
@ -666,7 +666,7 @@ YAP_BufferToAtomList(char *s)
Term t; Term t;
BACKUP_H(); BACKUP_H();
t = _YAP_StringToListOfAtoms(s); t = Yap_StringToListOfAtoms(s);
RECOVER_H(); RECOVER_H();
return(t); return(t);
@ -676,7 +676,7 @@ YAP_BufferToAtomList(char *s)
X_API void X_API void
YAP_Error(char *buf) YAP_Error(char *buf)
{ {
_YAP_Error(SYSTEM_ERROR,TermNil,buf); Yap_Error(SYSTEM_ERROR,TermNil,buf);
} }
static void myputc (int ch) static void myputc (int ch)
@ -691,7 +691,7 @@ YAP_RunGoal(Term t)
yamop *old_CP = CP; yamop *old_CP = CP;
BACKUP_MACHINE_REGS(); BACKUP_MACHINE_REGS();
out = _YAP_RunTopGoal(t); out = Yap_RunTopGoal(t);
if (out) { if (out) {
P = (yamop *)ENV[E_CP]; P = (yamop *)ENV[E_CP];
ENV = (CELL *)ENV[E_E]; ENV = (CELL *)ENV[E_E];
@ -713,10 +713,10 @@ YAP_RestartGoal(void)
P = (yamop *)FAILCODE; P = (yamop *)FAILCODE;
do_putcf = myputc; do_putcf = myputc;
out = _YAP_exec_absmi(TRUE); out = Yap_exec_absmi(TRUE);
if (out == FALSE) { if (out == FALSE) {
/* cleanup */ /* cleanup */
_YAP_trust_last(); Yap_trust_last();
} }
RECOVER_MACHINE_REGS(); RECOVER_MACHINE_REGS();
@ -729,7 +729,7 @@ YAP_ContinueGoal(void)
int out; int out;
BACKUP_MACHINE_REGS(); BACKUP_MACHINE_REGS();
out = _YAP_exec_absmi(TRUE); out = Yap_exec_absmi(TRUE);
RECOVER_MACHINE_REGS(); RECOVER_MACHINE_REGS();
return(out); return(out);
@ -767,9 +767,9 @@ YAP_InitConsult(int mode, char *filename)
BACKUP_MACHINE_REGS(); BACKUP_MACHINE_REGS();
if (mode == YAP_CONSULT_MODE) if (mode == YAP_CONSULT_MODE)
_YAP_init_consult(FALSE, filename); Yap_init_consult(FALSE, filename);
else else
_YAP_init_consult(TRUE, filename); Yap_init_consult(TRUE, filename);
RECOVER_MACHINE_REGS(); RECOVER_MACHINE_REGS();
} }
@ -779,7 +779,7 @@ YAP_EndConsult(void)
{ {
BACKUP_MACHINE_REGS(); BACKUP_MACHINE_REGS();
_YAP_end_consult(); Yap_end_consult();
RECOVER_MACHINE_REGS(); RECOVER_MACHINE_REGS();
} }
@ -794,14 +794,14 @@ YAP_Read(int (*mygetc)(void))
do_getf = mygetc; do_getf = mygetc;
old_TR = TR; old_TR = TR;
_YAP_tokptr = _YAP_toktide = _YAP_tokenizer(do_yap_getc, do_yap_getc); Yap_tokptr = Yap_toktide = Yap_tokenizer(do_yap_getc, do_yap_getc);
if (_YAP_ErrorMessage) if (Yap_ErrorMessage)
{ {
TR = old_TR; TR = old_TR;
save_machine_regs(); save_machine_regs();
return(0); return(0);
} }
t = _YAP_Parse(); t = Yap_Parse();
TR = old_TR; TR = old_TR;
RECOVER_MACHINE_REGS(); RECOVER_MACHINE_REGS();
@ -814,7 +814,7 @@ YAP_Write(Term t, void (*myputc)(int), int flags)
BACKUP_MACHINE_REGS(); BACKUP_MACHINE_REGS();
do_putcf = myputc; do_putcf = myputc;
_YAP_plwrite (t, do_yap_putc, flags); Yap_plwrite (t, do_yap_putc, flags);
RECOVER_MACHINE_REGS(); RECOVER_MACHINE_REGS();
} }
@ -822,22 +822,22 @@ YAP_Write(Term t, void (*myputc)(int), int flags)
X_API char * X_API char *
YAP_CompileClause(Term t) YAP_CompileClause(Term t)
{ {
char *_YAP_ErrorMessage; char *Yap_ErrorMessage;
CODEADDR codeaddr; CODEADDR codeaddr;
int mod = CurrentModule; int mod = CurrentModule;
BACKUP_MACHINE_REGS(); BACKUP_MACHINE_REGS();
_YAP_ErrorMessage = NULL; Yap_ErrorMessage = NULL;
ARG1 = t; ARG1 = t;
codeaddr = _YAP_cclause (t,0, mod); codeaddr = Yap_cclause (t,0, mod);
if (codeaddr != NULL) { if (codeaddr != NULL) {
t = Deref(ARG1); /* just in case there was an heap overflow */ t = Deref(ARG1); /* just in case there was an heap overflow */
_YAP_addclause (t, codeaddr, TRUE, mod); Yap_addclause (t, codeaddr, TRUE, mod);
} }
RECOVER_MACHINE_REGS(); RECOVER_MACHINE_REGS();
return(_YAP_ErrorMessage); return(Yap_ErrorMessage);
} }
/* this routine is supposed to be called from an external program /* this routine is supposed to be called from an external program
@ -850,11 +850,11 @@ YAP_Init(YAP_init_args *yap_init)
CELL Trail = 0, Stack = 0, Heap = 0; CELL Trail = 0, Stack = 0, Heap = 0;
BACKUP_MACHINE_REGS(); BACKUP_MACHINE_REGS();
_YAP_argv = yap_init->Argv; Yap_argv = yap_init->Argv;
_YAP_argc = yap_init->Argc; Yap_argc = yap_init->Argc;
if (yap_init->SavedState != NULL || if (yap_init->SavedState != NULL ||
yap_init->YapPrologBootFile == NULL) { yap_init->YapPrologBootFile == NULL) {
if (_YAP_SavedInfo (yap_init->SavedState, yap_init->YapLibDir, &Trail, &Stack, &Heap) != 1) { if (Yap_SavedInfo (yap_init->SavedState, yap_init->YapLibDir, &Trail, &Stack, &Heap) != 1) {
return(YAP_BOOT_FROM_SAVED_ERROR); return(YAP_BOOT_FROM_SAVED_ERROR);
} }
} }
@ -877,18 +877,18 @@ YAP_Init(YAP_init_args *yap_init)
Heap = yap_init->HeapSize; Heap = yap_init->HeapSize;
} }
_YAP_InitStacks (Heap, Stack, Trail, Yap_InitStacks (Heap, Stack, Trail,
yap_init->NumberWorkers, yap_init->NumberWorkers,
yap_init->SchedulerLoop, yap_init->SchedulerLoop,
yap_init->DelayedReleaseLoad yap_init->DelayedReleaseLoad
); );
_YAP_InitYaamRegs(); Yap_InitYaamRegs();
#if HAVE_MPI #if HAVE_MPI
_YAP_InitMPI (); Yap_InitMPI ();
#endif #endif
#if HAVE_MPE #if HAVE_MPE
_YAP_InitMPE (); Yap_InitMPE ();
#endif #endif
if (yap_init->YapPrologRCFile != NULL) { if (yap_init->YapPrologRCFile != NULL) {
@ -900,7 +900,7 @@ YAP_Init(YAP_init_args *yap_init)
} }
if (yap_init->SavedState != NULL || if (yap_init->SavedState != NULL ||
yap_init->YapPrologBootFile == NULL) { yap_init->YapPrologBootFile == NULL) {
restore_result = _YAP_Restore(yap_init->SavedState, yap_init->YapLibDir); restore_result = Yap_Restore(yap_init->SavedState, yap_init->YapLibDir);
} else { } else {
restore_result = FAIL_RESTORE; restore_result = FAIL_RESTORE;
} }
@ -918,12 +918,12 @@ YAP_Init(YAP_init_args *yap_init)
In the SBA we cannot just happily inherit registers In the SBA we cannot just happily inherit registers
from the other workers from the other workers
*/ */
_YAP_InitYaamRegs(); Yap_InitYaamRegs();
#endif #endif
/* slaves, waiting for work */ /* slaves, waiting for work */
CurrentModule = 1; CurrentModule = 1;
P = GETWORK_FIRST_TIME; P = GETWORK_FIRST_TIME;
_YAP_exec_absmi(FALSE); Yap_exec_absmi(FALSE);
abort_optyap("abstract machine unexpected exit"); abort_optyap("abstract machine unexpected exit");
} }
#endif /* YAPOR */ #endif /* YAPOR */
@ -931,7 +931,7 @@ YAP_Init(YAP_init_args *yap_init)
RECOVER_MACHINE_REGS(); RECOVER_MACHINE_REGS();
if (yap_init->YapPrologRCFile != NULL) { if (yap_init->YapPrologRCFile != NULL) {
_YAP_PutValue(_YAP_FullLookupAtom("$consult_on_boot"), MkAtomTerm(_YAP_LookupAtom(yap_init->YapPrologRCFile))); Yap_PutValue(Yap_FullLookupAtom("$consult_on_boot"), MkAtomTerm(Yap_LookupAtom(yap_init->YapPrologRCFile)));
/* /*
This must be done again after restore, as yap_flags This must be done again after restore, as yap_flags
has been overwritten .... has been overwritten ....
@ -977,13 +977,13 @@ YAP_FastInit(char saved_state[])
X_API void X_API void
YAP_PutValue(Atom at, Term t) YAP_PutValue(Atom at, Term t)
{ {
_YAP_PutValue(at, t); Yap_PutValue(at, t);
} }
X_API Term X_API Term
YAP_GetValue(Atom at) YAP_GetValue(Atom at)
{ {
return(_YAP_GetValue(at)); return(Yap_GetValue(at));
} }
X_API int X_API int
@ -996,11 +996,11 @@ YAP_Reset(void)
while (B->cp_b != NULL) while (B->cp_b != NULL)
B = B->cp_b; B = B->cp_b;
P = (yamop *)FAILCODE; P = (yamop *)FAILCODE;
if (_YAP_exec_absmi(0) != 0) if (Yap_exec_absmi(0) != 0)
return(FALSE); return(FALSE);
} }
/* reinitialise the engine */ /* reinitialise the engine */
_YAP_InitYaamRegs(); Yap_InitYaamRegs();
RECOVER_MACHINE_REGS(); RECOVER_MACHINE_REGS();
return(TRUE); return(TRUE);
@ -1009,14 +1009,14 @@ YAP_Reset(void)
X_API void X_API void
YAP_Exit(int retval) YAP_Exit(int retval)
{ {
_YAP_exit(retval); Yap_exit(retval);
} }
X_API void X_API void
YAP_InitSocks(char *host, long port) YAP_InitSocks(char *host, long port)
{ {
#if USE_SOCKET #if USE_SOCKET
_YAP_init_socks(host, port); Yap_init_socks(host, port);
#endif #endif
} }
@ -1031,7 +1031,7 @@ YAP_SetOutputMessage(void)
X_API int X_API int
YAP_StreamToFileNo(Term t) YAP_StreamToFileNo(Term t)
{ {
return(_YAP_StreamToFileNo(t)); return(Yap_StreamToFileNo(t));
} }
X_API void X_API void
@ -1039,7 +1039,7 @@ YAP_CloseAllOpenStreams(void)
{ {
BACKUP_H(); BACKUP_H();
_YAP_CloseStreams(FALSE); Yap_CloseStreams(FALSE);
RECOVER_H(); RECOVER_H();
} }
@ -1051,7 +1051,7 @@ YAP_OpenStream(void *fh, char *name, Term nm, int flags)
BACKUP_H(); BACKUP_H();
retv = _YAP_OpenStream((FILE *)fh, name, nm, flags); retv = Yap_OpenStream((FILE *)fh, name, nm, flags);
RECOVER_H(); RECOVER_H();
return retv; return retv;
@ -1061,14 +1061,14 @@ X_API void
YAP_Throw(Term t) YAP_Throw(Term t)
{ {
BACKUP_MACHINE_REGS(); BACKUP_MACHINE_REGS();
_YAP_JumpToEnv(t); Yap_JumpToEnv(t);
RECOVER_MACHINE_REGS(); RECOVER_MACHINE_REGS();
} }
X_API int X_API int
YAP_LookupModule(Term t) YAP_LookupModule(Term t)
{ {
return(_YAP_LookupModule(t)); return(Yap_LookupModule(t));
} }
X_API Term X_API Term
@ -1080,7 +1080,7 @@ YAP_ModuleName(int i)
X_API void X_API void
YAP_Halt(int i) YAP_Halt(int i)
{ {
_YAP_exit(i); Yap_exit(i);
} }
X_API CELL * X_API CELL *
@ -1095,7 +1095,7 @@ YAP_Predicate(Atom a, unsigned long int arity, int m)
if (arity == 0) { if (arity == 0) {
return((void *)RepPredProp(PredPropByAtom(a,m))); return((void *)RepPredProp(PredPropByAtom(a,m)));
} else { } else {
Functor f = _YAP_MkFunctor(a, arity); Functor f = Yap_MkFunctor(a, arity);
return((void *)RepPredProp(PredPropByFunc(f,m))); return((void *)RepPredProp(PredPropByFunc(f,m)));
} }
} }
@ -1117,14 +1117,14 @@ YAP_PredicateInfo(void *p, Atom* a, unsigned long int* arity, int* m)
X_API void X_API void
YAP_UserCPredicate(char *name, CPredicate def, unsigned long int arity) YAP_UserCPredicate(char *name, CPredicate def, unsigned long int arity)
{ {
_YAP_InitCPred(name, arity, def, UserCPredFlag); Yap_InitCPred(name, arity, def, UserCPredFlag);
} }
X_API void X_API void
YAP_UserBackCPredicate(char *name, CPredicate init, CPredicate cont, YAP_UserBackCPredicate(char *name, CPredicate init, CPredicate cont,
unsigned long int arity, unsigned int extra) unsigned long int arity, unsigned int extra)
{ {
_YAP_InitCPredBack(name, arity, extra, init, cont, UserCPredFlag); Yap_InitCPredBack(name, arity, extra, init, cont, UserCPredFlag);
} }
X_API void X_API void
@ -1135,9 +1135,9 @@ YAP_UserCPredicateWithArgs(char *a, CPredicate f, unsigned long int arity, int m
CurrentModule = mod; CurrentModule = mod;
YAP_UserCPredicate(a,f,arity); YAP_UserCPredicate(a,f,arity);
if (arity == 0) { if (arity == 0) {
pe = RepPredProp(PredPropByAtom(_YAP_LookupAtom(a),mod)); pe = RepPredProp(PredPropByAtom(Yap_LookupAtom(a),mod));
} else { } else {
Functor f = _YAP_MkFunctor(_YAP_LookupAtom(a), arity); Functor f = Yap_MkFunctor(Yap_LookupAtom(a), arity);
pe = RepPredProp(PredPropByFunc(f,mod)); pe = RepPredProp(PredPropByFunc(f,mod));
} }
pe->PredFlags |= CArgsPredFlag; pe->PredFlags |= CArgsPredFlag;

550
C/cdmgr.c
View File

File diff suppressed because it is too large Load Diff

148
C/cmppreds.c
View File

@ -98,7 +98,7 @@ static int compare_complex(register CELL *pt0, register CELL *pt0_end, register
out = IntOfTerm(d0) - LongIntOfTerm(d1); out = IntOfTerm(d0) - LongIntOfTerm(d1);
#ifdef USE_GMP #ifdef USE_GMP
} else if (IsBigIntTerm(d1)) { } else if (IsBigIntTerm(d1)) {
out = -mpz_cmp_si(_YAP_BigIntOfTerm(d1), IntOfTerm(d0)); out = -mpz_cmp_si(Yap_BigIntOfTerm(d1), IntOfTerm(d0));
#endif #endif
} else if (IsRefTerm(d1)) } else if (IsRefTerm(d1))
out = 1 ; out = 1 ;
@ -124,7 +124,7 @@ static int compare_complex(register CELL *pt0, register CELL *pt0_end, register
out = LongIntOfTerm(d0) - LongIntOfTerm(d1); out = LongIntOfTerm(d0) - LongIntOfTerm(d1);
#ifdef USE_GMP #ifdef USE_GMP
} else if (IsBigIntTerm(d1)) { } else if (IsBigIntTerm(d1)) {
out = -mpz_cmp_si(_YAP_BigIntOfTerm(d1), LongIntOfTerm(d0)); out = -mpz_cmp_si(Yap_BigIntOfTerm(d1), LongIntOfTerm(d0));
#endif #endif
} else if (IsRefTerm(d1)) { } else if (IsRefTerm(d1)) {
out = 1 ; out = 1 ;
@ -137,13 +137,13 @@ static int compare_complex(register CELL *pt0, register CELL *pt0_end, register
#ifdef USE_GMP #ifdef USE_GMP
else if (IsBigIntTerm(d0)) { else if (IsBigIntTerm(d0)) {
if (IsIntTerm(d1)) if (IsIntTerm(d1))
out = mpz_cmp_si(_YAP_BigIntOfTerm(d0), IntOfTerm(d1)); out = mpz_cmp_si(Yap_BigIntOfTerm(d0), IntOfTerm(d1));
else if (IsFloatTerm(d1)) { else if (IsFloatTerm(d1)) {
out = 1; out = 1;
} else if (IsLongIntTerm(d1)) } else if (IsLongIntTerm(d1))
out = mpz_cmp_si(_YAP_BigIntOfTerm(d0), LongIntOfTerm(d1)); out = mpz_cmp_si(Yap_BigIntOfTerm(d0), LongIntOfTerm(d1));
else if (IsBigIntTerm(d1)) else if (IsBigIntTerm(d1))
out = mpz_cmp(_YAP_BigIntOfTerm(d0), _YAP_BigIntOfTerm(d1)); out = mpz_cmp(Yap_BigIntOfTerm(d0), Yap_BigIntOfTerm(d1));
else if (IsRefTerm(d1)) else if (IsRefTerm(d1))
out = 1 ; out = 1 ;
else out = -1; else out = -1;
@ -308,7 +308,7 @@ compare(register Term t1,register Term t2) /* compare terms t1 and t2 */
return(IntOfTerm(t1) - LongIntOfTerm(t2)); return(IntOfTerm(t1) - LongIntOfTerm(t2));
#ifdef USE_GMP #ifdef USE_GMP
if (IsBigIntTerm(t2)) if (IsBigIntTerm(t2))
return(-mpz_cmp_si(_YAP_BigIntOfTerm(t2),IntOfTerm(t1))); return(-mpz_cmp_si(Yap_BigIntOfTerm(t2),IntOfTerm(t1)));
#endif #endif
if (IsRefTerm(t2)) if (IsRefTerm(t2))
return (1); return (1);
@ -331,7 +331,7 @@ compare(register Term t1,register Term t2) /* compare terms t1 and t2 */
return (LongIntOfTerm(t1) - LongIntOfTerm(t2)); return (LongIntOfTerm(t1) - LongIntOfTerm(t2));
#ifdef USE_GMP #ifdef USE_GMP
if (IsBigIntTerm(t2)) if (IsBigIntTerm(t2))
return(-mpz_cmp_si(_YAP_BigIntOfTerm(t2), LongIntOfTerm(t1))); return(-mpz_cmp_si(Yap_BigIntOfTerm(t2), LongIntOfTerm(t1)));
#endif #endif
if (IsRefTerm(t2)) if (IsRefTerm(t2))
return (1); return (1);
@ -340,14 +340,14 @@ compare(register Term t1,register Term t2) /* compare terms t1 and t2 */
#ifdef USE_GMP #ifdef USE_GMP
if (IsBigIntTerm(t1)) { if (IsBigIntTerm(t1)) {
if (IsIntTerm(t2)) if (IsIntTerm(t2))
return(mpz_cmp_si(_YAP_BigIntOfTerm(t1), IntOfTerm(t2))); return(mpz_cmp_si(Yap_BigIntOfTerm(t1), IntOfTerm(t2)));
if (IsFloatTerm(t2)) { if (IsFloatTerm(t2)) {
return(1); return(1);
} }
if (IsLongIntTerm(t2)) if (IsLongIntTerm(t2))
return(mpz_cmp_si(_YAP_BigIntOfTerm(t1), LongIntOfTerm(t2))); return(mpz_cmp_si(Yap_BigIntOfTerm(t1), LongIntOfTerm(t2)));
if (IsBigIntTerm(t2)) if (IsBigIntTerm(t2))
return(mpz_cmp(_YAP_BigIntOfTerm(t1), _YAP_BigIntOfTerm(t2))); return(mpz_cmp(Yap_BigIntOfTerm(t1), Yap_BigIntOfTerm(t2)));
if (IsRefTerm(t2)) if (IsRefTerm(t2))
return(1); return(1);
return(-1); return(-1);
@ -400,7 +400,7 @@ compare(register Term t1,register Term t2) /* compare terms t1 and t2 */
} }
} }
int _YAP_compare_terms(register CELL d0, register CELL d1) int Yap_compare_terms(register CELL d0, register CELL d1)
{ {
return (compare(d0,d1)); return (compare(d0,d1));
} }
@ -416,29 +416,29 @@ p_compare(void)
p = AtomGT; p = AtomGT;
else else
p = AtomEQ; p = AtomEQ;
return (_YAP_unify_constant(ARG1, MkAtomTerm(p))); return (Yap_unify_constant(ARG1, MkAtomTerm(p)));
} }
inline static int inline static int
int_cmp(Int dif) int_cmp(Int dif)
{ {
if (dif < 0) if (dif < 0)
return(_YAP_unify_constant(ARG1,MkAtomTerm(AtomLT))); return(Yap_unify_constant(ARG1,MkAtomTerm(AtomLT)));
else if (dif > 0) else if (dif > 0)
return(_YAP_unify_constant(ARG1,MkAtomTerm(AtomGT))); return(Yap_unify_constant(ARG1,MkAtomTerm(AtomGT)));
else else
return(_YAP_unify_constant(ARG1,MkAtomTerm(AtomEQ))); return(Yap_unify_constant(ARG1,MkAtomTerm(AtomEQ)));
} }
inline static int inline static int
flt_cmp(Float dif) flt_cmp(Float dif)
{ {
if (dif < 0.0) if (dif < 0.0)
return(_YAP_unify_constant(ARG1,MkAtomTerm(AtomLT))); return(Yap_unify_constant(ARG1,MkAtomTerm(AtomLT)));
else if (dif > 0.0) else if (dif > 0.0)
return(_YAP_unify_constant(ARG1,MkAtomTerm(AtomGT))); return(Yap_unify_constant(ARG1,MkAtomTerm(AtomGT)));
else else
return(_YAP_unify_constant(ARG1,MkAtomTerm(AtomEQ))); return(Yap_unify_constant(ARG1,MkAtomTerm(AtomEQ)));
} }
@ -451,11 +451,11 @@ p_acomp(void)
union arith_ret v1; union arith_ret v1;
if (IsVarTerm(t1)) { if (IsVarTerm(t1)) {
_YAP_Error(INSTANTIATION_ERROR, t1, "=:=/2"); Yap_Error(INSTANTIATION_ERROR, t1, "=:=/2");
return(FALSE); return(FALSE);
} }
if (IsVarTerm(t2)) { if (IsVarTerm(t2)) {
_YAP_Error(INSTANTIATION_ERROR, t2, "=:=/2"); Yap_Error(INSTANTIATION_ERROR, t2, "=:=/2");
return(FALSE); return(FALSE);
} }
if (IsIntegerTerm(t1) && IsIntegerTerm(t2)) { if (IsIntegerTerm(t1) && IsIntegerTerm(t2)) {
@ -463,12 +463,12 @@ p_acomp(void)
} if (IsFloatTerm(t1) && IsFloatTerm(t2)) { } if (IsFloatTerm(t1) && IsFloatTerm(t2)) {
return(flt_cmp(FloatOfTerm(t1)-FloatOfTerm(t2))); return(flt_cmp(FloatOfTerm(t1)-FloatOfTerm(t2)));
} }
bt1 = _YAP_Eval(t1, &v1); bt1 = Yap_Eval(t1, &v1);
switch (bt1) { switch (bt1) {
case long_int_e: case long_int_e:
{ {
union arith_ret v2; union arith_ret v2;
blob_type bt2 = _YAP_Eval(t2, &v2); blob_type bt2 = Yap_Eval(t2, &v2);
switch (bt2) { switch (bt2) {
case long_int_e: case long_int_e:
@ -486,7 +486,7 @@ p_acomp(void)
case double_e: case double_e:
{ {
union arith_ret v2; union arith_ret v2;
blob_type bt2 = _YAP_Eval(t2, &v2); blob_type bt2 = Yap_Eval(t2, &v2);
switch (bt2) { switch (bt2) {
case long_int_e: case long_int_e:
@ -505,7 +505,7 @@ p_acomp(void)
case big_int_e: case big_int_e:
{ {
union arith_ret v2; union arith_ret v2;
blob_type bt2 = _YAP_Eval(t2, &v2); blob_type bt2 = Yap_Eval(t2, &v2);
switch (bt2) { switch (bt2) {
case long_int_e: case long_int_e:
@ -531,23 +531,23 @@ a_eq(Term t1, Term t2)
union arith_ret v1; union arith_ret v1;
if (IsVarTerm(t1)) { if (IsVarTerm(t1)) {
_YAP_Error(INSTANTIATION_ERROR, t1, "=:=/2"); Yap_Error(INSTANTIATION_ERROR, t1, "=:=/2");
return(FALSE); return(FALSE);
} }
if (IsVarTerm(t2)) { if (IsVarTerm(t2)) {
_YAP_Error(INSTANTIATION_ERROR, t2, "=:=/2"); Yap_Error(INSTANTIATION_ERROR, t2, "=:=/2");
return(FALSE); return(FALSE);
} }
if (IsIntegerTerm(t1) && IsIntegerTerm(t2)) if (IsIntegerTerm(t1) && IsIntegerTerm(t2))
return (IntegerOfTerm(t1) == IntegerOfTerm(t2)); return (IntegerOfTerm(t1) == IntegerOfTerm(t2));
if (IsFloatTerm(t1) && IsFloatTerm(t2)) if (IsFloatTerm(t1) && IsFloatTerm(t2))
return (FloatOfTerm(t1) == FloatOfTerm(t2)); return (FloatOfTerm(t1) == FloatOfTerm(t2));
bt1 = _YAP_Eval(t1, &v1); bt1 = Yap_Eval(t1, &v1);
switch (bt1) { switch (bt1) {
case long_int_e: case long_int_e:
{ {
union arith_ret v2; union arith_ret v2;
blob_type bt2 = _YAP_Eval(t2, &v2); blob_type bt2 = Yap_Eval(t2, &v2);
switch (bt2) { switch (bt2) {
case long_int_e: case long_int_e:
@ -565,7 +565,7 @@ a_eq(Term t1, Term t2)
case double_e: case double_e:
{ {
union arith_ret v2; union arith_ret v2;
blob_type bt2 = _YAP_Eval(t2, &v2); blob_type bt2 = Yap_Eval(t2, &v2);
switch (bt2) { switch (bt2) {
case long_int_e: case long_int_e:
@ -584,7 +584,7 @@ a_eq(Term t1, Term t2)
case big_int_e: case big_int_e:
{ {
union arith_ret v2; union arith_ret v2;
blob_type bt2 = _YAP_Eval(t2, &v2); blob_type bt2 = Yap_Eval(t2, &v2);
switch (bt2) { switch (bt2) {
case long_int_e: case long_int_e:
@ -616,23 +616,23 @@ a_dif(Term t1, Term t2)
union arith_ret v1; union arith_ret v1;
if (IsVarTerm(t1)) { if (IsVarTerm(t1)) {
_YAP_Error(INSTANTIATION_ERROR, t1, "=\\=/2"); Yap_Error(INSTANTIATION_ERROR, t1, "=\\=/2");
return(FALSE); return(FALSE);
} }
if (IsVarTerm(t2)) { if (IsVarTerm(t2)) {
_YAP_Error(INSTANTIATION_ERROR, t2, "=\\=/2"); Yap_Error(INSTANTIATION_ERROR, t2, "=\\=/2");
return(FALSE); return(FALSE);
} }
if (IsIntegerTerm(t1) && IsIntegerTerm(t2)) if (IsIntegerTerm(t1) && IsIntegerTerm(t2))
return (IntegerOfTerm(t1) != IntegerOfTerm(t2)); return (IntegerOfTerm(t1) != IntegerOfTerm(t2));
if (IsFloatTerm(t1) && IsFloatTerm(t2)) if (IsFloatTerm(t1) && IsFloatTerm(t2))
return (FloatOfTerm(t1) != FloatOfTerm(t2)); return (FloatOfTerm(t1) != FloatOfTerm(t2));
bt1 = _YAP_Eval(t1, &v1); bt1 = Yap_Eval(t1, &v1);
switch (bt1) { switch (bt1) {
case long_int_e: case long_int_e:
{ {
union arith_ret v2; union arith_ret v2;
blob_type bt2 = _YAP_Eval(t2, &v2); blob_type bt2 = Yap_Eval(t2, &v2);
switch (bt2) { switch (bt2) {
case long_int_e: case long_int_e:
@ -650,7 +650,7 @@ a_dif(Term t1, Term t2)
case double_e: case double_e:
{ {
union arith_ret v2; union arith_ret v2;
blob_type bt2 = _YAP_Eval(t2, &v2); blob_type bt2 = Yap_Eval(t2, &v2);
switch (bt2) { switch (bt2) {
case long_int_e: case long_int_e:
@ -669,7 +669,7 @@ a_dif(Term t1, Term t2)
case big_int_e: case big_int_e:
{ {
union arith_ret v2; union arith_ret v2;
blob_type bt2 = _YAP_Eval(t2, &v2); blob_type bt2 = Yap_Eval(t2, &v2);
switch (bt2) { switch (bt2) {
case long_int_e: case long_int_e:
@ -701,23 +701,23 @@ a_gt(Term t1, Term t2)
union arith_ret v1; union arith_ret v1;
if (IsVarTerm(t1)) { if (IsVarTerm(t1)) {
_YAP_Error(INSTANTIATION_ERROR, t1, ">/2"); Yap_Error(INSTANTIATION_ERROR, t1, ">/2");
return(FALSE); return(FALSE);
} }
if (IsVarTerm(t2)) { if (IsVarTerm(t2)) {
_YAP_Error(INSTANTIATION_ERROR, t2, ">/2"); Yap_Error(INSTANTIATION_ERROR, t2, ">/2");
return(FALSE); return(FALSE);
} }
if (IsIntegerTerm(t1) && IsIntegerTerm(t2)) if (IsIntegerTerm(t1) && IsIntegerTerm(t2))
return (IntegerOfTerm(t1) > IntegerOfTerm(t2)); return (IntegerOfTerm(t1) > IntegerOfTerm(t2));
if (IsFloatTerm(t1) && IsFloatTerm(t2)) if (IsFloatTerm(t1) && IsFloatTerm(t2))
return (FloatOfTerm(t1) > FloatOfTerm(t2)); return (FloatOfTerm(t1) > FloatOfTerm(t2));
bt1 = _YAP_Eval(t1, &v1); bt1 = Yap_Eval(t1, &v1);
switch (bt1) { switch (bt1) {
case long_int_e: case long_int_e:
{ {
union arith_ret v2; union arith_ret v2;
blob_type bt2 = _YAP_Eval(t2, &v2); blob_type bt2 = Yap_Eval(t2, &v2);
switch (bt2) { switch (bt2) {
case long_int_e: case long_int_e:
@ -735,7 +735,7 @@ a_gt(Term t1, Term t2)
case double_e: case double_e:
{ {
union arith_ret v2; union arith_ret v2;
blob_type bt2 = _YAP_Eval(t2, &v2); blob_type bt2 = Yap_Eval(t2, &v2);
switch (bt2) { switch (bt2) {
case long_int_e: case long_int_e:
@ -754,7 +754,7 @@ a_gt(Term t1, Term t2)
case big_int_e: case big_int_e:
{ {
union arith_ret v2; union arith_ret v2;
blob_type bt2 = _YAP_Eval(t2, &v2); blob_type bt2 = Yap_Eval(t2, &v2);
switch (bt2) { switch (bt2) {
case long_int_e: case long_int_e:
@ -786,23 +786,23 @@ a_ge(Term t1, Term t2)
union arith_ret v1; union arith_ret v1;
if (IsVarTerm(t1)) { if (IsVarTerm(t1)) {
_YAP_Error(INSTANTIATION_ERROR, t1, ">=/2"); Yap_Error(INSTANTIATION_ERROR, t1, ">=/2");
return(FALSE); return(FALSE);
} }
if (IsVarTerm(t2)) { if (IsVarTerm(t2)) {
_YAP_Error(INSTANTIATION_ERROR, t1, ">=/2"); Yap_Error(INSTANTIATION_ERROR, t1, ">=/2");
return(FALSE); return(FALSE);
} }
if (IsIntegerTerm(t1) && IsIntegerTerm(t2)) if (IsIntegerTerm(t1) && IsIntegerTerm(t2))
return (IntegerOfTerm(t1) >= IntegerOfTerm(t2)); return (IntegerOfTerm(t1) >= IntegerOfTerm(t2));
if (IsFloatTerm(t1) && IsFloatTerm(t2)) if (IsFloatTerm(t1) && IsFloatTerm(t2))
return (FloatOfTerm(t1) >= FloatOfTerm(t2)); return (FloatOfTerm(t1) >= FloatOfTerm(t2));
bt1 = _YAP_Eval(t1, &v1); bt1 = Yap_Eval(t1, &v1);
switch (bt1) { switch (bt1) {
case long_int_e: case long_int_e:
{ {
union arith_ret v2; union arith_ret v2;
blob_type bt2 = _YAP_Eval(t2, &v2); blob_type bt2 = Yap_Eval(t2, &v2);
switch (bt2) { switch (bt2) {
case long_int_e: case long_int_e:
@ -820,7 +820,7 @@ a_ge(Term t1, Term t2)
case double_e: case double_e:
{ {
union arith_ret v2; union arith_ret v2;
blob_type bt2 = _YAP_Eval(t2, &v2); blob_type bt2 = Yap_Eval(t2, &v2);
switch (bt2) { switch (bt2) {
case long_int_e: case long_int_e:
@ -839,7 +839,7 @@ a_ge(Term t1, Term t2)
case big_int_e: case big_int_e:
{ {
union arith_ret v2; union arith_ret v2;
blob_type bt2 = _YAP_Eval(t2, &v2); blob_type bt2 = Yap_Eval(t2, &v2);
switch (bt2) { switch (bt2) {
case long_int_e: case long_int_e:
@ -871,23 +871,23 @@ a_lt(Term t1, Term t2)
union arith_ret v1; union arith_ret v1;
if (IsVarTerm(t1)) { if (IsVarTerm(t1)) {
_YAP_Error(INSTANTIATION_ERROR, t1, "</2"); Yap_Error(INSTANTIATION_ERROR, t1, "</2");
return(FALSE); return(FALSE);
} }
if (IsVarTerm(t2)) { if (IsVarTerm(t2)) {
_YAP_Error(INSTANTIATION_ERROR, t2, "</2"); Yap_Error(INSTANTIATION_ERROR, t2, "</2");
return(FALSE); return(FALSE);
} }
if (IsIntegerTerm(t1) && IsIntegerTerm(t2)) if (IsIntegerTerm(t1) && IsIntegerTerm(t2))
return (IntegerOfTerm(t1) < IntegerOfTerm(t2)); return (IntegerOfTerm(t1) < IntegerOfTerm(t2));
if (IsFloatTerm(t1) && IsFloatTerm(t2)) if (IsFloatTerm(t1) && IsFloatTerm(t2))
return (FloatOfTerm(t1) < FloatOfTerm(t2)); return (FloatOfTerm(t1) < FloatOfTerm(t2));
bt1 = _YAP_Eval(t1, &v1); bt1 = Yap_Eval(t1, &v1);
switch (bt1) { switch (bt1) {
case long_int_e: case long_int_e:
{ {
union arith_ret v2; union arith_ret v2;
blob_type bt2 = _YAP_Eval(t2, &v2); blob_type bt2 = Yap_Eval(t2, &v2);
switch (bt2) { switch (bt2) {
case long_int_e: case long_int_e:
@ -905,7 +905,7 @@ a_lt(Term t1, Term t2)
case double_e: case double_e:
{ {
union arith_ret v2; union arith_ret v2;
blob_type bt2 = _YAP_Eval(t2, &v2); blob_type bt2 = Yap_Eval(t2, &v2);
switch (bt2) { switch (bt2) {
case long_int_e: case long_int_e:
@ -924,7 +924,7 @@ a_lt(Term t1, Term t2)
case big_int_e: case big_int_e:
{ {
union arith_ret v2; union arith_ret v2;
blob_type bt2 = _YAP_Eval(t2, &v2); blob_type bt2 = Yap_Eval(t2, &v2);
switch (bt2) { switch (bt2) {
case long_int_e: case long_int_e:
@ -956,23 +956,23 @@ a_le(Term t1, Term t2)
union arith_ret v1; union arith_ret v1;
if (IsVarTerm(t1)) { if (IsVarTerm(t1)) {
_YAP_Error(INSTANTIATION_ERROR, t1, "=</2"); Yap_Error(INSTANTIATION_ERROR, t1, "=</2");
return(FALSE); return(FALSE);
} }
if (IsVarTerm(t2)) { if (IsVarTerm(t2)) {
_YAP_Error(INSTANTIATION_ERROR, t2, "=</2"); Yap_Error(INSTANTIATION_ERROR, t2, "=</2");
return(FALSE); return(FALSE);
} }
if (IsIntegerTerm(t1) && IsIntegerTerm(t2)) if (IsIntegerTerm(t1) && IsIntegerTerm(t2))
return (IntegerOfTerm(t1) <= IntegerOfTerm(t2)); return (IntegerOfTerm(t1) <= IntegerOfTerm(t2));
if (IsFloatTerm(t1) && IsFloatTerm(t2)) if (IsFloatTerm(t1) && IsFloatTerm(t2))
return (FloatOfTerm(t1) <= FloatOfTerm(t2)); return (FloatOfTerm(t1) <= FloatOfTerm(t2));
bt1 = _YAP_Eval(t1, &v1); bt1 = Yap_Eval(t1, &v1);
switch (bt1) { switch (bt1) {
case long_int_e: case long_int_e:
{ {
union arith_ret v2; union arith_ret v2;
blob_type bt2 = _YAP_Eval(t2, &v2); blob_type bt2 = Yap_Eval(t2, &v2);
switch (bt2) { switch (bt2) {
case long_int_e: case long_int_e:
@ -990,7 +990,7 @@ a_le(Term t1, Term t2)
case double_e: case double_e:
{ {
union arith_ret v2; union arith_ret v2;
blob_type bt2 = _YAP_Eval(t2, &v2); blob_type bt2 = Yap_Eval(t2, &v2);
switch (bt2) { switch (bt2) {
case long_int_e: case long_int_e:
@ -1009,7 +1009,7 @@ a_le(Term t1, Term t2)
case big_int_e: case big_int_e:
{ {
union arith_ret v2; union arith_ret v2;
blob_type bt2 = _YAP_Eval(t2, &v2); blob_type bt2 = Yap_Eval(t2, &v2);
switch (bt2) { switch (bt2) {
case long_int_e: case long_int_e:
@ -1066,19 +1066,19 @@ p_gen_ge(void)
void void
_YAP_InitCmpPreds(void) Yap_InitCmpPreds(void)
{ {
_YAP_InitCmpPred("=:=", 2, a_eq, p_eq, SafePredFlag | BinaryTestPredFlag); Yap_InitCmpPred("=:=", 2, a_eq, p_eq, SafePredFlag | BinaryTestPredFlag);
_YAP_InitCmpPred("=\\=", 2, a_dif, p_dif, SafePredFlag | BinaryTestPredFlag); Yap_InitCmpPred("=\\=", 2, a_dif, p_dif, SafePredFlag | BinaryTestPredFlag);
_YAP_InitCmpPred(">", 2, a_gt, p_gt, SafePredFlag | BinaryTestPredFlag); Yap_InitCmpPred(">", 2, a_gt, p_gt, SafePredFlag | BinaryTestPredFlag);
_YAP_InitCmpPred("=<", 2, a_le, p_le, SafePredFlag | BinaryTestPredFlag); Yap_InitCmpPred("=<", 2, a_le, p_le, SafePredFlag | BinaryTestPredFlag);
_YAP_InitCmpPred("<", 2, a_lt, p_lt, SafePredFlag | BinaryTestPredFlag); Yap_InitCmpPred("<", 2, a_lt, p_lt, SafePredFlag | BinaryTestPredFlag);
_YAP_InitCmpPred(">=", 2, a_ge, p_ge, SafePredFlag | BinaryTestPredFlag); Yap_InitCmpPred(">=", 2, a_ge, p_ge, SafePredFlag | BinaryTestPredFlag);
_YAP_InitCPred("$a_compare", 3, p_acomp, TestPredFlag | SafePredFlag); Yap_InitCPred("$a_compare", 3, p_acomp, TestPredFlag | SafePredFlag);
_YAP_InitCPred("\\==", 2, p_noteq, TestPredFlag | SafePredFlag); Yap_InitCPred("\\==", 2, p_noteq, TestPredFlag | SafePredFlag);
_YAP_InitCPred("@<", 2, p_gen_lt, TestPredFlag | SafePredFlag); Yap_InitCPred("@<", 2, p_gen_lt, TestPredFlag | SafePredFlag);
_YAP_InitCPred("@=<", 2, p_gen_le, TestPredFlag | SafePredFlag); Yap_InitCPred("@=<", 2, p_gen_le, TestPredFlag | SafePredFlag);
_YAP_InitCPred("@>", 2, p_gen_gt, TestPredFlag | SafePredFlag); Yap_InitCPred("@>", 2, p_gen_gt, TestPredFlag | SafePredFlag);
_YAP_InitCPred("@>=", 2, p_gen_ge, TestPredFlag | SafePredFlag); Yap_InitCPred("@>=", 2, p_gen_ge, TestPredFlag | SafePredFlag);
_YAP_InitCPred("compare", 3, p_compare, TestPredFlag | SafePredFlag); Yap_InitCPred("compare", 3, p_compare, TestPredFlag | SafePredFlag);
} }

706
C/compiler.c
View File

File diff suppressed because it is too large Load Diff

174
C/computils.c
View File

@ -48,9 +48,9 @@ static compiler_vm_op ic;
static CELL *cptr; static CELL *cptr;
char _YAP_Option[20]; char Yap_Option[20];
YP_FILE *_YAP_logfile; YP_FILE *Yap_logfile;
#endif #endif
static char * static char *
@ -66,19 +66,19 @@ AllocCMem (int size)
freep += size; freep += size;
if (ASP <= CellPtr (freep) + 256) { if (ASP <= CellPtr (freep) + 256) {
save_machine_regs(); save_machine_regs();
longjmp(_YAP_CompilerBotch,3); longjmp(Yap_CompilerBotch,3);
} }
return (p); return (p);
} }
char * char *
_YAP_AllocCMem (int size) Yap_AllocCMem (int size)
{ {
return(AllocCMem(size)); return(AllocCMem(size));
} }
int int
_YAP_is_a_test_pred (Term arg, SMALLUNSGN mod) Yap_is_a_test_pred (Term arg, SMALLUNSGN mod)
{ {
if (IsVarTerm (arg)) if (IsVarTerm (arg))
return (FALSE); return (FALSE);
@ -103,7 +103,7 @@ _YAP_is_a_test_pred (Term arg, SMALLUNSGN mod)
} }
void void
_YAP_emit (compiler_vm_op o, Int r1, CELL r2) Yap_emit (compiler_vm_op o, Int r1, CELL r2)
{ {
PInstr *p; PInstr *p;
p = (PInstr *) AllocCMem (sizeof (*p)); p = (PInstr *) AllocCMem (sizeof (*p));
@ -121,7 +121,7 @@ _YAP_emit (compiler_vm_op o, Int r1, CELL r2)
} }
void void
_YAP_emit_3ops (compiler_vm_op o, CELL r1, CELL r2, CELL r3) Yap_emit_3ops (compiler_vm_op o, CELL r1, CELL r2, CELL r3)
{ {
PInstr *p; PInstr *p;
p = (PInstr *) AllocCMem (sizeof (*p)+sizeof(CELL)); p = (PInstr *) AllocCMem (sizeof (*p)+sizeof(CELL));
@ -140,7 +140,7 @@ _YAP_emit_3ops (compiler_vm_op o, CELL r1, CELL r2, CELL r3)
} }
CELL * CELL *
_YAP_emit_extra_size (compiler_vm_op o, CELL r1, int size) Yap_emit_extra_size (compiler_vm_op o, CELL r1, int size)
{ {
PInstr *p; PInstr *p;
p = (PInstr *) AllocCMem (sizeof (*p) + size - CellSize); p = (PInstr *) AllocCMem (sizeof (*p) + size - CellSize);
@ -240,7 +240,7 @@ bip_name(Int op, char *s)
} }
void void
_YAP_bip_name(Int op, char *s) { Yap_bip_name(Int op, char *s) {
bip_name(op,s); bip_name(op,s);
} }
@ -258,7 +258,7 @@ ShowOp (f)
{ {
case 'a': case 'a':
case 'n': case 'n':
_YAP_plwrite ((Term) arg, _YAP_DebugPutc, 0); Yap_plwrite ((Term) arg, Yap_DebugPutc, 0);
break; break;
case 'b': case 'b':
/* write a variable bitmap for a call */ /* write a variable bitmap for a call */
@ -266,32 +266,32 @@ ShowOp (f)
int max = arg/(8*sizeof(CELL)), i; int max = arg/(8*sizeof(CELL)), i;
CELL *ptr = cptr; CELL *ptr = cptr;
for (i = 0; i <= max; i++) { for (i = 0; i <= max; i++) {
_YAP_plwrite(MkIntegerTerm((Int)(*ptr++)), _YAP_DebugPutc, 0); Yap_plwrite(MkIntegerTerm((Int)(*ptr++)), Yap_DebugPutc, 0);
} }
} }
break; break;
case 'l': case 'l':
_YAP_plwrite (MkIntTerm (arg), _YAP_DebugPutc, 0); Yap_plwrite (MkIntTerm (arg), Yap_DebugPutc, 0);
break; break;
case 'B': case 'B':
{ {
char s[32]; char s[32];
bip_name(rn,s); bip_name(rn,s);
_YAP_plwrite (MkAtomTerm(_YAP_LookupAtom(s)), _YAP_DebugPutc, 0); Yap_plwrite (MkAtomTerm(Yap_LookupAtom(s)), Yap_DebugPutc, 0);
} }
break; break;
case 'd': case 'd':
_YAP_plwrite (MkIntTerm (rn), _YAP_DebugPutc, 0); Yap_plwrite (MkIntTerm (rn), Yap_DebugPutc, 0);
break; break;
case 'z': case 'z':
_YAP_plwrite (MkIntTerm (cpc->rnd3), _YAP_DebugPutc, 0); Yap_plwrite (MkIntTerm (cpc->rnd3), Yap_DebugPutc, 0);
break; break;
case 'v': case 'v':
{ {
Ventry *v = (Ventry *) arg; Ventry *v = (Ventry *) arg;
_YAP_DebugPutc (_YAP_c_error_stream,v->KindOfVE == PermVar ? 'Y' : 'X'); Yap_DebugPutc (Yap_c_error_stream,v->KindOfVE == PermVar ? 'Y' : 'X');
_YAP_plwrite (MkIntTerm ((v->NoOfVE) & MaskVarAdrs), _YAP_DebugPutc, 0); Yap_plwrite (MkIntTerm ((v->NoOfVE) & MaskVarAdrs), Yap_DebugPutc, 0);
} }
break; break;
case 'N': case 'N':
@ -301,14 +301,14 @@ ShowOp (f)
cpc = cpc->nextInst; cpc = cpc->nextInst;
arg = cpc->rnd1; arg = cpc->rnd1;
v = (Ventry *) arg; v = (Ventry *) arg;
_YAP_DebugPutc (_YAP_c_error_stream,v->KindOfVE == PermVar ? 'Y' : 'X'); Yap_DebugPutc (Yap_c_error_stream,v->KindOfVE == PermVar ? 'Y' : 'X');
_YAP_plwrite (MkIntTerm ((v->NoOfVE) & MaskVarAdrs), _YAP_DebugPutc, 0); Yap_plwrite (MkIntTerm ((v->NoOfVE) & MaskVarAdrs), Yap_DebugPutc, 0);
} }
break; break;
case 'm': case 'm':
_YAP_plwrite (MkAtomTerm ((Atom) arg), _YAP_DebugPutc, 0); Yap_plwrite (MkAtomTerm ((Atom) arg), Yap_DebugPutc, 0);
_YAP_DebugPutc (_YAP_c_error_stream,'/'); Yap_DebugPutc (Yap_c_error_stream,'/');
_YAP_plwrite (MkIntTerm (rn), _YAP_DebugPutc, 0); Yap_plwrite (MkIntTerm (rn), Yap_DebugPutc, 0);
break; break;
case 'p': case 'p':
{ {
@ -318,14 +318,14 @@ ShowOp (f)
SMALLUNSGN mod = 0; SMALLUNSGN mod = 0;
if (p->ModuleOfPred) mod = IntOfTerm(p->ModuleOfPred); if (p->ModuleOfPred) mod = IntOfTerm(p->ModuleOfPred);
_YAP_plwrite (ModuleName[mod], _YAP_DebugPutc, 0); Yap_plwrite (ModuleName[mod], Yap_DebugPutc, 0);
_YAP_DebugPutc (_YAP_c_error_stream,':'); Yap_DebugPutc (Yap_c_error_stream,':');
if (arity == 0) if (arity == 0)
_YAP_plwrite (MkAtomTerm ((Atom)f), _YAP_DebugPutc, 0); Yap_plwrite (MkAtomTerm ((Atom)f), Yap_DebugPutc, 0);
else else
_YAP_plwrite (MkAtomTerm (NameOfFunctor (f)), _YAP_DebugPutc, 0); Yap_plwrite (MkAtomTerm (NameOfFunctor (f)), Yap_DebugPutc, 0);
_YAP_DebugPutc (_YAP_c_error_stream,'/'); Yap_DebugPutc (Yap_c_error_stream,'/');
_YAP_plwrite (MkIntTerm (arity), _YAP_DebugPutc, 0); Yap_plwrite (MkIntTerm (arity), Yap_DebugPutc, 0);
} }
break; break;
case 'P': case 'P':
@ -336,88 +336,88 @@ ShowOp (f)
SMALLUNSGN mod = 0; SMALLUNSGN mod = 0;
if (p->ModuleOfPred) mod = IntOfTerm(p->ModuleOfPred); if (p->ModuleOfPred) mod = IntOfTerm(p->ModuleOfPred);
_YAP_plwrite (ModuleName[mod], _YAP_DebugPutc, 0); Yap_plwrite (ModuleName[mod], Yap_DebugPutc, 0);
_YAP_DebugPutc (_YAP_c_error_stream,':'); Yap_DebugPutc (Yap_c_error_stream,':');
if (arity == 0) if (arity == 0)
_YAP_plwrite (MkAtomTerm ((Atom)f), _YAP_DebugPutc, 0); Yap_plwrite (MkAtomTerm ((Atom)f), Yap_DebugPutc, 0);
else else
_YAP_plwrite (MkAtomTerm (NameOfFunctor (f)), _YAP_DebugPutc, 0); Yap_plwrite (MkAtomTerm (NameOfFunctor (f)), Yap_DebugPutc, 0);
_YAP_DebugPutc (_YAP_c_error_stream,'/'); Yap_DebugPutc (Yap_c_error_stream,'/');
_YAP_plwrite (MkIntTerm (arity), _YAP_DebugPutc, 0); Yap_plwrite (MkIntTerm (arity), Yap_DebugPutc, 0);
} }
break; break;
case 'f': case 'f':
if (IsExtensionFunctor((Functor)arg)) { if (IsExtensionFunctor((Functor)arg)) {
if ((Functor)arg == FunctorDBRef) { if ((Functor)arg == FunctorDBRef) {
_YAP_plwrite(MkAtomTerm(_YAP_LookupAtom("DBRef")), _YAP_DebugPutc, 0); Yap_plwrite(MkAtomTerm(Yap_LookupAtom("DBRef")), Yap_DebugPutc, 0);
} else if ((Functor)arg == FunctorLongInt) { } else if ((Functor)arg == FunctorLongInt) {
_YAP_plwrite(MkAtomTerm(_YAP_LookupAtom("LongInt")), _YAP_DebugPutc, 0); Yap_plwrite(MkAtomTerm(Yap_LookupAtom("LongInt")), Yap_DebugPutc, 0);
} else if ((Functor)arg == FunctorDouble) { } else if ((Functor)arg == FunctorDouble) {
_YAP_plwrite(MkAtomTerm(_YAP_LookupAtom("Double")), _YAP_DebugPutc, 0); Yap_plwrite(MkAtomTerm(Yap_LookupAtom("Double")), Yap_DebugPutc, 0);
} }
} else { } else {
_YAP_plwrite(MkAtomTerm(NameOfFunctor ((Functor) arg)), _YAP_DebugPutc, 0); Yap_plwrite(MkAtomTerm(NameOfFunctor ((Functor) arg)), Yap_DebugPutc, 0);
_YAP_DebugPutc (_YAP_c_error_stream,'/'); Yap_DebugPutc (Yap_c_error_stream,'/');
_YAP_plwrite(MkIntTerm(ArityOfFunctor ((Functor) arg)), _YAP_DebugPutc, 0); Yap_plwrite(MkIntTerm(ArityOfFunctor ((Functor) arg)), Yap_DebugPutc, 0);
} }
break; break;
case 'r': case 'r':
_YAP_DebugPutc (_YAP_c_error_stream,'A'); Yap_DebugPutc (Yap_c_error_stream,'A');
_YAP_plwrite (MkIntTerm (rn), _YAP_DebugPutc, 0); Yap_plwrite (MkIntTerm (rn), Yap_DebugPutc, 0);
break; break;
case 'h': case 'h':
{ {
CELL my_arg = *cptr++; CELL my_arg = *cptr++;
if (my_arg & 1) if (my_arg & 1)
_YAP_plwrite (MkIntTerm (my_arg), Yap_plwrite (MkIntTerm (my_arg),
_YAP_DebugPutc, 0); Yap_DebugPutc, 0);
else if (my_arg == (CELL) FAILCODE) else if (my_arg == (CELL) FAILCODE)
_YAP_plwrite (MkAtomTerm (AtomFail), _YAP_DebugPutc, 0); Yap_plwrite (MkAtomTerm (AtomFail), Yap_DebugPutc, 0);
else else
_YAP_plwrite (MkIntegerTerm ((Int) my_arg), Yap_plwrite (MkIntegerTerm ((Int) my_arg),
_YAP_DebugPutc, 0); Yap_DebugPutc, 0);
} }
break; break;
case 'g': case 'g':
if (arg & 1) if (arg & 1)
_YAP_plwrite (MkIntTerm (arg), Yap_plwrite (MkIntTerm (arg),
_YAP_DebugPutc, 0); Yap_DebugPutc, 0);
else if (arg == (CELL) FAILCODE) else if (arg == (CELL) FAILCODE)
_YAP_plwrite (MkAtomTerm (AtomFail), _YAP_DebugPutc, 0); Yap_plwrite (MkAtomTerm (AtomFail), Yap_DebugPutc, 0);
else else
_YAP_plwrite (MkIntegerTerm ((Int) arg), _YAP_DebugPutc, 0); Yap_plwrite (MkIntegerTerm ((Int) arg), Yap_DebugPutc, 0);
break; break;
case 'i': case 'i':
_YAP_plwrite (MkIntTerm (arg), _YAP_DebugPutc, 0); Yap_plwrite (MkIntTerm (arg), Yap_DebugPutc, 0);
break; break;
case 'j': case 'j':
{ {
Functor fun = (Functor)*cptr++; Functor fun = (Functor)*cptr++;
if (IsExtensionFunctor(fun)) { if (IsExtensionFunctor(fun)) {
if (fun == FunctorDBRef) { if (fun == FunctorDBRef) {
_YAP_plwrite(MkAtomTerm(_YAP_LookupAtom("DBRef")), _YAP_DebugPutc, 0); Yap_plwrite(MkAtomTerm(Yap_LookupAtom("DBRef")), Yap_DebugPutc, 0);
} else if (fun == FunctorLongInt) { } else if (fun == FunctorLongInt) {
_YAP_plwrite(MkAtomTerm(_YAP_LookupAtom("LongInt")), _YAP_DebugPutc, 0); Yap_plwrite(MkAtomTerm(Yap_LookupAtom("LongInt")), Yap_DebugPutc, 0);
} else if (fun == FunctorDouble) { } else if (fun == FunctorDouble) {
_YAP_plwrite(MkAtomTerm(_YAP_LookupAtom("Double")), _YAP_DebugPutc, 0); Yap_plwrite(MkAtomTerm(Yap_LookupAtom("Double")), Yap_DebugPutc, 0);
} }
} else { } else {
_YAP_plwrite (MkAtomTerm(NameOfFunctor(fun)), _YAP_DebugPutc, 0); Yap_plwrite (MkAtomTerm(NameOfFunctor(fun)), Yap_DebugPutc, 0);
_YAP_DebugPutc (_YAP_c_error_stream,'/'); Yap_DebugPutc (Yap_c_error_stream,'/');
_YAP_plwrite (MkIntTerm(ArityOfFunctor(fun)), _YAP_DebugPutc, 0); Yap_plwrite (MkIntTerm(ArityOfFunctor(fun)), Yap_DebugPutc, 0);
} }
} }
break; break;
case 'O': case 'O':
_YAP_plwrite(AbsAppl(cptr), _YAP_DebugPutc, 0); Yap_plwrite(AbsAppl(cptr), Yap_DebugPutc, 0);
break; break;
case 'x': case 'x':
_YAP_plwrite (MkIntTerm (rn >> 1), _YAP_DebugPutc, 0); Yap_plwrite (MkIntTerm (rn >> 1), Yap_DebugPutc, 0);
_YAP_DebugPutc (_YAP_c_error_stream,'\t'); Yap_DebugPutc (Yap_c_error_stream,'\t');
_YAP_plwrite (MkIntTerm (rn & 1), _YAP_DebugPutc, 0); Yap_plwrite (MkIntTerm (rn & 1), Yap_DebugPutc, 0);
break; break;
case 'o': case 'o':
_YAP_plwrite ((Term) * cptr++, _YAP_DebugPutc, 0); Yap_plwrite ((Term) * cptr++, Yap_DebugPutc, 0);
case 'c': case 'c':
{ {
int i; int i;
@ -426,23 +426,23 @@ ShowOp (f)
CELL my_arg; CELL my_arg;
if (*cptr) if (*cptr)
{ {
_YAP_plwrite ((Term) * cptr++, _YAP_DebugPutc, 0); Yap_plwrite ((Term) * cptr++, Yap_DebugPutc, 0);
} }
else else
{ {
_YAP_plwrite (MkIntTerm (0), _YAP_DebugPutc, 0); Yap_plwrite (MkIntTerm (0), Yap_DebugPutc, 0);
cptr++; cptr++;
} }
_YAP_DebugPutc (_YAP_c_error_stream,'\t'); Yap_DebugPutc (Yap_c_error_stream,'\t');
my_arg = *cptr++; my_arg = *cptr++;
if (my_arg & 1) if (my_arg & 1)
_YAP_plwrite (MkIntTerm (my_arg), Yap_plwrite (MkIntTerm (my_arg),
_YAP_DebugPutc, 0); Yap_DebugPutc, 0);
else if (my_arg == (CELL) FAILCODE) else if (my_arg == (CELL) FAILCODE)
_YAP_plwrite (MkAtomTerm (AtomFail), _YAP_DebugPutc, 0); Yap_plwrite (MkAtomTerm (AtomFail), Yap_DebugPutc, 0);
else else
_YAP_plwrite (MkIntegerTerm ((Int) my_arg), _YAP_DebugPutc, 0); Yap_plwrite (MkIntegerTerm ((Int) my_arg), Yap_DebugPutc, 0);
_YAP_DebugPutc (_YAP_c_error_stream,'\n'); Yap_DebugPutc (Yap_c_error_stream,'\n');
} }
} }
break; break;
@ -454,36 +454,36 @@ ShowOp (f)
CELL my_arg; CELL my_arg;
if (*cptr) if (*cptr)
{ {
_YAP_plwrite (MkAtomTerm (NameOfFunctor ((Functor) * cptr)), _YAP_DebugPutc, 0); Yap_plwrite (MkAtomTerm (NameOfFunctor ((Functor) * cptr)), Yap_DebugPutc, 0);
_YAP_DebugPutc (_YAP_c_error_stream,'/'); Yap_DebugPutc (Yap_c_error_stream,'/');
_YAP_plwrite (MkIntTerm (ArityOfFunctor ((Functor) * cptr++)), _YAP_DebugPutc, 0); Yap_plwrite (MkIntTerm (ArityOfFunctor ((Functor) * cptr++)), Yap_DebugPutc, 0);
} }
else else
{ {
_YAP_plwrite (MkIntTerm (0), _YAP_DebugPutc, 0); Yap_plwrite (MkIntTerm (0), Yap_DebugPutc, 0);
cptr++; cptr++;
} }
_YAP_DebugPutc (_YAP_c_error_stream,'\t'); Yap_DebugPutc (Yap_c_error_stream,'\t');
my_arg = *cptr++; my_arg = *cptr++;
if (my_arg & 1) if (my_arg & 1)
_YAP_plwrite (MkIntTerm (my_arg), Yap_plwrite (MkIntTerm (my_arg),
_YAP_DebugPutc, 0); Yap_DebugPutc, 0);
else if (my_arg == (CELL) FAILCODE) else if (my_arg == (CELL) FAILCODE)
_YAP_plwrite (MkAtomTerm (AtomFail), _YAP_DebugPutc, 0); Yap_plwrite (MkAtomTerm (AtomFail), Yap_DebugPutc, 0);
else else
_YAP_plwrite (MkIntegerTerm ((Int) my_arg), _YAP_DebugPutc, 0); Yap_plwrite (MkIntegerTerm ((Int) my_arg), Yap_DebugPutc, 0);
_YAP_DebugPutc (_YAP_c_error_stream,'\n'); Yap_DebugPutc (Yap_c_error_stream,'\n');
} }
} }
break; break;
default: default:
_YAP_DebugPutc (_YAP_c_error_stream,'%'); Yap_DebugPutc (Yap_c_error_stream,'%');
_YAP_DebugPutc (_YAP_c_error_stream,ch); Yap_DebugPutc (Yap_c_error_stream,ch);
} }
else else
_YAP_DebugPutc (_YAP_c_error_stream,ch); Yap_DebugPutc (Yap_c_error_stream,ch);
} }
_YAP_DebugPutc (_YAP_c_error_stream,'\n'); Yap_DebugPutc (Yap_c_error_stream,'\n');
} }
static char *opformat[] = static char *opformat[] =
@ -654,7 +654,7 @@ static char *opformat[] =
void void
_YAP_ShowCode () Yap_ShowCode ()
{ {
CELL *OldH = H; CELL *OldH = H;
@ -671,7 +671,7 @@ _YAP_ShowCode ()
ShowOp (opformat[ic]); ShowOp (opformat[ic]);
cpc = cpc->nextInst; cpc = cpc->nextInst;
} }
_YAP_DebugPutc (_YAP_c_error_stream,'\n'); Yap_DebugPutc (Yap_c_error_stream,'\n');
H = OldH; H = OldH;
} }

114
C/corout.c
View File

@ -164,13 +164,13 @@ UpdateSVarList(sus_record *sl)
/* make sl the new head of the suspension list, and update the list /* make sl the new head of the suspension list, and update the list
to use the old one. Note that the list is only bound once, to use the old one. Note that the list is only bound once,
MutableList is the one variable being updated all the time */ MutableList is the one variable being updated all the time */
return((sus_record *)_YAP_UpdateTimedVar(MutableList, (CELL)sl)); return((sus_record *)Yap_UpdateTimedVar(MutableList, (CELL)sl));
} }
inline static sus_record * inline static sus_record *
GetSVarList(void) GetSVarList(void)
{ {
Term t = _YAP_ReadTimedVar(MutableList); Term t = Yap_ReadTimedVar(MutableList);
/* just return the start of the list */ /* just return the start of the list */
if (t == TermNil) if (t == TermNil)
return(NULL); return(NULL);
@ -190,7 +190,7 @@ GetSVarList(void)
static Term static Term
ListOfWokenGoals(void) { ListOfWokenGoals(void) {
sus_record *pt = (sus_record *)_YAP_ReadTimedVar(WokenGoals); sus_record *pt = (sus_record *)Yap_ReadTimedVar(WokenGoals);
Term t; Term t;
t = TermNil; t = TermNil;
@ -203,7 +203,7 @@ ListOfWokenGoals(void) {
} }
Term Term
_YAP_ListOfWokenGoals(void) { Yap_ListOfWokenGoals(void) {
return ListOfWokenGoals(); return ListOfWokenGoals();
} }
@ -211,10 +211,10 @@ _YAP_ListOfWokenGoals(void) {
static void ReleaseGoals(sus_record *from) static void ReleaseGoals(sus_record *from)
{ {
/* follow the chain */ /* follow the chain */
sus_record *WGs = (sus_record *)_YAP_ReadTimedVar(WokenGoals); sus_record *WGs = (sus_record *)Yap_ReadTimedVar(WokenGoals);
if ((Term)WGs == TermNil) { if ((Term)WGs == TermNil) {
_YAP_UpdateTimedVar(WokenGoals, (CELL)from); Yap_UpdateTimedVar(WokenGoals, (CELL)from);
} else { } else {
/* add to the end of the current list of suspended goals */ /* add to the end of the current list of suspended goals */
CELL *where_to = (CELL *)Deref((CELL)WGs); CELL *where_to = (CELL *)Deref((CELL)WGs);
@ -335,14 +335,14 @@ CopySuspendedVar(CELL *orig, CELL ***to_visit_ptr, CELL *res)
register sus_tag *sreg = (sus_tag *)orig, *vs; register sus_tag *sreg = (sus_tag *)orig, *vs;
/* add a new suspension */ /* add a new suspension */
vs = (sus_tag *)_YAP_ReadTimedVar(DelayedVars); vs = (sus_tag *)Yap_ReadTimedVar(DelayedVars);
if (H0 - (CELL *)vs < 1024) if (H0 - (CELL *)vs < 1024)
return(FALSE); return(FALSE);
RESET_VARIABLE(&(vs->ActiveSus)); RESET_VARIABLE(&(vs->ActiveSus));
vs->sus_id = susp_ext; vs->sus_id = susp_ext;
vs->SG = copy_suspended_goals(sreg->SG, to_visit_ptr); vs->SG = copy_suspended_goals(sreg->SG, to_visit_ptr);
*res = (CELL)&(vs->ActiveSus); *res = (CELL)&(vs->ActiveSus);
_YAP_UpdateTimedVar(DelayedVars, (CELL)(vs+1)); Yap_UpdateTimedVar(DelayedVars, (CELL)(vs+1));
return(TRUE); return(TRUE);
} }
@ -386,14 +386,14 @@ TermToSuspendedVar(Term gs, Term var)
{ {
register sus_tag *vs; register sus_tag *vs;
/* add a new suspension */ /* add a new suspension */
vs = (sus_tag *)_YAP_ReadTimedVar(DelayedVars); vs = (sus_tag *)Yap_ReadTimedVar(DelayedVars);
if (H0 - (CELL *)vs < 1024) if (H0 - (CELL *)vs < 1024)
return(FALSE); return(FALSE);
RESET_VARIABLE(&(vs->ActiveSus)); RESET_VARIABLE(&(vs->ActiveSus));
vs->sus_id = susp_ext; vs->sus_id = susp_ext;
vs->SG = terms_to_suspended_goals(gs); vs->SG = terms_to_suspended_goals(gs);
_YAP_unify(var,(CELL)&(vs->ActiveSus)); Yap_unify(var,(CELL)&(vs->ActiveSus));
_YAP_UpdateTimedVar(DelayedVars, (CELL)(vs+1)); Yap_UpdateTimedVar(DelayedVars, (CELL)(vs+1));
return(TRUE); return(TRUE);
} }
@ -404,10 +404,10 @@ mark_sus_record(sus_record *sg)
if (MARKED(((CELL)(sg->NR)))) if (MARKED(((CELL)(sg->NR))))
return; return;
MARK(((CELL *)&(sg->NR))); MARK(((CELL *)&(sg->NR)));
_YAP_inc_mark_variable(); Yap_inc_mark_variable();
_YAP_mark_variable((CELL *)&(sg->SG)); Yap_mark_variable((CELL *)&(sg->SG));
#ifdef MULTI_ASSIGNMENT_VARIABLES #ifdef MULTI_ASSIGNMENT_VARIABLES
_YAP_inc_mark_variable(); Yap_inc_mark_variable();
if (!IsAtomTerm((CELL)(sg->NS))) if (!IsAtomTerm((CELL)(sg->NS)))
mark_sus_record(sg->NS); mark_sus_record(sg->NS);
MARK(((CELL *)&(sg->NS))); MARK(((CELL *)&(sg->NS)));
@ -419,12 +419,12 @@ static void mark_suspended_goal(CELL *orig)
register sus_tag *sreg = (sus_tag *)orig; register sus_tag *sreg = (sus_tag *)orig;
mark_sus_record(sreg->SG); mark_sus_record(sreg->SG);
_YAP_mark_external_reference(((CELL *)&(sreg->SG))); Yap_mark_external_reference(((CELL *)&(sreg->SG)));
} }
void void
_YAP_mark_all_suspended_goals(void) Yap_mark_all_suspended_goals(void)
{ {
sus_record *sg = GetSVarList(); sus_record *sg = GetSVarList();
if (sg == NULL) if (sg == NULL)
@ -474,7 +474,7 @@ Wake(CELL *pt1, CELL reg2)
/* binding two suspended variables, be careful */ /* binding two suspended variables, be careful */
if (susp2->sus_id != susp_ext) { if (susp2->sus_id != susp_ext) {
/* joining two suspensions */ /* joining two suspensions */
_YAP_Error(SYSTEM_ERROR, TermNil, "joining two suspensions not implemented"); Yap_Error(SYSTEM_ERROR, TermNil, "joining two suspensions not implemented");
return; return;
} }
/* join the two suspended lists */ /* join the two suspended lists */
@ -573,19 +573,19 @@ freeze_goal(Term t, Term g)
id = (exts)(susp->sus_id); id = (exts)(susp->sus_id);
if (id != susp_ext) { if (id != susp_ext) {
/* obtain the term */ /* obtain the term */
_YAP_Error(SYSTEM_ERROR,TermNil,"multiple suspensions not supported"); Yap_Error(SYSTEM_ERROR,TermNil,"multiple suspensions not supported");
return(FALSE); return(FALSE);
} }
AddSuspendedGoal(g, susp->SG); AddSuspendedGoal(g, susp->SG);
return(TRUE); return(TRUE);
} }
vs = (sus_tag *)_YAP_ReadTimedVar(DelayedVars); vs = (sus_tag *)Yap_ReadTimedVar(DelayedVars);
if (H0 - (CELL *)vs < 1024) { if (H0 - (CELL *)vs < 1024) {
ARG1 = t; ARG1 = t;
ARG2 = g; ARG2 = g;
if (!_YAP_growglobal(NULL)) { if (!Yap_growglobal(NULL)) {
_YAP_Error(SYSTEM_ERROR, t, _YAP_ErrorMessage); Yap_Error(SYSTEM_ERROR, t, Yap_ErrorMessage);
return FALSE; return FALSE;
} }
t = ARG1; t = ARG1;
@ -603,13 +603,13 @@ freeze_goal(Term t, Term g)
vs->sus_id = susp_ext; vs->sus_id = susp_ext;
vs->SG = gf; vs->SG = gf;
RESET_VARIABLE(&(vs->ActiveSus)); RESET_VARIABLE(&(vs->ActiveSus));
_YAP_UpdateTimedVar(DelayedVars, (CELL)(vs+1)); Yap_UpdateTimedVar(DelayedVars, (CELL)(vs+1));
Bind_Global((CELL *)t,(CELL)&(vs->ActiveSus)); Bind_Global((CELL *)t,(CELL)&(vs->ActiveSus));
return(TRUE); return(TRUE);
} }
else { else {
/* Oops, first argument was bound :-( */ /* Oops, first argument was bound :-( */
_YAP_Error(TYPE_ERROR_VARIABLE, t, "freeze/2"); Yap_Error(TYPE_ERROR_VARIABLE, t, "freeze/2");
return(FALSE); return(FALSE);
} }
} }
@ -621,7 +621,7 @@ p_read_svar_list(void)
{ {
#ifdef COROUTINING #ifdef COROUTINING
#ifdef MULTI_ASSIGNMENT_VARIABLES #ifdef MULTI_ASSIGNMENT_VARIABLES
return(_YAP_unify(ARG1, MutableList) && _YAP_unify(ARG2, AttsMutableList)); return(Yap_unify(ARG1, MutableList) && Yap_unify(ARG2, AttsMutableList));
#else #else
return(TRUE); return(TRUE);
#endif #endif
@ -725,7 +725,7 @@ static Int p_frozen_goals(void)
} }
HB = B->cp_h; HB = B->cp_h;
#endif #endif
return(_YAP_unify(ARG2,t)); return(Yap_unify(ARG2,t));
} }
/* return a queue with all goals frozen in the system */ /* return a queue with all goals frozen in the system */
@ -733,11 +733,11 @@ static Int p_all_frozen_goals(void)
{ {
#ifdef COROUTINING #ifdef COROUTINING
/* initially, we do not know of any goals frozen */ /* initially, we do not know of any goals frozen */
Term t = _YAP_CurrentAttVars(); Term t = Yap_CurrentAttVars();
#ifdef MULTI_ASSIGNMENT_VARIABLES #ifdef MULTI_ASSIGNMENT_VARIABLES
sus_record *x = GetSVarList(); sus_record *x = GetSVarList();
if (x == NULL) if (x == NULL)
return(_YAP_unify(ARG1,t)); return(Yap_unify(ARG1,t));
/* okay, we are on top of the list of variables. Let's burn rubber! /* okay, we are on top of the list of variables. Let's burn rubber!
*/ */
while ((CELL)x != TermNil) { while ((CELL)x != TermNil) {
@ -745,9 +745,9 @@ static Int p_all_frozen_goals(void)
x = x->NS; x = x->NS;
} }
#endif #endif
return(_YAP_unify(ARG1,t)); return(Yap_unify(ARG1,t));
#else #else
return(_YAP_unify(ARG1,TermNil)); return(Yap_unify(ARG1,TermNil));
#endif #endif
} }
@ -777,7 +777,7 @@ static int can_unify_complex(register CELL *pt0,
CELL *saved_HB; CELL *saved_HB;
choiceptr saved_B; choiceptr saved_B;
register CELL **to_visit = (CELL **)_YAP_PreAllocCodeSpace(); register CELL **to_visit = (CELL **)Yap_PreAllocCodeSpace();
CELL **to_visit_base = to_visit; CELL **to_visit_base = to_visit;
/* make sure to trail all bindings */ /* make sure to trail all bindings */
@ -878,7 +878,7 @@ static int can_unify_complex(register CELL *pt0,
goto comparison_failed; goto comparison_failed;
#ifdef USE_GMP #ifdef USE_GMP
case (CELL)FunctorBigInt: case (CELL)FunctorBigInt:
if (mpz_cmp(_YAP_BigIntOfTerm(d0),_YAP_BigIntOfTerm(d1)) == 0) continue; if (mpz_cmp(Yap_BigIntOfTerm(d0),Yap_BigIntOfTerm(d1)) == 0) continue;
goto comparison_failed; goto comparison_failed;
#endif /* USE_GMP */ #endif /* USE_GMP */
default: default:
@ -929,7 +929,7 @@ static int can_unify_complex(register CELL *pt0,
goto loop; goto loop;
} }
/* success */ /* success */
_YAP_ReleasePreAllocCodeSpace((ADDR)to_visit); Yap_ReleasePreAllocCodeSpace((ADDR)to_visit);
/* restore B, and later HB */ /* restore B, and later HB */
B = saved_B; B = saved_B;
HB = saved_HB; HB = saved_HB;
@ -942,7 +942,7 @@ static int can_unify_complex(register CELL *pt0,
comparison_failed: comparison_failed:
/* failure */ /* failure */
_YAP_ReleasePreAllocCodeSpace((ADDR)to_visit); Yap_ReleasePreAllocCodeSpace((ADDR)to_visit);
#ifdef RATIONAL_TREES #ifdef RATIONAL_TREES
while (to_visit > (CELL **)to_visit_base) { while (to_visit > (CELL **)to_visit_base) {
to_visit -= 4; to_visit -= 4;
@ -1015,7 +1015,7 @@ can_unify(Term t1, Term t2, Term *Vars)
return(FALSE); return(FALSE);
#ifdef USE_GMP #ifdef USE_GMP
case (CELL)FunctorBigInt: case (CELL)FunctorBigInt:
if (mpz_cmp(_YAP_BigIntOfTerm(t1),_YAP_BigIntOfTerm(t2)) == 0) return(TRUE); if (mpz_cmp(Yap_BigIntOfTerm(t1),Yap_BigIntOfTerm(t2)) == 0) return(TRUE);
return(FALSE); return(FALSE);
#endif /* USE_GMP */ #endif /* USE_GMP */
default: default:
@ -1035,7 +1035,7 @@ static int non_ground_complex(register CELL *pt0,
Term *Var) Term *Var)
{ {
register CELL **to_visit = (CELL **)_YAP_PreAllocCodeSpace(); register CELL **to_visit = (CELL **)Yap_PreAllocCodeSpace();
CELL **to_visit_base = to_visit; CELL **to_visit_base = to_visit;
loop: loop:
@ -1113,12 +1113,12 @@ static int non_ground_complex(register CELL *pt0,
} }
/* the term is ground */ /* the term is ground */
_YAP_ReleasePreAllocCodeSpace((ADDR)to_visit); Yap_ReleasePreAllocCodeSpace((ADDR)to_visit);
return(FALSE); return(FALSE);
var_found: var_found:
/* the term is non-ground */ /* the term is non-ground */
_YAP_ReleasePreAllocCodeSpace((ADDR)to_visit); Yap_ReleasePreAllocCodeSpace((ADDR)to_visit);
#ifdef RATIONAL_TREES #ifdef RATIONAL_TREES
while (to_visit > (CELL **)to_visit_base) { while (to_visit > (CELL **)to_visit_base) {
to_visit -= 3; to_visit -= 3;
@ -1165,7 +1165,7 @@ static Int p_can_unify(void)
Term r = TermNil; Term r = TermNil;
if (!can_unify(ARG1, ARG2, &r)) if (!can_unify(ARG1, ARG2, &r))
return(FALSE); return(FALSE);
return (_YAP_unify(ARG3, r)); return (Yap_unify(ARG3, r));
#else #else
return(FALSE); return(FALSE);
#endif #endif
@ -1178,7 +1178,7 @@ static Int p_non_ground(void)
Term r; Term r;
if (!non_ground(ARG1, &r)) if (!non_ground(ARG1, &r))
return(FALSE); return(FALSE);
return (_YAP_unify(ARG2, r)); return (Yap_unify(ARG2, r));
#else #else
return(FALSE); return(FALSE);
#endif #endif
@ -1198,13 +1198,13 @@ static Int p_coroutining(void)
static Int p_awoken_goals(void) static Int p_awoken_goals(void)
{ {
#ifdef COROUTINING #ifdef COROUTINING
Term WGs = _YAP_ReadTimedVar(WokenGoals); Term WGs = Yap_ReadTimedVar(WokenGoals);
if (WGs == TermNil) { if (WGs == TermNil) {
return(FALSE); return(FALSE);
} }
WGs = ListOfWokenGoals(); WGs = ListOfWokenGoals();
_YAP_UpdateTimedVar(WokenGoals, TermNil); Yap_UpdateTimedVar(WokenGoals, TermNil);
return(_YAP_unify(ARG1,WGs)); return(Yap_unify(ARG1,WGs));
#else #else
return(FALSE); return(FALSE);
#endif #endif
@ -1212,7 +1212,7 @@ static Int p_awoken_goals(void)
#ifdef COROUTINING #ifdef COROUTINING
void void
_YAP_WakeUp(CELL *pt0) { Yap_WakeUp(CELL *pt0) {
CELL d0 = *pt0; CELL d0 = *pt0;
RESET_VARIABLE(pt0); RESET_VARIABLE(pt0);
TR--; TR--;
@ -1221,7 +1221,7 @@ _YAP_WakeUp(CELL *pt0) {
#endif #endif
void _YAP_InitCoroutPreds(void) void Yap_InitCoroutPreds(void)
{ {
#ifdef COROUTINING #ifdef COROUTINING
Atom at; Atom at;
@ -1232,21 +1232,21 @@ void _YAP_InitCoroutPreds(void)
attas[susp_ext].to_term_op = SuspendedVarToTerm; attas[susp_ext].to_term_op = SuspendedVarToTerm;
attas[susp_ext].term_to_op = TermToSuspendedVar; attas[susp_ext].term_to_op = TermToSuspendedVar;
attas[susp_ext].mark_op = mark_suspended_goal; attas[susp_ext].mark_op = mark_suspended_goal;
at = _YAP_LookupAtom("$wake_up_goal"); at = Yap_LookupAtom("$wake_up_goal");
pred = RepPredProp(PredPropByFunc(_YAP_MkFunctor(at, 2),0)); pred = RepPredProp(PredPropByFunc(Yap_MkFunctor(at, 2),0));
WakeUpCode = pred; WakeUpCode = pred;
_YAP_InitAttVarPreds(); Yap_InitAttVarPreds();
#endif /* COROUTINING */ #endif /* COROUTINING */
_YAP_InitCPred("$read_svar_list", 2, p_read_svar_list, SafePredFlag); Yap_InitCPred("$read_svar_list", 2, p_read_svar_list, SafePredFlag);
_YAP_InitCPred("$set_svar_list", 2, p_set_svar_list, SafePredFlag); Yap_InitCPred("$set_svar_list", 2, p_set_svar_list, SafePredFlag);
_YAP_InitCPred("$freeze", 2, p_freeze, 0); Yap_InitCPred("$freeze", 2, p_freeze, 0);
_YAP_InitCPred("freeze_on_first", 2, p_freeze_on_first, TestPredFlag); Yap_InitCPred("freeze_on_first", 2, p_freeze_on_first, TestPredFlag);
_YAP_InitCPred("$frozen_goals", 2, p_frozen_goals, SafePredFlag); Yap_InitCPred("$frozen_goals", 2, p_frozen_goals, SafePredFlag);
_YAP_InitCPred("$all_frozen_goals", 1, p_all_frozen_goals, SafePredFlag); Yap_InitCPred("$all_frozen_goals", 1, p_all_frozen_goals, SafePredFlag);
_YAP_InitCPred("$can_unify", 3, p_can_unify, SafePredFlag); Yap_InitCPred("$can_unify", 3, p_can_unify, SafePredFlag);
_YAP_InitCPred("$non_ground", 2, p_non_ground, SafePredFlag); Yap_InitCPred("$non_ground", 2, p_non_ground, SafePredFlag);
_YAP_InitCPred("$coroutining", 0, p_coroutining, SafePredFlag); Yap_InitCPred("$coroutining", 0, p_coroutining, SafePredFlag);
_YAP_InitCPred("$awoken_goals", 1, p_awoken_goals, SafePredFlag); Yap_InitCPred("$awoken_goals", 1, p_awoken_goals, SafePredFlag);
} }

490
C/dbase.c
View File

File diff suppressed because it is too large Load Diff

12
C/depth_bound.c
View File

@ -29,7 +29,7 @@ STD_PROTO(static Int p_set_depth_limit, (void));
static Int p_get_depth_limit(void) static Int p_get_depth_limit(void)
{ {
return(_YAP_unify_constant(ARG1, MkIntTerm(IntOfTerm(DEPTH/2)))); return(Yap_unify_constant(ARG1, MkIntTerm(IntOfTerm(DEPTH/2))));
} }
static Int p_set_depth_limit(void) static Int p_set_depth_limit(void)
@ -37,10 +37,10 @@ static Int p_set_depth_limit(void)
Term d = Deref(ARG1); Term d = Deref(ARG1);
if (IsVarTerm(d)) { if (IsVarTerm(d)) {
_YAP_Error(INSTANTIATION_ERROR, d, "set-depth_limit"); Yap_Error(INSTANTIATION_ERROR, d, "set-depth_limit");
return(FALSE); return(FALSE);
} else if (!IsIntegerTerm(d)) { } else if (!IsIntegerTerm(d)) {
_YAP_Error(TYPE_ERROR_INTEGER, d, "set-depth_limit"); Yap_Error(TYPE_ERROR_INTEGER, d, "set-depth_limit");
return(FALSE); return(FALSE);
} }
d = MkIntTerm(IntegerOfTerm(d)*2); d = MkIntTerm(IntegerOfTerm(d)*2);
@ -51,10 +51,10 @@ static Int p_set_depth_limit(void)
return(TRUE); return(TRUE);
} }
void _YAP_InitItDeepenPreds(void) void Yap_InitItDeepenPreds(void)
{ {
_YAP_InitCPred("get_depth_limit", 1, p_get_depth_limit, SafePredFlag); Yap_InitCPred("get_depth_limit", 1, p_get_depth_limit, SafePredFlag);
_YAP_InitCPred("$set_depth_limit", 1, p_set_depth_limit, 0); Yap_InitCPred("$set_depth_limit", 1, p_set_depth_limit, 0);
} }
#endif #endif

552
C/errors.c
View File

File diff suppressed because it is too large Load Diff

46
C/eval.c
View File

@ -27,7 +27,7 @@ static char SccsId[] = "%W% %G%";
#include "Heap.h" #include "Heap.h"
#include "eval.h" #include "eval.h"
yap_error_number _YAP_matherror = YAP_NO_ERROR; yap_error_number Yap_matherror = YAP_NO_ERROR;
#define E_FUNC blob_type #define E_FUNC blob_type
#define E_ARGS arith_retptr o #define E_ARGS arith_retptr o
@ -48,7 +48,7 @@ EvalToTerm(blob_type bt, union arith_ret *res)
return(MkFloatTerm(res->dbl)); return(MkFloatTerm(res->dbl));
#ifdef USE_GMP #ifdef USE_GMP
case big_int_e: case big_int_e:
return(_YAP_MkBigIntTerm(res->big)); return(Yap_MkBigIntTerm(res->big));
#endif #endif
default: default:
return(TermNil); return(TermNil);
@ -59,7 +59,7 @@ static E_FUNC
Eval(Term t, E_ARGS) Eval(Term t, E_ARGS)
{ {
if (IsVarTerm(t)) { if (IsVarTerm(t)) {
_YAP_Error(INSTANTIATION_ERROR,TermNil,"in arithmetic"); Yap_Error(INSTANTIATION_ERROR,TermNil,"in arithmetic");
P = (yamop *)FAILCODE; P = (yamop *)FAILCODE;
RERROR(); RERROR();
} }
@ -72,7 +72,7 @@ Eval(Term t, E_ARGS)
RFLOAT(FloatOfTerm(t)); RFLOAT(FloatOfTerm(t));
#ifdef USE_GMP #ifdef USE_GMP
case (CELL)FunctorBigInt: case (CELL)FunctorBigInt:
RBIG(_YAP_BigIntOfTerm(t)); RBIG(Yap_BigIntOfTerm(t));
#endif #endif
default: default:
{ {
@ -80,14 +80,14 @@ Eval(Term t, E_ARGS)
Atom name = NameOfFunctor(fun); Atom name = NameOfFunctor(fun);
ExpEntry *p; ExpEntry *p;
if (EndOfPAEntr(p = RepExpProp(_YAP_GetExpProp(name, n)))) { if (EndOfPAEntr(p = RepExpProp(Yap_GetExpProp(name, n)))) {
Term ti[2]; Term ti[2];
/* error */ /* error */
ti[0] = t; ti[0] = t;
ti[1] = MkIntegerTerm(n); ti[1] = MkIntegerTerm(n);
t = _YAP_MkApplTerm(_YAP_MkFunctor(_YAP_LookupAtom("/"),2), 2, ti); t = Yap_MkApplTerm(Yap_MkFunctor(Yap_LookupAtom("/"),2), 2, ti);
_YAP_Error(TYPE_ERROR_EVALUABLE, t, Yap_Error(TYPE_ERROR_EVALUABLE, t,
"functor %s/%d for arithmetic expression", "functor %s/%d for arithmetic expression",
RepAtom(name)->StrOfAE,n); RepAtom(name)->StrOfAE,n);
P = (yamop *)FAILCODE; P = (yamop *)FAILCODE;
@ -106,9 +106,9 @@ Eval(Term t, E_ARGS)
Atom name = AtomOfTerm(t); Atom name = AtomOfTerm(t);
ExpEntry *p; ExpEntry *p;
if (EndOfPAEntr(p = RepExpProp(_YAP_GetExpProp(name, 0)))) { if (EndOfPAEntr(p = RepExpProp(Yap_GetExpProp(name, 0)))) {
/* error */ /* error */
_YAP_Error(TYPE_ERROR_EVALUABLE, t, Yap_Error(TYPE_ERROR_EVALUABLE, t,
"atom %s for arithmetic expression", "atom %s for arithmetic expression",
RepAtom(name)->StrOfAE); RepAtom(name)->StrOfAE);
P = (yamop *)FAILCODE; P = (yamop *)FAILCODE;
@ -119,10 +119,10 @@ Eval(Term t, E_ARGS)
} }
E_FUNC E_FUNC
_YAP_Eval(Term t, E_ARGS) Yap_Eval(Term t, E_ARGS)
{ {
if (IsVarTerm(t)) { if (IsVarTerm(t)) {
_YAP_Error(INSTANTIATION_ERROR,TermNil,"in arithmetic"); Yap_Error(INSTANTIATION_ERROR,TermNil,"in arithmetic");
P = (yamop *)FAILCODE; P = (yamop *)FAILCODE;
RERROR(); RERROR();
} }
@ -135,7 +135,7 @@ _YAP_Eval(Term t, E_ARGS)
RFLOAT(FloatOfTerm(t)); RFLOAT(FloatOfTerm(t));
#ifdef USE_GMP #ifdef USE_GMP
case (CELL)FunctorBigInt: case (CELL)FunctorBigInt:
RBIG(_YAP_BigIntOfTerm(t)); RBIG(Yap_BigIntOfTerm(t));
#endif #endif
default: default:
{ {
@ -143,14 +143,14 @@ _YAP_Eval(Term t, E_ARGS)
Atom name = NameOfFunctor(fun); Atom name = NameOfFunctor(fun);
ExpEntry *p; ExpEntry *p;
if (EndOfPAEntr(p = RepExpProp(_YAP_GetExpProp(name, n)))) { if (EndOfPAEntr(p = RepExpProp(Yap_GetExpProp(name, n)))) {
Term ti[2]; Term ti[2];
/* error */ /* error */
ti[0] = t; ti[0] = t;
ti[1] = MkIntegerTerm(n); ti[1] = MkIntegerTerm(n);
t = _YAP_MkApplTerm(_YAP_MkFunctor(_YAP_LookupAtom("/"),2), 2, ti); t = Yap_MkApplTerm(Yap_MkFunctor(Yap_LookupAtom("/"),2), 2, ti);
_YAP_Error(TYPE_ERROR_EVALUABLE, t, Yap_Error(TYPE_ERROR_EVALUABLE, t,
"functor %s/%d for arithmetic expression", "functor %s/%d for arithmetic expression",
RepAtom(name)->StrOfAE,n); RepAtom(name)->StrOfAE,n);
P = (yamop *)FAILCODE; P = (yamop *)FAILCODE;
@ -169,9 +169,9 @@ _YAP_Eval(Term t, E_ARGS)
Atom name = AtomOfTerm(t); Atom name = AtomOfTerm(t);
ExpEntry *p; ExpEntry *p;
if (EndOfPAEntr(p = RepExpProp(_YAP_GetExpProp(name, 0)))) { if (EndOfPAEntr(p = RepExpProp(Yap_GetExpProp(name, 0)))) {
/* error */ /* error */
_YAP_Error(TYPE_ERROR_EVALUABLE, t, Yap_Error(TYPE_ERROR_EVALUABLE, t,
"atom %s for arithmetic expression", "atom %s for arithmetic expression",
RepAtom(name)->StrOfAE); RepAtom(name)->StrOfAE);
P = (yamop *)FAILCODE; P = (yamop *)FAILCODE;
@ -188,16 +188,16 @@ p_is(void)
blob_type bt; blob_type bt;
bt = Eval(Deref(ARG2), &res); bt = Eval(Deref(ARG2), &res);
return (_YAP_unify_constant(ARG1,EvalToTerm(bt,&res))); return (Yap_unify_constant(ARG1,EvalToTerm(bt,&res)));
} }
void void
_YAP_InitEval(void) Yap_InitEval(void)
{ {
/* here are the arithmetical predicates */ /* here are the arithmetical predicates */
_YAP_InitConstExps(); Yap_InitConstExps();
_YAP_InitUnaryExps(); Yap_InitUnaryExps();
_YAP_InitBinaryExps(); Yap_InitBinaryExps();
_YAP_InitCPred("is", 2, p_is, TestPredFlag | SafePredFlag); Yap_InitCPred("is", 2, p_is, TestPredFlag | SafePredFlag);
} }

306
C/exec.c
View File

@ -29,8 +29,8 @@ STATIC_PROTO(Int p_execute0, (void));
STATIC_PROTO(Int p_at_execute, (void)); STATIC_PROTO(Int p_at_execute, (void));
/************ table of C-Predicates *************/ /************ table of C-Predicates *************/
CPredicate _YAP_c_predicates[MAX_C_PREDS]; CPredicate Yap_c_predicates[MAX_C_PREDS];
cmp_entry _YAP_cmp_funcs[MAX_CMP_FUNCS]; cmp_entry Yap_cmp_funcs[MAX_CMP_FUNCS];
static Term static Term
current_cp_as_integer(void) current_cp_as_integer(void)
@ -52,7 +52,7 @@ CallPredicate(PredEntry *pen, choiceptr cut_pt) {
DEPTH -= MkIntConstant(2); DEPTH -= MkIntConstant(2);
#endif /* DEPTH_LIMIT */ #endif /* DEPTH_LIMIT */
#ifdef LOW_LEVEL_TRACER #ifdef LOW_LEVEL_TRACER
if (_YAP_do_low_level_trace) if (Yap_do_low_level_trace)
low_level_trace(enter_pred,pen,XREGS+1); low_level_trace(enter_pred,pen,XREGS+1);
#endif /* LOW_LEVEL_TRACE */ #endif /* LOW_LEVEL_TRACE */
CP = P; CP = P;
@ -79,13 +79,13 @@ CallMetaCall(SMALLUNSGN mod) {
} }
Term Term
_YAP_ExecuteCallMetaCall(SMALLUNSGN mod) { Yap_ExecuteCallMetaCall(SMALLUNSGN mod) {
Term ts[4]; Term ts[4];
ts[0] = ARG1; ts[0] = ARG1;
ts[1] = current_cp_as_integer(); /* p_save_cp */ ts[1] = current_cp_as_integer(); /* p_save_cp */
ts[2] = ARG1; ts[2] = ARG1;
ts[3] = ModuleName[mod]; ts[3] = ModuleName[mod];
return(_YAP_MkApplTerm(PredMetaCall->FunctorOfPred,4,ts)); return(Yap_MkApplTerm(PredMetaCall->FunctorOfPred,4,ts));
} }
static Int static Int
@ -94,7 +94,7 @@ CallError(yap_error_number err, SMALLUNSGN mod)
if (yap_flags[LANGUAGE_MODE_FLAG] == 1) { if (yap_flags[LANGUAGE_MODE_FLAG] == 1) {
return(CallMetaCall(mod)); return(CallMetaCall(mod));
} else { } else {
_YAP_Error(err, ARG1, "call/1"); Yap_Error(err, ARG1, "call/1");
return(FALSE); return(FALSE);
} }
} }
@ -121,7 +121,7 @@ CallClause(PredEntry *pen, unsigned int arity, Int position)
DEPTH -= MkIntConstant(2); DEPTH -= MkIntConstant(2);
#endif /* DEPTH_LIMIT */ #endif /* DEPTH_LIMIT */
#ifdef LOW_LEVEL_TRACER #ifdef LOW_LEVEL_TRACER
if (_YAP_do_low_level_trace) if (Yap_do_low_level_trace)
low_level_trace(enter_pred,pen,XREGS+1); low_level_trace(enter_pred,pen,XREGS+1);
#endif /* LOW_LEVEL_TRACE */ #endif /* LOW_LEVEL_TRACE */
ENV = YENV; ENV = YENV;
@ -176,7 +176,7 @@ CallClause(PredEntry *pen, unsigned int arity, Int position)
return (Unsigned(pen)); return (Unsigned(pen));
} }
} else { } else {
_YAP_Error(SYSTEM_ERROR,ARG1,"debugger tries to debug clause for builtin"); Yap_Error(SYSTEM_ERROR,ARG1,"debugger tries to debug clause for builtin");
return (FALSE); return (FALSE);
} }
} }
@ -194,7 +194,7 @@ p_save_cp(void)
BIND((CELL *)t,td,bind_save_cp); BIND((CELL *)t,td,bind_save_cp);
#ifdef COROUTINING #ifdef COROUTINING
DO_TRAIL(CellPtr(t), td); DO_TRAIL(CellPtr(t), td);
if (CellPtr(t) < H0) _YAP_WakeUp((CELL *)t); if (CellPtr(t) < H0) Yap_WakeUp((CELL *)t);
bind_save_cp: bind_save_cp:
#endif #endif
return(TRUE); return(TRUE);
@ -203,7 +203,7 @@ p_save_cp(void)
static Int static Int
EnterCreepMode(SMALLUNSGN mod) { EnterCreepMode(SMALLUNSGN mod) {
PredEntry *PredSpy = RepPredProp(PredPropByFunc(FunctorSpy,0)); PredEntry *PredSpy = RepPredProp(PredPropByFunc(FunctorSpy,0));
Term tn = _YAP_MkApplTerm(_YAP_MkFunctor(AtomMetaCall,1),1,&ARG1); Term tn = Yap_MkApplTerm(Yap_MkFunctor(AtomMetaCall,1),1,&ARG1);
ARG1 = MkPairTerm(ModuleName[mod],tn); ARG1 = MkPairTerm(ModuleName[mod],tn);
CreepFlag = CalculateStackGap(); CreepFlag = CalculateStackGap();
P_before_spy = P; P_before_spy = P;
@ -219,17 +219,17 @@ PushModule(Term t,SMALLUNSGN mod) {
Term ti[2], tf[2]; Term ti[2], tf[2];
ti[0] = tmod; ti[0] = tmod;
ti[1] = ArgOfTerm(1,t); ti[1] = ArgOfTerm(1,t);
tf[0] = _YAP_MkApplTerm(FunctorModule,2,ti); tf[0] = Yap_MkApplTerm(FunctorModule,2,ti);
ti[0] = tmod; ti[0] = tmod;
ti[1] = ArgOfTerm(2,t); ti[1] = ArgOfTerm(2,t);
tf[1] = _YAP_MkApplTerm(FunctorModule,2,ti); tf[1] = Yap_MkApplTerm(FunctorModule,2,ti);
return(_YAP_MkApplTerm(f,2,tf)); return(Yap_MkApplTerm(f,2,tf));
} else { } else {
Term ti[2], tf[1]; Term ti[2], tf[1];
ti[0] = tmod; ti[0] = tmod;
ti[1] = ArgOfTerm(1,t); ti[1] = ArgOfTerm(1,t);
tf[0] = _YAP_MkApplTerm(FunctorModule,2,ti); tf[0] = Yap_MkApplTerm(FunctorModule,2,ti);
return(_YAP_MkApplTerm(f,1,tf)); return(Yap_MkApplTerm(f,1,tf));
} }
} }
@ -263,7 +263,7 @@ do_execute(Term t, SMALLUNSGN mod)
if (f == FunctorModule) { if (f == FunctorModule) {
Term tmod = ArgOfTerm(1,t); Term tmod = ArgOfTerm(1,t);
if (!IsVarTerm(tmod) && IsAtomTerm(tmod)) { if (!IsVarTerm(tmod) && IsAtomTerm(tmod)) {
mod = _YAP_LookupModule(tmod); mod = Yap_LookupModule(tmod);
t = ArgOfTerm(2,t); t = ArgOfTerm(2,t);
goto restart_exec; goto restart_exec;
} }
@ -338,7 +338,7 @@ p_execute_within(void)
unsigned int arity; unsigned int arity;
Prop pe; Prop pe;
Atom a; Atom a;
SMALLUNSGN mod = _YAP_LookupModule(tmod); SMALLUNSGN mod = Yap_LookupModule(tmod);
#ifdef SBA #ifdef SBA
choiceptr cut_pt = (choiceptr)IntegerOfTerm(Deref(ARG2)); choiceptr cut_pt = (choiceptr)IntegerOfTerm(Deref(ARG2));
#else #else
@ -375,7 +375,7 @@ p_execute_within(void)
if (f == FunctorModule) { if (f == FunctorModule) {
Term tmod = ArgOfTerm(1,t); Term tmod = ArgOfTerm(1,t);
if (!IsVarTerm(tmod) && IsAtomTerm(tmod)) { if (!IsVarTerm(tmod) && IsAtomTerm(tmod)) {
mod = _YAP_LookupModule(tmod); mod = Yap_LookupModule(tmod);
t = ArgOfTerm(2,t); t = ArgOfTerm(2,t);
goto restart_exec; goto restart_exec;
} }
@ -464,7 +464,7 @@ p_execute_within2(void)
if (f == FunctorModule) { if (f == FunctorModule) {
Term tmod = ArgOfTerm(1,t); Term tmod = ArgOfTerm(1,t);
if (!IsVarTerm(tmod) && IsAtomTerm(tmod)) { if (!IsVarTerm(tmod) && IsAtomTerm(tmod)) {
mod = _YAP_LookupModule(tmod); mod = Yap_LookupModule(tmod);
t = ArgOfTerm(2,t); t = ArgOfTerm(2,t);
goto restart_exec; goto restart_exec;
} }
@ -557,11 +557,11 @@ p_execute0(void)
Term tmod = Deref(ARG2); Term tmod = Deref(ARG2);
unsigned int arity; unsigned int arity;
Prop pe; Prop pe;
SMALLUNSGN mod = _YAP_LookupModule(tmod); SMALLUNSGN mod = Yap_LookupModule(tmod);
restart_exec: restart_exec:
if (IsVarTerm(t)) { if (IsVarTerm(t)) {
_YAP_Error(INSTANTIATION_ERROR,ARG3,"call/1"); Yap_Error(INSTANTIATION_ERROR,ARG3,"call/1");
return(FALSE); return(FALSE);
} else if (IsAtomTerm(t)) { } else if (IsAtomTerm(t)) {
Atom a = AtomOfTerm(t); Atom a = AtomOfTerm(t);
@ -576,7 +576,7 @@ p_execute0(void)
if (f == FunctorModule) { if (f == FunctorModule) {
Term tmod = ArgOfTerm(1,t); Term tmod = ArgOfTerm(1,t);
if (!IsVarTerm(tmod) && IsAtomTerm(tmod)) { if (!IsVarTerm(tmod) && IsAtomTerm(tmod)) {
mod = _YAP_LookupModule(tmod); mod = Yap_LookupModule(tmod);
t = ArgOfTerm(2,t); t = ArgOfTerm(2,t);
goto restart_exec; goto restart_exec;
} }
@ -602,7 +602,7 @@ p_execute0(void)
#endif #endif
} }
} else { } else {
_YAP_Error(TYPE_ERROR_CALLABLE,ARG3,"call/1"); Yap_Error(TYPE_ERROR_CALLABLE,ARG3,"call/1");
return(FALSE); return(FALSE);
} }
/* N = arity; */ /* N = arity; */
@ -614,7 +614,7 @@ static Int
p_execute_0(void) p_execute_0(void)
{ /* '$execute_0'(Goal) */ { /* '$execute_0'(Goal) */
Term t = Deref(ARG1); Term t = Deref(ARG1);
SMALLUNSGN mod = _YAP_LookupModule(Deref(ARG2)); SMALLUNSGN mod = Yap_LookupModule(Deref(ARG2));
Prop pe; Prop pe;
if (IsAtomTerm(t)) { if (IsAtomTerm(t)) {
@ -627,7 +627,7 @@ p_execute_0(void)
CELL *ptr; CELL *ptr;
if (IsExtensionFunctor(f)) { if (IsExtensionFunctor(f)) {
_YAP_Error(TYPE_ERROR_CALLABLE, t, "call_with_args/1"); Yap_Error(TYPE_ERROR_CALLABLE, t, "call_with_args/1");
return(FALSE); return(FALSE);
} }
pe = PredPropByFunc(f, mod); pe = PredPropByFunc(f, mod);
@ -639,7 +639,7 @@ p_execute_0(void)
} else { } else {
CELL *ptr; CELL *ptr;
pe = PredPropByFunc(_YAP_MkFunctor(AtomDot,2), mod); pe = PredPropByFunc(Yap_MkFunctor(AtomDot,2), mod);
ptr = RepPair(t); ptr = RepPair(t);
XREGS[1] = ptr[0]; XREGS[1] = ptr[0];
XREGS[2] = ptr[1]; XREGS[2] = ptr[1];
@ -651,18 +651,18 @@ static Int
p_execute_1(void) p_execute_1(void)
{ /* '$execute_0'(Goal) */ { /* '$execute_0'(Goal) */
Term t = Deref(ARG1); Term t = Deref(ARG1);
SMALLUNSGN mod = _YAP_LookupModule(Deref(ARG3)); SMALLUNSGN mod = Yap_LookupModule(Deref(ARG3));
Prop pe; Prop pe;
if (!IsAtomTerm(t)) { if (!IsAtomTerm(t)) {
_YAP_Error(TYPE_ERROR_ATOM,ARG1,"call_with_args/2"); Yap_Error(TYPE_ERROR_ATOM,ARG1,"call_with_args/2");
return(FALSE); return(FALSE);
} }
if (IsAtomTerm(t)) { if (IsAtomTerm(t)) {
Atom a; Atom a;
a = AtomOfTerm(t); a = AtomOfTerm(t);
ARG1 = ARG2; ARG1 = ARG2;
pe = PredPropByFunc(_YAP_MkFunctor(a,1),mod); pe = PredPropByFunc(Yap_MkFunctor(a,1),mod);
} else if (IsApplTerm(t)) { } else if (IsApplTerm(t)) {
Functor f = FunctorOfTerm(t); Functor f = FunctorOfTerm(t);
Int Arity, i; Int Arity, i;
@ -670,12 +670,12 @@ p_execute_1(void)
CELL *ptr; CELL *ptr;
if (IsExtensionFunctor(f)) { if (IsExtensionFunctor(f)) {
_YAP_Error(TYPE_ERROR_CALLABLE, t, "call_with_args/2"); Yap_Error(TYPE_ERROR_CALLABLE, t, "call_with_args/2");
return(FALSE); return(FALSE);
} }
Arity = ArityOfFunctor(f); Arity = ArityOfFunctor(f);
a = NameOfFunctor(f); a = NameOfFunctor(f);
pe = PredPropByFunc(_YAP_MkFunctor(a,Arity+1), mod); pe = PredPropByFunc(Yap_MkFunctor(a,Arity+1), mod);
XREGS[Arity+1] = ARG2; XREGS[Arity+1] = ARG2;
ptr = RepAppl(t)+1; ptr = RepAppl(t)+1;
for (i=1;i<=Arity;i++) { for (i=1;i<=Arity;i++) {
@ -684,7 +684,7 @@ p_execute_1(void)
} else { } else {
CELL *ptr; CELL *ptr;
pe = PredPropByFunc(_YAP_MkFunctor(AtomDot,3), mod); pe = PredPropByFunc(Yap_MkFunctor(AtomDot,3), mod);
ptr = RepPair(t); ptr = RepPair(t);
XREGS[3] = ARG2; XREGS[3] = ARG2;
XREGS[1] = ptr[0]; XREGS[1] = ptr[0];
@ -697,7 +697,7 @@ static Int
p_execute_2(void) p_execute_2(void)
{ /* '$execute_2'(Goal) */ { /* '$execute_2'(Goal) */
Term t = Deref(ARG1); Term t = Deref(ARG1);
SMALLUNSGN mod = _YAP_LookupModule(Deref(ARG4)); SMALLUNSGN mod = Yap_LookupModule(Deref(ARG4));
Prop pe; Prop pe;
if (IsAtomTerm(t)) { if (IsAtomTerm(t)) {
@ -705,7 +705,7 @@ p_execute_2(void)
a = AtomOfTerm(t); a = AtomOfTerm(t);
ARG1 = ARG2; ARG1 = ARG2;
ARG2 = ARG3; ARG2 = ARG3;
pe = PredPropByFunc(_YAP_MkFunctor(a,2),mod); pe = PredPropByFunc(Yap_MkFunctor(a,2),mod);
} else if (IsApplTerm(t)) { } else if (IsApplTerm(t)) {
Functor f = FunctorOfTerm(t); Functor f = FunctorOfTerm(t);
Int Arity, i; Int Arity, i;
@ -713,12 +713,12 @@ p_execute_2(void)
CELL *ptr; CELL *ptr;
if (IsExtensionFunctor(f)) { if (IsExtensionFunctor(f)) {
_YAP_Error(TYPE_ERROR_CALLABLE, t, "call_with_args/3"); Yap_Error(TYPE_ERROR_CALLABLE, t, "call_with_args/3");
return(FALSE); return(FALSE);
} }
Arity = ArityOfFunctor(f); Arity = ArityOfFunctor(f);
a = NameOfFunctor(f); a = NameOfFunctor(f);
pe = PredPropByFunc(_YAP_MkFunctor(a,Arity+2), mod); pe = PredPropByFunc(Yap_MkFunctor(a,Arity+2), mod);
XREGS[Arity+2] = ARG3; XREGS[Arity+2] = ARG3;
XREGS[Arity+1] = ARG2; XREGS[Arity+1] = ARG2;
ptr = RepAppl(t)+1; ptr = RepAppl(t)+1;
@ -728,7 +728,7 @@ p_execute_2(void)
} else { } else {
CELL *ptr; CELL *ptr;
pe = PredPropByFunc(_YAP_MkFunctor(AtomDot,4), mod); pe = PredPropByFunc(Yap_MkFunctor(AtomDot,4), mod);
ptr = RepPair(t); ptr = RepPair(t);
XREGS[4] = ARG3; XREGS[4] = ARG3;
XREGS[3] = ARG2; XREGS[3] = ARG2;
@ -742,11 +742,11 @@ static Int
p_execute_3(void) p_execute_3(void)
{ /* '$execute_3'(Goal) */ { /* '$execute_3'(Goal) */
Term t = Deref(ARG1); Term t = Deref(ARG1);
SMALLUNSGN mod = _YAP_LookupModule(Deref(ARG5)); SMALLUNSGN mod = Yap_LookupModule(Deref(ARG5));
Prop pe; Prop pe;
if (!IsAtomTerm(t)) { if (!IsAtomTerm(t)) {
_YAP_Error(TYPE_ERROR_ATOM,ARG1,"call_with_args/4"); Yap_Error(TYPE_ERROR_ATOM,ARG1,"call_with_args/4");
return(FALSE); return(FALSE);
} }
if (IsAtomTerm(t)) { if (IsAtomTerm(t)) {
@ -755,7 +755,7 @@ p_execute_3(void)
ARG1 = ARG2; ARG1 = ARG2;
ARG2 = ARG3; ARG2 = ARG3;
ARG3 = ARG4; ARG3 = ARG4;
pe = PredPropByFunc(_YAP_MkFunctor(a,3),mod); pe = PredPropByFunc(Yap_MkFunctor(a,3),mod);
} else if (IsApplTerm(t)) { } else if (IsApplTerm(t)) {
Functor f = FunctorOfTerm(t); Functor f = FunctorOfTerm(t);
Int Arity, i; Int Arity, i;
@ -763,12 +763,12 @@ p_execute_3(void)
CELL *ptr; CELL *ptr;
if (IsExtensionFunctor(f)) { if (IsExtensionFunctor(f)) {
_YAP_Error(TYPE_ERROR_CALLABLE, t, "call_with_args/2"); Yap_Error(TYPE_ERROR_CALLABLE, t, "call_with_args/2");
return(FALSE); return(FALSE);
} }
Arity = ArityOfFunctor(f); Arity = ArityOfFunctor(f);
a = NameOfFunctor(f); a = NameOfFunctor(f);
pe = PredPropByFunc(_YAP_MkFunctor(a,Arity+3), mod); pe = PredPropByFunc(Yap_MkFunctor(a,Arity+3), mod);
XREGS[Arity+3] = ARG4; XREGS[Arity+3] = ARG4;
XREGS[Arity+2] = ARG3; XREGS[Arity+2] = ARG3;
XREGS[Arity+1] = ARG2; XREGS[Arity+1] = ARG2;
@ -779,7 +779,7 @@ p_execute_3(void)
} else { } else {
CELL *ptr; CELL *ptr;
pe = PredPropByFunc(_YAP_MkFunctor(AtomDot,5), mod); pe = PredPropByFunc(Yap_MkFunctor(AtomDot,5), mod);
ptr = RepPair(t); ptr = RepPair(t);
XREGS[5] = ARG4; XREGS[5] = ARG4;
XREGS[4] = ARG3; XREGS[4] = ARG3;
@ -794,7 +794,7 @@ static Int
p_execute_4(void) p_execute_4(void)
{ /* '$execute_4'(Goal) */ { /* '$execute_4'(Goal) */
Term t = Deref(ARG1); Term t = Deref(ARG1);
SMALLUNSGN mod = _YAP_LookupModule(Deref(ARG6)); SMALLUNSGN mod = Yap_LookupModule(Deref(ARG6));
Prop pe; Prop pe;
if (IsAtomTerm(t)) { if (IsAtomTerm(t)) {
@ -804,7 +804,7 @@ p_execute_4(void)
ARG2 = ARG3; ARG2 = ARG3;
ARG3 = ARG4; ARG3 = ARG4;
ARG4 = ARG5; ARG4 = ARG5;
pe = PredPropByFunc(_YAP_MkFunctor(a,4),mod); pe = PredPropByFunc(Yap_MkFunctor(a,4),mod);
} else if (IsApplTerm(t)) { } else if (IsApplTerm(t)) {
Functor f = FunctorOfTerm(t); Functor f = FunctorOfTerm(t);
Int Arity, i; Int Arity, i;
@ -812,12 +812,12 @@ p_execute_4(void)
CELL *ptr; CELL *ptr;
if (IsExtensionFunctor(f)) { if (IsExtensionFunctor(f)) {
_YAP_Error(TYPE_ERROR_CALLABLE, t, "call_with_args/5"); Yap_Error(TYPE_ERROR_CALLABLE, t, "call_with_args/5");
return(FALSE); return(FALSE);
} }
Arity = ArityOfFunctor(f); Arity = ArityOfFunctor(f);
a = NameOfFunctor(f); a = NameOfFunctor(f);
pe = PredPropByFunc(_YAP_MkFunctor(a,Arity+4), mod); pe = PredPropByFunc(Yap_MkFunctor(a,Arity+4), mod);
XREGS[Arity+4] = ARG5; XREGS[Arity+4] = ARG5;
XREGS[Arity+3] = ARG4; XREGS[Arity+3] = ARG4;
XREGS[Arity+2] = ARG3; XREGS[Arity+2] = ARG3;
@ -829,7 +829,7 @@ p_execute_4(void)
} else { } else {
CELL *ptr; CELL *ptr;
pe = PredPropByFunc(_YAP_MkFunctor(AtomDot,6), mod); pe = PredPropByFunc(Yap_MkFunctor(AtomDot,6), mod);
ptr = RepPair(t); ptr = RepPair(t);
XREGS[6] = ARG5; XREGS[6] = ARG5;
XREGS[5] = ARG4; XREGS[5] = ARG4;
@ -845,7 +845,7 @@ static Int
p_execute_5(void) p_execute_5(void)
{ /* '$execute_5'(Goal) */ { /* '$execute_5'(Goal) */
Term t = Deref(ARG1); Term t = Deref(ARG1);
SMALLUNSGN mod = _YAP_LookupModule(Deref(ARG7)); SMALLUNSGN mod = Yap_LookupModule(Deref(ARG7));
Prop pe; Prop pe;
if (IsAtomTerm(t)) { if (IsAtomTerm(t)) {
@ -856,7 +856,7 @@ p_execute_5(void)
ARG3 = ARG4; ARG3 = ARG4;
ARG4 = ARG5; ARG4 = ARG5;
ARG5 = ARG6; ARG5 = ARG6;
pe = PredPropByFunc(_YAP_MkFunctor(a,5),mod); pe = PredPropByFunc(Yap_MkFunctor(a,5),mod);
} else if (IsApplTerm(t)) { } else if (IsApplTerm(t)) {
Functor f = FunctorOfTerm(t); Functor f = FunctorOfTerm(t);
Int Arity, i; Int Arity, i;
@ -864,12 +864,12 @@ p_execute_5(void)
CELL *ptr; CELL *ptr;
if (IsExtensionFunctor(f)) { if (IsExtensionFunctor(f)) {
_YAP_Error(TYPE_ERROR_CALLABLE, t, "call_with_args/6"); Yap_Error(TYPE_ERROR_CALLABLE, t, "call_with_args/6");
return(FALSE); return(FALSE);
} }
Arity = ArityOfFunctor(f); Arity = ArityOfFunctor(f);
a = NameOfFunctor(f); a = NameOfFunctor(f);
pe = PredPropByFunc(_YAP_MkFunctor(a,Arity+5), mod); pe = PredPropByFunc(Yap_MkFunctor(a,Arity+5), mod);
XREGS[Arity+5] = ARG6; XREGS[Arity+5] = ARG6;
XREGS[Arity+4] = ARG5; XREGS[Arity+4] = ARG5;
XREGS[Arity+3] = ARG4; XREGS[Arity+3] = ARG4;
@ -882,7 +882,7 @@ p_execute_5(void)
} else { } else {
CELL *ptr; CELL *ptr;
pe = PredPropByFunc(_YAP_MkFunctor(AtomDot,7), mod); pe = PredPropByFunc(Yap_MkFunctor(AtomDot,7), mod);
ptr = RepPair(t); ptr = RepPair(t);
XREGS[7] = ARG6; XREGS[7] = ARG6;
XREGS[6] = ARG5; XREGS[6] = ARG5;
@ -899,7 +899,7 @@ static Int
p_execute_6(void) p_execute_6(void)
{ /* '$execute_6'(Goal) */ { /* '$execute_6'(Goal) */
Term t = Deref(ARG1); Term t = Deref(ARG1);
SMALLUNSGN mod = _YAP_LookupModule(Deref(ARG8)); SMALLUNSGN mod = Yap_LookupModule(Deref(ARG8));
Prop pe; Prop pe;
if (IsAtomTerm(t)) { if (IsAtomTerm(t)) {
@ -911,7 +911,7 @@ p_execute_6(void)
ARG4 = ARG5; ARG4 = ARG5;
ARG5 = ARG6; ARG5 = ARG6;
ARG6 = ARG7; ARG6 = ARG7;
pe = PredPropByFunc(_YAP_MkFunctor(a,6),mod); pe = PredPropByFunc(Yap_MkFunctor(a,6),mod);
} else if (IsApplTerm(t)) { } else if (IsApplTerm(t)) {
Functor f = FunctorOfTerm(t); Functor f = FunctorOfTerm(t);
Int Arity, i; Int Arity, i;
@ -919,12 +919,12 @@ p_execute_6(void)
CELL *ptr; CELL *ptr;
if (IsExtensionFunctor(f)) { if (IsExtensionFunctor(f)) {
_YAP_Error(TYPE_ERROR_CALLABLE, t, "call_with_args/7"); Yap_Error(TYPE_ERROR_CALLABLE, t, "call_with_args/7");
return(FALSE); return(FALSE);
} }
Arity = ArityOfFunctor(f); Arity = ArityOfFunctor(f);
a = NameOfFunctor(f); a = NameOfFunctor(f);
pe = PredPropByFunc(_YAP_MkFunctor(a,Arity+6), mod); pe = PredPropByFunc(Yap_MkFunctor(a,Arity+6), mod);
XREGS[Arity+6] = ARG7; XREGS[Arity+6] = ARG7;
XREGS[Arity+5] = ARG6; XREGS[Arity+5] = ARG6;
XREGS[Arity+4] = ARG5; XREGS[Arity+4] = ARG5;
@ -938,7 +938,7 @@ p_execute_6(void)
} else { } else {
CELL *ptr; CELL *ptr;
pe = PredPropByFunc(_YAP_MkFunctor(AtomDot,8), mod); pe = PredPropByFunc(Yap_MkFunctor(AtomDot,8), mod);
ptr = RepPair(t); ptr = RepPair(t);
XREGS[8] = ARG7; XREGS[8] = ARG7;
XREGS[7] = ARG6; XREGS[7] = ARG6;
@ -956,7 +956,7 @@ static Int
p_execute_7(void) p_execute_7(void)
{ /* '$execute_7'(Goal) */ { /* '$execute_7'(Goal) */
Term t = Deref(ARG1); Term t = Deref(ARG1);
SMALLUNSGN mod = _YAP_LookupModule(Deref(ARG9)); SMALLUNSGN mod = Yap_LookupModule(Deref(ARG9));
Prop pe; Prop pe;
if (IsAtomTerm(t)) { if (IsAtomTerm(t)) {
@ -969,7 +969,7 @@ p_execute_7(void)
ARG5 = ARG6; ARG5 = ARG6;
ARG6 = ARG7; ARG6 = ARG7;
ARG7 = ARG8; ARG7 = ARG8;
pe = PredPropByFunc(_YAP_MkFunctor(a,7),mod); pe = PredPropByFunc(Yap_MkFunctor(a,7),mod);
} else if (IsApplTerm(t)) { } else if (IsApplTerm(t)) {
Functor f = FunctorOfTerm(t); Functor f = FunctorOfTerm(t);
Int Arity, i; Int Arity, i;
@ -977,12 +977,12 @@ p_execute_7(void)
CELL *ptr; CELL *ptr;
if (IsExtensionFunctor(f)) { if (IsExtensionFunctor(f)) {
_YAP_Error(TYPE_ERROR_CALLABLE, t, "call_with_args/8"); Yap_Error(TYPE_ERROR_CALLABLE, t, "call_with_args/8");
return(FALSE); return(FALSE);
} }
Arity = ArityOfFunctor(f); Arity = ArityOfFunctor(f);
a = NameOfFunctor(f); a = NameOfFunctor(f);
pe = PredPropByFunc(_YAP_MkFunctor(a,Arity+7), mod); pe = PredPropByFunc(Yap_MkFunctor(a,Arity+7), mod);
XREGS[Arity+7] = ARG8; XREGS[Arity+7] = ARG8;
XREGS[Arity+6] = ARG7; XREGS[Arity+6] = ARG7;
XREGS[Arity+5] = ARG6; XREGS[Arity+5] = ARG6;
@ -997,7 +997,7 @@ p_execute_7(void)
} else { } else {
CELL *ptr; CELL *ptr;
pe = PredPropByFunc(_YAP_MkFunctor(AtomDot,9), mod); pe = PredPropByFunc(Yap_MkFunctor(AtomDot,9), mod);
ptr = RepPair(t); ptr = RepPair(t);
XREGS[9] = ARG8; XREGS[9] = ARG8;
XREGS[8] = ARG7; XREGS[8] = ARG7;
@ -1016,7 +1016,7 @@ static Int
p_execute_8(void) p_execute_8(void)
{ /* '$execute_8'(Goal) */ { /* '$execute_8'(Goal) */
Term t = Deref(ARG1); Term t = Deref(ARG1);
SMALLUNSGN mod = _YAP_LookupModule(Deref(ARG10)); SMALLUNSGN mod = Yap_LookupModule(Deref(ARG10));
Prop pe; Prop pe;
if (IsAtomTerm(t)) { if (IsAtomTerm(t)) {
@ -1030,7 +1030,7 @@ p_execute_8(void)
ARG6 = ARG7; ARG6 = ARG7;
ARG7 = ARG8; ARG7 = ARG8;
ARG8 = ARG9; ARG8 = ARG9;
pe = PredPropByFunc(_YAP_MkFunctor(a,8),mod); pe = PredPropByFunc(Yap_MkFunctor(a,8),mod);
} else if (IsApplTerm(t)) { } else if (IsApplTerm(t)) {
Functor f = FunctorOfTerm(t); Functor f = FunctorOfTerm(t);
Int Arity, i; Int Arity, i;
@ -1038,12 +1038,12 @@ p_execute_8(void)
CELL *ptr; CELL *ptr;
if (IsExtensionFunctor(f)) { if (IsExtensionFunctor(f)) {
_YAP_Error(TYPE_ERROR_CALLABLE, t, "call_with_args/9"); Yap_Error(TYPE_ERROR_CALLABLE, t, "call_with_args/9");
return(FALSE); return(FALSE);
} }
Arity = ArityOfFunctor(f); Arity = ArityOfFunctor(f);
a = NameOfFunctor(f); a = NameOfFunctor(f);
pe = PredPropByFunc(_YAP_MkFunctor(a,Arity+8), mod); pe = PredPropByFunc(Yap_MkFunctor(a,Arity+8), mod);
XREGS[Arity+8] = ARG9; XREGS[Arity+8] = ARG9;
XREGS[Arity+7] = ARG8; XREGS[Arity+7] = ARG8;
XREGS[Arity+6] = ARG7; XREGS[Arity+6] = ARG7;
@ -1059,7 +1059,7 @@ p_execute_8(void)
} else { } else {
CELL *ptr; CELL *ptr;
pe = PredPropByFunc(_YAP_MkFunctor(AtomDot,10), mod); pe = PredPropByFunc(Yap_MkFunctor(AtomDot,10), mod);
ptr = RepPair(t); ptr = RepPair(t);
XREGS[10] = ARG9; XREGS[10] = ARG9;
XREGS[9] = ARG8; XREGS[9] = ARG8;
@ -1079,7 +1079,7 @@ static Int
p_execute_9(void) p_execute_9(void)
{ /* '$execute_9'(Goal) */ { /* '$execute_9'(Goal) */
Term t = Deref(ARG1); Term t = Deref(ARG1);
SMALLUNSGN mod = _YAP_LookupModule(Deref(ARG11)); SMALLUNSGN mod = Yap_LookupModule(Deref(ARG11));
Prop pe; Prop pe;
if (IsAtomTerm(t)) { if (IsAtomTerm(t)) {
@ -1094,7 +1094,7 @@ p_execute_9(void)
ARG7 = ARG8; ARG7 = ARG8;
ARG8 = ARG9; ARG8 = ARG9;
ARG9 = ARG10; ARG9 = ARG10;
pe = PredPropByFunc(_YAP_MkFunctor(a,9),mod); pe = PredPropByFunc(Yap_MkFunctor(a,9),mod);
} else if (IsApplTerm(t)) { } else if (IsApplTerm(t)) {
Functor f = FunctorOfTerm(t); Functor f = FunctorOfTerm(t);
Int Arity, i; Int Arity, i;
@ -1102,12 +1102,12 @@ p_execute_9(void)
CELL *ptr; CELL *ptr;
if (IsExtensionFunctor(f)) { if (IsExtensionFunctor(f)) {
_YAP_Error(TYPE_ERROR_CALLABLE, t, "call_with_args/10"); Yap_Error(TYPE_ERROR_CALLABLE, t, "call_with_args/10");
return(FALSE); return(FALSE);
} }
Arity = ArityOfFunctor(f); Arity = ArityOfFunctor(f);
a = NameOfFunctor(f); a = NameOfFunctor(f);
pe = PredPropByFunc(_YAP_MkFunctor(a,Arity+9), mod); pe = PredPropByFunc(Yap_MkFunctor(a,Arity+9), mod);
XREGS[Arity+9] = ARG10; XREGS[Arity+9] = ARG10;
XREGS[Arity+8] = ARG9; XREGS[Arity+8] = ARG9;
XREGS[Arity+7] = ARG8; XREGS[Arity+7] = ARG8;
@ -1124,7 +1124,7 @@ p_execute_9(void)
} else { } else {
CELL *ptr; CELL *ptr;
pe = PredPropByFunc(_YAP_MkFunctor(AtomDot,11), mod); pe = PredPropByFunc(Yap_MkFunctor(AtomDot,11), mod);
ptr = RepPair(t); ptr = RepPair(t);
XREGS[11] = ARG10; XREGS[11] = ARG10;
XREGS[10] = ARG9; XREGS[10] = ARG9;
@ -1145,7 +1145,7 @@ static Int
p_execute_10(void) p_execute_10(void)
{ /* '$execute_10'(Goal) */ { /* '$execute_10'(Goal) */
Term t = Deref(ARG1); Term t = Deref(ARG1);
SMALLUNSGN mod = _YAP_LookupModule(Deref(ARG12)); SMALLUNSGN mod = Yap_LookupModule(Deref(ARG12));
Prop pe; Prop pe;
if (IsAtomTerm(t)) { if (IsAtomTerm(t)) {
@ -1161,7 +1161,7 @@ p_execute_10(void)
ARG8 = ARG9; ARG8 = ARG9;
ARG9 = ARG10; ARG9 = ARG10;
ARG10 = ARG11; ARG10 = ARG11;
pe = PredPropByFunc(_YAP_MkFunctor(a,10),mod); pe = PredPropByFunc(Yap_MkFunctor(a,10),mod);
} else if (IsApplTerm(t)) { } else if (IsApplTerm(t)) {
Functor f = FunctorOfTerm(t); Functor f = FunctorOfTerm(t);
Int Arity, i; Int Arity, i;
@ -1169,12 +1169,12 @@ p_execute_10(void)
CELL *ptr; CELL *ptr;
if (IsExtensionFunctor(f)) { if (IsExtensionFunctor(f)) {
_YAP_Error(TYPE_ERROR_CALLABLE, t, "call_with_args/11"); Yap_Error(TYPE_ERROR_CALLABLE, t, "call_with_args/11");
return(FALSE); return(FALSE);
} }
Arity = ArityOfFunctor(f); Arity = ArityOfFunctor(f);
a = NameOfFunctor(f); a = NameOfFunctor(f);
pe = PredPropByFunc(_YAP_MkFunctor(a,Arity+10), mod); pe = PredPropByFunc(Yap_MkFunctor(a,Arity+10), mod);
XREGS[Arity+10] = ARG11; XREGS[Arity+10] = ARG11;
XREGS[Arity+9] = ARG10; XREGS[Arity+9] = ARG10;
XREGS[Arity+8] = ARG9; XREGS[Arity+8] = ARG9;
@ -1192,7 +1192,7 @@ p_execute_10(void)
} else { } else {
CELL *ptr; CELL *ptr;
pe = PredPropByFunc(_YAP_MkFunctor(AtomDot,12), mod); pe = PredPropByFunc(Yap_MkFunctor(AtomDot,12), mod);
ptr = RepPair(t); ptr = RepPair(t);
XREGS[12] = ARG11; XREGS[12] = ARG11;
XREGS[11] = ARG10; XREGS[11] = ARG10;
@ -1215,9 +1215,9 @@ static Int
p_execute_depth_limit(void) { p_execute_depth_limit(void) {
Term d = Deref(ARG2); Term d = Deref(ARG2);
if (IsVarTerm(d)) { if (IsVarTerm(d)) {
_YAP_Error(INSTANTIATION_ERROR,d,"depth_bound_call/2"); Yap_Error(INSTANTIATION_ERROR,d,"depth_bound_call/2");
} else if (!IsIntTerm(d)) { } else if (!IsIntTerm(d)) {
_YAP_Error(TYPE_ERROR_INTEGER, d, "depth_bound_call/2"); Yap_Error(TYPE_ERROR_INTEGER, d, "depth_bound_call/2");
return(FALSE); return(FALSE);
} }
DEPTH = MkIntTerm(IntOfTerm(d)*2); DEPTH = MkIntTerm(IntOfTerm(d)*2);
@ -1239,7 +1239,7 @@ p_at_execute(void)
unsigned int arity; unsigned int arity;
Prop pe; Prop pe;
Atom a; Atom a;
SMALLUNSGN mod = _YAP_LookupModule(tmod); SMALLUNSGN mod = Yap_LookupModule(tmod);
restart_exec: restart_exec:
if (IsAtomTerm(t)) { if (IsAtomTerm(t)) {
@ -1256,14 +1256,14 @@ p_at_execute(void)
if (f == FunctorModule) { if (f == FunctorModule) {
Term tmod = ArgOfTerm(1,t); Term tmod = ArgOfTerm(1,t);
if (!IsVarTerm(tmod) && IsAtomTerm(tmod)) { if (!IsVarTerm(tmod) && IsAtomTerm(tmod)) {
mod = _YAP_LookupModule(tmod); mod = Yap_LookupModule(tmod);
t = ArgOfTerm(2,t); t = ArgOfTerm(2,t);
goto restart_exec; goto restart_exec;
} }
if (IsVarTerm(tmod)) { if (IsVarTerm(tmod)) {
_YAP_Error(INSTANTIATION_ERROR, ARG1, "calling clause in debugger"); Yap_Error(INSTANTIATION_ERROR, ARG1, "calling clause in debugger");
} }
_YAP_Error(TYPE_ERROR_ATOM, ARG1, "calling clause in debugger"); Yap_Error(TYPE_ERROR_ATOM, ARG1, "calling clause in debugger");
} }
pe = PredPropByFunc(f,mod); pe = PredPropByFunc(f,mod);
if (RepPredProp(pe)->PredFlags & PushModPredFlag) { if (RepPredProp(pe)->PredFlags & PushModPredFlag) {
@ -1300,12 +1300,12 @@ static int
exec_absmi(int top) exec_absmi(int top)
{ {
int lval; int lval;
if (top && (lval = sigsetjmp (_YAP_RestartEnv, 1)) != 0) { if (top && (lval = sigsetjmp (Yap_RestartEnv, 1)) != 0) {
switch(lval) { switch(lval) {
case 1: case 1:
{ /* restart */ { /* restart */
/* otherwise, SetDBForThrow will fail entering critical mode */ /* otherwise, SetDBForThrow will fail entering critical mode */
_YAP_PrologMode = UserMode; Yap_PrologMode = UserMode;
/* find out where to cut to */ /* find out where to cut to */
#if defined(__GNUC__) #if defined(__GNUC__)
#if defined(hppa) || defined(__alpha) #if defined(hppa) || defined(__alpha)
@ -1320,18 +1320,18 @@ exec_absmi(int top)
yap_flags[SPY_CREEP_FLAG] = 0; yap_flags[SPY_CREEP_FLAG] = 0;
CreepFlag = CalculateStackGap(); CreepFlag = CalculateStackGap();
P = (yamop *)FAILCODE; P = (yamop *)FAILCODE;
_YAP_PrologMode = UserMode; Yap_PrologMode = UserMode;
} }
break; break;
case 2: case 2:
{ {
/* arithmetic exception */ /* arithmetic exception */
/* must be done here, otherwise siglongjmp will clobber all the registers */ /* must be done here, otherwise siglongjmp will clobber all the registers */
_YAP_Error(_YAP_matherror,TermNil,NULL); Yap_Error(Yap_matherror,TermNil,NULL);
/* reset the registers so that we don't have trash in abstract machine */ /* reset the registers so that we don't have trash in abstract machine */
_YAP_set_fpu_exceptions(yap_flags[LANGUAGE_MODE_FLAG] == 1); Yap_set_fpu_exceptions(yap_flags[LANGUAGE_MODE_FLAG] == 1);
P = (yamop *)FAILCODE; P = (yamop *)FAILCODE;
_YAP_PrologMode = UserMode; Yap_PrologMode = UserMode;
} }
break; break;
case 3: case 3:
@ -1340,12 +1340,12 @@ exec_absmi(int top)
} }
default: default:
/* do nothing */ /* do nothing */
_YAP_PrologMode = UserMode; Yap_PrologMode = UserMode;
} }
} else { } else {
_YAP_PrologMode = UserMode; Yap_PrologMode = UserMode;
} }
return(_YAP_absmi(0)); return(Yap_absmi(0));
} }
static int static int
@ -1396,20 +1396,20 @@ do_goal(CODEADDR CodeAdr, int arity, CELL *pt, int args_to_save, int top)
YENV[E_CB] = Unsigned (B); YENV[E_CB] = Unsigned (B);
P = (yamop *) CodeAdr; P = (yamop *) CodeAdr;
CP = YESCODE; CP = YESCODE;
S = CellPtr (RepPredProp (PredPropByFunc (_YAP_MkFunctor(AtomCall, 1),0))); /* A1 mishaps */ S = CellPtr (RepPredProp (PredPropByFunc (Yap_MkFunctor(AtomCall, 1),0))); /* A1 mishaps */
return(exec_absmi(top)); return(exec_absmi(top));
} }
int int
_YAP_exec_absmi(int top) Yap_exec_absmi(int top)
{ {
return exec_absmi(top); return exec_absmi(top);
} }
Int Int
_YAP_execute_goal(Term t, int nargs, SMALLUNSGN mod) Yap_execute_goal(Term t, int nargs, SMALLUNSGN mod)
{ {
Int out; Int out;
CODEADDR CodeAdr; CODEADDR CodeAdr;
@ -1433,7 +1433,7 @@ _YAP_execute_goal(Term t, int nargs, SMALLUNSGN mod)
Functor f = FunctorOfTerm(t); Functor f = FunctorOfTerm(t);
if (IsBlobFunctor(f)) { if (IsBlobFunctor(f)) {
_YAP_Error(TYPE_ERROR_CALLABLE,t,"call/1"); Yap_Error(TYPE_ERROR_CALLABLE,t,"call/1");
return(FALSE); return(FALSE);
} }
/* I cannot use the standard macro here because /* I cannot use the standard macro here because
@ -1442,7 +1442,7 @@ _YAP_execute_goal(Term t, int nargs, SMALLUNSGN mod)
pt = RepAppl(t)+1; pt = RepAppl(t)+1;
pe = PredPropByFunc(f, mod); pe = PredPropByFunc(f, mod);
} else { } else {
_YAP_Error(TYPE_ERROR_CALLABLE,t,"call/1"); Yap_Error(TYPE_ERROR_CALLABLE,t,"call/1");
return(FALSE); return(FALSE);
} }
ppe = RepPredProp(pe); ppe = RepPredProp(pe);
@ -1508,13 +1508,13 @@ _YAP_execute_goal(Term t, int nargs, SMALLUNSGN mod)
HB = PROTECT_FROZEN_H(B); HB = PROTECT_FROZEN_H(B);
return(FALSE); return(FALSE);
} else { } else {
_YAP_Error(SYSTEM_ERROR,TermNil,"emulator crashed"); Yap_Error(SYSTEM_ERROR,TermNil,"emulator crashed");
return(FALSE); return(FALSE);
} }
} }
void void
_YAP_trust_last(void) Yap_trust_last(void)
{ {
ASP = B->cp_env; ASP = B->cp_env;
P = (yamop *)(B->cp_env[E_CP]); P = (yamop *)(B->cp_env[E_CP]);
@ -1533,7 +1533,7 @@ _YAP_trust_last(void)
} }
int int
_YAP_RunTopGoal(Term t) Yap_RunTopGoal(Term t)
{ {
CODEADDR CodeAdr; CODEADDR CodeAdr;
Prop pe; Prop pe;
@ -1553,13 +1553,13 @@ _YAP_RunTopGoal(Term t)
Functor f = FunctorOfTerm(t); Functor f = FunctorOfTerm(t);
if (IsBlobFunctor(f)) { if (IsBlobFunctor(f)) {
_YAP_Error(TYPE_ERROR_CALLABLE,t,"call/1"); Yap_Error(TYPE_ERROR_CALLABLE,t,"call/1");
return(FALSE); return(FALSE);
} }
if (f == FunctorModule) { if (f == FunctorModule) {
Term tmod = ArgOfTerm(1,t); Term tmod = ArgOfTerm(1,t);
if (!IsVarTerm(tmod) && IsAtomTerm(tmod)) { if (!IsVarTerm(tmod) && IsAtomTerm(tmod)) {
mod = _YAP_LookupModule(tmod); mod = Yap_LookupModule(tmod);
t = ArgOfTerm(2,t); t = ArgOfTerm(2,t);
goto restart_runtopgoal; goto restart_runtopgoal;
} }
@ -1567,11 +1567,11 @@ _YAP_RunTopGoal(Term t)
/* I cannot use the standard macro here because /* I cannot use the standard macro here because
otherwise I would dereference the argument and otherwise I would dereference the argument and
might skip a svar */ might skip a svar */
pe = _YAP_GetPredPropByFunc(f, CurrentModule); pe = Yap_GetPredPropByFunc(f, CurrentModule);
pt = RepAppl(t)+1; pt = RepAppl(t)+1;
arity = ArityOfFunctor(f); arity = ArityOfFunctor(f);
} else { } else {
_YAP_Error(TYPE_ERROR_CALLABLE,t,"call/1"); Yap_Error(TYPE_ERROR_CALLABLE,t,"call/1");
return(FALSE); return(FALSE);
} }
ppe = RepPredProp(pe); ppe = RepPredProp(pe);
@ -1586,9 +1586,9 @@ _YAP_RunTopGoal(Term t)
return(FALSE); return(FALSE);
} }
CodeAdr = ppe->CodeOfPred; CodeAdr = ppe->CodeOfPred;
if (_YAP_TrailTop - HeapTop < 2048) { if (Yap_TrailTop - HeapTop < 2048) {
_YAP_PrologMode = BootMode; Yap_PrologMode = BootMode;
_YAP_Error(SYSTEM_ERROR,TermNil, Yap_Error(SYSTEM_ERROR,TermNil,
"unable to boot because of too little heap space"); "unable to boot because of too little heap space");
} }
goal_out = do_goal(CodeAdr, arity, pt, 0, TRUE); goal_out = do_goal(CodeAdr, arity, pt, 0, TRUE);
@ -1617,7 +1617,7 @@ p_restore_regs(void)
{ {
Term t = Deref(ARG1); Term t = Deref(ARG1);
if (IsVarTerm(t)) { if (IsVarTerm(t)) {
_YAP_Error(INSTANTIATION_ERROR,t,"support for coroutining"); Yap_Error(INSTANTIATION_ERROR,t,"support for coroutining");
return(FALSE); return(FALSE);
} }
if (IsAtomTerm(t)) return(TRUE); if (IsAtomTerm(t)) return(TRUE);
@ -1633,7 +1633,7 @@ p_restore_regs2(void)
Term t = Deref(ARG1), d0; Term t = Deref(ARG1), d0;
choiceptr pt0; choiceptr pt0;
if (IsVarTerm(t)) { if (IsVarTerm(t)) {
_YAP_Error(INSTANTIATION_ERROR,t,"support for coroutining"); Yap_Error(INSTANTIATION_ERROR,t,"support for coroutining");
return(FALSE); return(FALSE);
} }
d0 = Deref(ARG2); d0 = Deref(ARG2);
@ -1641,7 +1641,7 @@ p_restore_regs2(void)
restore_regs(t); restore_regs(t);
} }
if (IsVarTerm(d0)) { if (IsVarTerm(d0)) {
_YAP_Error(INSTANTIATION_ERROR,d0,"support for coroutining"); Yap_Error(INSTANTIATION_ERROR,d0,"support for coroutining");
return(FALSE); return(FALSE);
} }
if (!IsIntegerTerm(d0)) { if (!IsIntegerTerm(d0)) {
@ -1714,9 +1714,9 @@ JumpToEnv(Term t) {
if (B == NULL) { if (B == NULL) {
B = B0; B = B0;
#if PUSH_REGS #if PUSH_REGS
restore_absmi_regs(&_YAP_standard_regs); restore_absmi_regs(&Yap_standard_regs);
#endif #endif
siglongjmp(_YAP_RestartEnv,1); siglongjmp(Yap_RestartEnv,1);
} }
/* is it a continuation? */ /* is it a continuation? */
env = B->cp_env; env = B->cp_env;
@ -1747,7 +1747,7 @@ JumpToEnv(Term t) {
} }
Int Int
_YAP_JumpToEnv(Term t) { Yap_JumpToEnv(Term t) {
return JumpToEnv(t); return JumpToEnv(t);
} }
@ -1759,23 +1759,23 @@ p_jump_env(void) {
} }
void void
_YAP_InitYaamRegs(void) Yap_InitYaamRegs(void)
{ {
#if PUSH_REGS #if PUSH_REGS
/* Guarantee that after a longjmp we go back to the original abstract /* Guarantee that after a longjmp we go back to the original abstract
machine registers */ machine registers */
_YAP_regp = &_YAP_standard_regs; Yap_regp = &Yap_standard_regs;
#endif /* PUSH_REGS */ #endif /* PUSH_REGS */
_YAP_PutValue (AtomBreak, MkIntTerm (0)); Yap_PutValue (AtomBreak, MkIntTerm (0));
_YAP_PutValue (AtomIndex, MkAtomTerm (AtomTrue)); Yap_PutValue (AtomIndex, MkAtomTerm (AtomTrue));
AuxSp = (CELL *)AuxTop; AuxSp = (CELL *)AuxTop;
TR = (tr_fr_ptr)_YAP_TrailBase; TR = (tr_fr_ptr)Yap_TrailBase;
#ifdef COROUTINING #ifdef COROUTINING
H = H0 = ((CELL *) _YAP_GlobalBase)+ 2048; H = H0 = ((CELL *) Yap_GlobalBase)+ 2048;
#else #else
H = H0 = (CELL *) _YAP_GlobalBase; H = H0 = (CELL *) Yap_GlobalBase;
#endif #endif
LCL0 = ASP = (CELL *) _YAP_LocalBase; LCL0 = ASP = (CELL *) Yap_LocalBase;
/* notice that an initial choice-point and environment /* notice that an initial choice-point and environment
*must* be created since for the garbage collector to work */ *must* be created since for the garbage collector to work */
B = NULL; B = NULL;
@ -1798,43 +1798,43 @@ _YAP_InitYaamRegs(void)
/* for slots to work */ /* for slots to work */
*--ASP = MkIntTerm(0); *--ASP = MkIntTerm(0);
#if COROUTINING #if COROUTINING
RESET_VARIABLE((CELL *)_YAP_GlobalBase); RESET_VARIABLE((CELL *)Yap_GlobalBase);
DelayedVars = _YAP_NewTimedVar((CELL)_YAP_GlobalBase); DelayedVars = Yap_NewTimedVar((CELL)Yap_GlobalBase);
WokenGoals = _YAP_NewTimedVar(TermNil); WokenGoals = Yap_NewTimedVar(TermNil);
MutableList = _YAP_NewTimedVar(TermNil); MutableList = Yap_NewTimedVar(TermNil);
AttsMutableList = _YAP_NewTimedVar(TermNil); AttsMutableList = Yap_NewTimedVar(TermNil);
#endif #endif
} }
void void
_YAP_InitExecFs(void) Yap_InitExecFs(void)
{ {
_YAP_InitCPred("$execute", 1, p_execute, 0); Yap_InitCPred("$execute", 1, p_execute, 0);
_YAP_InitCPred("$execute_in_mod", 2, p_execute_in_mod, 0); Yap_InitCPred("$execute_in_mod", 2, p_execute_in_mod, 0);
_YAP_InitCPred("$execute_within", 4, p_execute_within, 0); Yap_InitCPred("$execute_within", 4, p_execute_within, 0);
_YAP_InitCPred("$execute_within", 1, p_execute_within2, 0); Yap_InitCPred("$execute_within", 1, p_execute_within2, 0);
_YAP_InitCPred("$last_execute_within", 1, p_execute_within2, 0); Yap_InitCPred("$last_execute_within", 1, p_execute_within2, 0);
_YAP_InitCPred("$execute", 3, p_at_execute, 0); Yap_InitCPred("$execute", 3, p_at_execute, 0);
_YAP_InitCPred("$call_with_args", 2, p_execute_0, 0); Yap_InitCPred("$call_with_args", 2, p_execute_0, 0);
_YAP_InitCPred("$call_with_args", 3, p_execute_1, 0); Yap_InitCPred("$call_with_args", 3, p_execute_1, 0);
_YAP_InitCPred("$call_with_args", 4, p_execute_2, 0); Yap_InitCPred("$call_with_args", 4, p_execute_2, 0);
_YAP_InitCPred("$call_with_args", 5, p_execute_3, 0); Yap_InitCPred("$call_with_args", 5, p_execute_3, 0);
_YAP_InitCPred("$call_with_args", 6, p_execute_4, 0); Yap_InitCPred("$call_with_args", 6, p_execute_4, 0);
_YAP_InitCPred("$call_with_args", 7, p_execute_5, 0); Yap_InitCPred("$call_with_args", 7, p_execute_5, 0);
_YAP_InitCPred("$call_with_args", 8, p_execute_6, 0); Yap_InitCPred("$call_with_args", 8, p_execute_6, 0);
_YAP_InitCPred("$call_with_args", 9, p_execute_7, 0); Yap_InitCPred("$call_with_args", 9, p_execute_7, 0);
_YAP_InitCPred("$call_with_args", 10, p_execute_8, 0); Yap_InitCPred("$call_with_args", 10, p_execute_8, 0);
_YAP_InitCPred("$call_with_args", 11, p_execute_9, 0); Yap_InitCPred("$call_with_args", 11, p_execute_9, 0);
_YAP_InitCPred("$call_with_args", 12, p_execute_10, 0); Yap_InitCPred("$call_with_args", 12, p_execute_10, 0);
#ifdef DEPTH_LIMIT #ifdef DEPTH_LIMIT
_YAP_InitCPred("$execute_under_depth_limit", 2, p_execute_depth_limit, 0); Yap_InitCPred("$execute_under_depth_limit", 2, p_execute_depth_limit, 0);
#endif #endif
_YAP_InitCPred("$execute0", 2, p_execute0, 0); Yap_InitCPred("$execute0", 2, p_execute0, 0);
_YAP_InitCPred("$save_current_choice_point", 1, p_save_cp, 0); Yap_InitCPred("$save_current_choice_point", 1, p_save_cp, 0);
_YAP_InitCPred("$pred_goal_expansion_on", 0, p_pred_goal_expansion_on, SafePredFlag); Yap_InitCPred("$pred_goal_expansion_on", 0, p_pred_goal_expansion_on, SafePredFlag);
_YAP_InitCPred("$restore_regs", 1, p_restore_regs, SafePredFlag); Yap_InitCPred("$restore_regs", 1, p_restore_regs, SafePredFlag);
_YAP_InitCPred("$restore_regs", 2, p_restore_regs2, SafePredFlag); Yap_InitCPred("$restore_regs", 2, p_restore_regs2, SafePredFlag);
_YAP_InitCPred("$clean_ifcp", 1, p_clean_ifcp, SafePredFlag); Yap_InitCPred("$clean_ifcp", 1, p_clean_ifcp, SafePredFlag);
_YAP_InitCPred("$jump_env_and_store_ball", 1, p_jump_env, 0); Yap_InitCPred("$jump_env_and_store_ball", 1, p_jump_env, 0);
} }

228
C/grow.c
View File

@ -99,24 +99,24 @@ static void
SetHeapRegs(void) SetHeapRegs(void)
{ {
#ifdef undf7 #ifdef undf7
fprintf(_YAP_stderr,"HeapBase = %x\tHeapTop=%x\nGlobalBase=%x\tGlobalTop=%x\nLocalBase=%x\tLocatTop=%x\n", _YAP_HeapBase, HeapTop, _YAP_GlobalBase, H, LCL0, ASP); fprintf(Yap_stderr,"HeapBase = %x\tHeapTop=%x\nGlobalBase=%x\tGlobalTop=%x\nLocalBase=%x\tLocatTop=%x\n", Yap_HeapBase, HeapTop, Yap_GlobalBase, H, LCL0, ASP);
#endif #endif
/* The old stack pointers */ /* The old stack pointers */
OldLCL0 = LCL0; OldLCL0 = LCL0;
OldASP = ASP; OldASP = ASP;
OldGlobalBase = (CELL *)_YAP_GlobalBase; OldGlobalBase = (CELL *)Yap_GlobalBase;
OldH = H; OldH = H;
OldH0 = H0; OldH0 = H0;
OldTrailBase = _YAP_TrailBase; OldTrailBase = Yap_TrailBase;
OldTrailTop = _YAP_TrailTop; OldTrailTop = Yap_TrailTop;
OldTR = TR; OldTR = TR;
OldHeapBase = _YAP_HeapBase; OldHeapBase = Yap_HeapBase;
OldHeapTop = HeapTop; OldHeapTop = HeapTop;
/* Adjust stack addresses */ /* Adjust stack addresses */
_YAP_TrailBase = TrailAddrAdjust(_YAP_TrailBase); Yap_TrailBase = TrailAddrAdjust(Yap_TrailBase);
_YAP_TrailTop = TrailAddrAdjust(_YAP_TrailTop); Yap_TrailTop = TrailAddrAdjust(Yap_TrailTop);
_YAP_GlobalBase = DelayAddrAdjust(_YAP_GlobalBase); Yap_GlobalBase = DelayAddrAdjust(Yap_GlobalBase);
_YAP_LocalBase = LocalAddrAdjust(_YAP_LocalBase); Yap_LocalBase = LocalAddrAdjust(Yap_LocalBase);
AuxSp = PtoDelayAdjust(AuxSp); AuxSp = PtoDelayAdjust(AuxSp);
AuxTop = DelayAddrAdjust(AuxTop); AuxTop = DelayAddrAdjust(AuxTop);
/* The registers pointing to one of the stacks */ /* The registers pointing to one of the stacks */
@ -155,16 +155,16 @@ SetStackRegs(void)
OldASP = ASP; OldASP = ASP;
OldH = H; OldH = H;
OldH0 = H0; OldH0 = H0;
OldGlobalBase = (CELL *)_YAP_GlobalBase; OldGlobalBase = (CELL *)Yap_GlobalBase;
OldTrailTop = _YAP_TrailTop; OldTrailTop = Yap_TrailTop;
OldTrailBase = _YAP_TrailBase; OldTrailBase = Yap_TrailBase;
OldTR = TR; OldTR = TR;
OldHeapBase = _YAP_HeapBase; OldHeapBase = Yap_HeapBase;
OldHeapTop = HeapTop; OldHeapTop = HeapTop;
/* The local and aux stack addresses */ /* The local and aux stack addresses */
_YAP_TrailBase = TrailAddrAdjust(_YAP_TrailBase); Yap_TrailBase = TrailAddrAdjust(Yap_TrailBase);
_YAP_TrailTop = TrailAddrAdjust(_YAP_TrailTop); Yap_TrailTop = TrailAddrAdjust(Yap_TrailTop);
_YAP_LocalBase = LocalAddrAdjust(_YAP_LocalBase); Yap_LocalBase = LocalAddrAdjust(Yap_LocalBase);
TR = PtoTRAdjust(TR); TR = PtoTRAdjust(TR);
/* The registers pointing to the local stack */ /* The registers pointing to the local stack */
ENV = PtoLocAdjust(ENV); ENV = PtoLocAdjust(ENV);
@ -200,7 +200,7 @@ MoveGlobal(void)
* absmi.asm * absmi.asm
*/ */
#if HAVE_MEMMOVE #if HAVE_MEMMOVE
cpcellsd((CELL *)_YAP_GlobalBase, (CELL *)OldGlobalBase, OldH - (CELL *)OldGlobalBase); cpcellsd((CELL *)Yap_GlobalBase, (CELL *)OldGlobalBase, OldH - (CELL *)OldGlobalBase);
#else #else
cpcellsd(H, OldH, OldH - (CELL *)OldGlobalBase); cpcellsd(H, OldH, OldH - (CELL *)OldGlobalBase);
#endif #endif
@ -236,7 +236,7 @@ AdjustAppl(register CELL t0)
#ifdef DEBUG #ifdef DEBUG
else { else {
/* strange cell */ /* strange cell */
/* fprintf(_YAP_stderr,"[ garbage appl %lx found in stacks by stack shifter ]\n", t0);*/ /* fprintf(Yap_stderr,"[ garbage appl %lx found in stacks by stack shifter ]\n", t0);*/
} }
#endif #endif
return(t0); return(t0);
@ -256,7 +256,7 @@ AdjustPair(register CELL t0)
else if (IsHeapP(t)) else if (IsHeapP(t))
return (AbsPair(CellPtoHeapAdjust(t))); return (AbsPair(CellPtoHeapAdjust(t)));
#ifdef DEBUG #ifdef DEBUG
/* fprintf(_YAP_stderr,"[ garbage pair %lx found in stacks by stack shifter ]\n", t0);*/ /* fprintf(Yap_stderr,"[ garbage pair %lx found in stacks by stack shifter ]\n", t0);*/
#endif #endif
return(t0); return(t0);
} }
@ -268,7 +268,7 @@ AdjustTrail(int adjusting_heap)
ptt = TR; ptt = TR;
/* moving the trail is simple */ /* moving the trail is simple */
while (ptt != (tr_fr_ptr)_YAP_TrailBase) { while (ptt != (tr_fr_ptr)Yap_TrailBase) {
register CELL reg = TrailTerm(ptt-1); register CELL reg = TrailTerm(ptt-1);
#ifdef FROZEN_STACKS #ifdef FROZEN_STACKS
register CELL reg2 = TrailVal(ptt-1); register CELL reg2 = TrailVal(ptt-1);
@ -295,7 +295,7 @@ AdjustTrail(int adjusting_heap)
} }
#ifdef DEBUG #ifdef DEBUG
else else
fprintf(_YAP_stderr,"[ garbage heap ptr %p to %lx found in trail at %p by stack shifter ]\n", ptr, (unsigned long int)*ptr, ptt); fprintf(Yap_stderr,"[ garbage heap ptr %p to %lx found in trail at %p by stack shifter ]\n", ptr, (unsigned long int)*ptr, ptt);
#endif #endif
} }
} else if (IsPairTerm(reg)) { } else if (IsPairTerm(reg)) {
@ -367,7 +367,7 @@ AdjustGlobal(void)
* to clean the global now that functors are just variables pointing to * to clean the global now that functors are just variables pointing to
* the code * the code
*/ */
pt = CellPtr(_YAP_GlobalBase); pt = CellPtr(Yap_GlobalBase);
while (pt < H) { while (pt < H) {
register CELL reg; register CELL reg;
@ -437,7 +437,7 @@ AdjustStacksAndTrail(void)
} }
void void
_YAP_AdjustStacksAndTrail(void) Yap_AdjustStacksAndTrail(void)
{ {
AdjustStacksAndTrail(); AdjustStacksAndTrail();
} }
@ -481,7 +481,7 @@ AdjustRegs(int n)
} }
void void
_YAP_AdjustRegs(int n) Yap_AdjustRegs(int n)
{ {
AdjustRegs(n); AdjustRegs(n);
} }
@ -495,17 +495,17 @@ static_growheap(long size, int fix_code)
/* adjust to a multiple of 256) */ /* adjust to a multiple of 256) */
size = AdjustPageSize(size); size = AdjustPageSize(size);
_YAP_ErrorMessage = NULL; Yap_ErrorMessage = NULL;
if (!_YAP_ExtendWorkSpace(size)) { if (!Yap_ExtendWorkSpace(size)) {
strncat(_YAP_ErrorMessage,": heap crashed against stacks", MAX_ERROR_MSG_SIZE); strncat(Yap_ErrorMessage,": heap crashed against stacks", MAX_ERROR_MSG_SIZE);
return(FALSE); return(FALSE);
} }
start_growth_time = _YAP_cputime(); start_growth_time = Yap_cputime();
gc_verbose = _YAP_is_gc_verbose(); gc_verbose = Yap_is_gc_verbose();
heap_overflows++; heap_overflows++;
if (gc_verbose) { if (gc_verbose) {
fprintf(_YAP_stderr, "[HO] Heap overflow %d\n", heap_overflows); fprintf(Yap_stderr, "[HO] Heap overflow %d\n", heap_overflows);
fprintf(_YAP_stderr, "[HO] growing the heap %ld bytes\n", size); fprintf(Yap_stderr, "[HO] growing the heap %ld bytes\n", size);
} }
ASP -= 256; ASP -= 256;
TrDiff = LDiff = GDiff = DelayDiff = size; TrDiff = LDiff = GDiff = DelayDiff = size;
@ -525,11 +525,11 @@ static_growheap(long size, int fix_code)
AdjustRegs(MaxTemps); AdjustRegs(MaxTemps);
YAPLeaveCriticalSection(); YAPLeaveCriticalSection();
ASP += 256; ASP += 256;
growth_time = _YAP_cputime()-start_growth_time; growth_time = Yap_cputime()-start_growth_time;
total_heap_overflow_time += growth_time; total_heap_overflow_time += growth_time;
if (gc_verbose) { if (gc_verbose) {
fprintf(_YAP_stderr, "[HO] took %g sec\n", (double)growth_time/1000); fprintf(Yap_stderr, "[HO] took %g sec\n", (double)growth_time/1000);
fprintf(_YAP_stderr, "[HO] Total of %g sec expanding heap \n", (double)total_heap_overflow_time/1000); fprintf(Yap_stderr, "[HO] Total of %g sec expanding heap \n", (double)total_heap_overflow_time/1000);
} }
return(TRUE); return(TRUE);
} }
@ -543,17 +543,17 @@ static_growglobal(long size, CELL **ptr)
/* adjust to a multiple of 256) */ /* adjust to a multiple of 256) */
size = AdjustPageSize(size); size = AdjustPageSize(size);
_YAP_ErrorMessage = NULL; Yap_ErrorMessage = NULL;
if (!_YAP_ExtendWorkSpace(size)) { if (!Yap_ExtendWorkSpace(size)) {
strncat(_YAP_ErrorMessage,": global crashed against local", MAX_ERROR_MSG_SIZE); strncat(Yap_ErrorMessage,": global crashed against local", MAX_ERROR_MSG_SIZE);
return(FALSE); return(FALSE);
} }
start_growth_time = _YAP_cputime(); start_growth_time = Yap_cputime();
gc_verbose = _YAP_is_gc_verbose(); gc_verbose = Yap_is_gc_verbose();
delay_overflows++; delay_overflows++;
if (gc_verbose) { if (gc_verbose) {
fprintf(_YAP_stderr, "[DO] Delay overflow %d\n", delay_overflows); fprintf(Yap_stderr, "[DO] Delay overflow %d\n", delay_overflows);
fprintf(_YAP_stderr, "[DO] growing the stacks %ld bytes\n", size); fprintf(Yap_stderr, "[DO] growing the stacks %ld bytes\n", size);
} }
ASP -= 256; ASP -= 256;
TrDiff = LDiff = GDiff = size; TrDiff = LDiff = GDiff = size;
@ -568,11 +568,11 @@ static_growglobal(long size, CELL **ptr)
*ptr = PtoLocAdjust(*ptr); *ptr = PtoLocAdjust(*ptr);
YAPLeaveCriticalSection(); YAPLeaveCriticalSection();
ASP += 256; ASP += 256;
growth_time = _YAP_cputime()-start_growth_time; growth_time = Yap_cputime()-start_growth_time;
total_delay_overflow_time += growth_time; total_delay_overflow_time += growth_time;
if (gc_verbose) { if (gc_verbose) {
fprintf(_YAP_stderr, "[DO] took %g sec\n", (double)growth_time/1000); fprintf(Yap_stderr, "[DO] took %g sec\n", (double)growth_time/1000);
fprintf(_YAP_stderr, "[DO] Total of %g sec expanding stacks \n", (double)total_delay_overflow_time/1000); fprintf(Yap_stderr, "[DO] Total of %g sec expanding stacks \n", (double)total_delay_overflow_time/1000);
} }
return(TRUE); return(TRUE);
} }
@ -644,7 +644,7 @@ fix_tabling_info(void)
#endif /* TABLING */ #endif /* TABLING */
int int
_YAP_growheap(int fix_code) Yap_growheap(int fix_code)
{ {
unsigned long size = sizeof(CELL) * 16 * 1024L; unsigned long size = sizeof(CELL) * 16 * 1024L;
int shift_factor = (heap_overflows > 8 ? 8 : heap_overflows); int shift_factor = (heap_overflows > 8 ? 8 : heap_overflows);
@ -652,7 +652,7 @@ _YAP_growheap(int fix_code)
#if defined(YAPOR) || defined(THREADS) #if defined(YAPOR) || defined(THREADS)
if (NOfThreads != 1) { if (NOfThreads != 1) {
_YAP_Error(SYSTEM_ERROR,TermNil,"cannot grow Heap: more than a worker/thread running"); Yap_Error(SYSTEM_ERROR,TermNil,"cannot grow Heap: more than a worker/thread running");
return(FALSE); return(FALSE);
} }
#endif #endif
@ -688,13 +688,13 @@ _YAP_growheap(int fix_code)
} }
int int
_YAP_growglobal(CELL **ptr) Yap_growglobal(CELL **ptr)
{ {
unsigned long sz = sizeof(CELL) * 16 * 1024L; unsigned long sz = sizeof(CELL) * 16 * 1024L;
#if defined(YAPOR) || defined(THREADS) #if defined(YAPOR) || defined(THREADS)
if (NOfThreads != 1) { if (NOfThreads != 1) {
_YAP_Error(SYSTEM_ERROR,TermNil,"cannot grow Global: more than a worker/thread running"); Yap_Error(SYSTEM_ERROR,TermNil,"cannot grow Global: more than a worker/thread running");
return(FALSE); return(FALSE);
} }
#endif #endif
@ -716,27 +716,27 @@ growstack(long size)
#if defined(YAPOR) || defined(THREADS) #if defined(YAPOR) || defined(THREADS)
if (NOfThreads != 1) { if (NOfThreads != 1) {
_YAP_Error(SYSTEM_ERROR,TermNil,"cannot grow Local: more than a worker/thread running"); Yap_Error(SYSTEM_ERROR,TermNil,"cannot grow Local: more than a worker/thread running");
return(FALSE); return(FALSE);
} }
#endif #endif
/* adjust to a multiple of 256) */ /* adjust to a multiple of 256) */
size = AdjustPageSize(size); size = AdjustPageSize(size);
_YAP_ErrorMessage = NULL; Yap_ErrorMessage = NULL;
if (!_YAP_ExtendWorkSpace(size)) { if (!Yap_ExtendWorkSpace(size)) {
strncat(_YAP_ErrorMessage,": local crashed against global", MAX_ERROR_MSG_SIZE); strncat(Yap_ErrorMessage,": local crashed against global", MAX_ERROR_MSG_SIZE);
return(FALSE); return(FALSE);
} }
start_growth_time = _YAP_cputime(); start_growth_time = Yap_cputime();
gc_verbose = _YAP_is_gc_verbose(); gc_verbose = Yap_is_gc_verbose();
stack_overflows++; stack_overflows++;
if (gc_verbose) { if (gc_verbose) {
fprintf(_YAP_stderr, "[SO] Stack Overflow %d\n", stack_overflows); fprintf(Yap_stderr, "[SO] Stack Overflow %d\n", stack_overflows);
fprintf(_YAP_stderr, "[SO] Heap: %8ld cells (%p-%p)\n", (unsigned long int)(H-(CELL *)_YAP_GlobalBase),_YAP_GlobalBase,H); fprintf(Yap_stderr, "[SO] Heap: %8ld cells (%p-%p)\n", (unsigned long int)(H-(CELL *)Yap_GlobalBase),Yap_GlobalBase,H);
fprintf(_YAP_stderr, "[SO] Local:%8ld cells (%p-%p)\n", (unsigned long int)(LCL0-ASP),LCL0,ASP); fprintf(Yap_stderr, "[SO] Local:%8ld cells (%p-%p)\n", (unsigned long int)(LCL0-ASP),LCL0,ASP);
fprintf(_YAP_stderr, "[SO] Trail:%8ld cells (%p-%p)\n", fprintf(Yap_stderr, "[SO] Trail:%8ld cells (%p-%p)\n",
(unsigned long int)(TR-(tr_fr_ptr)_YAP_TrailBase),_YAP_TrailBase,TR); (unsigned long int)(TR-(tr_fr_ptr)Yap_TrailBase),Yap_TrailBase,TR);
fprintf(_YAP_stderr, "[SO] growing the stacks %ld bytes\n", size); fprintf(Yap_stderr, "[SO] growing the stacks %ld bytes\n", size);
} }
TrDiff = LDiff = size; TrDiff = LDiff = size;
XDiff = HDiff = GDiff = DelayDiff = 0; XDiff = HDiff = GDiff = DelayDiff = 0;
@ -752,17 +752,17 @@ growstack(long size)
YAPLeaveCriticalSection(); YAPLeaveCriticalSection();
CreepFlag = CalculateStackGap(); CreepFlag = CalculateStackGap();
ASP += 256; ASP += 256;
growth_time = _YAP_cputime()-start_growth_time; growth_time = Yap_cputime()-start_growth_time;
total_stack_overflow_time += growth_time; total_stack_overflow_time += growth_time;
if (gc_verbose) { if (gc_verbose) {
fprintf(_YAP_stderr, "[SO] took %g sec\n", (double)growth_time/1000); fprintf(Yap_stderr, "[SO] took %g sec\n", (double)growth_time/1000);
fprintf(_YAP_stderr, "[SO] Total of %g sec expanding stacks \n", (double)total_stack_overflow_time/1000); fprintf(Yap_stderr, "[SO] Total of %g sec expanding stacks \n", (double)total_stack_overflow_time/1000);
} }
return(TRUE); return(TRUE);
} }
int int
_YAP_growstack(long size) Yap_growstack(long size)
{ {
return growstack(size); return growstack(size);
} }
@ -819,9 +819,9 @@ AdjustScannerStacks(TokEntry **tksp, VarEntry **vep)
ves = *vep = (VarEntry *)TrailAddrAdjust((ADDR)ves); ves = *vep = (VarEntry *)TrailAddrAdjust((ADDR)ves);
AdjustVarTable(ves); AdjustVarTable(ves);
} }
ves = _YAP_AnonVarTable; ves = Yap_AnonVarTable;
if (ves != NULL) { if (ves != NULL) {
ves = _YAP_AnonVarTable = VarEntryAdjust(ves); ves = Yap_AnonVarTable = VarEntryAdjust(ves);
} }
while (ves != NULL) { while (ves != NULL) {
VarEntry *vetmp = ves->VarLeft; VarEntry *vetmp = ves->VarLeft;
@ -836,35 +836,35 @@ AdjustScannerStacks(TokEntry **tksp, VarEntry **vep)
/* Used by parser when we're short of stack space */ /* Used by parser when we're short of stack space */
int int
_YAP_growstack_in_parser(tr_fr_ptr *old_trp, TokEntry **tksp, VarEntry **vep) Yap_growstack_in_parser(tr_fr_ptr *old_trp, TokEntry **tksp, VarEntry **vep)
{ {
Int start_growth_time, growth_time; Int start_growth_time, growth_time;
int gc_verbose; int gc_verbose;
long size = sizeof(CELL)*(LCL0-(CELL *)_YAP_GlobalBase); long size = sizeof(CELL)*(LCL0-(CELL *)Yap_GlobalBase);
#if defined(YAPOR) || defined(THREADS) #if defined(YAPOR) || defined(THREADS)
if (NOfThreads != 1) { if (NOfThreads != 1) {
_YAP_Error(SYSTEM_ERROR,TermNil,"cannot grow Parser Stack: more than a worker/thread running"); Yap_Error(SYSTEM_ERROR,TermNil,"cannot grow Parser Stack: more than a worker/thread running");
return(FALSE); return(FALSE);
} }
#endif #endif
/* adjust to a multiple of 256) */ /* adjust to a multiple of 256) */
size = AdjustPageSize(size); size = AdjustPageSize(size);
_YAP_ErrorMessage = NULL; Yap_ErrorMessage = NULL;
if (!_YAP_ExtendWorkSpace(size)) { if (!Yap_ExtendWorkSpace(size)) {
strncat(_YAP_ErrorMessage,": parser stack overflowed", MAX_ERROR_MSG_SIZE); strncat(Yap_ErrorMessage,": parser stack overflowed", MAX_ERROR_MSG_SIZE);
return(FALSE); return(FALSE);
} }
start_growth_time = _YAP_cputime(); start_growth_time = Yap_cputime();
gc_verbose = _YAP_is_gc_verbose(); gc_verbose = Yap_is_gc_verbose();
stack_overflows++; stack_overflows++;
if (gc_verbose) { if (gc_verbose) {
fprintf(_YAP_stderr, "[SO] Stack overflow %d\n", stack_overflows); fprintf(Yap_stderr, "[SO] Stack overflow %d\n", stack_overflows);
fprintf(_YAP_stderr, "[SO] Heap: %8ld cells (%p-%p)\n", (unsigned long int)(H-(CELL *)_YAP_GlobalBase),(CELL *)_YAP_GlobalBase,H); fprintf(Yap_stderr, "[SO] Heap: %8ld cells (%p-%p)\n", (unsigned long int)(H-(CELL *)Yap_GlobalBase),(CELL *)Yap_GlobalBase,H);
fprintf(_YAP_stderr, "[SO] Local:%8ld cells (%p-%p)\n", (unsigned long int)(LCL0-ASP),LCL0,ASP); fprintf(Yap_stderr, "[SO] Local:%8ld cells (%p-%p)\n", (unsigned long int)(LCL0-ASP),LCL0,ASP);
fprintf(_YAP_stderr, "[SO] Trail:%8ld cells (%p-%p)\n", fprintf(Yap_stderr, "[SO] Trail:%8ld cells (%p-%p)\n",
(unsigned long int)(TR-(tr_fr_ptr)_YAP_TrailBase),_YAP_TrailBase,TR); (unsigned long int)(TR-(tr_fr_ptr)Yap_TrailBase),Yap_TrailBase,TR);
fprintf(_YAP_stderr, "[SO] growing the stacks %ld bytes\n", size); fprintf(Yap_stderr, "[SO] growing the stacks %ld bytes\n", size);
} }
TrDiff = LDiff = size; TrDiff = LDiff = size;
XDiff = HDiff = GDiff = DelayDiff = 0; XDiff = HDiff = GDiff = DelayDiff = 0;
@ -885,11 +885,11 @@ _YAP_growstack_in_parser(tr_fr_ptr *old_trp, TokEntry **tksp, VarEntry **vep)
YAPLeaveCriticalSection(); YAPLeaveCriticalSection();
CreepFlag = CalculateStackGap(); CreepFlag = CalculateStackGap();
ASP += 256; ASP += 256;
growth_time = _YAP_cputime()-start_growth_time; growth_time = Yap_cputime()-start_growth_time;
total_stack_overflow_time += growth_time; total_stack_overflow_time += growth_time;
if (gc_verbose) { if (gc_verbose) {
fprintf(_YAP_stderr, "[SO] took %g sec\n", (double)growth_time/1000); fprintf(Yap_stderr, "[SO] took %g sec\n", (double)growth_time/1000);
fprintf(_YAP_stderr, "[SO] Total of %g sec expanding stacks \n", (double)total_stack_overflow_time/1000); fprintf(Yap_stderr, "[SO] Total of %g sec expanding stacks \n", (double)total_stack_overflow_time/1000);
} }
return(TRUE); return(TRUE);
} }
@ -897,14 +897,14 @@ _YAP_growstack_in_parser(tr_fr_ptr *old_trp, TokEntry **tksp, VarEntry **vep)
/* Used by do_goal() when we're short of stack space */ /* Used by do_goal() when we're short of stack space */
int int
_YAP_growtrail(long size) Yap_growtrail(long size)
{ {
Int start_growth_time = _YAP_cputime(), growth_time; Int start_growth_time = Yap_cputime(), growth_time;
int gc_verbose = _YAP_is_gc_verbose(); int gc_verbose = Yap_is_gc_verbose();
#if defined(YAPOR) || defined(THREADS) #if defined(YAPOR) || defined(THREADS)
if (NOfThreads != 1) { if (NOfThreads != 1) {
_YAP_Error(SYSTEM_ERROR,TermNil,"cannot grow trail: more than a worker/thread running"); Yap_Error(SYSTEM_ERROR,TermNil,"cannot grow trail: more than a worker/thread running");
return(FALSE); return(FALSE);
} }
#endif #endif
@ -912,22 +912,22 @@ _YAP_growtrail(long size)
size = AdjustPageSize(size); size = AdjustPageSize(size);
trail_overflows++; trail_overflows++;
if (gc_verbose) { if (gc_verbose) {
fprintf(_YAP_stderr, "[TO] Trail overflow %d\n", trail_overflows); fprintf(Yap_stderr, "[TO] Trail overflow %d\n", trail_overflows);
fprintf(_YAP_stderr, "[TO] growing the trail %ld bytes\n", size); fprintf(Yap_stderr, "[TO] growing the trail %ld bytes\n", size);
} }
_YAP_ErrorMessage = NULL; Yap_ErrorMessage = NULL;
if (!_YAP_ExtendWorkSpace(size)) { if (!Yap_ExtendWorkSpace(size)) {
strncat(_YAP_ErrorMessage,": trail stack overflowed", MAX_ERROR_MSG_SIZE); strncat(Yap_ErrorMessage,": trail stack overflowed", MAX_ERROR_MSG_SIZE);
return(FALSE); return(FALSE);
} }
YAPEnterCriticalSection(); YAPEnterCriticalSection();
_YAP_TrailTop += size; Yap_TrailTop += size;
YAPLeaveCriticalSection(); YAPLeaveCriticalSection();
growth_time = _YAP_cputime()-start_growth_time; growth_time = Yap_cputime()-start_growth_time;
total_trail_overflow_time += growth_time; total_trail_overflow_time += growth_time;
if (gc_verbose) { if (gc_verbose) {
fprintf(_YAP_stderr, "[TO] took %g sec\n", (double)growth_time/1000); fprintf(Yap_stderr, "[TO] took %g sec\n", (double)growth_time/1000);
fprintf(_YAP_stderr, "[TO] Total of %g sec expanding stacks \n", (double)total_stack_overflow_time/1000); fprintf(Yap_stderr, "[TO] Total of %g sec expanding stacks \n", (double)total_stack_overflow_time/1000);
} }
return(TRUE); return(TRUE);
} }
@ -939,7 +939,7 @@ p_inform_trail_overflows(void)
Term tn = MkIntTerm(trail_overflows); Term tn = MkIntTerm(trail_overflows);
Term tt = MkIntegerTerm(total_trail_overflow_time); Term tt = MkIntegerTerm(total_trail_overflow_time);
return(_YAP_unify(tn, ARG1) && _YAP_unify(tt, ARG2)); return(Yap_unify(tn, ARG1) && Yap_unify(tt, ARG2));
} }
/* :- grow_heap(Size) */ /* :- grow_heap(Size) */
@ -950,15 +950,15 @@ p_growheap(void)
Term t1 = Deref(ARG1); Term t1 = Deref(ARG1);
if (IsVarTerm(t1)) { if (IsVarTerm(t1)) {
_YAP_Error(INSTANTIATION_ERROR, t1, "grow_heap/1"); Yap_Error(INSTANTIATION_ERROR, t1, "grow_heap/1");
return(FALSE); return(FALSE);
} else if (!IsIntTerm(t1)) { } else if (!IsIntTerm(t1)) {
_YAP_Error(TYPE_ERROR_INTEGER, t1, "grow_heap/1"); Yap_Error(TYPE_ERROR_INTEGER, t1, "grow_heap/1");
return(FALSE); return(FALSE);
} }
diff = IntOfTerm(t1); diff = IntOfTerm(t1);
if (diff < 0) { if (diff < 0) {
_YAP_Error(DOMAIN_ERROR_NOT_LESS_THAN_ZERO, t1, "grow_heap/1"); Yap_Error(DOMAIN_ERROR_NOT_LESS_THAN_ZERO, t1, "grow_heap/1");
} }
return(static_growheap(diff, FALSE)); return(static_growheap(diff, FALSE));
} }
@ -969,7 +969,7 @@ p_inform_heap_overflows(void)
Term tn = MkIntTerm(heap_overflows); Term tn = MkIntTerm(heap_overflows);
Term tt = MkIntegerTerm(total_heap_overflow_time); Term tt = MkIntegerTerm(total_heap_overflow_time);
return(_YAP_unify(tn, ARG1) && _YAP_unify(tt, ARG2)); return(Yap_unify(tn, ARG1) && Yap_unify(tt, ARG2));
} }
/* :- grow_stack(Size) */ /* :- grow_stack(Size) */
@ -980,15 +980,15 @@ p_growstack(void)
Term t1 = Deref(ARG1); Term t1 = Deref(ARG1);
if (IsVarTerm(t1)) { if (IsVarTerm(t1)) {
_YAP_Error(INSTANTIATION_ERROR, t1, "grow_stack/1"); Yap_Error(INSTANTIATION_ERROR, t1, "grow_stack/1");
return(FALSE); return(FALSE);
} else if (!IsIntTerm(t1)) { } else if (!IsIntTerm(t1)) {
_YAP_Error(TYPE_ERROR_INTEGER, t1, "grow_stack/1"); Yap_Error(TYPE_ERROR_INTEGER, t1, "grow_stack/1");
return(FALSE); return(FALSE);
} }
diff = IntOfTerm(t1); diff = IntOfTerm(t1);
if (diff < 0) { if (diff < 0) {
_YAP_Error(DOMAIN_ERROR_NOT_LESS_THAN_ZERO, t1, "grow_stack/1"); Yap_Error(DOMAIN_ERROR_NOT_LESS_THAN_ZERO, t1, "grow_stack/1");
} }
return(growstack(diff)); return(growstack(diff));
} }
@ -999,12 +999,12 @@ p_inform_stack_overflows(void)
Term tn = MkIntTerm(stack_overflows); Term tn = MkIntTerm(stack_overflows);
Term tt = MkIntegerTerm(total_stack_overflow_time); Term tt = MkIntegerTerm(total_stack_overflow_time);
return(_YAP_unify(tn, ARG1) && _YAP_unify(tt, ARG2)); return(Yap_unify(tn, ARG1) && Yap_unify(tt, ARG2));
} }
Int Int
_YAP_total_stack_shift_time(void) Yap_total_stack_shift_time(void)
{ {
return(total_heap_overflow_time+ return(total_heap_overflow_time+
total_stack_overflow_time+ total_stack_overflow_time+
@ -1012,13 +1012,13 @@ _YAP_total_stack_shift_time(void)
} }
void void
_YAP_InitGrowPreds(void) Yap_InitGrowPreds(void)
{ {
_YAP_InitCPred("$grow_heap", 1, p_growheap, SafePredFlag); Yap_InitCPred("$grow_heap", 1, p_growheap, SafePredFlag);
_YAP_InitCPred("$grow_stack", 1, p_growstack, SafePredFlag); Yap_InitCPred("$grow_stack", 1, p_growstack, SafePredFlag);
_YAP_InitCPred("$inform_trail_overflows", 2, p_inform_trail_overflows, SafePredFlag); Yap_InitCPred("$inform_trail_overflows", 2, p_inform_trail_overflows, SafePredFlag);
_YAP_InitCPred("$inform_heap_overflows", 2, p_inform_heap_overflows, SafePredFlag); Yap_InitCPred("$inform_heap_overflows", 2, p_inform_heap_overflows, SafePredFlag);
_YAP_InitCPred("$inform_stack_overflows", 2, p_inform_stack_overflows, SafePredFlag); Yap_InitCPred("$inform_stack_overflows", 2, p_inform_stack_overflows, SafePredFlag);
_YAP_init_gc(); Yap_init_gc();
_YAP_init_agc(); Yap_init_agc();
} }

248
C/heapgc.c
View File

@ -104,8 +104,8 @@ PUSH_CONTINUATION(CELL *v, int nof) {
if (nof == 0) return; if (nof == 0) return;
x = cont_top; x = cont_top;
x++; x++;
if ((ADDR)x > _YAP_TrailTop-1024) if ((ADDR)x > Yap_TrailTop-1024)
_YAP_growtrail(64 * 1024L); Yap_growtrail(64 * 1024L);
x->v = v; x->v = v;
x->nof = nof; x->nof = nof;
cont_top = x; cont_top = x;
@ -288,8 +288,8 @@ static inline struct gc_ma_h_entry *
GC_ALLOC_NEW_MASPACE(void) GC_ALLOC_NEW_MASPACE(void)
{ {
gc_ma_h_inner_struct *new = gc_ma_h_top; gc_ma_h_inner_struct *new = gc_ma_h_top;
if ((char *)gc_ma_h_top > _YAP_TrailTop-1024) if ((char *)gc_ma_h_top > Yap_TrailTop-1024)
_YAP_growtrail(64 * 1024L); Yap_growtrail(64 * 1024L);
gc_ma_h_top++; gc_ma_h_top++;
cont_top = (cont *)gc_ma_h_top; cont_top = (cont *)gc_ma_h_top;
#ifdef EASY_SHUNTING #ifdef EASY_SHUNTING
@ -386,8 +386,8 @@ push_registers(Int num_regs, yamop *nextop)
for (i = 1; i <= num_regs; i++) for (i = 1; i <= num_regs; i++)
TrailTerm(TR++) = (CELL) XREGS[i]; TrailTerm(TR++) = (CELL) XREGS[i];
/* push any live registers we might have hanging around */ /* push any live registers we might have hanging around */
if (nextop->opc == _YAP_opcode(_move_back) || if (nextop->opc == Yap_opcode(_move_back) ||
nextop->opc == _YAP_opcode(_skip)) { nextop->opc == Yap_opcode(_skip)) {
CELL *lab = (CELL *)(nextop->u.l.l); CELL *lab = (CELL *)(nextop->u.l.l);
CELL max = lab[0]; CELL max = lab[0];
Int curr = lab[1]; Int curr = lab[1];
@ -437,8 +437,8 @@ pop_registers(Int num_regs, yamop *nextop)
for (i = 1; i <= num_regs; i++) for (i = 1; i <= num_regs; i++)
XREGS[i] = TrailTerm(ptr++); XREGS[i] = TrailTerm(ptr++);
/* pop any live registers we might have hanging around */ /* pop any live registers we might have hanging around */
if (nextop->opc == _YAP_opcode(_move_back) || if (nextop->opc == Yap_opcode(_move_back) ||
nextop->opc == _YAP_opcode(_skip)) { nextop->opc == Yap_opcode(_skip)) {
CELL *lab = (CELL *)(nextop->u.l.l); CELL *lab = (CELL *)(nextop->u.l.l);
CELL max = lab[0]; CELL max = lab[0];
Int curr = lab[1]; Int curr = lab[1];
@ -496,10 +496,10 @@ store_ref_in_dbtable(DBRef entry)
dbentry parent = db_vec0; dbentry parent = db_vec0;
dbentry new = db_vec; dbentry new = db_vec;
if ((ADDR)new > _YAP_TrailTop-1024) if ((ADDR)new > Yap_TrailTop-1024)
_YAP_growtrail(64 * 1024L); Yap_growtrail(64 * 1024L);
new->val = entry; new->val = entry;
new->lim = (CELL *)((CODEADDR)entry+_YAP_SizeOfBlock((CODEADDR)entry)); new->lim = (CELL *)((CODEADDR)entry+Yap_SizeOfBlock((CODEADDR)entry));
new->left = new->right = NULL; new->left = new->right = NULL;
if (db_vec == db_vec0) { if (db_vec == db_vec0) {
db_vec++; db_vec++;
@ -532,10 +532,10 @@ store_cl_in_dbtable(Clause *cl)
dbentry parent = db_vec0; dbentry parent = db_vec0;
dbentry new = db_vec; dbentry new = db_vec;
if ((ADDR)new > _YAP_TrailTop-1024) if ((ADDR)new > Yap_TrailTop-1024)
_YAP_growtrail(64 * 1024L); Yap_growtrail(64 * 1024L);
new->val = (DBRef)cl; new->val = (DBRef)cl;
new->lim = (CELL *)((CODEADDR)cl + _YAP_SizeOfBlock((CODEADDR)cl)); new->lim = (CELL *)((CODEADDR)cl + Yap_SizeOfBlock((CODEADDR)cl));
new->left = new->right = NULL; new->left = new->right = NULL;
if (db_vec == db_vec0) { if (db_vec == db_vec0) {
db_vec++; db_vec++;
@ -593,7 +593,7 @@ init_dbtable(tr_fr_ptr trail_ptr) {
Clause *cl = DeadClauses; Clause *cl = DeadClauses;
db_vec0 = db_vec = (dbentry)TR; db_vec0 = db_vec = (dbentry)TR;
while (trail_ptr > (tr_fr_ptr)_YAP_TrailBase) { while (trail_ptr > (tr_fr_ptr)Yap_TrailBase) {
register CELL trail_cell; register CELL trail_cell;
trail_ptr--; trail_ptr--;
@ -612,7 +612,7 @@ init_dbtable(tr_fr_ptr trail_ptr) {
#ifdef SBA #ifdef SBA
(ADDR) pt0 >= HeapTop (ADDR) pt0 >= HeapTop
#else #else
(ADDR) pt0 >= _YAP_TrailBase (ADDR) pt0 >= Yap_TrailBase
#endif #endif
) { ) {
continue; continue;
@ -691,17 +691,17 @@ inc_vars_of_type(CELL *curr,gc_types val) {
static void static void
put_type_info(unsigned long total) put_type_info(unsigned long total)
{ {
fprintf(_YAP_stderr,"[GC] type info for %lu cells\n", total); fprintf(Yap_stderr,"[GC] type info for %lu cells\n", total);
fprintf(_YAP_stderr,"[GC] %lu vars\n", vars[gc_var]); fprintf(Yap_stderr,"[GC] %lu vars\n", vars[gc_var]);
fprintf(_YAP_stderr,"[GC] %lu refs\n", vars[gc_ref]); fprintf(Yap_stderr,"[GC] %lu refs\n", vars[gc_ref]);
fprintf(_YAP_stderr,"[GC] %lu references from env\n", env_vars); fprintf(Yap_stderr,"[GC] %lu references from env\n", env_vars);
fprintf(_YAP_stderr,"[GC] %lu atoms\n", vars[gc_atom]); fprintf(Yap_stderr,"[GC] %lu atoms\n", vars[gc_atom]);
fprintf(_YAP_stderr,"[GC] %lu small ints\n", vars[gc_int]); fprintf(Yap_stderr,"[GC] %lu small ints\n", vars[gc_int]);
fprintf(_YAP_stderr,"[GC] %lu other numbers\n", vars[gc_num]); fprintf(Yap_stderr,"[GC] %lu other numbers\n", vars[gc_num]);
fprintf(_YAP_stderr,"[GC] %lu lists\n", vars[gc_list]); fprintf(Yap_stderr,"[GC] %lu lists\n", vars[gc_list]);
fprintf(_YAP_stderr,"[GC] %lu compound terms\n", vars[gc_appl]); fprintf(Yap_stderr,"[GC] %lu compound terms\n", vars[gc_appl]);
fprintf(_YAP_stderr,"[GC] %lu functors\n", vars[gc_func]); fprintf(Yap_stderr,"[GC] %lu functors\n", vars[gc_func]);
fprintf(_YAP_stderr,"[GC] %lu suspensions\n", vars[gc_susp]); fprintf(Yap_stderr,"[GC] %lu suspensions\n", vars[gc_susp]);
} }
static void static void
@ -894,7 +894,7 @@ mark_variable(CELL_PTR current)
} }
#ifdef DEBUG #ifdef DEBUG
else if (next < (CELL *)AtomBase || next < (CELL *)HeapTop) else if (next < (CELL *)AtomBase || next < (CELL *)HeapTop)
fprintf(_YAP_stderr, "ooops while marking %lx, %p at %p\n", (unsigned long int)ccur, current, next); fprintf(Yap_stderr, "ooops while marking %lx, %p at %p\n", (unsigned long int)ccur, current, next);
#endif #endif
#ifdef INSTRUMENT_GC #ifdef INSTRUMENT_GC
else else
@ -1006,7 +1006,7 @@ mark_variable(CELL_PTR current)
} }
void void
_YAP_mark_variable(CELL_PTR current) Yap_mark_variable(CELL_PTR current)
{ {
mark_variable(current); mark_variable(current);
} }
@ -1084,7 +1084,7 @@ mark_external_reference(CELL *ptr) {
*/ */
void void
_YAP_mark_external_reference(CELL *ptr) { Yap_mark_external_reference(CELL *ptr) {
mark_external_reference(ptr); mark_external_reference(ptr);
} }
@ -1104,7 +1104,7 @@ mark_regs(tr_fr_ptr old_TR)
static void static void
mark_delays(CELL *max) mark_delays(CELL *max)
{ {
CELL *ptr = (CELL *)_YAP_GlobalBase; CELL *ptr = (CELL *)Yap_GlobalBase;
for (; ptr < max; ptr++) { for (; ptr < max; ptr++) {
mark_external_reference(ptr); mark_external_reference(ptr);
} }
@ -1125,7 +1125,7 @@ mark_environments(CELL_PTR gc_ENV, OPREG size, CELL *pvbmap)
#ifdef DEBUG #ifdef DEBUG
if (size < 0 || size > 512) if (size < 0 || size > 512)
fprintf(_YAP_stderr,"Oops, env size for %p is %ld\n", gc_ENV, (unsigned long int)size); fprintf(Yap_stderr,"Oops, env size for %p is %ld\n", gc_ENV, (unsigned long int)size);
#endif #endif
if ((cl = (Clause *)find_ref_in_dbtable((DBRef)gc_ENV[E_CP])) != NULL) { if ((cl = (Clause *)find_ref_in_dbtable((DBRef)gc_ENV[E_CP])) != NULL) {
cl->ClFlags |= GcFoundMask; cl->ClFlags |= GcFoundMask;
@ -1194,12 +1194,12 @@ mark_environments(CELL_PTR gc_ENV, OPREG size, CELL *pvbmap)
#if 0 #if 0
if (size < 0) { if (size < 0) {
PredEntry *pe = EnvPreg(gc_ENV[E_CP]); PredEntry *pe = EnvPreg(gc_ENV[E_CP]);
op_numbers op = _YAP_op_from_opcode(ENV_ToOp(gc_ENV[E_CP])); op_numbers op = Yap_op_from_opcode(ENV_ToOp(gc_ENV[E_CP]));
fprintf(_YAP_stderr,"ENV %p-%p(%d) %s\n", gc_ENV, pvbmap, size-EnvSizeInCells, op_names[op]); fprintf(Yap_stderr,"ENV %p-%p(%d) %s\n", gc_ENV, pvbmap, size-EnvSizeInCells, op_names[op]);
if (pe->ArityOfPE) if (pe->ArityOfPE)
fprintf(_YAP_stderr," %s/%d\n", RepAtom(NameOfFunctor(pe->FunctorOfPred))->StrOfAE, pe->ArityOfPE); fprintf(Yap_stderr," %s/%d\n", RepAtom(NameOfFunctor(pe->FunctorOfPred))->StrOfAE, pe->ArityOfPE);
else else
fprintf(_YAP_stderr," %s\n", RepAtom((Atom)(pe->FunctorOfPred))->StrOfAE); fprintf(Yap_stderr," %s\n", RepAtom((Atom)(pe->FunctorOfPred))->StrOfAE);
} }
#endif #endif
gc_ENV = (CELL_PTR) gc_ENV[E_E]; /* link to prev gc_ENV = (CELL_PTR) gc_ENV[E_E]; /* link to prev
@ -1261,7 +1261,7 @@ mark_trail(tr_fr_ptr trail_ptr, tr_fr_ptr trail_base, CELL *gc_H, choiceptr gc_B
/* I decided to allow pointers from the Heap back into the trail. /* I decided to allow pointers from the Heap back into the trail.
The point of doing so is to have dynamic arrays */ The point of doing so is to have dynamic arrays */
mark_external_reference(hp); mark_external_reference(hp);
} else if ((hp < (CELL *)gc_B && hp >= gc_H) || hp > (CELL *)_YAP_TrailBase) { } else if ((hp < (CELL *)gc_B && hp >= gc_H) || hp > (CELL *)Yap_TrailBase) {
/* clean the trail, avoid dangling pointers! */ /* clean the trail, avoid dangling pointers! */
RESET_VARIABLE(&TrailTerm(trail_ptr)); RESET_VARIABLE(&TrailTerm(trail_ptr));
#ifdef FROZEN_STACKS #ifdef FROZEN_STACKS
@ -1280,8 +1280,8 @@ mark_trail(tr_fr_ptr trail_ptr, tr_fr_ptr trail_base, CELL *gc_H, choiceptr gc_B
tr_fr_ptr nsTR = (tr_fr_ptr)cont_top0; tr_fr_ptr nsTR = (tr_fr_ptr)cont_top0;
CELL *cptr = (CELL *)trail_cell; CELL *cptr = (CELL *)trail_cell;
if ((ADDR)nsTR > _YAP_TrailTop-1024) if ((ADDR)nsTR > Yap_TrailTop-1024)
_YAP_growtrail(64 * 1024L); Yap_growtrail(64 * 1024L);
TrailTerm(nsTR) = (CELL)NULL; TrailTerm(nsTR) = (CELL)NULL;
TrailTerm(nsTR+1) = *hp; TrailTerm(nsTR+1) = *hp;
TrailTerm(nsTR+2) = trail_cell; TrailTerm(nsTR+2) = trail_cell;
@ -1456,7 +1456,7 @@ mark_choicepoints(register choiceptr gc_B, tr_fr_ptr saved_TR, int very_verbose)
#endif #endif
{ {
op = rtp->opc; op = rtp->opc;
opnum = _YAP_op_from_opcode(op); opnum = Yap_op_from_opcode(op);
} }
if (very_verbose) { if (very_verbose) {
switch (opnum) { switch (opnum) {
@ -1481,13 +1481,13 @@ mark_choicepoints(register choiceptr gc_B, tr_fr_ptr saved_TR, int very_verbose)
Atom at; Atom at;
Int arity; Int arity;
SMALLUNSGN mod; SMALLUNSGN mod;
if (_YAP_PredForCode((CODEADDR)gc_B->cp_ap, &at, &arity, &mod)) { if (Yap_PredForCode((CODEADDR)gc_B->cp_ap, &at, &arity, &mod)) {
if (arity) if (arity)
fprintf(_YAP_stderr,"[GC] %s/%d marked %d (%s)\n", RepAtom(at)->StrOfAE, arity, total_marked, op_names[opnum]); fprintf(Yap_stderr,"[GC] %s/%d marked %d (%s)\n", RepAtom(at)->StrOfAE, arity, total_marked, op_names[opnum]);
else else
fprintf(_YAP_stderr,"[GC] %s marked %d (%s)\n", RepAtom(at)->StrOfAE, total_marked, op_names[opnum]); fprintf(Yap_stderr,"[GC] %s marked %d (%s)\n", RepAtom(at)->StrOfAE, total_marked, op_names[opnum]);
} else } else
fprintf(_YAP_stderr,"[GC] marked %d (%s)\n", total_marked, op_names[opnum]); fprintf(Yap_stderr,"[GC] marked %d (%s)\n", total_marked, op_names[opnum]);
} }
break; break;
#ifdef TABLING #ifdef TABLING
@ -1495,12 +1495,12 @@ mark_choicepoints(register choiceptr gc_B, tr_fr_ptr saved_TR, int very_verbose)
case _table_answer_resolution: case _table_answer_resolution:
{ {
PredEntry *pe = ENV_ToP(gc_B->cp_cp); PredEntry *pe = ENV_ToP(gc_B->cp_cp);
op_numbers caller_op = _YAP_op_from_opcode(ENV_ToOp(gc_B->cp_cp)); op_numbers caller_op = Yap_op_from_opcode(ENV_ToOp(gc_B->cp_cp));
/* first condition checks if this was a meta-call */ /* first condition checks if this was a meta-call */
if ((caller_op != _call && caller_op != _fcall) || pe == NULL) { if ((caller_op != _call && caller_op != _fcall) || pe == NULL) {
fprintf(_YAP_stderr,"[GC] marked %d (%s)\n", total_marked, op_names[opnum]); fprintf(Yap_stderr,"[GC] marked %d (%s)\n", total_marked, op_names[opnum]);
} else } else
fprintf(_YAP_stderr,"[GC] %s/%d marked %d (%s)\n", RepAtom(NameOfFunctor(pe->FunctorOfPred))->StrOfAE, pe->ArityOfPE, total_marked, op_names[opnum]); fprintf(Yap_stderr,"[GC] %s/%d marked %d (%s)\n", RepAtom(NameOfFunctor(pe->FunctorOfPred))->StrOfAE, pe->ArityOfPE, total_marked, op_names[opnum]);
} }
break; break;
case _trie_retry_var: case _trie_retry_var:
@ -1513,19 +1513,19 @@ mark_choicepoints(register choiceptr gc_B, tr_fr_ptr saved_TR, int very_verbose)
case _trie_trust_list: case _trie_trust_list:
case _trie_retry_struct: case _trie_retry_struct:
case _trie_trust_struct: case _trie_trust_struct:
fprintf(_YAP_stderr,"[GC] marked %d (%s)\n", total_marked, op_names[opnum]); fprintf(Yap_stderr,"[GC] marked %d (%s)\n", total_marked, op_names[opnum]);
break; break;
#endif #endif
default: default:
{ {
PredEntry *pe = (PredEntry *)gc_B->cp_ap->u.ld.p; PredEntry *pe = (PredEntry *)gc_B->cp_ap->u.ld.p;
if (pe == NULL) { if (pe == NULL) {
fprintf(_YAP_stderr,"[GC] marked %d (%s)\n", total_marked, op_names[opnum]); fprintf(Yap_stderr,"[GC] marked %d (%s)\n", total_marked, op_names[opnum]);
} else } else
if (pe->ArityOfPE) if (pe->ArityOfPE)
fprintf(_YAP_stderr,"[GC] %s/%d marked %d (%s)\n", RepAtom(NameOfFunctor(pe->FunctorOfPred))->StrOfAE, pe->ArityOfPE, total_marked, op_names[opnum]); fprintf(Yap_stderr,"[GC] %s/%d marked %d (%s)\n", RepAtom(NameOfFunctor(pe->FunctorOfPred))->StrOfAE, pe->ArityOfPE, total_marked, op_names[opnum]);
else else
fprintf(_YAP_stderr,"[GC] %s marked %d (%s)\n", RepAtom((Atom)(pe->FunctorOfPred))->StrOfAE, total_marked, op_names[opnum]); fprintf(Yap_stderr,"[GC] %s marked %d (%s)\n", RepAtom((Atom)(pe->FunctorOfPred))->StrOfAE, total_marked, op_names[opnum]);
} }
} }
} }
@ -1612,7 +1612,7 @@ mark_choicepoints(register choiceptr gc_B, tr_fr_ptr saved_TR, int very_verbose)
case _count_retry: case _count_retry:
rtp = NEXTOP(rtp,l); rtp = NEXTOP(rtp,l);
op = rtp->opc; op = rtp->opc;
opnum = _YAP_op_from_opcode(op); opnum = Yap_op_from_opcode(op);
goto restart_cp; goto restart_cp;
case _trust_fail: case _trust_fail:
nargs = 0; nargs = 0;
@ -1752,7 +1752,7 @@ mark_choicepoints(register choiceptr gc_B, tr_fr_ptr saved_TR, int very_verbose)
nargs = rtp->u.ld.s; nargs = rtp->u.ld.s;
break; break;
default: default:
fprintf(_YAP_stderr, "OOps in GC: Unexpected opcode: %d\n", opnum); fprintf(Yap_stderr, "OOps in GC: Unexpected opcode: %d\n", opnum);
nargs = 0; nargs = 0;
#else #else
default: default:
@ -1803,7 +1803,7 @@ into_relocation_chain(CELL_PTR current, CELL_PTR next)
*next = AbsAppl((CELL *) *next = AbsAppl((CELL *)
((MARKED(cnext) ? MBIT : 0) | RBIT | (Int) current)); ((MARKED(cnext) ? MBIT : 0) | RBIT | (Int) current));
} else { } else {
fprintf(_YAP_stderr," OH MY GOD !!!!!!!!!!!!\n"); fprintf(Yap_stderr," OH MY GOD !!!!!!!!!!!!\n");
} }
#else #else
CELL current_tag; CELL current_tag;
@ -1838,11 +1838,11 @@ sweep_trail(choiceptr gc_B, tr_fr_ptr old_TR)
we don't compress TR if we have freeze. we don't compress TR if we have freeze.
*/ */
{ {
Int size = old_TR-(tr_fr_ptr)_YAP_TrailBase; Int size = old_TR-(tr_fr_ptr)Yap_TrailBase;
size -= discard_trail_entries; size -= discard_trail_entries;
while (gc_B != NULL) { while (gc_B != NULL) {
size -= (UInt)(gc_B->cp_tr); size -= (UInt)(gc_B->cp_tr);
gc_B->cp_tr = (tr_fr_ptr)_YAP_TrailBase+size; gc_B->cp_tr = (tr_fr_ptr)Yap_TrailBase+size;
gc_B = gc_B->cp_b; gc_B = gc_B->cp_b;
} }
} }
@ -1860,7 +1860,7 @@ sweep_trail(choiceptr gc_B, tr_fr_ptr old_TR)
} }
/* next, follows the real trail entries */ /* next, follows the real trail entries */
trail_ptr = (tr_fr_ptr)_YAP_TrailBase; trail_ptr = (tr_fr_ptr)Yap_TrailBase;
dest = trail_ptr; dest = trail_ptr;
while (trail_ptr < old_TR) { while (trail_ptr < old_TR) {
register CELL trail_cell; register CELL trail_cell;
@ -1922,7 +1922,7 @@ sweep_trail(choiceptr gc_B, tr_fr_ptr old_TR)
#ifdef SBA #ifdef SBA
(ADDR) pt0 >= HeapTop (ADDR) pt0 >= HeapTop
#else #else
(ADDR) pt0 >= _YAP_TrailBase (ADDR) pt0 >= Yap_TrailBase
#endif #endif
) { ) {
trail_ptr++; trail_ptr++;
@ -1953,7 +1953,7 @@ sweep_trail(choiceptr gc_B, tr_fr_ptr old_TR)
dbr->Flags &= ~InUseMask; dbr->Flags &= ~InUseMask;
DEC_DBREF_COUNT(dbr); DEC_DBREF_COUNT(dbr);
if (dbr->Flags & ErasedMask) { if (dbr->Flags & ErasedMask) {
_YAP_ErDBE(dbr); Yap_ErDBE(dbr);
} }
} else { } else {
Clause *cl = ClauseFlagsToClause((CELL)pt0); Clause *cl = ClauseFlagsToClause((CELL)pt0);
@ -1968,7 +1968,7 @@ sweep_trail(choiceptr gc_B, tr_fr_ptr old_TR)
if (erase) { if (erase) {
/* at this point, /* at this point,
no one is accessing the clause */ no one is accessing the clause */
_YAP_ErCl(cl); Yap_ErCl(cl);
} }
} }
RESET_VARIABLE(&TrailTerm(dest)); RESET_VARIABLE(&TrailTerm(dest));
@ -2029,27 +2029,27 @@ sweep_trail(choiceptr gc_B, tr_fr_ptr old_TR)
} }
new_TR = dest; new_TR = dest;
if (is_gc_verbose()) { if (is_gc_verbose()) {
if (old_TR != (tr_fr_ptr)_YAP_TrailBase) if (old_TR != (tr_fr_ptr)Yap_TrailBase)
fprintf(_YAP_stderr, fprintf(Yap_stderr,
"[GC] Trail: discarded %d (%ld%%) cells out of %ld\n", "[GC] Trail: discarded %d (%ld%%) cells out of %ld\n",
discard_trail_entries, discard_trail_entries,
(unsigned long int)(discard_trail_entries*100/(old_TR-(tr_fr_ptr)_YAP_TrailBase)), (unsigned long int)(discard_trail_entries*100/(old_TR-(tr_fr_ptr)Yap_TrailBase)),
(unsigned long int)(old_TR-(tr_fr_ptr)_YAP_TrailBase)); (unsigned long int)(old_TR-(tr_fr_ptr)Yap_TrailBase));
#ifdef DEBUG #ifdef DEBUG
if (hp_entrs > 0) if (hp_entrs > 0)
fprintf(_YAP_stderr, fprintf(Yap_stderr,
"[GC] Trail: unmarked %ld dbentries (%ld%%) out of %ld\n", "[GC] Trail: unmarked %ld dbentries (%ld%%) out of %ld\n",
(long int)hp_not_in_use, (long int)hp_not_in_use,
(long int)(hp_not_in_use*100/hp_entrs), (long int)(hp_not_in_use*100/hp_entrs),
(long int)hp_entrs); (long int)hp_entrs);
if (hp_in_use_erased > 0 && hp_erased > 0) if (hp_in_use_erased > 0 && hp_erased > 0)
fprintf(_YAP_stderr, fprintf(Yap_stderr,
"[GC] Trail: deleted %ld dbentries (%ld%%) out of %ld\n", "[GC] Trail: deleted %ld dbentries (%ld%%) out of %ld\n",
(long int)hp_erased, (long int)hp_erased,
(long int)(hp_erased*100/(hp_erased+hp_in_use_erased)), (long int)(hp_erased*100/(hp_erased+hp_in_use_erased)),
(long int)(hp_erased+hp_in_use_erased)); (long int)(hp_erased+hp_in_use_erased));
#endif #endif
fprintf(_YAP_stderr, fprintf(Yap_stderr,
"[GC] Heap: recovered %ld bytes (%ld%%) out of %ld\n", "[GC] Heap: recovered %ld bytes (%ld%%) out of %ld\n",
(unsigned long int)(OldHeapUsed-HeapUsed), (unsigned long int)(OldHeapUsed-HeapUsed),
(unsigned long int)((OldHeapUsed-HeapUsed)/(OldHeapUsed/100)), (unsigned long int)((OldHeapUsed-HeapUsed)/(OldHeapUsed/100)),
@ -2062,7 +2062,7 @@ sweep_trail(choiceptr gc_B, tr_fr_ptr old_TR)
char *ocl = (char *)cl; char *ocl = (char *)cl;
cl = cl->u.NextCl; cl = cl->u.NextCl;
*cptr = cl; *cptr = cl;
_YAP_FreeCodeSpace(ocl); Yap_FreeCodeSpace(ocl);
} else { } else {
cl->ClFlags &= ~GcFoundMask; cl->ClFlags &= ~GcFoundMask;
cptr = &(cl->u.NextCl); cptr = &(cl->u.NextCl);
@ -2180,12 +2180,12 @@ sweep_choicepoints(choiceptr gc_B)
#endif #endif
{ {
op = rtp->opc; op = rtp->opc;
opnum = _YAP_op_from_opcode(op); opnum = Yap_op_from_opcode(op);
} }
restart_cp: restart_cp:
/* /*
* fprintf(_YAP_stderr,"sweeping cps: %x, %x, %x\n", * fprintf(Yap_stderr,"sweeping cps: %x, %x, %x\n",
* *gc_B,CP_Extra(gc_B),CP_Nargs(gc_B)); * *gc_B,CP_Extra(gc_B),CP_Nargs(gc_B));
*/ */
/* any choice point */ /* any choice point */
@ -2223,7 +2223,7 @@ sweep_choicepoints(choiceptr gc_B)
case _count_retry: case _count_retry:
rtp = NEXTOP(rtp,l); rtp = NEXTOP(rtp,l);
op = rtp->opc; op = rtp->opc;
opnum = _YAP_op_from_opcode(op); opnum = Yap_op_from_opcode(op);
goto restart_cp; goto restart_cp;
#ifdef TABLING #ifdef TABLING
case _table_answer_resolution: case _table_answer_resolution:
@ -2465,7 +2465,7 @@ update_relocation_chain(CELL_PTR current, CELL_PTR dest)
} }
#ifdef DEBUG #ifdef DEBUG
else { else {
_YAP_Error(SYSTEM_ERROR, TermNil, "ATOMIC in a GC relocation chain"); Yap_Error(SYSTEM_ERROR, TermNil, "ATOMIC in a GC relocation chain");
} }
#endif #endif
} }
@ -2601,7 +2601,7 @@ compact_heap(void)
#ifdef DEBUG #ifdef DEBUG
if (total_marked != found_marked) if (total_marked != found_marked)
fprintf(_YAP_stderr,"[GC] Upward (%d): %ld total against %ld found\n", fprintf(Yap_stderr,"[GC] Upward (%d): %ld total against %ld found\n",
gc_calls, gc_calls,
(unsigned long int)total_marked, (unsigned long int)total_marked,
(unsigned long int)found_marked); (unsigned long int)found_marked);
@ -2659,7 +2659,7 @@ compact_heap(void)
} }
#ifdef DEBUG #ifdef DEBUG
if (total_marked != found_marked) if (total_marked != found_marked)
fprintf(_YAP_stderr,"[GC] Downward (%d): %ld total against %ld found\n", fprintf(Yap_stderr,"[GC] Downward (%d): %ld total against %ld found\n",
gc_calls, gc_calls,
(unsigned long int)total_marked, (unsigned long int)total_marked,
(unsigned long int)found_marked); (unsigned long int)found_marked);
@ -2702,7 +2702,7 @@ adjust_cp_hbs(void)
gc_B->cp_h = H0; gc_B->cp_h = H0;
break; break;
} else { } else {
_YAP_Error(SYSTEM_ERROR,TermNil,"Bug in Garbage collector"); Yap_Error(SYSTEM_ERROR,TermNil,"Bug in Garbage collector");
return; return;
} }
} }
@ -2793,7 +2793,7 @@ icompact_heap(void)
#ifdef DEBUG #ifdef DEBUG
if (total_marked != found_marked) if (total_marked != found_marked)
fprintf(_YAP_stderr,"[GC] Upward (%d): %ld total against %ld found\n", fprintf(Yap_stderr,"[GC] Upward (%d): %ld total against %ld found\n",
gc_calls, gc_calls,
(unsigned long int)total_marked, (unsigned long int)total_marked,
(unsigned long int)found_marked); (unsigned long int)found_marked);
@ -2848,7 +2848,7 @@ icompact_heap(void)
} }
#ifdef DEBUG #ifdef DEBUG
if (total_marked != found_marked) if (total_marked != found_marked)
fprintf(_YAP_stderr,"[GC] Downward (%d): %ld total against %ld found\n", fprintf(Yap_stderr,"[GC] Downward (%d): %ld total against %ld found\n",
gc_calls, gc_calls,
(unsigned long int)total_marked, (unsigned long int)total_marked,
(unsigned long int)found_marked); (unsigned long int)found_marked);
@ -2903,7 +2903,7 @@ marking_phase(tr_fr_ptr old_TR, CELL *current_env, yamop *curp, CELL *max)
/* These two must be marked first so that our trail optimisation won't lose /* These two must be marked first so that our trail optimisation won't lose
values */ values */
#ifdef COROUTINING #ifdef COROUTINING
_YAP_mark_all_suspended_goals(); Yap_mark_all_suspended_goals();
#endif #endif
mark_regs(old_TR); /* active registers & trail */ mark_regs(old_TR); /* active registers & trail */
#ifdef COROUTINING #ifdef COROUTINING
@ -2921,7 +2921,7 @@ marking_phase(tr_fr_ptr old_TR, CELL *current_env, yamop *curp, CELL *max)
static void static void
sweep_delays(CELL *max) sweep_delays(CELL *max)
{ {
CELL *ptr = (CELL *)_YAP_GlobalBase; CELL *ptr = (CELL *)Yap_GlobalBase;
while (ptr < max) { while (ptr < max) {
if (MARKED(*ptr)) { if (MARKED(*ptr)) {
UNMARK(ptr); UNMARK(ptr);
@ -2952,12 +2952,12 @@ compaction_phase(tr_fr_ptr old_TR, CELL *current_env, yamop *curp, CELL *max)
#ifdef HYBRID_SCHEME #ifdef HYBRID_SCHEME
#ifdef DEBUG #ifdef DEBUG
if (total_marked != iptop-(CELL_PTR *)H && iptop < (CELL_PTR *)ASP -1024) if (total_marked != iptop-(CELL_PTR *)H && iptop < (CELL_PTR *)ASP -1024)
fprintf(_YAP_stderr,"[GC] Oops on iptop-H (%d) vs %d\n", iptop-(CELL_PTR *)H, total_marked); fprintf(Yap_stderr,"[GC] Oops on iptop-H (%d) vs %d\n", iptop-(CELL_PTR *)H, total_marked);
#endif #endif
if (iptop < (CELL_PTR *)ASP && 10*total_marked < H-H0) { if (iptop < (CELL_PTR *)ASP && 10*total_marked < H-H0) {
#ifdef INSTRUMENT_GC #ifdef INSTRUMENT_GC
int effectiveness = (((H-H0)-total_marked)*100)/(H-H0); int effectiveness = (((H-H0)-total_marked)*100)/(H-H0);
fprintf(_YAP_stderr,"[GC] using pointers (%d)\n", effectiveness); fprintf(Yap_stderr,"[GC] using pointers (%d)\n", effectiveness);
#endif #endif
quicksort((CELL_PTR *)H, 0, (iptop-(CELL_PTR *)H)-1); quicksort((CELL_PTR *)H, 0, (iptop-(CELL_PTR *)H)-1);
adjust_cp_hbs(); adjust_cp_hbs();
@ -2983,7 +2983,7 @@ do_gc(Int predarity, CELL *current_env, yamop *nextop)
tr_fr_ptr old_TR; tr_fr_ptr old_TR;
Int m_time, c_time, time_start, gc_time; Int m_time, c_time, time_start, gc_time;
#if COROUTINING #if COROUTINING
CELL *max = (CELL *)_YAP_ReadTimedVar(DelayedVars); CELL *max = (CELL *)Yap_ReadTimedVar(DelayedVars);
#else #else
CELL *max = NULL; CELL *max = NULL;
#endif #endif
@ -2992,8 +2992,8 @@ do_gc(Int predarity, CELL *current_env, yamop *nextop)
#if COROUTINING #if COROUTINING
if (H0 - max < 1024+(2*NUM_OF_ATTS)) { if (H0 - max < 1024+(2*NUM_OF_ATTS)) {
if (!_YAP_growglobal(&current_env)) { if (!Yap_growglobal(&current_env)) {
_YAP_Error(SYSTEM_ERROR, TermNil, _YAP_ErrorMessage); Yap_Error(SYSTEM_ERROR, TermNil, Yap_ErrorMessage);
return FALSE; return FALSE;
} }
} }
@ -3021,40 +3021,40 @@ do_gc(Int predarity, CELL *current_env, yamop *nextop)
#ifdef DEBUG #ifdef DEBUG
check_global(); check_global();
#endif #endif
if (_YAP_GetValue(AtomGcTrace) != TermNil) if (Yap_GetValue(AtomGcTrace) != TermNil)
gc_trace = 1; gc_trace = 1;
/* sanity check: can we still do garbage_collection ? */ /* sanity check: can we still do garbage_collection ? */
if ((CELL)_YAP_TrailTop & (MBIT|RBIT)) { if ((CELL)Yap_TrailTop & (MBIT|RBIT)) {
/* oops, we can't */ /* oops, we can't */
if (gc_verbose) { if (gc_verbose) {
fprintf(_YAP_stderr, "[GC] TrailTop at %p clashes with gc bits: %lx\n", _YAP_TrailTop, (unsigned long int)(MBIT|RBIT)); fprintf(Yap_stderr, "[GC] TrailTop at %p clashes with gc bits: %lx\n", Yap_TrailTop, (unsigned long int)(MBIT|RBIT));
fprintf(_YAP_stderr, "[GC] garbage collection disallowed\n"); fprintf(Yap_stderr, "[GC] garbage collection disallowed\n");
} }
return(0); return(0);
} }
gc_calls++; gc_calls++;
if (gc_trace) { if (gc_trace) {
fprintf(_YAP_stderr, "[gc]\n"); fprintf(Yap_stderr, "[gc]\n");
} else if (gc_verbose) { } else if (gc_verbose) {
fprintf(_YAP_stderr, "[GC] Start of garbage collection %d:\n", gc_calls); fprintf(Yap_stderr, "[GC] Start of garbage collection %d:\n", gc_calls);
#ifndef EARLY_RESET #ifndef EARLY_RESET
fprintf(_YAP_stderr, "[GC] no early reset in trail\n"); fprintf(Yap_stderr, "[GC] no early reset in trail\n");
#endif #endif
fprintf(_YAP_stderr, "[GC] Global: %8ld cells (%p-%p)\n", (long int)heap_cells,H0,H); fprintf(Yap_stderr, "[GC] Global: %8ld cells (%p-%p)\n", (long int)heap_cells,H0,H);
fprintf(_YAP_stderr, "[GC] Local:%8ld cells (%p-%p)\n", (unsigned long int)(LCL0-ASP),LCL0,ASP); fprintf(Yap_stderr, "[GC] Local:%8ld cells (%p-%p)\n", (unsigned long int)(LCL0-ASP),LCL0,ASP);
fprintf(_YAP_stderr, "[GC] Trail:%8ld cells (%p-%p)\n", fprintf(Yap_stderr, "[GC] Trail:%8ld cells (%p-%p)\n",
(unsigned long int)(TR-(tr_fr_ptr)_YAP_TrailBase),_YAP_TrailBase,TR); (unsigned long int)(TR-(tr_fr_ptr)Yap_TrailBase),Yap_TrailBase,TR);
} }
if (HeapTop >= _YAP_GlobalBase - MinHeapGap) { if (HeapTop >= Yap_GlobalBase - MinHeapGap) {
*--ASP = (CELL)current_env; *--ASP = (CELL)current_env;
if (!_YAP_growheap(FALSE)) { if (!Yap_growheap(FALSE)) {
_YAP_Error(SYSTEM_ERROR, TermNil, _YAP_ErrorMessage); Yap_Error(SYSTEM_ERROR, TermNil, Yap_ErrorMessage);
return(FALSE); return(FALSE);
} }
current_env = (CELL *)*ASP; current_env = (CELL *)*ASP;
ASP++; ASP++;
} }
time_start = _YAP_cputime(); time_start = Yap_cputime();
total_marked = 0; total_marked = 0;
discard_trail_entries = 0; discard_trail_entries = 0;
#ifdef HYBRID_SCHEME #ifdef HYBRID_SCHEME
@ -3065,26 +3065,26 @@ do_gc(Int predarity, CELL *current_env, yamop *nextop)
old_TR = TR; old_TR = TR;
push_registers(predarity, nextop); push_registers(predarity, nextop);
marking_phase(old_TR, current_env, nextop, max); marking_phase(old_TR, current_env, nextop, max);
m_time = _YAP_cputime(); m_time = Yap_cputime();
gc_time = m_time-time_start; gc_time = m_time-time_start;
if (heap_cells) if (heap_cells)
effectiveness = ((heap_cells-total_marked)*100)/heap_cells; effectiveness = ((heap_cells-total_marked)*100)/heap_cells;
else else
effectiveness = 0; effectiveness = 0;
if (gc_verbose) { if (gc_verbose) {
fprintf(_YAP_stderr, "[GC] Mark: Recovered %ld cells of %ld (%ld%%) in %g sec\n", fprintf(Yap_stderr, "[GC] Mark: Recovered %ld cells of %ld (%ld%%) in %g sec\n",
(long int)(heap_cells-total_marked), (long int)heap_cells, (long int)effectiveness, (double)(m_time-time_start)/1000); (long int)(heap_cells-total_marked), (long int)heap_cells, (long int)effectiveness, (double)(m_time-time_start)/1000);
#ifdef INSTRUMENT_GC #ifdef INSTRUMENT_GC
{ {
int i; int i;
for (i=0; i<16; i++) { for (i=0; i<16; i++) {
if (chain[i]) { if (chain[i]) {
fprintf(_YAP_stderr, "[GC] chain[%d]=%lu\n", i, chain[i]); fprintf(Yap_stderr, "[GC] chain[%d]=%lu\n", i, chain[i]);
} }
} }
put_type_info((unsigned long int)total_marked); put_type_info((unsigned long int)total_marked);
fprintf(_YAP_stderr,"[GC] %lu/%ld before and %lu/%ld after\n", old_vars, (unsigned long int)(B->cp_h-H0), new_vars, (unsigned long int)(H-B->cp_h)); fprintf(Yap_stderr,"[GC] %lu/%ld before and %lu/%ld after\n", old_vars, (unsigned long int)(B->cp_h-H0), new_vars, (unsigned long int)(H-B->cp_h));
fprintf(_YAP_stderr,"[GC] %ld choicepoints\n", num_bs); fprintf(Yap_stderr,"[GC] %ld choicepoints\n", num_bs);
} }
#endif #endif
} }
@ -3094,16 +3094,16 @@ do_gc(Int predarity, CELL *current_env, yamop *nextop)
pop_registers(predarity, nextop); pop_registers(predarity, nextop);
TR = new_TR; TR = new_TR;
YAPLeaveCriticalSection(); YAPLeaveCriticalSection();
c_time = _YAP_cputime(); c_time = Yap_cputime();
if (gc_verbose) { if (gc_verbose) {
fprintf(_YAP_stderr, "[GC] Compress: took %g sec\n", (double)(c_time-time_start)/1000); fprintf(Yap_stderr, "[GC] Compress: took %g sec\n", (double)(c_time-time_start)/1000);
} }
gc_time += (c_time-time_start); gc_time += (c_time-time_start);
tot_gc_time += gc_time; tot_gc_time += gc_time;
tot_gc_recovered += heap_cells-total_marked; tot_gc_recovered += heap_cells-total_marked;
if (gc_verbose) { if (gc_verbose) {
fprintf(_YAP_stderr, "[GC] GC %d took %g sec, total of %g sec doing GC so far.\n", gc_calls, (double)gc_time/1000, (double)tot_gc_time/1000); fprintf(Yap_stderr, "[GC] GC %d took %g sec, total of %g sec doing GC so far.\n", gc_calls, (double)gc_time/1000, (double)tot_gc_time/1000);
fprintf(_YAP_stderr, "[GC] Left %ld cells free in stacks.\n", fprintf(Yap_stderr, "[GC] Left %ld cells free in stacks.\n",
(unsigned long int)(ASP-H)); (unsigned long int)(ASP-H));
} }
check_global(); check_global();
@ -3117,13 +3117,13 @@ is_gc_verbose(void)
/* always give info when we are debugging gc */ /* always give info when we are debugging gc */
return(TRUE); return(TRUE);
#else #else
return(_YAP_GetValue(AtomGcVerbose) != TermNil || return(Yap_GetValue(AtomGcVerbose) != TermNil ||
_YAP_GetValue(AtomGcVeryVerbose) != TermNil); Yap_GetValue(AtomGcVeryVerbose) != TermNil);
#endif #endif
} }
int int
_YAP_is_gc_verbose(void) Yap_is_gc_verbose(void)
{ {
return is_gc_verbose(); return is_gc_verbose();
} }
@ -3131,11 +3131,11 @@ _YAP_is_gc_verbose(void)
static int static int
is_gc_very_verbose(void) is_gc_very_verbose(void)
{ {
return(_YAP_GetValue(AtomGcVeryVerbose) != TermNil); return(Yap_GetValue(AtomGcVeryVerbose) != TermNil);
} }
Int Int
_YAP_total_gc_time(void) Yap_total_gc_time(void)
{ {
return(tot_gc_time); return(tot_gc_time);
} }
@ -3147,13 +3147,13 @@ p_inform_gc(void)
Term tt = MkIntegerTerm(gc_calls); Term tt = MkIntegerTerm(gc_calls);
Term ts = MkIntegerTerm((tot_gc_recovered*sizeof(CELL))); Term ts = MkIntegerTerm((tot_gc_recovered*sizeof(CELL)));
return(_YAP_unify(tn, ARG2) && _YAP_unify(tt, ARG1) && _YAP_unify(ts, ARG3)); return(Yap_unify(tn, ARG2) && Yap_unify(tt, ARG1) && Yap_unify(ts, ARG3));
} }
int int
_YAP_gc(Int predarity, CELL *current_env, yamop *nextop) Yap_gc(Int predarity, CELL *current_env, yamop *nextop)
{ {
Int gc_margin = 128; Int gc_margin = 128;
Term Tgc_margin; Term Tgc_margin;
@ -3162,13 +3162,13 @@ _YAP_gc(Int predarity, CELL *current_env, yamop *nextop)
#if defined(YAPOR) || defined(THREADS) #if defined(YAPOR) || defined(THREADS)
if (NOfThreads != 1) { if (NOfThreads != 1) {
_YAP_Error(SYSTEM_ERROR,TermNil,"cannot perform garbage collection: more than a worker/thread running"); Yap_Error(SYSTEM_ERROR,TermNil,"cannot perform garbage collection: more than a worker/thread running");
return(FALSE); return(FALSE);
} }
#endif #endif
if (_YAP_GetValue(AtomGc) != TermNil) if (Yap_GetValue(AtomGc) != TermNil)
gc_on = TRUE; gc_on = TRUE;
if (IsIntTerm(Tgc_margin = _YAP_GetValue(AtomGcMargin))) if (IsIntTerm(Tgc_margin = Yap_GetValue(AtomGcMargin)))
gc_margin = IntOfTerm(Tgc_margin); gc_margin = IntOfTerm(Tgc_margin);
else { else {
if (gc_calls < 8) if (gc_calls < 8)
@ -3195,14 +3195,14 @@ _YAP_gc(Int predarity, CELL *current_env, yamop *nextop)
gc_margin = ((gc_margin >> 16) + 1) << 16; gc_margin = ((gc_margin >> 16) + 1) << 16;
if (gc_margin < gap) if (gc_margin < gap)
gc_margin = gap; gc_margin = gap;
while (gc_margin >= gap && !_YAP_growstack(gc_margin)) while (gc_margin >= gap && !Yap_growstack(gc_margin))
gc_margin = gc_margin/2; gc_margin = gc_margin/2;
check_global(); check_global();
return(gc_margin >= gap); return(gc_margin >= gap);
} }
/* /*
* debug for(save_total=1; save_total<=N; ++save_total) * debug for(save_total=1; save_total<=N; ++save_total)
* plwrite(XREGS[save_total],_YAP_DebugPutc,0); * plwrite(XREGS[save_total],Yap_DebugPutc,0);
*/ */
return ( TRUE ); return ( TRUE );
} }
@ -3216,14 +3216,14 @@ p_gc(void)
} }
void void
_YAP_init_gc(void) Yap_init_gc(void)
{ {
_YAP_InitCPred("$gc", 0, p_gc, 0); Yap_InitCPred("$gc", 0, p_gc, 0);
_YAP_InitCPred("$inform_gc", 3, p_inform_gc, 0); Yap_InitCPred("$inform_gc", 3, p_inform_gc, 0);
} }
void void
_YAP_inc_mark_variable() Yap_inc_mark_variable()
{ {
total_marked++; total_marked++;
} }

138
C/index.c
View File

@ -126,33 +126,33 @@ static int followed_by_cut(yamop * code)
register yamop *p = code; register yamop *p = code;
while (TRUE) while (TRUE)
{ {
if (p->opc == _YAP_opcode(_get_x_var)) if (p->opc == Yap_opcode(_get_x_var))
p = NEXTOP(p,xx); p = NEXTOP(p,xx);
if (p->opc == _YAP_opcode(_get_y_var)) if (p->opc == Yap_opcode(_get_y_var))
p = NEXTOP(p,yx); p = NEXTOP(p,yx);
else if (p->opc == _YAP_opcode(_allocate)) else if (p->opc == Yap_opcode(_allocate))
p = NEXTOP(p,e); p = NEXTOP(p,e);
else if (p->opc == _YAP_opcode(_unify_x_var)) else if (p->opc == Yap_opcode(_unify_x_var))
p = NEXTOP(p,ox); p = NEXTOP(p,ox);
else if (p->opc == _YAP_opcode(_unify_y_var)) else if (p->opc == Yap_opcode(_unify_y_var))
p = NEXTOP(p,oy); p = NEXTOP(p,oy);
else if (p->opc == _YAP_opcode(_unify_l_x_var)) else if (p->opc == Yap_opcode(_unify_l_x_var))
p = NEXTOP(p,ox); p = NEXTOP(p,ox);
else if (p->opc == _YAP_opcode(_unify_l_y_var)) else if (p->opc == Yap_opcode(_unify_l_y_var))
p = NEXTOP(p,oy); p = NEXTOP(p,oy);
else if (p->opc == _YAP_opcode(_unify_void)) else if (p->opc == Yap_opcode(_unify_void))
p = NEXTOP(p,o); p = NEXTOP(p,o);
else if (p->opc == _YAP_opcode(_unify_n_voids)) else if (p->opc == Yap_opcode(_unify_n_voids))
p = NEXTOP(p,os); p = NEXTOP(p,os);
else if (p->opc == _YAP_opcode(_unify_l_void)) else if (p->opc == Yap_opcode(_unify_l_void))
p = NEXTOP(p,o); p = NEXTOP(p,o);
else if (p->opc == _YAP_opcode(_unify_l_n_voids)) else if (p->opc == Yap_opcode(_unify_l_n_voids))
p = NEXTOP(p,os); p = NEXTOP(p,os);
else if (p->opc == _YAP_opcode(_cut)) else if (p->opc == Yap_opcode(_cut))
return(TRUE); return(TRUE);
else if (p->opc == _YAP_opcode(_cut_t)) else if (p->opc == Yap_opcode(_cut_t))
return(TRUE); return(TRUE);
else if (p->opc == _YAP_opcode(_cut_e)) else if (p->opc == Yap_opcode(_cut_e))
return(TRUE); return(TRUE);
else return(FALSE); else return(FALSE);
} }
@ -165,7 +165,7 @@ static int followed_by_cut(yamop * code)
inline static void inline static void
emit_tr(compiler_vm_op op, yamop * Address, int NClauses, int HasCut) emit_tr(compiler_vm_op op, yamop * Address, int NClauses, int HasCut)
{ {
_YAP_emit(op, Unsigned(Address), (NClauses << 1) + HasCut); Yap_emit(op, Unsigned(Address), (NClauses << 1) + HasCut);
} }
/* emits an opcode followed by an adress */ /* emits an opcode followed by an adress */
@ -180,7 +180,7 @@ emit_try(compiler_vm_op op, int op_offset, yamop * Address, int NClauses, int Ha
return; return;
} }
} }
_YAP_emit((compiler_vm_op)((int)op + op_offset), Unsigned(Address), (NClauses << 1) + HasCut); Yap_emit((compiler_vm_op)((int)op + op_offset), Unsigned(Address), (NClauses << 1) + HasCut);
} }
/* /*
@ -200,7 +200,7 @@ inline static yamop *
SecB(yamop * Arg) SecB(yamop * Arg)
{ {
yamop *pc = NEXTOP(Arg,ld); yamop *pc = NEXTOP(Arg,ld);
if (pc->opc == _YAP_opcode(_get_struct)) if (pc->opc == Yap_opcode(_get_struct))
return (NEXTOP(pc,xf)); return (NEXTOP(pc,xf));
else else
return (NEXTOP(pc,xc)); return (NEXTOP(pc,xc));
@ -225,7 +225,7 @@ inline static yamop *
ThiB(yamop * Arg) ThiB(yamop * Arg)
{ {
yamop *pc = NEXTOP(NEXTOP(Arg,ld),x); yamop *pc = NEXTOP(NEXTOP(Arg,ld),x);
if (pc->opc == _YAP_opcode(_unify_struct)) if (pc->opc == Yap_opcode(_unify_struct))
return (NEXTOP(pc,of)); return (NEXTOP(pc,of));
else else
return (NEXTOP(pc,oc)); return (NEXTOP(pc,oc));
@ -249,9 +249,9 @@ emit_cp_inst(compiler_vm_op op, yamop * Address, int Flag, int NClausesAfter)
indexed_code_for_cut = NIL; indexed_code_for_cut = NIL;
if (op != try_op && profiling) if (op != try_op && profiling)
_YAP_emit(retry_profiled_op, Unsigned(CurrentPred), Zero); Yap_emit(retry_profiled_op, Unsigned(CurrentPred), Zero);
else if (op != try_op && call_counting) else if (op != try_op && call_counting)
_YAP_emit(count_retry_op, Unsigned(CurrentPred), Zero); Yap_emit(count_retry_op, Unsigned(CurrentPred), Zero);
if (NGroups == 1) if (NGroups == 1)
Flag = Flag | LoneGroup; Flag = Flag | LoneGroup;
else if (Flag & LastGroup) { else if (Flag & LastGroup) {
@ -346,8 +346,8 @@ static CELL
emit_space(compiler_vm_op op, int space, int nof) emit_space(compiler_vm_op op, int space, int nof)
{ {
labelno += 2; labelno += 2;
_YAP_emit(label_op, labelno, Zero); Yap_emit(label_op, labelno, Zero);
StorePoint = _YAP_emit_extra_size(op, Unsigned(nof), space); StorePoint = Yap_emit_extra_size(op, Unsigned(nof), space);
return (labelno); return (labelno);
} }
@ -356,11 +356,11 @@ static CELL
emit_go(int Gender, Term Name) emit_go(int Gender, Term Name)
{ {
labelno += 2; labelno += 2;
_YAP_emit(label_op, labelno, Zero); Yap_emit(label_op, labelno, Zero);
if (Gender == ApplCl) if (Gender == ApplCl)
StorePoint = _YAP_emit_extra_size(go_f_op, Zero, 3 * CellSize); StorePoint = Yap_emit_extra_size(go_f_op, Zero, 3 * CellSize);
else else
StorePoint = _YAP_emit_extra_size(go_c_op, Zero, 3 * CellSize); StorePoint = Yap_emit_extra_size(go_c_op, Zero, 3 * CellSize);
*StorePoint++ = Unsigned(Name); *StorePoint++ = Unsigned(Name);
StorePoint[1] = (CELL)FailAddress; StorePoint[1] = (CELL)FailAddress;
return (labelno); return (labelno);
@ -371,7 +371,7 @@ emit_go(int Gender, Term Name)
static void static void
emit_if_not(Term T1, CELL Ad1, CELL Ad2) emit_if_not(Term T1, CELL Ad1, CELL Ad2)
{ {
StorePoint = _YAP_emit_extra_size(if_not_op, Zero, 3 * CellSize); StorePoint = Yap_emit_extra_size(if_not_op, Zero, 3 * CellSize);
*StorePoint++ = Unsigned(T1); *StorePoint++ = Unsigned(T1);
*StorePoint++ = Unsigned(Ad1); *StorePoint++ = Unsigned(Ad1);
StorePoint[0] = Unsigned(Ad2); StorePoint[0] = Unsigned(Ad2);
@ -470,8 +470,8 @@ NGroupsIn(PredEntry *ap)
if (y != PresentGroup) { if (y != PresentGroup) {
Group++->Last = (ActualCl - 1)->Code; Group++->Last = (ActualCl - 1)->Code;
NGroups++; NGroups++;
if ((ADDR)Group > _YAP_TrailTop-1024) if ((ADDR)Group > Yap_TrailTop-1024)
_YAP_growtrail(64 * 1024L); Yap_growtrail(64 * 1024L);
Group->First = q; Group->First = q;
Group->Start = ActualCl; Group->Start = ActualCl;
Group->NCl = 0; Group->NCl = 0;
@ -502,7 +502,7 @@ NGroupsIn(PredEntry *ap)
if (ASP <= CellPtr (ActualCl) + 256) { if (ASP <= CellPtr (ActualCl) + 256) {
freep = (char *)ActualCl; freep = (char *)ActualCl;
save_machine_regs(); save_machine_regs();
longjmp(_YAP_CompilerBotch, 3); longjmp(Yap_CompilerBotch, 3);
} }
(Group->Type[x])++; (Group->Type[x])++;
(Group->NCl)++; (Group->NCl)++;
@ -598,7 +598,7 @@ BuildHash(CELL *WhereTo, int NOfEntries, int TableSize, int Gend)
} }
#ifdef DEBUG #ifdef DEBUG
#ifdef CLASHES #ifdef CLASHES
fprintf(_YAP_stderr,"hash table clashes: %d %d\n", clashes, NOfEntries); fprintf(Yap_stderr,"hash table clashes: %d %d\n", clashes, NOfEntries);
#endif /* CLASHES */ #endif /* CLASHES */
#endif /* DEBUG */ #endif /* DEBUG */
} }
@ -627,7 +627,7 @@ TreatEntry(EntryDef *Entrance, int Gender, int PositionFlag, GroupDef *Gr)
/* last group, meaning we already have a choice point set */ /* last group, meaning we already have a choice point set */
register yamop * k = (Entrance->First)->Code; register yamop * k = (Entrance->First)->Code;
labelno += 2; labelno += 2;
_YAP_emit(label_op, Entrance->Code = labelno, Zero); Yap_emit(label_op, Entrance->Code = labelno, Zero);
if (PositionFlag & HeadIndex) { if (PositionFlag & HeadIndex) {
emit_tr(trust_op, ThiB(k), 1, clause_has_cut(k)); emit_tr(trust_op, ThiB(k), 1, clause_has_cut(k));
} else { } else {
@ -641,7 +641,7 @@ TreatEntry(EntryDef *Entrance, int Gender, int PositionFlag, GroupDef *Gr)
/* a single alternative and a catchall clause */ /* a single alternative and a catchall clause */
register yamop * k = (Entrance->First)->Code; register yamop * k = (Entrance->First)->Code;
labelno += 2; labelno += 2;
_YAP_emit(label_op, Entrance->Code = labelno, Zero); Yap_emit(label_op, Entrance->Code = labelno, Zero);
/* if we are in a list */ /* if we are in a list */
if (PositionFlag & HeadIndex) { if (PositionFlag & HeadIndex) {
/* we cannot emit to SecLB because switch might have already /* we cannot emit to SecLB because switch might have already
@ -683,7 +683,7 @@ TreatEntry(EntryDef *Entrance, int Gender, int PositionFlag, GroupDef *Gr)
nofalts = Gr->NofClausesAfter+nofentries; nofalts = Gr->NofClausesAfter+nofentries;
k = Entrance->First; k = Entrance->First;
labelno += 2; labelno += 2;
_YAP_emit(label_op, (Entrance->Code = labelno), Zero); Yap_emit(label_op, (Entrance->Code = labelno), Zero);
emit_cp_inst(try_op, k->Code, PositionFlag, nofalts); emit_cp_inst(try_op, k->Code, PositionFlag, nofalts);
nofalts--; nofalts--;
if (indexed_code_for_cut != NIL) { if (indexed_code_for_cut != NIL) {
@ -696,7 +696,7 @@ TreatEntry(EntryDef *Entrance, int Gender, int PositionFlag, GroupDef *Gr)
emit_cp_inst(trust_op, k->Code, PositionFlag, nofalts); emit_cp_inst(trust_op, k->Code, PositionFlag, nofalts);
/* emit a jump with the place to jump to after finishing this group */ /* emit a jump with the place to jump to after finishing this group */
if (NGroups > 1 && !(PositionFlag & LastGroup) && !ExtendedSingle) if (NGroups > 1 && !(PositionFlag & LastGroup) && !ExtendedSingle)
_YAP_emit(jump_op, (CELL)((Gr+1)->First), Zero); Yap_emit(jump_op, (CELL)((Gr+1)->First), Zero);
} }
} }
} }
@ -725,8 +725,8 @@ DealFixed(ClauseDef *j, int Gender, compiler_vm_op op, int Flag, GroupDef *Gr)
while (l < NDiffTerms && Entry->Class != HeadName) while (l < NDiffTerms && Entry->Class != HeadName)
Entry++, l++; Entry++, l++;
if (l == NDiffTerms) { if (l == NDiffTerms) {
if ((ADDR)Entry > _YAP_TrailTop-1024) if ((ADDR)Entry > Yap_TrailTop-1024)
_YAP_growtrail(64 * 1024L); Yap_growtrail(64 * 1024L);
Entry->Class = HeadName; Entry->Class = HeadName;
Entry->Last = Entry->First = j; Entry->Last = Entry->First = j;
NDiffTerms++; NDiffTerms++;
@ -784,7 +784,7 @@ DealFixedWithBips(ClauseDef *j, int NClauses, int Flag, GroupDef *Gr)
labelno += 2; labelno += 2;
my_labelno = labelno; my_labelno = labelno;
_YAP_emit(label_op, labelno, Zero); Yap_emit(label_op, labelno, Zero);
#ifdef AGRESSIVE_BIPS #ifdef AGRESSIVE_BIPS
if (j->Name != 0x0 && j->Next->Name != 0x0) { if (j->Name != 0x0 && j->Next->Name != 0x0) {
/* /*
@ -809,7 +809,7 @@ DealFixedWithBips(ClauseDef *j, int NClauses, int Flag, GroupDef *Gr)
while (j->Name != 0x0) i++, j = j->Next; while (j->Name != 0x0) i++, j = j->Next;
Gr->NofClausesAfter = old_NAlts + G->NCl - i; Gr->NofClausesAfter = old_NAlts + G->NCl - i;
DealFixed(j0, AtCl, switch_c_op, FirstIndex | IsAtom, Gr); DealFixed(j0, AtCl, switch_c_op, FirstIndex | IsAtom, Gr);
_YAP_emit(label_op, old_labelno, Zero); Yap_emit(label_op, old_labelno, Zero);
FailAddress = old_FailAddress; FailAddress = old_FailAddress;
ExtendedSingle = old_ExtendedSingle; ExtendedSingle = old_ExtendedSingle;
Gr->NofClausesAfter = old_NAlts; Gr->NofClausesAfter = old_NAlts;
@ -836,7 +836,7 @@ DealFixedWithBips(ClauseDef *j, int NClauses, int Flag, GroupDef *Gr)
emit_cp_inst(trust_op, j->Code, Flag, nofalts); emit_cp_inst(trust_op, j->Code, Flag, nofalts);
/* emit a jump with the place to jump to after finishing this group */ /* emit a jump with the place to jump to after finishing this group */
if (NGroups > 1 && !(Flag & LastGroup) && !ExtendedSingle) if (NGroups > 1 && !(Flag & LastGroup) && !ExtendedSingle)
_YAP_emit(jump_op, (CELL)((Gr+1)->First), Zero); Yap_emit(jump_op, (CELL)((Gr+1)->First), Zero);
return(my_labelno); return(my_labelno);
} }
@ -850,14 +850,14 @@ DealCons(int i)
if (FinalGr(i)) { if (FinalGr(i)) {
yamop * Cl = FindFirst(i, AtCl); yamop * Cl = FindFirst(i, AtCl);
labelno += 2; labelno += 2;
_YAP_emit(label_op, labelno, Zero); Yap_emit(label_op, labelno, Zero);
emit_tr(trust_op, Cl, 1, clause_has_cut(Cl)); emit_tr(trust_op, Cl, 1, clause_has_cut(Cl));
return (labelno); return (labelno);
} else if (ExtendedSingle) { } else if (ExtendedSingle) {
yamop * Cl = FindFirst(i, AtCl); yamop * Cl = FindFirst(i, AtCl);
labelno += 2; labelno += 2;
_YAP_emit(label_op, labelno, Zero); Yap_emit(label_op, labelno, Zero);
emit_tr(try_op, Cl, 2, clause_has_cut(Cl)); emit_tr(try_op, Cl, 2, clause_has_cut(Cl));
emit_tr(trust_op, FailAddress, 1, clause_has_cut(FailAddress)); emit_tr(trust_op, FailAddress, 1, clause_has_cut(FailAddress));
return (labelno); return (labelno);
@ -895,13 +895,13 @@ DealAppl(int i)
if (FinalGr(i)) { if (FinalGr(i)) {
yamop * Cl = FindFirst(i, ApplCl); yamop * Cl = FindFirst(i, ApplCl);
labelno += 2; labelno += 2;
_YAP_emit(label_op, labelno, Zero); Yap_emit(label_op, labelno, Zero);
emit_tr(trust_op, Cl, 1, clause_has_cut(Cl)); emit_tr(trust_op, Cl, 1, clause_has_cut(Cl));
return (labelno); return (labelno);
} else if (ExtendedSingle) { } else if (ExtendedSingle) {
yamop * Cl = FindFirst(i, ApplCl); yamop * Cl = FindFirst(i, ApplCl);
labelno += 2; labelno += 2;
_YAP_emit(label_op, labelno, Zero); Yap_emit(label_op, labelno, Zero);
emit_tr(try_op, Cl, 2, clause_has_cut(Cl)); emit_tr(try_op, Cl, 2, clause_has_cut(Cl));
emit_tr(trust_op, FailAddress, 1, clause_has_cut(FailAddress)); emit_tr(trust_op, FailAddress, 1, clause_has_cut(FailAddress));
return (labelno); return (labelno);
@ -929,12 +929,12 @@ StartList(int i)
j++; j++;
if (FinalGr(i)) { if (FinalGr(i)) {
labelno += 2; labelno += 2;
_YAP_emit(label_op, labelno, Zero); Yap_emit(label_op, labelno, Zero);
emit_tr(trust_op, SecLB(j->Code), 1, clause_has_cut(j->Code)); emit_tr(trust_op, SecLB(j->Code), 1, clause_has_cut(j->Code));
return (labelno); return (labelno);
} else if (ExtendedSingle) { } else if (ExtendedSingle) {
labelno += 2; labelno += 2;
_YAP_emit(label_op, labelno, Zero); Yap_emit(label_op, labelno, Zero);
emit_tr(try_op, SecLB(j->Code), 2, clause_has_cut(j->Code)); emit_tr(try_op, SecLB(j->Code), 2, clause_has_cut(j->Code));
emit_tr(trust_op, FailAddress, 1, clause_has_cut(FailAddress)); emit_tr(trust_op, FailAddress, 1, clause_has_cut(FailAddress));
return (labelno); return (labelno);
@ -978,7 +978,7 @@ DealLList(ClauseDef *j, int NOfClauses, int PositionFlag, int NG)
else if (NOfClauses == 1) { else if (NOfClauses == 1) {
if (FinalGr(NG)) { if (FinalGr(NG)) {
labelno += 2; labelno += 2;
_YAP_emit(label_op, labelno, Zero); Yap_emit(label_op, labelno, Zero);
if (PositionFlag & FirstIndex) if (PositionFlag & FirstIndex)
emit_tr(trust_op, SecLB(j->Code), 1, clause_has_cut(j->Code)); emit_tr(trust_op, SecLB(j->Code), 1, clause_has_cut(j->Code));
else else
@ -986,7 +986,7 @@ DealLList(ClauseDef *j, int NOfClauses, int PositionFlag, int NG)
return (labelno); return (labelno);
} else if (ExtendedSingle) { } else if (ExtendedSingle) {
labelno += 2; labelno += 2;
_YAP_emit(label_op, labelno, Zero); Yap_emit(label_op, labelno, Zero);
if (PositionFlag & FirstIndex) if (PositionFlag & FirstIndex)
emit_tr(try_op, SecLB(j->Code), 2, clause_has_cut(j->Code)); emit_tr(try_op, SecLB(j->Code), 2, clause_has_cut(j->Code));
else else
@ -1001,7 +1001,7 @@ DealLList(ClauseDef *j, int NOfClauses, int PositionFlag, int NG)
if (FinalGr(NG)) if (FinalGr(NG))
PositionFlag |= LastGroup; PositionFlag |= LastGroup;
labelno += 2; labelno += 2;
_YAP_emit(label_op, labelno, Zero); Yap_emit(label_op, labelno, Zero);
nofalts = Groups[NG].NofClausesAfter+NOfClauses; nofalts = Groups[NG].NofClausesAfter+NOfClauses;
emit_cp_inst(try_op, j->Code, PositionFlag, nofalts); emit_cp_inst(try_op, j->Code, PositionFlag, nofalts);
nofalts--; nofalts--;
@ -1017,7 +1017,7 @@ DealLList(ClauseDef *j, int NOfClauses, int PositionFlag, int NG)
emit_cp_inst(trust_op, j->Code, PositionFlag, nofalts); emit_cp_inst(trust_op, j->Code, PositionFlag, nofalts);
/* emit a jump with the place to jump to after finishing this group */ /* emit a jump with the place to jump to after finishing this group */
if (NGroups > 1 && !(PositionFlag & LastGroup) && !ExtendedSingle) if (NGroups > 1 && !(PositionFlag & LastGroup) && !ExtendedSingle)
_YAP_emit(jump_op, (CELL)(Groups[NG+1].First), Zero); Yap_emit(jump_op, (CELL)(Groups[NG+1].First), Zero);
return (labelno); return (labelno);
} }
} }
@ -1095,7 +1095,7 @@ DealList(int i)
else else
VFlags = FirstIndex | LastFoundList; VFlags = FirstIndex | LastFoundList;
labelno += 2; labelno += 2;
_YAP_emit(label_op, labelno, Zero); Yap_emit(label_op, labelno, Zero);
emit_cp_inst(try_op, j->Code, VFlags, nofalts); emit_cp_inst(try_op, j->Code, VFlags, nofalts);
nofalts--; nofalts--;
if (indexed_code_for_cut != NIL) { if (indexed_code_for_cut != NIL) {
@ -1110,7 +1110,7 @@ DealList(int i)
emit_cp_inst(trust_op, j->Code, VFlags, nofalts); emit_cp_inst(trust_op, j->Code, VFlags, nofalts);
/* emit a jump with the place to jump to after finishing this group */ /* emit a jump with the place to jump to after finishing this group */
if (NGroups > 1 && !(VFlags & LastGroup) && !ExtendedSingle) if (NGroups > 1 && !(VFlags & LastGroup) && !ExtendedSingle)
_YAP_emit(jump_op, (CELL)(Groups[i+1].First), Zero); Yap_emit(jump_op, (CELL)(Groups[i+1].First), Zero);
return (labelno); return (labelno);
} }
} }
@ -1239,11 +1239,11 @@ IndexVarGr(int Count)
Cla++; Cla++;
nofalts--; nofalts--;
} else if (Count == NGroups - 1 && Gr->NCl == 1) { } else if (Count == NGroups - 1 && Gr->NCl == 1) {
_YAP_emit(label_op, Unsigned(Gr->First), Zero); Yap_emit(label_op, Unsigned(Gr->First), Zero);
emit_tr(trust_op, Body((Cla)->Code), 1, clause_has_cut(Cla->Code)); emit_tr(trust_op, Body((Cla)->Code), 1, clause_has_cut(Cla->Code));
return; return;
} else { } else {
_YAP_emit(label_op, Unsigned(Gr->First), Zero); Yap_emit(label_op, Unsigned(Gr->First), Zero);
emit_tr(retry_op, Body((Cla)->Code), nofalts, clause_has_cut(Cla->Code)); emit_tr(retry_op, Body((Cla)->Code), nofalts, clause_has_cut(Cla->Code));
Cla++; Cla++;
nofalts--; nofalts--;
@ -1277,7 +1277,7 @@ ComplexCase(void)
if (IsExtendedSingle(0)) if (IsExtendedSingle(0))
return (SimpleCase()); return (SimpleCase());
_YAP_emit(jump_v_op, (CELL) FirstCl, Zero); Yap_emit(jump_v_op, (CELL) FirstCl, Zero);
if (Groups[0].Type[VarCl] == 0) if (Groups[0].Type[VarCl] == 0)
i = 0; i = 0;
else { else {
@ -1317,19 +1317,19 @@ SpecialCases(void)
} }
CODEADDR CODEADDR
_YAP_PredIsIndexable(PredEntry *ap) Yap_PredIsIndexable(PredEntry *ap)
{ {
int NGr, Indexable = 0; int NGr, Indexable = 0;
CODEADDR indx_out = NIL; CODEADDR indx_out = NIL;
log_update = 0; log_update = 0;
if (setjmp(_YAP_CompilerBotch) == 3) { if (setjmp(Yap_CompilerBotch) == 3) {
/* just duplicate the stack */ /* just duplicate the stack */
restore_machine_regs(); restore_machine_regs();
_YAP_gc(ap->ArityOfPE, ENV, CP); Yap_gc(ap->ArityOfPE, ENV, CP);
} }
restart_index: restart_index:
_YAP_ErrorMessage = NULL; Yap_ErrorMessage = NULL;
labelno = 1; labelno = 1;
RemovedCl = FALSE; RemovedCl = FALSE;
FirstCl = (yamop *)(ap->FirstClause); FirstCl = (yamop *)(ap->FirstClause);
@ -1351,7 +1351,7 @@ _YAP_PredIsIndexable(PredEntry *ap)
Entries = (EntryDef *) (Groups + NGroups); Entries = (EntryDef *) (Groups + NGroups);
CodeStart = cpc = NIL; CodeStart = cpc = NIL;
freep = (char *) (ArOfCl + NClauses); freep = (char *) (ArOfCl + NClauses);
if (_YAP_ErrorMessage != NULL) { if (Yap_ErrorMessage != NULL) {
return (NIL); return (NIL);
} }
if (CurrentPred->PredFlags & LogUpdatePredFlag) { if (CurrentPred->PredFlags & LogUpdatePredFlag) {
@ -1370,7 +1370,7 @@ _YAP_PredIsIndexable(PredEntry *ap)
Indexable = SpecialCases(); Indexable = SpecialCases();
} }
if (CellPtr(freep) >= ASP) { if (CellPtr(freep) >= ASP) {
_YAP_Error(SYSTEM_ERROR, TermNil, "out of stack space while indexing"); Yap_Error(SYSTEM_ERROR, TermNil, "out of stack space while indexing");
return(NIL); return(NIL);
} }
if (log_update && NClauses > 1) { if (log_update && NClauses > 1) {
@ -1378,8 +1378,8 @@ _YAP_PredIsIndexable(PredEntry *ap)
Clause *cl; Clause *cl;
Indexable = TRUE; Indexable = TRUE;
_YAP_emit(label_op, log_update, Zero); Yap_emit(label_op, log_update, Zero);
_YAP_emit(try_op, Unsigned(Body(ArOfCl[0].Code)), Zero); Yap_emit(try_op, Unsigned(Body(ArOfCl[0].Code)), Zero);
cl = ClauseCodeToClause(ArOfCl[0].Code); cl = ClauseCodeToClause(ArOfCl[0].Code);
if (cl->ClFlags & LogUpdRuleMask) { if (cl->ClFlags & LogUpdRuleMask) {
cl->u2.ClExt->u.EC.ClRefs++; cl->u2.ClExt->u.EC.ClRefs++;
@ -1387,7 +1387,7 @@ _YAP_PredIsIndexable(PredEntry *ap)
cl->u2.ClUse++; cl->u2.ClUse++;
} }
for (i = 1; i < NClauses-1; i++) { for (i = 1; i < NClauses-1; i++) {
_YAP_emit(retry_op, Unsigned(Body(ArOfCl[i].Code)), Zero); Yap_emit(retry_op, Unsigned(Body(ArOfCl[i].Code)), Zero);
cl = ClauseCodeToClause(ArOfCl[0].Code); cl = ClauseCodeToClause(ArOfCl[0].Code);
if (cl->ClFlags & LogUpdRuleMask) { if (cl->ClFlags & LogUpdRuleMask) {
cl->u2.ClExt->u.EC.ClRefs++; cl->u2.ClExt->u.EC.ClRefs++;
@ -1395,7 +1395,7 @@ _YAP_PredIsIndexable(PredEntry *ap)
cl->u2.ClUse++; cl->u2.ClUse++;
} }
} }
_YAP_emit(trust_op, Unsigned(Body(ArOfCl[i].Code)), Zero); Yap_emit(trust_op, Unsigned(Body(ArOfCl[i].Code)), Zero);
cl = ClauseCodeToClause(ArOfCl[i].Code); cl = ClauseCodeToClause(ArOfCl[i].Code);
if (cl->ClFlags & LogUpdRuleMask) { if (cl->ClFlags & LogUpdRuleMask) {
cl->u2.ClExt->u.EC.ClRefs++; cl->u2.ClExt->u.EC.ClRefs++;
@ -1407,13 +1407,13 @@ _YAP_PredIsIndexable(PredEntry *ap)
return (NIL); return (NIL);
} else { } else {
#ifdef DEBUG #ifdef DEBUG
if (_YAP_Option['i' - 'a' + 1]) { if (Yap_Option['i' - 'a' + 1]) {
_YAP_ShowCode(); Yap_ShowCode();
} }
#endif #endif
if ((indx_out = _YAP_assemble(ASSEMBLING_INDEX)) == NIL) { if ((indx_out = Yap_assemble(ASSEMBLING_INDEX)) == NIL) {
if (!_YAP_growheap(FALSE)) { if (!Yap_growheap(FALSE)) {
_YAP_Error(SYSTEM_ERROR, TermNil, _YAP_ErrorMessage); Yap_Error(SYSTEM_ERROR, TermNil, Yap_ErrorMessage);
return(FALSE); return(FALSE);
} }
goto restart_index; goto restart_index;

544
C/init.c
View File

File diff suppressed because it is too large Load Diff

106
C/inlines.c
View File

@ -245,7 +245,7 @@ p_var(void)
static Int static Int
p_equal(void) p_equal(void)
{ /* ?=? */ { /* ?=? */
return(_YAP_IUnify(ARG1, ARG2)); return(Yap_IUnify(ARG1, ARG2));
} }
static Int static Int
@ -288,7 +288,7 @@ p_eq(void)
return(LongIntOfTerm(d0) == LongIntOfTerm(d1)); return(LongIntOfTerm(d0) == LongIntOfTerm(d1));
#ifdef USE_GMP #ifdef USE_GMP
case (CELL)FunctorBigInt: case (CELL)FunctorBigInt:
return (mpz_cmp(_YAP_BigIntOfTerm(d0), _YAP_BigIntOfTerm(d1)) == 0); return (mpz_cmp(Yap_BigIntOfTerm(d0), Yap_BigIntOfTerm(d1)) == 0);
#endif #endif
case (CELL)FunctorDouble: case (CELL)FunctorDouble:
return(FloatOfTerm(d0) == FloatOfTerm(d1)); return(FloatOfTerm(d0) == FloatOfTerm(d1));
@ -362,7 +362,7 @@ p_dif(void)
* woken goals that should be ok, but otherwise we need * woken goals that should be ok, but otherwise we need
* to restore WokenGoals to its previous value. * to restore WokenGoals to its previous value.
*/ */
CELL OldWokenGoals = _YAP_ReadTimedVar(WokenGoals); CELL OldWokenGoals = Yap_ReadTimedVar(WokenGoals);
#endif #endif
/* We will have to look inside compound terms */ /* We will have to look inside compound terms */
@ -377,7 +377,7 @@ p_dif(void)
HBREG = H; HBREG = H;
B = (choiceptr) H; B = (choiceptr) H;
save_hb(); save_hb();
if (_YAP_IUnify(d0, d1) == TRUE) { if (Yap_IUnify(d0, d1) == TRUE) {
/* restore B, no need to restore HB */ /* restore B, no need to restore HB */
B = pt1; B = pt1;
return(FALSE); return(FALSE);
@ -386,7 +386,7 @@ p_dif(void)
/* restore B, and later HB */ /* restore B, and later HB */
ENDCHO(pt1); ENDCHO(pt1);
BEGP(pt1); BEGP(pt1);
/* untrail all bindings made by _YAP_IUnify */ /* untrail all bindings made by Yap_IUnify */
while (TR != (tr_fr_ptr)pt0) { while (TR != (tr_fr_ptr)pt0) {
pt1 = (CELL *) TrailTerm(--TR); pt1 = (CELL *) TrailTerm(--TR);
RESET_VARIABLE(pt1); RESET_VARIABLE(pt1);
@ -396,7 +396,7 @@ p_dif(void)
} }
#ifdef COROUTINING #ifdef COROUTINING
/* now restore Woken Goals to its old value */ /* now restore Woken Goals to its old value */
_YAP_UpdateTimedVar(WokenGoals, OldWokenGoals); Yap_UpdateTimedVar(WokenGoals, OldWokenGoals);
#endif #endif
return(TRUE); return(TRUE);
ENDP(pt0); ENDP(pt0);
@ -432,7 +432,7 @@ p_arg(void)
else if (IsLongIntTerm(d0)) { else if (IsLongIntTerm(d0)) {
d0 = LongIntOfTerm(d0); d0 = LongIntOfTerm(d0);
} else { } else {
_YAP_Error(TYPE_ERROR_INTEGER,d0,"arg 1 of arg/3"); Yap_Error(TYPE_ERROR_INTEGER,d0,"arg 1 of arg/3");
return(FALSE); return(FALSE);
} }
@ -453,10 +453,10 @@ p_arg(void)
save_hb(); save_hb();
if ((Int)d0 <= 0 || if ((Int)d0 <= 0 ||
(Int)d0 > ArityOfFunctor((Functor) d1) || (Int)d0 > ArityOfFunctor((Functor) d1) ||
_YAP_IUnify(pt0[d0], ARG3) == FALSE) { Yap_IUnify(pt0[d0], ARG3) == FALSE) {
/* don't complain here for Prolog compatibility /* don't complain here for Prolog compatibility
if ((Int)d0 <= 0) { if ((Int)d0 <= 0) {
_YAP_Error(DOMAIN_ERROR_NOT_LESS_THAN_ZERO, Yap_Error(DOMAIN_ERROR_NOT_LESS_THAN_ZERO,
MkIntegerTerm(d0),"arg 1 of arg/3"); MkIntegerTerm(d0),"arg 1 of arg/3");
} }
*/ */
@ -470,41 +470,41 @@ p_arg(void)
pt0 = RepPair(d1); pt0 = RepPair(d1);
if (d0 == 1) { if (d0 == 1) {
save_hb(); save_hb();
if (_YAP_IUnify((CELL)pt0, ARG3) == FALSE) { if (Yap_IUnify((CELL)pt0, ARG3) == FALSE) {
return(FALSE); return(FALSE);
} }
return(TRUE); return(TRUE);
} }
else if (d0 == 2) { else if (d0 == 2) {
save_hb(); save_hb();
if (_YAP_IUnify((CELL)(pt0+1), ARG3) == FALSE) { if (Yap_IUnify((CELL)(pt0+1), ARG3) == FALSE) {
return(FALSE); return(FALSE);
} }
return(TRUE); return(TRUE);
} }
else { else {
if ((Int)d0 < 0) if ((Int)d0 < 0)
_YAP_Error(DOMAIN_ERROR_NOT_LESS_THAN_ZERO, Yap_Error(DOMAIN_ERROR_NOT_LESS_THAN_ZERO,
MkIntegerTerm(d0),"arg 1 of arg/3"); MkIntegerTerm(d0),"arg 1 of arg/3");
return(FALSE); return(FALSE);
} }
ENDP(pt0); ENDP(pt0);
} }
else { else {
_YAP_Error(TYPE_ERROR_COMPOUND, d1, "arg 2 of arg/3"); Yap_Error(TYPE_ERROR_COMPOUND, d1, "arg 2 of arg/3");
return(FALSE); return(FALSE);
} }
BEGP(pt0); BEGP(pt0);
deref_body(d1, pt0, arg_arg2_unk, arg_arg2_nvar); deref_body(d1, pt0, arg_arg2_unk, arg_arg2_nvar);
_YAP_Error(INSTANTIATION_ERROR,(CELL)pt0,"arg 2 of arg/3");; Yap_Error(INSTANTIATION_ERROR,(CELL)pt0,"arg 2 of arg/3");;
ENDP(pt0); ENDP(pt0);
return(FALSE); return(FALSE);
ENDD(d1); ENDD(d1);
BEGP(pt0); BEGP(pt0);
deref_body(d0, pt0, arg_arg1_unk, arg_arg1_nvar); deref_body(d0, pt0, arg_arg1_unk, arg_arg1_nvar);
_YAP_Error(INSTANTIATION_ERROR,(CELL)pt0,"arg 1 of arg/3");; Yap_Error(INSTANTIATION_ERROR,(CELL)pt0,"arg 1 of arg/3");;
ENDP(pt0); ENDP(pt0);
return(FALSE); return(FALSE);
ENDD(d0); ENDD(d0);
@ -571,7 +571,7 @@ p_functor(void) /* functor(?,?,?) */
BIND(pt0, d0, bind_func_nvar_var); BIND(pt0, d0, bind_func_nvar_var);
#ifdef COROUTINING #ifdef COROUTINING
DO_TRAIL(pt0, d0); DO_TRAIL(pt0, d0);
if (pt0 < H0) _YAP_WakeUp(pt0); if (pt0 < H0) Yap_WakeUp(pt0);
bind_func_nvar_var: bind_func_nvar_var:
#endif #endif
/* have to buffer ENDP and label */ /* have to buffer ENDP and label */
@ -598,7 +598,7 @@ p_functor(void) /* functor(?,?,?) */
/* Done */ /* Done */
#ifdef COROUTINING #ifdef COROUTINING
DO_TRAIL(pt0, d0); DO_TRAIL(pt0, d0);
if (pt0 < H0) _YAP_WakeUp(pt0); if (pt0 < H0) Yap_WakeUp(pt0);
bind_func_nvar3_var: bind_func_nvar3_var:
#endif #endif
return(TRUE); return(TRUE);
@ -624,11 +624,11 @@ p_functor(void) /* functor(?,?,?) */
if (IsIntTerm(d1)) if (IsIntTerm(d1))
d1 = IntOfTerm(d1); d1 = IntOfTerm(d1);
else { else {
_YAP_Error(TYPE_ERROR_INTEGER,ARG3,"functor/3"); Yap_Error(TYPE_ERROR_INTEGER,ARG3,"functor/3");
return(FALSE); return(FALSE);
} }
if (!IsAtomicTerm(d0)) { if (!IsAtomicTerm(d0)) {
_YAP_Error(TYPE_ERROR_ATOMIC,d0,"functor/3"); Yap_Error(TYPE_ERROR_ATOMIC,d0,"functor/3");
return(FALSE); return(FALSE);
} }
/* We made it!!!!! we got in d0 the name, in d1 the arity and /* We made it!!!!! we got in d0 the name, in d1 the arity and
@ -642,7 +642,7 @@ p_functor(void) /* functor(?,?,?) */
else if ((Int)d1 > 0) { else if ((Int)d1 > 0) {
/* now let's build a compound term */ /* now let's build a compound term */
if (!IsAtomTerm(d0)) { if (!IsAtomTerm(d0)) {
_YAP_Error(TYPE_ERROR_ATOM,d0,"functor/3"); Yap_Error(TYPE_ERROR_ATOM,d0,"functor/3");
return(FALSE); return(FALSE);
} }
BEGP(pt1); BEGP(pt1);
@ -650,13 +650,13 @@ p_functor(void) /* functor(?,?,?) */
return(FALSE); return(FALSE);
} }
else else
d0 = (CELL) _YAP_MkFunctor(AtomOfTerm(d0), (Int) d1); d0 = (CELL) Yap_MkFunctor(AtomOfTerm(d0), (Int) d1);
pt1 = H; pt1 = H;
*pt1++ = d0; *pt1++ = d0;
d0 = AbsAppl(H); d0 = AbsAppl(H);
if (pt1+d1 > ENV - CreepFlag) { if (pt1+d1 > ENV - CreepFlag) {
if (!_YAP_gc(3, ENV, P)) { if (!Yap_gc(3, ENV, P)) {
_YAP_Error(OUT_OF_STACK_ERROR, TermNil, _YAP_ErrorMessage); Yap_Error(OUT_OF_STACK_ERROR, TermNil, Yap_ErrorMessage);
return(FALSE); return(FALSE);
} }
goto restart; goto restart;
@ -669,7 +669,7 @@ p_functor(void) /* functor(?,?,?) */
H = pt1; H = pt1;
ENDP(pt1); ENDP(pt1);
} else if ((Int)d1 < 0) { } else if ((Int)d1 < 0) {
_YAP_Error(DOMAIN_ERROR_NOT_LESS_THAN_ZERO,MkIntegerTerm(d1),"functor/3"); Yap_Error(DOMAIN_ERROR_NOT_LESS_THAN_ZERO,MkIntegerTerm(d1),"functor/3");
return(FALSE); return(FALSE);
} }
/* else if arity is 0 just pass d0 through */ /* else if arity is 0 just pass d0 through */
@ -677,7 +677,7 @@ p_functor(void) /* functor(?,?,?) */
BIND(pt0, d0, bind_func_var_3nvar); BIND(pt0, d0, bind_func_var_3nvar);
#ifdef COROUTINING #ifdef COROUTINING
DO_TRAIL(pt0, d0); DO_TRAIL(pt0, d0);
if (pt0 < H0) _YAP_WakeUp(pt0); if (pt0 < H0) Yap_WakeUp(pt0);
bind_func_var_3nvar: bind_func_var_3nvar:
#endif #endif
return(TRUE); return(TRUE);
@ -685,7 +685,7 @@ p_functor(void) /* functor(?,?,?) */
BEGP(pt1); BEGP(pt1);
deref_body(d1, pt1, func_var_3unk, func_var_3nvar); deref_body(d1, pt1, func_var_3unk, func_var_3nvar);
_YAP_Error(INSTANTIATION_ERROR,(CELL)pt1,"functor/3"); Yap_Error(INSTANTIATION_ERROR,(CELL)pt1,"functor/3");
ENDP(pt1); ENDP(pt1);
/* Oops, third argument was unbound */ /* Oops, third argument was unbound */
return(FALSE); return(FALSE);
@ -694,7 +694,7 @@ p_functor(void) /* functor(?,?,?) */
BEGP(pt1); BEGP(pt1);
deref_body(d0, pt1, func_var_2unk, func_var_2nvar); deref_body(d0, pt1, func_var_2unk, func_var_2nvar);
_YAP_Error(INSTANTIATION_ERROR,(CELL)pt1,"functor/3"); Yap_Error(INSTANTIATION_ERROR,(CELL)pt1,"functor/3");
ENDP(pt1); ENDP(pt1);
/* Oops, second argument was unbound too */ /* Oops, second argument was unbound too */
return(FALSE); return(FALSE);
@ -751,37 +751,37 @@ p_cut_by( void)
static Int static Int
p_erroneous_call(void) p_erroneous_call(void)
{ {
_YAP_Error(SYSTEM_ERROR, TermNil, "bad call to internal built-in"); Yap_Error(SYSTEM_ERROR, TermNil, "bad call to internal built-in");
return(FALSE); return(FALSE);
} }
void void
_YAP_InitInlines(void) Yap_InitInlines(void)
{ {
_YAP_InitAsmPred("$$cut_by", 1, _cut_by, p_cut_by, SafePredFlag); Yap_InitAsmPred("$$cut_by", 1, _cut_by, p_cut_by, SafePredFlag);
_YAP_InitAsmPred("atom", 1, _atom, p_atom, SafePredFlag); Yap_InitAsmPred("atom", 1, _atom, p_atom, SafePredFlag);
_YAP_InitAsmPred("atomic", 1, _atomic, p_atomic, SafePredFlag); Yap_InitAsmPred("atomic", 1, _atomic, p_atomic, SafePredFlag);
_YAP_InitAsmPred("integer", 1, _integer, p_integer, SafePredFlag); Yap_InitAsmPred("integer", 1, _integer, p_integer, SafePredFlag);
_YAP_InitAsmPred("nonvar", 1, _nonvar, p_nonvar, SafePredFlag); Yap_InitAsmPred("nonvar", 1, _nonvar, p_nonvar, SafePredFlag);
_YAP_InitAsmPred("number", 1, _number, p_number, SafePredFlag); Yap_InitAsmPred("number", 1, _number, p_number, SafePredFlag);
_YAP_InitAsmPred("var", 1, _var, p_var, SafePredFlag); Yap_InitAsmPred("var", 1, _var, p_var, SafePredFlag);
_YAP_InitAsmPred("db_reference", 1, _db_ref, p_db_ref, SafePredFlag); Yap_InitAsmPred("db_reference", 1, _db_ref, p_db_ref, SafePredFlag);
_YAP_InitAsmPred("primitive", 1, _primitive, p_primitive, SafePredFlag); Yap_InitAsmPred("primitive", 1, _primitive, p_primitive, SafePredFlag);
_YAP_InitAsmPred("compound", 1, _compound, p_compound, SafePredFlag); Yap_InitAsmPred("compound", 1, _compound, p_compound, SafePredFlag);
_YAP_InitAsmPred("float", 1, _float, p_float, SafePredFlag); Yap_InitAsmPred("float", 1, _float, p_float, SafePredFlag);
_YAP_InitAsmPred("=", 2, _equal, p_equal, SafePredFlag); Yap_InitAsmPred("=", 2, _equal, p_equal, SafePredFlag);
_YAP_InitAsmPred("\\=", 2, _dif, p_dif, SafePredFlag); Yap_InitAsmPred("\\=", 2, _dif, p_dif, SafePredFlag);
_YAP_InitAsmPred("==", 2, _eq, p_eq, SafePredFlag); Yap_InitAsmPred("==", 2, _eq, p_eq, SafePredFlag);
_YAP_InitAsmPred("arg", 3, _arg, p_arg, SafePredFlag); Yap_InitAsmPred("arg", 3, _arg, p_arg, SafePredFlag);
_YAP_InitAsmPred("functor", 3, _functor, p_functor, SafePredFlag); Yap_InitAsmPred("functor", 3, _functor, p_functor, SafePredFlag);
_YAP_InitAsmPred("$plus", 3, _plus, p_erroneous_call, SafePredFlag); Yap_InitAsmPred("$plus", 3, _plus, p_erroneous_call, SafePredFlag);
_YAP_InitAsmPred("$minus", 3, _minus, p_erroneous_call, SafePredFlag); Yap_InitAsmPred("$minus", 3, _minus, p_erroneous_call, SafePredFlag);
_YAP_InitAsmPred("$times", 3, _times, p_erroneous_call, SafePredFlag); Yap_InitAsmPred("$times", 3, _times, p_erroneous_call, SafePredFlag);
_YAP_InitAsmPred("$div", 3, _div, p_erroneous_call, SafePredFlag); Yap_InitAsmPred("$div", 3, _div, p_erroneous_call, SafePredFlag);
_YAP_InitAsmPred("$and", 3, _and, p_erroneous_call, SafePredFlag); Yap_InitAsmPred("$and", 3, _and, p_erroneous_call, SafePredFlag);
_YAP_InitAsmPred("$or", 3, _or, p_erroneous_call, SafePredFlag); Yap_InitAsmPred("$or", 3, _or, p_erroneous_call, SafePredFlag);
_YAP_InitAsmPred("$sll", 3, _sll, p_erroneous_call, SafePredFlag); Yap_InitAsmPred("$sll", 3, _sll, p_erroneous_call, SafePredFlag);
_YAP_InitAsmPred("$slr", 3, _slr, p_erroneous_call, SafePredFlag); Yap_InitAsmPred("$slr", 3, _slr, p_erroneous_call, SafePredFlag);
} }

1212
C/iopreds.c
View File

File diff suppressed because it is too large Load Diff

18
C/load_aix.c
View File

@ -27,7 +27,7 @@
* locate the executable of Yap * locate the executable of Yap
*/ */
void void
_YAP_FindExecutable(char *name) Yap_FindExecutable(char *name)
{ {
} }
@ -45,35 +45,35 @@ LoadForeign(StringList ofiles, StringList libs,
/* load wants to follow the LIBRARY_PATH */ /* load wants to follow the LIBRARY_PATH */
if (ofiles->next != NULL || libs != NULL) { if (ofiles->next != NULL || libs != NULL) {
strcpy(_YAP_ErrorSay," Load Failed: in AIX you must load a single object file"); strcpy(Yap_ErrorSay," Load Failed: in AIX you must load a single object file");
return LOAD_FAILLED; return LOAD_FAILLED;
} }
if (!_YAP_TrueFileName(ofiles->s, _YAP_FileNameBuf, TRUE)) { if (!Yap_TrueFileName(ofiles->s, Yap_FileNameBuf, TRUE)) {
strcpy(_YAP_ErrorSay, " Trying to open unexisting file in LoadForeign "); strcpy(Yap_ErrorSay, " Trying to open unexisting file in LoadForeign ");
return LOAD_FAILLED; return LOAD_FAILLED;
} }
/* In AIX, just call load and everything will go in */ /* In AIX, just call load and everything will go in */
if ((*init_proc=((YapInitProc *)load(_YAP_FileNameBuf,0,NULL))) == NULL) { if ((*init_proc=((YapInitProc *)load(Yap_FileNameBuf,0,NULL))) == NULL) {
strcpy(_YAP_ErrorSay,sys_errlist[errno]); strcpy(Yap_ErrorSay,sys_errlist[errno]);
return LOAD_FAILLED; return LOAD_FAILLED;
} }
return LOAD_SUCCEEDED; return LOAD_SUCCEEDED;
} }
Int Int
_YAP_LoadForeign(StringList ofiles, StringList libs, Yap_LoadForeign(StringList ofiles, StringList libs,
char *proc_name, YapInitProc *init_proc) char *proc_name, YapInitProc *init_proc)
{ {
return LoadForeign(ofiles, libs, proc_name, init_proc); return LoadForeign(ofiles, libs, proc_name, init_proc);
} }
void void
_YAP_ShutdownLoadForeign(void) Yap_ShutdownLoadForeign(void)
{ {
} }
Int Int
_YAP_ReLoadForeign(StringList ofiles, StringList libs, Yap_ReLoadForeign(StringList ofiles, StringList libs,
char *proc_name, YapInitProc *init_proc) char *proc_name, YapInitProc *init_proc)
{ {
return(LoadForeign(ofiles,libs, proc_name, init_proc)); return(LoadForeign(ofiles,libs, proc_name, init_proc));

50
C/load_aout.c
View File

@ -55,7 +55,7 @@ static char YapExecutable[YAP_FILE_MAX];
* locate the executable of Yap * locate the executable of Yap
*/ */
void void
_YAP_FindExecutable(char *name) Yap_FindExecutable(char *name)
{ {
register char *cp, *cp2; register char *cp, *cp2;
struct stat stbuf; struct stat stbuf;
@ -64,10 +64,10 @@ _YAP_FindExecutable(char *name)
cp = (char *)getenv("PATH"); cp = (char *)getenv("PATH");
if (cp == NULL) if (cp == NULL)
cp = ".:/usr/ucb:/bin:/usr/bin:/usr/local/bin"; cp = ".:/usr/ucb:/bin:/usr/bin:/usr/local/bin";
if (*_YAP_argv[0] == '/') { if (*Yap_argv[0] == '/') {
if (oktox(_YAP_argv[0])) { if (oktox(Yap_argv[0])) {
strcpy(_YAP_FileNameBuf, _YAP_argv[0]); strcpy(Yap_FileNameBuf, Yap_argv[0]);
_YAP_TrueFileName(_YAP_FileNameBuf, YapExecutable, TRUE); Yap_TrueFileName(Yap_FileNameBuf, YapExecutable, TRUE);
return; return;
} }
} }
@ -79,24 +79,24 @@ _YAP_FindExecutable(char *name)
* argv[0] * argv[0]
*/ */
for (cp2 = _YAP_FileNameBuf; (*cp) != 0 && (*cp) != ':';) for (cp2 = Yap_FileNameBuf; (*cp) != 0 && (*cp) != ':';)
*cp2++ = *cp++; *cp2++ = *cp++;
*cp2++ = '/'; *cp2++ = '/';
strcpy(cp2, _YAP_argv[0]); strcpy(cp2, Yap_argv[0]);
if (*cp) if (*cp)
cp++; cp++;
if (!oktox(_YAP_FileNameBuf)) if (!oktox(Yap_FileNameBuf))
continue; continue;
_YAP_TrueFileName(_YAP_FileNameBuf, YapExecutable, TRUE); Yap_TrueFileName(Yap_FileNameBuf, YapExecutable, TRUE);
return; return;
} }
/* one last try for dual systems */ /* one last try for dual systems */
strcpy(_YAP_FileNameBuf, _YAP_argv[0]); strcpy(Yap_FileNameBuf, Yap_argv[0]);
_YAP_TrueFileName(_YAP_FileNameBuf, YapExecutable, TRUE); Yap_TrueFileName(Yap_FileNameBuf, YapExecutable, TRUE);
if (oktox(YapExecutable)) if (oktox(YapExecutable))
return; return;
else else
_YAP_Error(SYSTEM_ERROR,MkAtomTerm(_YAP_LookupAtom(YapExecutable)), Yap_Error(SYSTEM_ERROR,MkAtomTerm(Yap_LookupAtom(YapExecutable)),
"cannot find file being executed"); "cannot find file being executed");
} }
@ -156,7 +156,7 @@ LoadForeign(StringList ofiles,
/* prepare the magic */ /* prepare the magic */
if (strlen(o_files) + strlen(l_files) + strlen(proc_name) + if (strlen(o_files) + strlen(l_files) + strlen(proc_name) +
strlen(YapExecutable) > 2*MAXPATHLEN) { strlen(YapExecutable) > 2*MAXPATHLEN) {
strcpy(_YAP_ErrorSay, " too many parameters in load_foreign/3 "); strcpy(Yap_ErrorSay, " too many parameters in load_foreign/3 ");
return LOAD_FAILLED; return LOAD_FAILLED;
} }
sprintf(command, "/usr/bin/ld -N -A %s -o %s -u _%s %s %s -lc", sprintf(command, "/usr/bin/ld -N -A %s -o %s -u _%s %s %s -lc",
@ -165,12 +165,12 @@ LoadForeign(StringList ofiles,
/* now, do the magic */ /* now, do the magic */
if (system(command) != 0) { if (system(command) != 0) {
unlink(tfile); unlink(tfile);
strcpy(_YAP_ErrorSay," ld returned error status in load_foreign_files "); strcpy(Yap_ErrorSay," ld returned error status in load_foreign_files ");
return LOAD_FAILLED; return LOAD_FAILLED;
} }
/* now check the music has played */ /* now check the music has played */
if ((fildes = open(tfile, O_RDONLY)) < 0) { if ((fildes = open(tfile, O_RDONLY)) < 0) {
strcpy(_YAP_ErrorSay," unable to open temp file in load_foreign_files "); strcpy(Yap_ErrorSay," unable to open temp file in load_foreign_files ");
return LOAD_FAILLED; return LOAD_FAILLED;
} }
/* it did, get the mice */ /* it did, get the mice */
@ -184,8 +184,8 @@ LoadForeign(StringList ofiles,
/* keep this copy */ /* keep this copy */
firstloadImSz = loadImageSize; firstloadImSz = loadImageSize;
/* now fetch the space we need */ /* now fetch the space we need */
if (!(FCodeBase = _YAP_AllocCodeSpace((int) loadImageSize))) { if (!(FCodeBase = Yap_AllocCodeSpace((int) loadImageSize))) {
strcpy(_YAP_ErrorSay," unable to allocate space for external code "); strcpy(Yap_ErrorSay," unable to allocate space for external code ");
return LOAD_FAILLED; return LOAD_FAILLED;
} }
/* now, a new incantation to load the new foreign code */ /* now, a new incantation to load the new foreign code */
@ -196,17 +196,17 @@ LoadForeign(StringList ofiles,
/* and do it */ /* and do it */
if (system(command) != 0) { if (system(command) != 0) {
unlink(tfile); unlink(tfile);
strcpy(_YAP_ErrorSay," ld returned error status in load_foreign_files "); strcpy(Yap_ErrorSay," ld returned error status in load_foreign_files ");
return LOAD_FAILLED; return LOAD_FAILLED;
} }
if ((fildes = open(tfile, O_RDONLY)) < 0) { if ((fildes = open(tfile, O_RDONLY)) < 0) {
strcpy(_YAP_ErrorSay," unable to open temp file in load_foreign_files "); strcpy(Yap_ErrorSay," unable to open temp file in load_foreign_files ");
return LOAD_FAILLED; return LOAD_FAILLED;
} }
read(fildes, (char *) &header, sizeof(header)); read(fildes, (char *) &header, sizeof(header));
loadImageSize = header.a_text + header.a_data + header.a_bss; loadImageSize = header.a_text + header.a_data + header.a_bss;
if (firstloadImSz < loadImageSize) { if (firstloadImSz < loadImageSize) {
strcpy(_YAP_ErrorSay," miscalculation in load_foreign/3 "); strcpy(Yap_ErrorSay," miscalculation in load_foreign/3 ");
return LOAD_FAILLED; return LOAD_FAILLED;
} }
/* now search for our init function */ /* now search for our init function */
@ -217,11 +217,11 @@ LoadForeign(StringList ofiles,
func_info[0].n_un.n_name = entry_fun; func_info[0].n_un.n_name = entry_fun;
func_info[1].n_un.n_name = NULL; func_info[1].n_un.n_name = NULL;
if (nlist(tfile, func_info) == -1) { if (nlist(tfile, func_info) == -1) {
strcpy(_YAP_ErrorSay," in nlist(3) "); strcpy(Yap_ErrorSay," in nlist(3) ");
return LOAD_FAILLED; return LOAD_FAILLED;
} }
if (func_info[0].n_type == 0) { if (func_info[0].n_type == 0) {
strcpy(_YAP_ErrorSay," in nlist(3) "); strcpy(Yap_ErrorSay," in nlist(3) ");
return LOAD_FAILLED; return LOAD_FAILLED;
} }
*init_proc = (YapInitProc)(func_info[0].n_value); *init_proc = (YapInitProc)(func_info[0].n_value);
@ -242,19 +242,19 @@ LoadForeign(StringList ofiles,
} }
Int Int
_YAP_LoadForeign(StringList ofiles, StringList libs, Yap_LoadForeign(StringList ofiles, StringList libs,
char *proc_name, YapInitProc *init_proc) char *proc_name, YapInitProc *init_proc)
{ {
return LoadForeign(ofiles, libs, proc_name, init_proc); return LoadForeign(ofiles, libs, proc_name, init_proc);
} }
void void
_YAP_ShutdownLoadForeign(void) Yap_ShutdownLoadForeign(void)
{ {
} }
Int Int
_YAP_ReLoadForeign(StringList ofiles, StringList libs, Yap_ReLoadForeign(StringList ofiles, StringList libs,
char *proc_name, YapInitProc *init_proc) char *proc_name, YapInitProc *init_proc)
{ {
return(LoadForeign(ofiles,libs, proc_name, init_proc)); return(LoadForeign(ofiles,libs, proc_name, init_proc));

52
C/load_coff.c
View File

@ -53,7 +53,7 @@ static char YapExecutable[YAP_FILE_MAX];
* locate the executable of Yap * locate the executable of Yap
*/ */
void void
_YAP_FindExecutable(char *name) Yap_FindExecutable(char *name)
{ {
register char *cp, *cp2; register char *cp, *cp2;
struct stat stbuf; struct stat stbuf;
@ -62,10 +62,10 @@ _YAP_FindExecutable(char *name)
cp = (char *)getenv("PATH"); cp = (char *)getenv("PATH");
if (cp == NULL) if (cp == NULL)
cp = ".:/usr/ucb:/bin:/usr/bin:/usr/local/bin"; cp = ".:/usr/ucb:/bin:/usr/bin:/usr/local/bin";
if (*_YAP_argv[0] == '/') { if (*Yap_argv[0] == '/') {
if (oktox(_YAP_argv[0])) { if (oktox(Yap_argv[0])) {
strcpy(_YAP_FileNameBuf, _YAP_argv[0]); strcpy(Yap_FileNameBuf, Yap_argv[0]);
_YAP_TrueFileName(_YAP_FileNameBuf, YapExecutable, TRUE); Yap_TrueFileName(Yap_FileNameBuf, YapExecutable, TRUE);
return; return;
} }
} }
@ -77,24 +77,24 @@ _YAP_FindExecutable(char *name)
* argv[0] * argv[0]
*/ */
for (cp2 = _YAP_FileNameBuf; (*cp) != 0 && (*cp) != ':';) for (cp2 = Yap_FileNameBuf; (*cp) != 0 && (*cp) != ':';)
*cp2++ = *cp++; *cp2++ = *cp++;
*cp2++ = '/'; *cp2++ = '/';
strcpy(cp2, _YAP_argv[0]); strcpy(cp2, Yap_argv[0]);
if (*cp) if (*cp)
cp++; cp++;
if (!oktox(_YAP_FileNameBuf)) if (!oktox(Yap_FileNameBuf))
continue; continue;
_YAP_TrueFileName(_YAP_FileNameBuf, YapExecutable, TRUE); Yap_TrueFileName(Yap_FileNameBuf, YapExecutable, TRUE);
return; return;
} }
/* one last try for dual systems */ /* one last try for dual systems */
strcpy(_YAP_FileNameBuf, _YAP_argv[0]); strcpy(Yap_FileNameBuf, Yap_argv[0]);
_YAP_TrueFileName(_YAP_FileNameBuf, YapExecutable, TRUE); Yap_TrueFileName(Yap_FileNameBuf, YapExecutable, TRUE);
if (oktox(YapExecutable)) if (oktox(YapExecutable))
return; return;
else else
_YAP_Error(SYSTEM_ERROR,MkAtomTerm(_YAP_LookupAtom(YapExecutable)), Yap_Error(SYSTEM_ERROR,MkAtomTerm(Yap_LookupAtom(YapExecutable)),
"cannot find file being executed"); "cannot find file being executed");
} }
@ -157,7 +157,7 @@ LoadForeign(StringList ofiles,
/* prepare the magic */ /* prepare the magic */
if (strlen(o_files) + strlen(l_files) + strlen(proc_name) + if (strlen(o_files) + strlen(l_files) + strlen(proc_name) +
strlen(YapExecutable) > 2*MAXPATHLEN) { strlen(YapExecutable) > 2*MAXPATHLEN) {
strcpy(_YAP_ErrorSay, " too many parameters in load_foreign/3 "); strcpy(Yap_ErrorSay, " too many parameters in load_foreign/3 ");
return LOAD_FAILLED; return LOAD_FAILLED;
} }
sprintf(command, "/usr/bin/ld -N -A %s -o %s %s %s -lc", sprintf(command, "/usr/bin/ld -N -A %s -o %s %s %s -lc",
@ -166,12 +166,12 @@ LoadForeign(StringList ofiles,
/* now, do the magic */ /* now, do the magic */
if (system(command) != 0) { if (system(command) != 0) {
unlink(tfile); unlink(tfile);
strcpy(_YAP_ErrorSay," ld returned error status in load_foreign_files "); strcpy(Yap_ErrorSay," ld returned error status in load_foreign_files ");
return LOAD_FAILLED; return LOAD_FAILLED;
} }
/* now check the music has played */ /* now check the music has played */
if ((fildes = open(tfile, O_RDONLY)) < 0) { if ((fildes = open(tfile, O_RDONLY)) < 0) {
strcpy(_YAP_ErrorSay," unable to open temp file in load_foreign_files "); strcpy(Yap_ErrorSay," unable to open temp file in load_foreign_files ");
return LOAD_FAILLED; return LOAD_FAILLED;
} }
/* it did, get the mice */ /* it did, get the mice */
@ -196,12 +196,12 @@ LoadForeign(StringList ofiles,
/* keep this copy */ /* keep this copy */
firstloadImSz = loadImageSize; firstloadImSz = loadImageSize;
/* now fetch the space we need */ /* now fetch the space we need */
if (!(FCodeBase = _YAP_AllocCodeSpace((int) loadImageSize)) if (!(FCodeBase = Yap_AllocCodeSpace((int) loadImageSize))
#ifdef pyr #ifdef pyr
|| activate_code(ForeignCodeBase, u1) || activate_code(ForeignCodeBase, u1)
#endif /* pyr */ #endif /* pyr */
) { ) {
strcpy(_YAP_ErrorSay," unable to allocate space for external code "); strcpy(Yap_ErrorSay," unable to allocate space for external code ");
return LOAD_FAILLED; return LOAD_FAILLED;
} }
#ifdef mips #ifdef mips
@ -215,7 +215,7 @@ LoadForeign(StringList ofiles,
sprintf(command, "ld -x -A %s -T %lx -o %s -u %s %s %s -lc", sprintf(command, "ld -x -A %s -T %lx -o %s -u %s %s %s -lc",
ostabf, ostabf,
((unsigned long) (((unsigned long) (ForeignCodeBase)) & ((unsigned long) (((unsigned long) (ForeignCodeBase)) &
((unsigned long) (~_YAP_HeapBase)) ((unsigned long) (~Yap_HeapBase))
) )
), tfile, entry_point, o_files, l_files); ), tfile, entry_point, o_files, l_files);
#else #else
@ -234,11 +234,11 @@ LoadForeign(StringList ofiles,
/* and do it */ /* and do it */
if (system(command) != 0) { if (system(command) != 0) {
unlink(tfile); unlink(tfile);
strcpy(_YAP_ErrorSay," ld returned error status in load_foreign_files "); strcpy(Yap_ErrorSay," ld returned error status in load_foreign_files ");
return LOAD_FAILLED; return LOAD_FAILLED;
} }
if ((fildes = open(tfile, O_RDONLY)) < 0) { if ((fildes = open(tfile, O_RDONLY)) < 0) {
strcpy(_YAP_ErrorSay," unable to open temp file in load_foreign_files "); strcpy(Yap_ErrorSay," unable to open temp file in load_foreign_files ");
return LOAD_FAILLED; return LOAD_FAILLED;
} }
read(fildes, (char *) &fileHeader, sizeof(fileHeader)); read(fildes, (char *) &fileHeader, sizeof(fileHeader));
@ -250,7 +250,7 @@ LoadForeign(StringList ofiles,
} }
loadImageSize = sysHeader.tsize + sysHeader.dsize + sysHeader.bsize; loadImageSize = sysHeader.tsize + sysHeader.dsize + sysHeader.bsize;
if (firstloadImSz < loadImageSize) { if (firstloadImSz < loadImageSize) {
strcpy(_YAP_ErrorSay," miscalculation in load_foreign/3 "); strcpy(Yap_ErrorSay," miscalculation in load_foreign/3 ");
return LOAD_FAILLED; return LOAD_FAILLED;
} }
/* now search for our init function */ /* now search for our init function */
@ -266,11 +266,11 @@ LoadForeign(StringList ofiles,
func_info[0].n_name = entry_fun; func_info[0].n_name = entry_fun;
func_info[1].n_name = NULL; func_info[1].n_name = NULL;
if (nlist(tfile, func_info) == -1) { if (nlist(tfile, func_info) == -1) {
strcpy(_YAP_ErrorSay," in nlist(3) "); strcpy(Yap_ErrorSay," in nlist(3) ");
return LOAD_FAILLED; return LOAD_FAILLED;
} }
if (func_info[0].n_type == 0) { if (func_info[0].n_type == 0) {
strcpy(_YAP_ErrorSay," in nlist(3) "); strcpy(Yap_ErrorSay," in nlist(3) ");
return LOAD_FAILLED; return LOAD_FAILLED;
} }
*init_proc = (YapInitProc)(func_info[0].n_value); *init_proc = (YapInitProc)(func_info[0].n_value);
@ -291,19 +291,19 @@ LoadForeign(StringList ofiles,
} }
Int Int
_YAP_LoadForeign(StringList ofiles, StringList libs, Yap_LoadForeign(StringList ofiles, StringList libs,
char *proc_name, YapInitProc *init_proc) char *proc_name, YapInitProc *init_proc)
{ {
return LoadForeign(ofiles, libs, proc_name, init_proc); return LoadForeign(ofiles, libs, proc_name, init_proc);
} }
void void
_YAP_ShutdownLoadForeign(void) Yap_ShutdownLoadForeign(void)
{ {
} }
Int Int
_YAP_ReLoadForeign(StringList ofiles, StringList libs, Yap_ReLoadForeign(StringList ofiles, StringList libs,
char *proc_name, YapInitProc *init_proc) char *proc_name, YapInitProc *init_proc)
{ {
return(LoadForeign(ofiles,libs, proc_name, init_proc)); return(LoadForeign(ofiles,libs, proc_name, init_proc));

36
C/load_dl.c
View File

@ -30,7 +30,7 @@
* locate the executable of Yap * locate the executable of Yap
*/ */
void void
_YAP_FindExecutable(char *name) Yap_FindExecutable(char *name)
{ {
} }
@ -48,18 +48,18 @@ LoadForeign(StringList ofiles, StringList libs,
void *handle; void *handle;
/* dlopen wants to follow the LD_CONFIG_PATH */ /* dlopen wants to follow the LD_CONFIG_PATH */
if (!_YAP_TrueFileName(ofiles->s, _YAP_FileNameBuf, TRUE)) { if (!Yap_TrueFileName(ofiles->s, Yap_FileNameBuf, TRUE)) {
strcpy(_YAP_ErrorSay, "[ Trying to open unexisting file in LoadForeign ]"); strcpy(Yap_ErrorSay, "[ Trying to open unexisting file in LoadForeign ]");
return LOAD_FAILLED; return LOAD_FAILLED;
} }
#ifdef __osf__ #ifdef __osf__
if((handle=dlopen(_YAP_FileNameBuf,RTLD_LAZY)) == 0) if((handle=dlopen(Yap_FileNameBuf,RTLD_LAZY)) == 0)
#else #else
if((handle=dlopen(_YAP_FileNameBuf,RTLD_LAZY|RTLD_GLOBAL)) == 0) if((handle=dlopen(Yap_FileNameBuf,RTLD_LAZY|RTLD_GLOBAL)) == 0)
#endif #endif
{ {
fprintf(stderr,"dlopen of %s failed with error %s\n", _YAP_FileNameBuf, dlerror()); fprintf(stderr,"dlopen of %s failed with error %s\n", Yap_FileNameBuf, dlerror());
/* strcpy(_YAP_ErrorSay,dlerror());*/ /* strcpy(Yap_ErrorSay,dlerror());*/
return LOAD_FAILLED; return LOAD_FAILLED;
} }
@ -72,7 +72,7 @@ LoadForeign(StringList ofiles, StringList libs,
} }
if(! *init_proc) { if(! *init_proc) {
strcpy(_YAP_ErrorSay,"Could not locate initialization routine"); strcpy(Yap_ErrorSay,"Could not locate initialization routine");
return LOAD_FAILLED; return LOAD_FAILLED;
} }
@ -81,20 +81,20 @@ LoadForeign(StringList ofiles, StringList libs,
while (libs) { while (libs) {
if (libs->s[0] == '-') { if (libs->s[0] == '-') {
strcpy(_YAP_FileNameBuf,"lib"); strcpy(Yap_FileNameBuf,"lib");
strcat(_YAP_FileNameBuf,libs->s+2); strcat(Yap_FileNameBuf,libs->s+2);
strcat(_YAP_FileNameBuf,".so"); strcat(Yap_FileNameBuf,".so");
} else { } else {
strcpy(_YAP_FileNameBuf,libs->s); strcpy(Yap_FileNameBuf,libs->s);
} }
#ifdef __osf__ #ifdef __osf__
if((libs->handle=dlopen(_YAP_FileNameBuf,RTLD_LAZY)) == NULL) if((libs->handle=dlopen(Yap_FileNameBuf,RTLD_LAZY)) == NULL)
#else #else
if((libs->handle=dlopen(_YAP_FileNameBuf,RTLD_LAZY|RTLD_GLOBAL)) == NULL) if((libs->handle=dlopen(Yap_FileNameBuf,RTLD_LAZY|RTLD_GLOBAL)) == NULL)
#endif #endif
{ {
strcpy(_YAP_ErrorSay,dlerror()); strcpy(Yap_ErrorSay,dlerror());
return LOAD_FAILLED; return LOAD_FAILLED;
} }
libs = libs->next; libs = libs->next;
@ -103,14 +103,14 @@ LoadForeign(StringList ofiles, StringList libs,
} }
Int Int
_YAP_LoadForeign(StringList ofiles, StringList libs, Yap_LoadForeign(StringList ofiles, StringList libs,
char *proc_name, YapInitProc *init_proc) char *proc_name, YapInitProc *init_proc)
{ {
return LoadForeign(ofiles, libs, proc_name, init_proc); return LoadForeign(ofiles, libs, proc_name, init_proc);
} }
void void
_YAP_ShutdownLoadForeign(void) Yap_ShutdownLoadForeign(void)
{ {
ForeignObj *f_code; ForeignObj *f_code;
@ -135,7 +135,7 @@ _YAP_ShutdownLoadForeign(void)
} }
Int Int
_YAP_ReLoadForeign(StringList ofiles, StringList libs, Yap_ReLoadForeign(StringList ofiles, StringList libs,
char *proc_name, YapInitProc *init_proc) char *proc_name, YapInitProc *init_proc)
{ {
return(LoadForeign(ofiles,libs, proc_name, init_proc)); return(LoadForeign(ofiles,libs, proc_name, init_proc));

16
C/load_dld.c
View File

@ -28,7 +28,7 @@ static char YapExecutable[YAP_FILE_MAX];
* locate the executable of Yap * locate the executable of Yap
*/ */
void void
_YAP_FindExecutable(char *name) Yap_FindExecutable(char *name)
{ {
/* use dld_find_executable */ /* use dld_find_executable */
char *res; char *res;
@ -54,7 +54,7 @@ LoadForeign(StringList ofiles, StringList libs,
if(firstTime) { if(firstTime) {
error = dld_init(YapExecutable); error = dld_init(YapExecutable);
if(error) { if(error) {
strcpy(_YAP_ErrorSay,dld_strerror(error)); strcpy(Yap_ErrorSay,dld_strerror(error));
return LOAD_FAILLED; return LOAD_FAILLED;
} }
firstTime=0; firstTime=0;
@ -62,7 +62,7 @@ LoadForeign(StringList ofiles, StringList libs,
while (ofiles) { while (ofiles) {
if((error=dld_link(ofiles->s)) !=0) { if((error=dld_link(ofiles->s)) !=0) {
strcpy(_YAP_ErrorSay,dld_strerror(error)); strcpy(Yap_ErrorSay,dld_strerror(error));
return LOAD_FAILLED; return LOAD_FAILLED;
} }
ofiles = ofiles->next; ofiles = ofiles->next;
@ -72,14 +72,14 @@ LoadForeign(StringList ofiles, StringList libs,
/* TODO: handle libs */ /* TODO: handle libs */
*init_proc = (YapInitProc) dld_get_func(proc_name); *init_proc = (YapInitProc) dld_get_func(proc_name);
if(! *init_proc) { if(! *init_proc) {
strcpy(_YAP_ErrorSay,"Could not locate initialization routine"); strcpy(Yap_ErrorSay,"Could not locate initialization routine");
return LOAD_FAILLED; return LOAD_FAILLED;
} }
if(!dld_function_executable_p(proc_name)) { if(!dld_function_executable_p(proc_name)) {
char **undefs = dld_list_undefined_sym(); char **undefs = dld_list_undefined_sym();
char **p = undefs; char **p = undefs;
int k = dld_undefined_sym_count; int k = dld_undefined_sym_count;
strcpy(_YAP_ErrorSay,"Could not resolve all symbols"); strcpy(Yap_ErrorSay,"Could not resolve all symbols");
while(k) { while(k) {
YP_printf("[undefined symbol %s]\n",*p++); YP_printf("[undefined symbol %s]\n",*p++);
--k; --k;
@ -92,19 +92,19 @@ LoadForeign(StringList ofiles, StringList libs,
} }
Int Int
_YAP_LoadForeign(StringList ofiles, StringList libs, Yap_LoadForeign(StringList ofiles, StringList libs,
char *proc_name, YapInitProc *init_proc) char *proc_name, YapInitProc *init_proc)
{ {
return LoadForeign(ofiles, libs, proc_name, init_proc); return LoadForeign(ofiles, libs, proc_name, init_proc);
} }
void void
_YAP_ShutdownLoadForeign(void) Yap_ShutdownLoadForeign(void)
{ {
} }
Int Int
_YAP_ReLoadForeign(StringList ofiles, StringList libs, Yap_ReLoadForeign(StringList ofiles, StringList libs,
char *proc_name, YapInitProc *init_proc) char *proc_name, YapInitProc *init_proc)
{ {
return(LoadForeign(ofiles,libs, proc_name, init_proc)); return(LoadForeign(ofiles,libs, proc_name, init_proc));

24
C/load_dll.c
View File

@ -28,7 +28,7 @@
* locate the executable of Yap * locate the executable of Yap
*/ */
void void
_YAP_FindExecutable(char *name) Yap_FindExecutable(char *name)
{ {
} }
@ -45,8 +45,8 @@ LoadForeign(StringList ofiles, StringList libs,
while (ofiles) { while (ofiles) {
HINSTANCE handle; HINSTANCE handle;
if (_YAP_TrueFileName(ofiles->s, _YAP_FileNameBuf, TRUE) && if (Yap_TrueFileName(ofiles->s, Yap_FileNameBuf, TRUE) &&
(handle=LoadLibrary(_YAP_FileNameBuf)) != 0) (handle=LoadLibrary(Yap_FileNameBuf)) != 0)
{ {
if (*init_proc == NULL) if (*init_proc == NULL)
*init_proc = (YapInitProc)GetProcAddress((HMODULE)handle, proc_name); *init_proc = (YapInitProc)GetProcAddress((HMODULE)handle, proc_name);
@ -60,15 +60,15 @@ LoadForeign(StringList ofiles, StringList libs,
HINSTANCE handle; HINSTANCE handle;
if (libs->s[0] == '-') { if (libs->s[0] == '-') {
strcat(_YAP_FileNameBuf,libs->s+2); strcat(Yap_FileNameBuf,libs->s+2);
strcat(_YAP_FileNameBuf,".dll"); strcat(Yap_FileNameBuf,".dll");
} else { } else {
strcpy(_YAP_FileNameBuf,libs->s); strcpy(Yap_FileNameBuf,libs->s);
} }
if((handle=LoadLibrary(_YAP_FileNameBuf)) == 0) if((handle=LoadLibrary(Yap_FileNameBuf)) == 0)
{ {
/* strcpy(_YAP_ErrorSay,dlerror());*/ /* strcpy(Yap_ErrorSay,dlerror());*/
return LOAD_FAILLED; return LOAD_FAILLED;
} }
@ -79,7 +79,7 @@ LoadForeign(StringList ofiles, StringList libs,
} }
if(*init_proc == NULL) { if(*init_proc == NULL) {
strcpy(_YAP_ErrorSay,"Could not locate initialization routine"); strcpy(Yap_ErrorSay,"Could not locate initialization routine");
return LOAD_FAILLED; return LOAD_FAILLED;
} }
@ -87,19 +87,19 @@ LoadForeign(StringList ofiles, StringList libs,
} }
Int Int
_YAP_LoadForeign(StringList ofiles, StringList libs, Yap_LoadForeign(StringList ofiles, StringList libs,
char *proc_name, YapInitProc *init_proc) char *proc_name, YapInitProc *init_proc)
{ {
return LoadForeign(ofiles, libs, proc_name, init_proc); return LoadForeign(ofiles, libs, proc_name, init_proc);
} }
void void
_YAP_ShutdownLoadForeign(void) Yap_ShutdownLoadForeign(void)
{ {
} }
Int Int
_YAP_ReLoadForeign(StringList ofiles, StringList libs, Yap_ReLoadForeign(StringList ofiles, StringList libs,
char *proc_name, YapInitProc *init_proc) char *proc_name, YapInitProc *init_proc)
{ {
return(LoadForeign(ofiles,libs, proc_name, init_proc)); return(LoadForeign(ofiles,libs, proc_name, init_proc));

30
C/load_dyld.c
View File

@ -63,7 +63,7 @@ mydlerror(void)
* locate the executable of Yap * locate the executable of Yap
*/ */
void void
_YAP_FindExecutable(char *name) Yap_FindExecutable(char *name)
{ {
} }
@ -122,14 +122,14 @@ LoadForeign(StringList ofiles, StringList libs,
void *handle; void *handle;
/* mydlopen wants to follow the LD_CONFIG_PATH */ /* mydlopen wants to follow the LD_CONFIG_PATH */
if (!_YAP_TrueFileName(ofiles->s, _YAP_FileNameBuf, TRUE)) { if (!Yap_TrueFileName(ofiles->s, Yap_FileNameBuf, TRUE)) {
strcpy(_YAP_ErrorSay, "[ Trying to open unexisting file in LoadForeign ]"); strcpy(Yap_ErrorSay, "[ Trying to open unexisting file in LoadForeign ]");
return LOAD_FAILLED; return LOAD_FAILLED;
} }
if((handle=mydlopen(_YAP_FileNameBuf)) == 0) if((handle=mydlopen(Yap_FileNameBuf)) == 0)
{ {
fprintf(stderr,"calling dlopen with error %s\n", mydlerror()); fprintf(stderr,"calling dlopen with error %s\n", mydlerror());
/* strcpy(_YAP_ErrorSay,dlerror());*/ /* strcpy(Yap_ErrorSay,dlerror());*/
return LOAD_FAILLED; return LOAD_FAILLED;
} }
@ -142,16 +142,16 @@ LoadForeign(StringList ofiles, StringList libs,
while (libs) { while (libs) {
if (libs->s[0] == '-') { if (libs->s[0] == '-') {
strcpy(_YAP_FileNameBuf,"lib"); strcpy(Yap_FileNameBuf,"lib");
strcat(_YAP_FileNameBuf,libs->s+2); strcat(Yap_FileNameBuf,libs->s+2);
strcat(_YAP_FileNameBuf,".so"); strcat(Yap_FileNameBuf,".so");
} else { } else {
strcpy(_YAP_FileNameBuf,libs->s); strcpy(Yap_FileNameBuf,libs->s);
} }
if((libs->handle=mydlopen(_YAP_FileNameBuf)) == NULL) if((libs->handle=mydlopen(Yap_FileNameBuf)) == NULL)
{ {
strcpy(_YAP_ErrorSay,mydlerror()); strcpy(Yap_ErrorSay,mydlerror());
return LOAD_FAILLED; return LOAD_FAILLED;
} }
libs = libs->next; libs = libs->next;
@ -160,7 +160,7 @@ LoadForeign(StringList ofiles, StringList libs,
*init_proc = (YapInitProc) mydlsym(proc_name); *init_proc = (YapInitProc) mydlsym(proc_name);
if(! *init_proc) { if(! *init_proc) {
strcpy(_YAP_ErrorSay,"Could not locate initialization routine"); strcpy(Yap_ErrorSay,"Could not locate initialization routine");
return LOAD_FAILLED; return LOAD_FAILLED;
} }
@ -168,14 +168,14 @@ LoadForeign(StringList ofiles, StringList libs,
} }
Int Int
_YAP_LoadForeign(StringList ofiles, StringList libs, Yap_LoadForeign(StringList ofiles, StringList libs,
char *proc_name, YapInitProc *init_proc) char *proc_name, YapInitProc *init_proc)
{ {
return LoadForeign(ofiles, libs, proc_name, init_proc); return LoadForeign(ofiles, libs, proc_name, init_proc);
} }
void void
_YAP_ShutdownLoadForeign(void) Yap_ShutdownLoadForeign(void)
{ {
ForeignObj *f_code; ForeignObj *f_code;
@ -200,7 +200,7 @@ _YAP_ShutdownLoadForeign(void)
} }
Int Int
_YAP_ReLoadForeign(StringList ofiles, StringList libs, Yap_ReLoadForeign(StringList ofiles, StringList libs,
char *proc_name, YapInitProc *init_proc) char *proc_name, YapInitProc *init_proc)
{ {
return(LoadForeign(ofiles,libs, proc_name, init_proc)); return(LoadForeign(ofiles,libs, proc_name, init_proc));

28
C/load_foreign.c
View File

@ -47,7 +47,7 @@ p_load_foreign(void)
StringList new; StringList new;
Int returncode = FALSE; Int returncode = FALSE;
strcpy(_YAP_ErrorSay,"Invalid arguments"); strcpy(Yap_ErrorSay,"Invalid arguments");
/* collect the list of object files */ /* collect the list of object files */
t = Deref(ARG1); t = Deref(ARG1);
@ -55,7 +55,7 @@ p_load_foreign(void)
if (t == TermNil) break; if (t == TermNil) break;
t1 = HeadOfTerm(t); t1 = HeadOfTerm(t);
t = TailOfTerm(t); t = TailOfTerm(t);
new = (StringList) _YAP_AllocCodeSpace(sizeof(StringListItem)); new = (StringList) Yap_AllocCodeSpace(sizeof(StringListItem));
new->next = ofiles; new->next = ofiles;
new->s = RepAtom(AtomOfTerm(t1))->StrOfAE; new->s = RepAtom(AtomOfTerm(t1))->StrOfAE;
ofiles = new; ofiles = new;
@ -67,7 +67,7 @@ p_load_foreign(void)
if (t == TermNil) break; if (t == TermNil) break;
t1 = HeadOfTerm(t); t1 = HeadOfTerm(t);
t = TailOfTerm(t); t = TailOfTerm(t);
new = (StringList) _YAP_AllocCodeSpace(sizeof(StringListItem)); new = (StringList) Yap_AllocCodeSpace(sizeof(StringListItem));
new->next = libs; new->next = libs;
new->s = RepAtom(AtomOfTerm(t1))->StrOfAE; new->s = RepAtom(AtomOfTerm(t1))->StrOfAE;
libs = new; libs = new;
@ -80,14 +80,14 @@ p_load_foreign(void)
/* call the OS specific function for dynamic loading */ /* call the OS specific function for dynamic loading */
if(_YAP_LoadForeign(ofiles,libs,InitProcName,&InitProc)==LOAD_SUCCEEDED) { if(Yap_LoadForeign(ofiles,libs,InitProcName,&InitProc)==LOAD_SUCCEEDED) {
(*InitProc)(); (*InitProc)();
returncode = TRUE; returncode = TRUE;
} }
/* I should recover space if load foreign fails */ /* I should recover space if load foreign fails */
if (returncode == TRUE) { if (returncode == TRUE) {
ForeignObj *f_code = (ForeignObj *)_YAP_AllocCodeSpace(sizeof(ForeignObj)); ForeignObj *f_code = (ForeignObj *)Yap_AllocCodeSpace(sizeof(ForeignObj));
f_code->objs = ofiles; f_code->objs = ofiles;
f_code->libs = libs; f_code->libs = libs;
f_code->f = InitProcName; f_code->f = InitProcName;
@ -100,22 +100,22 @@ p_load_foreign(void)
static Int static Int
p_obj_suffix(void) { p_obj_suffix(void) {
return(_YAP_unify(_YAP_StringToList(SHLIB_SUFFIX),ARG1)); return(Yap_unify(Yap_StringToList(SHLIB_SUFFIX),ARG1));
} }
void void
_YAP_InitLoadForeign(void) Yap_InitLoadForeign(void)
{ {
if (_YAP_argv == NULL) if (Yap_argv == NULL)
_YAP_FindExecutable("yap"); Yap_FindExecutable("yap");
else else
_YAP_FindExecutable(_YAP_argv[0]); Yap_FindExecutable(Yap_argv[0]);
_YAP_InitCPred("$load_foreign_files", 3, p_load_foreign, SafePredFlag|SyncPredFlag); Yap_InitCPred("$load_foreign_files", 3, p_load_foreign, SafePredFlag|SyncPredFlag);
_YAP_InitCPred("$obj_suffix", 1, p_obj_suffix, SafePredFlag); Yap_InitCPred("$obj_suffix", 1, p_obj_suffix, SafePredFlag);
} }
void void
_YAP_ReOpenLoadForeign(void) Yap_ReOpenLoadForeign(void)
{ {
ForeignObj *f_code = ForeignCodeLoaded; ForeignObj *f_code = ForeignCodeLoaded;
SMALLUNSGN OldModule = CurrentModule; SMALLUNSGN OldModule = CurrentModule;
@ -123,7 +123,7 @@ _YAP_ReOpenLoadForeign(void)
while (f_code != NULL) { while (f_code != NULL) {
CurrentModule = f_code->module; CurrentModule = f_code->module;
if(_YAP_ReLoadForeign(f_code->objs,f_code->libs,f_code->f,&InitProc)==LOAD_SUCCEEDED) { if(Yap_ReLoadForeign(f_code->objs,f_code->libs,f_code->f,&InitProc)==LOAD_SUCCEEDED) {
(*InitProc)(); (*InitProc)();
} }
f_code = f_code->next; f_code = f_code->next;

10
C/load_none.c
View File

@ -26,7 +26,7 @@
* locate the executable of Yap * locate the executable of Yap
*/ */
void void
_YAP_FindExecutable(char *name) Yap_FindExecutable(char *name)
{ {
} }
@ -36,20 +36,20 @@ _YAP_FindExecutable(char *name)
* code file and locates an initialization routine * code file and locates an initialization routine
*/ */
Int Int
_YAP_LoadForeign(StringList ofiles, StringList libs, Yap_LoadForeign(StringList ofiles, StringList libs,
char *proc_name, YapInitProc *init_proc) char *proc_name, YapInitProc *init_proc)
{ {
strcpy(_YAP_ErrorSay,"load_foreign not supported in this version of Yap"); strcpy(Yap_ErrorSay,"load_foreign not supported in this version of Yap");
return LOAD_FAILLED; return LOAD_FAILLED;
} }
void void
_YAP_ShutdownLoadForeign(void) Yap_ShutdownLoadForeign(void)
{ {
} }
Int Int
_YAP_ReLoadForeign(StringList ofiles, StringList libs, Yap_ReLoadForeign(StringList ofiles, StringList libs,
char *proc_name, YapInitProc *init_proc) char *proc_name, YapInitProc *init_proc)
{ {
return(LoadForeign(ofiles,libs, proc_name, init_proc)); return(LoadForeign(ofiles,libs, proc_name, init_proc));

36
C/load_shl.c
View File

@ -16,7 +16,7 @@
* locate the executable of Yap * locate the executable of Yap
*/ */
void _YAP_FindExecutable(char *name) void Yap_FindExecutable(char *name)
{ {
} }
@ -41,17 +41,17 @@ LoadForeign( StringList ofiles, StringList libs,
int valid_fname; int valid_fname;
/* shl_load wants to follow the LD_CONFIG_PATH */ /* shl_load wants to follow the LD_CONFIG_PATH */
valid_fname = _YAP_TrueFileName( ofiles->s, _YAP_FileNameBuf, TRUE ); valid_fname = Yap_TrueFileName( ofiles->s, Yap_FileNameBuf, TRUE );
if( !valid_fname ) { if( !valid_fname ) {
strcpy( _YAP_ErrorSay, "[ Trying to open non-existing file in LoadForeign ]" ); strcpy( Yap_ErrorSay, "[ Trying to open non-existing file in LoadForeign ]" );
return LOAD_FAILLED; return LOAD_FAILLED;
} }
ofiles->handle = _YAP_AllocCodeSpace( sizeof(shl_t) ); ofiles->handle = Yap_AllocCodeSpace( sizeof(shl_t) );
*(shl_t *)ofiles->handle = shl_load( _YAP_FileNameBuf, BIND_DEFERRED, 0 ); *(shl_t *)ofiles->handle = shl_load( Yap_FileNameBuf, BIND_DEFERRED, 0 );
if( *(shl_t *)ofiles->handle == NULL ) { if( *(shl_t *)ofiles->handle == NULL ) {
strncpy( _YAP_ErrorSay, strerror(errno), MAX_ERROR_MSG_SIZE ); strncpy( Yap_ErrorSay, strerror(errno), MAX_ERROR_MSG_SIZE );
return LOAD_FAILLED; return LOAD_FAILLED;
} }
@ -64,24 +64,24 @@ LoadForeign( StringList ofiles, StringList libs,
} }
if( init_missing ) { if( init_missing ) {
strcpy( _YAP_ErrorSay, "Could not locate initialization routine" ); strcpy( Yap_ErrorSay, "Could not locate initialization routine" );
return LOAD_FAILLED; return LOAD_FAILLED;
} }
while( libs ) { while( libs ) {
if( libs->s[0] == '-' ) { if( libs->s[0] == '-' ) {
strcpy( _YAP_FileNameBuf, "lib" ); strcpy( Yap_FileNameBuf, "lib" );
strcat( _YAP_FileNameBuf, libs->s+2 ); strcat( Yap_FileNameBuf, libs->s+2 );
strcat( _YAP_FileNameBuf, ".sl" ); strcat( Yap_FileNameBuf, ".sl" );
} }
else { else {
strcpy( _YAP_FileNameBuf, libs->s ); strcpy( Yap_FileNameBuf, libs->s );
} }
*(shl_t *)libs->handle = shl_load( _YAP_FileNameBuf, BIND_DEFERRED, 0 ); *(shl_t *)libs->handle = shl_load( Yap_FileNameBuf, BIND_DEFERRED, 0 );
if( *(shl_t *)libs->handle == NULL ) { if( *(shl_t *)libs->handle == NULL ) {
strncpy( _YAP_ErrorSay, strerror(errno), MAX_ERROR_MSG_SIZE ); strncpy( Yap_ErrorSay, strerror(errno), MAX_ERROR_MSG_SIZE );
return LOAD_FAILLED; return LOAD_FAILLED;
} }
@ -93,14 +93,14 @@ LoadForeign( StringList ofiles, StringList libs,
Int Int
_YAP_LoadForeign(StringList ofiles, StringList libs, Yap_LoadForeign(StringList ofiles, StringList libs,
char *proc_name, YapInitProc *init_proc) char *proc_name, YapInitProc *init_proc)
{ {
return LoadForeign(ofiles, libs, proc_name, init_proc); return LoadForeign(ofiles, libs, proc_name, init_proc);
} }
void void
_YAP_ShutdownLoadForeign( void ) Yap_ShutdownLoadForeign( void )
{ {
ForeignObj *f_code; ForeignObj *f_code;
int err; int err;
@ -117,7 +117,7 @@ _YAP_ShutdownLoadForeign( void )
perror( NULL ); perror( NULL );
return; return;
} }
_YAP_FreeCodeSpace( objs->handle ); Yap_FreeCodeSpace( objs->handle );
objs = objs->next; objs = objs->next;
} }
@ -129,7 +129,7 @@ _YAP_ShutdownLoadForeign( void )
perror( NULL ); perror( NULL );
return; return;
} }
_YAP_FreeCodeSpace( libs->handle ); Yap_FreeCodeSpace( libs->handle );
libs = libs->next; libs = libs->next;
} }
f_code = f_code->next; f_code = f_code->next;
@ -137,7 +137,7 @@ _YAP_ShutdownLoadForeign( void )
} }
Int Int
_YAP_ReLoadForeign(StringList ofiles, StringList libs, Yap_ReLoadForeign(StringList ofiles, StringList libs,
char *proc_name, YapInitProc *init_proc) char *proc_name, YapInitProc *init_proc)
{ {
ShutdownLoadForeign(); ShutdownLoadForeign();

60
C/mavar.c
View File

@ -35,32 +35,32 @@ p_setarg(void)
CELL ti = Deref(ARG1), ts = Deref(ARG2); CELL ti = Deref(ARG1), ts = Deref(ARG2);
Int i; Int i;
if (IsVarTerm(ti)) { if (IsVarTerm(ti)) {
_YAP_Error(INSTANTIATION_ERROR,ti,"setarg/3"); Yap_Error(INSTANTIATION_ERROR,ti,"setarg/3");
return(FALSE); return(FALSE);
} else { } else {
if (IsIntTerm(ti)) if (IsIntTerm(ti))
i = IntOfTerm(ti); i = IntOfTerm(ti);
else { else {
union arith_ret v; union arith_ret v;
if (_YAP_Eval(ti, &v) == long_int_e) { if (Yap_Eval(ti, &v) == long_int_e) {
i = v.Int; i = v.Int;
} else { } else {
_YAP_Error(TYPE_ERROR_INTEGER,ti,"setarg/3"); Yap_Error(TYPE_ERROR_INTEGER,ti,"setarg/3");
return(FALSE); return(FALSE);
} }
} }
} }
if (IsVarTerm(ts)) { if (IsVarTerm(ts)) {
_YAP_Error(INSTANTIATION_ERROR,ts,"setarg/3"); Yap_Error(INSTANTIATION_ERROR,ts,"setarg/3");
} else if(IsApplTerm(ts)) { } else if(IsApplTerm(ts)) {
CELL *pt; CELL *pt;
if (IsExtensionFunctor(FunctorOfTerm(ts))) { if (IsExtensionFunctor(FunctorOfTerm(ts))) {
_YAP_Error(TYPE_ERROR_COMPOUND,ts,"setarg/3"); Yap_Error(TYPE_ERROR_COMPOUND,ts,"setarg/3");
return(FALSE); return(FALSE);
} }
if (i < 0 || i > (Int)ArityOfFunctor(FunctorOfTerm(ts))) { if (i < 0 || i > (Int)ArityOfFunctor(FunctorOfTerm(ts))) {
if (i<0) if (i<0)
_YAP_Error(DOMAIN_ERROR_NOT_LESS_THAN_ZERO,ts,"setarg/3"); Yap_Error(DOMAIN_ERROR_NOT_LESS_THAN_ZERO,ts,"setarg/3");
return(FALSE); return(FALSE);
} }
pt = RepAppl(ts)+i; pt = RepAppl(ts)+i;
@ -70,14 +70,14 @@ p_setarg(void)
CELL *pt; CELL *pt;
if (i != 1 || i != 2) { if (i != 1 || i != 2) {
if (i<0) if (i<0)
_YAP_Error(DOMAIN_ERROR_NOT_LESS_THAN_ZERO,ts,"setarg/3"); Yap_Error(DOMAIN_ERROR_NOT_LESS_THAN_ZERO,ts,"setarg/3");
return(FALSE); return(FALSE);
} }
pt = RepPair(ts)+i-1; pt = RepPair(ts)+i-1;
/* the evil deed is to be done now */ /* the evil deed is to be done now */
MaBind(pt, Deref(ARG3)); MaBind(pt, Deref(ARG3));
} else { } else {
_YAP_Error(TYPE_ERROR_COMPOUND,ts,"setarg/3"); Yap_Error(TYPE_ERROR_COMPOUND,ts,"setarg/3");
return(FALSE); return(FALSE);
} }
return(TRUE); return(TRUE);
@ -112,7 +112,7 @@ static void
CreateTimedVar(Term val) CreateTimedVar(Term val)
{ {
timed_var *tv = (timed_var *)H; timed_var *tv = (timed_var *)H;
tv->clock = MkIntegerTerm(B->cp_tr-(tr_fr_ptr)_YAP_TrailBase); tv->clock = MkIntegerTerm(B->cp_tr-(tr_fr_ptr)Yap_TrailBase);
if (B->cp_tr == TR) { if (B->cp_tr == TR) {
/* we run the risk of not making non-determinate bindings before /* we run the risk of not making non-determinate bindings before
the end of the night */ the end of the night */
@ -127,7 +127,7 @@ static void
CreateEmptyTimedVar(void) CreateEmptyTimedVar(void)
{ {
timed_var *tv = (timed_var *)H; timed_var *tv = (timed_var *)H;
tv->clock = MkIntegerTerm(B->cp_tr-(tr_fr_ptr)_YAP_TrailBase); tv->clock = MkIntegerTerm(B->cp_tr-(tr_fr_ptr)Yap_TrailBase);
if (B->cp_tr == TR) { if (B->cp_tr == TR) {
/* we run the risk of not making non-determinate bindings before /* we run the risk of not making non-determinate bindings before
the end of the night */ the end of the night */
@ -158,13 +158,13 @@ NewTimedVar(CELL val)
} }
Term Term
_YAP_NewTimedVar(CELL val) Yap_NewTimedVar(CELL val)
{ {
return NewTimedVar(val); return NewTimedVar(val);
} }
Term Term
_YAP_NewEmptyTimedVar(void) Yap_NewEmptyTimedVar(void)
{ {
Term out = AbsAppl(H); Term out = AbsAppl(H);
#if FROZEN_STACKS #if FROZEN_STACKS
@ -189,7 +189,7 @@ ReadTimedVar(Term inv)
} }
Term Term
_YAP_ReadTimedVar(Term inv) Yap_ReadTimedVar(Term inv)
{ {
return ReadTimedVar(inv); return ReadTimedVar(inv);
} }
@ -202,7 +202,7 @@ UpdateTimedVar(Term inv, Term new)
timed_var *tv = (timed_var *)(RepAppl(inv)+1); timed_var *tv = (timed_var *)(RepAppl(inv)+1);
CELL t = tv->value; CELL t = tv->value;
#if FROZEN_STACKS #if FROZEN_STACKS
tr_fr_ptr timestmp = (tr_fr_ptr)_YAP_TrailBase + IntegerOfTerm(tv->clock); tr_fr_ptr timestmp = (tr_fr_ptr)Yap_TrailBase + IntegerOfTerm(tv->clock);
if (B->cp_tr <= timestmp && timestmp <= TR) { if (B->cp_tr <= timestmp && timestmp <= TR) {
/* last assignment more recent than last B */ /* last assignment more recent than last B */
@ -219,7 +219,7 @@ UpdateTimedVar(Term inv, Term new)
} else { } else {
Term nclock; Term nclock;
MaBind(&(tv->value), new); MaBind(&(tv->value), new);
nclock = MkIntegerTerm(TR-(tr_fr_ptr)_YAP_TrailBase); nclock = MkIntegerTerm(TR-(tr_fr_ptr)Yap_TrailBase);
MaBind(&(tv->clock), nclock); MaBind(&(tv->clock), nclock);
} }
#else #else
@ -246,7 +246,7 @@ UpdateTimedVar(Term inv, Term new)
/* update a timed var with a new value */ /* update a timed var with a new value */
Term Term
_YAP_UpdateTimedVar(Term inv, Term new) Yap_UpdateTimedVar(Term inv, Term new)
{ {
return UpdateTimedVar(inv, new); return UpdateTimedVar(inv, new);
} }
@ -255,7 +255,7 @@ static Int
p_create_mutable(void) p_create_mutable(void)
{ {
Term t = NewTimedVar(Deref(ARG1)); Term t = NewTimedVar(Deref(ARG1));
return(_YAP_unify(ARG2,t)); return(Yap_unify(ARG2,t));
} }
static Int static Int
@ -263,19 +263,19 @@ p_get_mutable(void)
{ {
Term t = Deref(ARG2); Term t = Deref(ARG2);
if (IsVarTerm(t)) { if (IsVarTerm(t)) {
_YAP_Error(INSTANTIATION_ERROR, t, "get_mutable/3"); Yap_Error(INSTANTIATION_ERROR, t, "get_mutable/3");
return(FALSE); return(FALSE);
} }
if (!IsApplTerm(t)) { if (!IsApplTerm(t)) {
_YAP_Error(TYPE_ERROR_COMPOUND,t,"get_mutable/3"); Yap_Error(TYPE_ERROR_COMPOUND,t,"get_mutable/3");
return(FALSE); return(FALSE);
} }
if (FunctorOfTerm(t) != FunctorMutable) { if (FunctorOfTerm(t) != FunctorMutable) {
_YAP_Error(DOMAIN_ERROR_MUTABLE,t,"get_mutable/3"); Yap_Error(DOMAIN_ERROR_MUTABLE,t,"get_mutable/3");
return(FALSE); return(FALSE);
} }
t = ReadTimedVar(t); t = ReadTimedVar(t);
return(_YAP_unify(ARG1, t)); return(Yap_unify(ARG1, t));
} }
static Int static Int
@ -283,15 +283,15 @@ p_update_mutable(void)
{ {
Term t = Deref(ARG2); Term t = Deref(ARG2);
if (IsVarTerm(t)) { if (IsVarTerm(t)) {
_YAP_Error(INSTANTIATION_ERROR, t, "update_mutable/3"); Yap_Error(INSTANTIATION_ERROR, t, "update_mutable/3");
return(FALSE); return(FALSE);
} }
if (!IsApplTerm(t)) { if (!IsApplTerm(t)) {
_YAP_Error(TYPE_ERROR_COMPOUND,t,"update_mutable/3"); Yap_Error(TYPE_ERROR_COMPOUND,t,"update_mutable/3");
return(FALSE); return(FALSE);
} }
if (FunctorOfTerm(t) != FunctorMutable) { if (FunctorOfTerm(t) != FunctorMutable) {
_YAP_Error(DOMAIN_ERROR_MUTABLE,t,"update_mutable/3"); Yap_Error(DOMAIN_ERROR_MUTABLE,t,"update_mutable/3");
return(FALSE); return(FALSE);
} }
UpdateTimedVar(t, Deref(ARG1)); UpdateTimedVar(t, Deref(ARG1));
@ -317,14 +317,14 @@ p_is_mutable(void)
#endif #endif
void void
_YAP_InitMaVarCPreds(void) Yap_InitMaVarCPreds(void)
{ {
#ifdef MULTI_ASSIGNMENT_VARIABLES #ifdef MULTI_ASSIGNMENT_VARIABLES
/* The most famous contributions of SICStus to the Prolog language */ /* The most famous contributions of SICStus to the Prolog language */
_YAP_InitCPred("setarg", 3, p_setarg, SafePredFlag); Yap_InitCPred("setarg", 3, p_setarg, SafePredFlag);
_YAP_InitCPred("create_mutable", 2, p_create_mutable, SafePredFlag); Yap_InitCPred("create_mutable", 2, p_create_mutable, SafePredFlag);
_YAP_InitCPred("get_mutable", 2, p_get_mutable, SafePredFlag); Yap_InitCPred("get_mutable", 2, p_get_mutable, SafePredFlag);
_YAP_InitCPred("update_mutable", 2, p_update_mutable, SafePredFlag); Yap_InitCPred("update_mutable", 2, p_update_mutable, SafePredFlag);
_YAP_InitCPred("is_mutable", 1, p_is_mutable, SafePredFlag); Yap_InitCPred("is_mutable", 1, p_is_mutable, SafePredFlag);
#endif #endif
} }

32
C/modules.c
View File

@ -27,7 +27,7 @@ STATIC_PROTO(Int p_current_module1, (void));
#define ByteAdr(X) ((char *) &(X)) #define ByteAdr(X) ((char *) &(X))
Term Term
_YAP_Module_Name(CODEADDR cap) Yap_Module_Name(CODEADDR cap)
{ {
PredEntry *ap = (PredEntry *)cap; PredEntry *ap = (PredEntry *)cap;
@ -57,13 +57,13 @@ LookupModule(Term a)
} }
ModuleName[i = NoOfModules++] = a; ModuleName[i = NoOfModules++] = a;
if (NoOfModules == MaxModules) { if (NoOfModules == MaxModules) {
_YAP_Error(SYSTEM_ERROR,a,"number of modules overflowed"); Yap_Error(SYSTEM_ERROR,a,"number of modules overflowed");
} }
return (i); return (i);
} }
SMALLUNSGN SMALLUNSGN
_YAP_LookupModule(Term a) Yap_LookupModule(Term a)
{ {
return(LookupModule(a)); return(LookupModule(a));
} }
@ -73,7 +73,7 @@ p_current_module(void)
{ /* $current_module(Old,New) */ { /* $current_module(Old,New) */
Term t; Term t;
if (!_YAP_unify_constant(ARG1, ModuleName[CurrentModule])) if (!Yap_unify_constant(ARG1, ModuleName[CurrentModule]))
return (0); return (0);
t = Deref(ARG2); t = Deref(ARG2);
if (IsVarTerm(t) || !IsAtomTerm(t)) if (IsVarTerm(t) || !IsAtomTerm(t))
@ -85,7 +85,7 @@ p_current_module(void)
static Int static Int
p_current_module1(void) p_current_module1(void)
{ /* $current_module(Old) */ { /* $current_module(Old) */
if (!_YAP_unify_constant(ARG1, ModuleName[CurrentModule])) if (!Yap_unify_constant(ARG1, ModuleName[CurrentModule]))
return (0); return (0);
return (1); return (1);
} }
@ -104,10 +104,10 @@ p_module_number(void)
Term tname = Deref(ARG1); Term tname = Deref(ARG1);
Term t; Term t;
if (IsVarTerm(tname)) { if (IsVarTerm(tname)) {
return(_YAP_unify(tname, ModuleName[IntOfTerm(Deref(ARG2))])); return(Yap_unify(tname, ModuleName[IntOfTerm(Deref(ARG2))]));
}else { }else {
t = MkIntTerm(LookupModule(Deref(ARG1))); t = MkIntTerm(LookupModule(Deref(ARG1)));
_YAP_unify(t,ARG2); Yap_unify(t,ARG2);
ARG2 = t; ARG2 = t;
} }
return(TRUE); return(TRUE);
@ -123,7 +123,7 @@ cont_current_module(void)
cut_fail(); cut_fail();
} }
EXTRA_CBACK_ARG(1,1) = MkIntTerm(mod+1); EXTRA_CBACK_ARG(1,1) = MkIntTerm(mod+1);
return(_YAP_unify(ARG1,t)); return(Yap_unify(ARG1,t));
} }
static Int static Int
@ -134,18 +134,18 @@ init_current_module(void)
} }
void void
_YAP_InitModules(void) Yap_InitModules(void)
{ {
ModuleName[PrimitivesModule = 0] = ModuleName[PrimitivesModule = 0] =
MkAtomTerm(_YAP_LookupAtom("prolog")); MkAtomTerm(Yap_LookupAtom("prolog"));
ModuleName[1] = ModuleName[1] =
MkAtomTerm(_YAP_LookupAtom("user")); MkAtomTerm(Yap_LookupAtom("user"));
NoOfModules = 2; NoOfModules = 2;
CurrentModule = 0; CurrentModule = 0;
_YAP_InitCPred("$current_module", 2, p_current_module, SafePredFlag|SyncPredFlag); Yap_InitCPred("$current_module", 2, p_current_module, SafePredFlag|SyncPredFlag);
_YAP_InitCPred("$current_module", 1, p_current_module1, SafePredFlag|SyncPredFlag); Yap_InitCPred("$current_module", 1, p_current_module1, SafePredFlag|SyncPredFlag);
_YAP_InitCPred("$change_module", 1, p_change_module, SafePredFlag|SyncPredFlag); Yap_InitCPred("$change_module", 1, p_change_module, SafePredFlag|SyncPredFlag);
_YAP_InitCPred("$module_number", 2, p_module_number, SafePredFlag); Yap_InitCPred("$module_number", 2, p_module_number, SafePredFlag);
_YAP_InitCPredBack("$all_current_modules", 1, 1, init_current_module, cont_current_module, Yap_InitCPredBack("$all_current_modules", 1, 1, init_current_module, cont_current_module,
SafePredFlag|SyncPredFlag); SafePredFlag|SyncPredFlag);
} }

14
C/other.c
View File

@ -23,21 +23,21 @@ static char SccsId[] = "%W% %G%";
#include "Yatom.h" #include "Yatom.h"
#include "Heap.h" #include "Heap.h"
/* exile _YAP_standard_regs here, otherwise WIN32 linkers may complain */ /* exile Yap_standard_regs here, otherwise WIN32 linkers may complain */
REGSTORE _YAP_standard_regs; REGSTORE Yap_standard_regs;
#if PUSH_REGS #if PUSH_REGS
REGSTORE *_YAP_regp; REGSTORE *Yap_regp;
#else #else
REGSTORE _YAP_REGS; REGSTORE Yap_REGS;
#endif #endif
Term Term
_YAP_MkNewPairTerm(void) Yap_MkNewPairTerm(void)
{ {
register CELL *p = H; register CELL *p = H;
@ -48,7 +48,7 @@ _YAP_MkNewPairTerm(void)
} }
Term Term
_YAP_MkApplTerm(Functor f, unsigned int n, register Term *a) Yap_MkApplTerm(Functor f, unsigned int n, register Term *a)
/* build compound term with functor f and n /* build compound term with functor f and n
* args a */ * args a */
{ {
@ -65,7 +65,7 @@ _YAP_MkApplTerm(Functor f, unsigned int n, register Term *a)
} }
Term Term
_YAP_MkNewApplTerm(Functor f, unsigned int n) Yap_MkNewApplTerm(Functor f, unsigned int n)
/* build compound term with functor f and n /* build compound term with functor f and n
* args a */ * args a */
{ {

172
C/parser.c
View File

@ -79,7 +79,7 @@ static JMPBUFF FailBuff;
#define TRY(S,P) \ #define TRY(S,P) \
{ Volatile JMPBUFF saveenv;\ { Volatile JMPBUFF saveenv;\
Volatile TokEntry *saveT=_YAP_tokptr; \ Volatile TokEntry *saveT=Yap_tokptr; \
Volatile CELL *saveH=H;\ Volatile CELL *saveH=H;\
Volatile int savecurprio=curprio;\ Volatile int savecurprio=curprio;\
saveenv=FailBuff;\ saveenv=FailBuff;\
@ -91,39 +91,39 @@ static JMPBUFF FailBuff;
else { FailBuff=saveenv; \ else { FailBuff=saveenv; \
H=saveH; \ H=saveH; \
curprio = savecurprio; \ curprio = savecurprio; \
_YAP_tokptr=saveT; \ Yap_tokptr=saveT; \
}\ }\
}\ }\
#define TRY3(S,P,F) \ #define TRY3(S,P,F) \
{ Volatile JMPBUFF saveenv;\ { Volatile JMPBUFF saveenv;\
Volatile TokEntry *saveT=_YAP_tokptr; Volatile CELL *saveH=H;\ Volatile TokEntry *saveT=Yap_tokptr; Volatile CELL *saveH=H;\
saveenv=FailBuff;\ saveenv=FailBuff;\
if(!setjmp(FailBuff.JmpBuff)) {\ if(!setjmp(FailBuff.JmpBuff)) {\
S;\ S;\
FailBuff=saveenv;\ FailBuff=saveenv;\
P;\ P;\
}\ }\
else { FailBuff=saveenv; H=saveH; _YAP_tokptr=saveT; F }\ else { FailBuff=saveenv; H=saveH; Yap_tokptr=saveT; F }\
}\ }\
#define FAIL longjmp(FailBuff.JmpBuff,1) #define FAIL longjmp(FailBuff.JmpBuff,1)
VarEntry * VarEntry *
_YAP_LookupVar(char *var) /* lookup variable in variables table */ Yap_LookupVar(char *var) /* lookup variable in variables table */
{ {
VarEntry *p; VarEntry *p;
#ifdef DEBUG #ifdef DEBUG
if (_YAP_Option[4]) if (Yap_Option[4])
fprintf(_YAP_stderr,"[LookupVar %s]", var); fprintf(Yap_stderr,"[LookupVar %s]", var);
#endif #endif
if (var[0] != '_' || var[1] != '\0') { if (var[0] != '_' || var[1] != '\0') {
VarEntry **op = &_YAP_VarTable; VarEntry **op = &Yap_VarTable;
unsigned char *vp = (unsigned char *)var; unsigned char *vp = (unsigned char *)var;
CELL hv; CELL hv;
p = _YAP_VarTable; p = Yap_VarTable;
HashFunction(vp, hv); HashFunction(vp, hv);
while (p != NULL) { while (p != NULL) {
CELL hpv = p->hv; CELL hpv = p->hv;
@ -146,16 +146,16 @@ _YAP_LookupVar(char *var) /* lookup variable in variables table */
p = p->VarRight; p = p->VarRight;
} }
} }
p = (VarEntry *) _YAP_AllocScannerMemory(strlen(var) + sizeof(VarEntry)); p = (VarEntry *) Yap_AllocScannerMemory(strlen(var) + sizeof(VarEntry));
*op = p; *op = p;
p->VarLeft = p->VarRight = NULL; p->VarLeft = p->VarRight = NULL;
p->hv = hv; p->hv = hv;
strcpy(p->VarRep, var); strcpy(p->VarRep, var);
} else { } else {
/* anon var */ /* anon var */
p = (VarEntry *) _YAP_AllocScannerMemory(sizeof(VarEntry) + 2); p = (VarEntry *) Yap_AllocScannerMemory(sizeof(VarEntry) + 2);
p->VarLeft = _YAP_AnonVarTable; p->VarLeft = Yap_AnonVarTable;
_YAP_AnonVarTable = p; Yap_AnonVarTable = p;
p->VarRight = NULL; p->VarRight = NULL;
p->hv = 0L; p->hv = 0L;
p->VarRep[0] = '_'; p->VarRep[0] = '_';
@ -170,11 +170,11 @@ VarNames(VarEntry *p,Term l)
{ {
if (p != NULL) { if (p != NULL) {
if (strcmp(p->VarRep, "_") != 0) { if (strcmp(p->VarRep, "_") != 0) {
Term o = MkPairTerm(MkPairTerm(_YAP_StringToList(p->VarRep), p->VarAdr), Term o = MkPairTerm(MkPairTerm(Yap_StringToList(p->VarRep), p->VarAdr),
VarNames(p->VarRight, VarNames(p->VarRight,
VarNames(p->VarLeft,l))); VarNames(p->VarLeft,l)));
if (H > ASP-4096) { if (H > ASP-4096) {
longjmp(_YAP_IOBotch,1); longjmp(Yap_IOBotch,1);
} }
return(o); return(o);
} else { } else {
@ -186,7 +186,7 @@ VarNames(VarEntry *p,Term l)
} }
Term Term
_YAP_VarNames(VarEntry *p,Term l) Yap_VarNames(VarEntry *p,Term l)
{ {
return VarNames(p,l); return VarNames(p,l);
} }
@ -210,7 +210,7 @@ IsPrefixOp(Prop opinfo,int *pptr, int *rpptr)
} }
int int
_YAP_IsPrefixOp(Prop opinfo,int *pptr, int *rpptr) Yap_IsPrefixOp(Prop opinfo,int *pptr, int *rpptr)
{ {
return IsPrefixOp(opinfo,pptr,rpptr); return IsPrefixOp(opinfo,pptr,rpptr);
} }
@ -236,7 +236,7 @@ IsInfixOp(Prop opinfo, int *pptr, int *lpptr, int *rpptr)
} }
int int
_YAP_IsInfixOp(Prop opinfo, int *pptr, int *lpptr, int *rpptr) Yap_IsInfixOp(Prop opinfo, int *pptr, int *lpptr, int *rpptr)
{ {
return IsInfixOp(opinfo, pptr, lpptr, rpptr); return IsInfixOp(opinfo, pptr, lpptr, rpptr);
} }
@ -259,7 +259,7 @@ IsPosfixOp(Prop opinfo, int *pptr, int *lpptr)
} }
int int
_YAP_IsPosfixOp(Prop opinfo, int *pptr, int *lpptr) Yap_IsPosfixOp(Prop opinfo, int *pptr, int *lpptr)
{ {
return IsPosfixOp(opinfo, pptr, lpptr); return IsPosfixOp(opinfo, pptr, lpptr);
} }
@ -267,24 +267,24 @@ _YAP_IsPosfixOp(Prop opinfo, int *pptr, int *lpptr)
inline static void inline static void
GNextToken(void) GNextToken(void)
{ {
if (_YAP_tokptr->Tok == Ord(eot_tok)) if (Yap_tokptr->Tok == Ord(eot_tok))
return; return;
#ifdef EMACS #ifdef EMACS
if ((_YAP_tokptr = _YAP_tokptr->TokNext)->TokPos > _YAP_toktide->TokPos) if ((Yap_tokptr = Yap_tokptr->TokNext)->TokPos > Yap_toktide->TokPos)
_YAP_toktide = _YAP_tokptr; Yap_toktide = Yap_tokptr;
#else #else
if (_YAP_tokptr == _YAP_toktide) if (Yap_tokptr == Yap_toktide)
_YAP_toktide = _YAP_tokptr = _YAP_tokptr->TokNext; Yap_toktide = Yap_tokptr = Yap_tokptr->TokNext;
else else
_YAP_tokptr = _YAP_tokptr->TokNext; Yap_tokptr = Yap_tokptr->TokNext;
#endif #endif
} }
inline static void inline static void
checkfor(Term c) checkfor(Term c)
{ {
if (_YAP_tokptr->Tok != Ord(Ponctuation_tok) if (Yap_tokptr->Tok != Ord(Ponctuation_tok)
|| _YAP_tokptr->TokInfo != c) || Yap_tokptr->TokInfo != c)
FAIL; FAIL;
NextToken; NextToken;
} }
@ -295,7 +295,7 @@ ParseArgs(Atom a)
int nargs = 0; int nargs = 0;
Term *p, t; Term *p, t;
#ifdef SFUNC #ifdef SFUNC
SFEntry *pe = (SFEntry *) _YAP_GetAProp(a, SFProperty); SFEntry *pe = (SFEntry *) Yap_GetAProp(a, SFProperty);
#endif #endif
NextToken; NextToken;
@ -305,9 +305,9 @@ ParseArgs(Atom a)
*tp++ = Unsigned(ParseTerm(999)); *tp++ = Unsigned(ParseTerm(999));
ParserAuxSp = (tr_fr_ptr)tp; ParserAuxSp = (tr_fr_ptr)tp;
++nargs; ++nargs;
if (_YAP_tokptr->Tok != Ord(Ponctuation_tok)) if (Yap_tokptr->Tok != Ord(Ponctuation_tok))
break; break;
if (((int) _YAP_tokptr->TokInfo) != ',') if (((int) Yap_tokptr->TokInfo) != ',')
break; break;
NextToken; NextToken;
} }
@ -317,16 +317,16 @@ ParseArgs(Atom a)
* order * order
*/ */
if (H > ASP-(nargs+1)) { if (H > ASP-(nargs+1)) {
_YAP_ErrorMessage = "Stack Overflow"; Yap_ErrorMessage = "Stack Overflow";
FAIL; FAIL;
} }
#ifdef SFUNC #ifdef SFUNC
if (pe) if (pe)
t = MkSFTerm(_YAP_MkFunctor(a, SFArity), nargs, p, pe->NilValue); t = MkSFTerm(Yap_MkFunctor(a, SFArity), nargs, p, pe->NilValue);
else else
t = _YAP_MkApplTerm(_YAP_MkFunctor(a, nargs), nargs, p); t = Yap_MkApplTerm(Yap_MkFunctor(a, nargs), nargs, p);
#else #else
t = _YAP_MkApplTerm(_YAP_MkFunctor(a, nargs), nargs, p); t = Yap_MkApplTerm(Yap_MkFunctor(a, nargs), nargs, p);
#endif #endif
/* check for possible overflow against local stack */ /* check for possible overflow against local stack */
checkfor((Term) ')'); checkfor((Term) ')');
@ -344,25 +344,25 @@ ParseList(void)
to_store = H; to_store = H;
H+=2; H+=2;
to_store[0] = ParseTerm(999); to_store[0] = ParseTerm(999);
if (_YAP_tokptr->Tok == Ord(Ponctuation_tok)) { if (Yap_tokptr->Tok == Ord(Ponctuation_tok)) {
if (((int) _YAP_tokptr->TokInfo) == ',') { if (((int) Yap_tokptr->TokInfo) == ',') {
NextToken; NextToken;
if (_YAP_tokptr->Tok == Ord(Name_tok) if (Yap_tokptr->Tok == Ord(Name_tok)
&& strcmp(RepAtom((Atom)(_YAP_tokptr->TokInfo))->StrOfAE, "..") == 0) { && strcmp(RepAtom((Atom)(Yap_tokptr->TokInfo))->StrOfAE, "..") == 0) {
NextToken; NextToken;
to_store[1] = ParseTerm(999); to_store[1] = ParseTerm(999);
} else { } else {
/* check for possible overflow against local stack */ /* check for possible overflow against local stack */
if (H > ASP-4096) { if (H > ASP-4096) {
to_store[1] = TermNil; to_store[1] = TermNil;
_YAP_ErrorMessage = "Stack Overflow"; Yap_ErrorMessage = "Stack Overflow";
FAIL; FAIL;
} else { } else {
to_store[1] = AbsPair(H); to_store[1] = AbsPair(H);
goto loop; goto loop;
} }
} }
} else if (((int) _YAP_tokptr->TokInfo) == '|') { } else if (((int) Yap_tokptr->TokInfo) == '|') {
NextToken; NextToken;
to_store[1] = ParseTerm(999); to_store[1] = ParseTerm(999);
} else { } else {
@ -391,29 +391,29 @@ ParseTerm(int prio)
Volatile VarEntry *varinfo; Volatile VarEntry *varinfo;
Volatile int curprio = 0, opprio, oplprio, oprprio; Volatile int curprio = 0, opprio, oplprio, oprprio;
switch (_YAP_tokptr->Tok) { switch (Yap_tokptr->Tok) {
case Name_tok: case Name_tok:
t = _YAP_tokptr->TokInfo; t = Yap_tokptr->TokInfo;
NextToken; NextToken;
if ((_YAP_tokptr->Tok != Ord(Ponctuation_tok) if ((Yap_tokptr->Tok != Ord(Ponctuation_tok)
|| Unsigned(_YAP_tokptr->TokInfo) != 'l') || Unsigned(Yap_tokptr->TokInfo) != 'l')
&& (opinfo = _YAP_GetAProp((Atom) t, OpProperty)) && (opinfo = Yap_GetAProp((Atom) t, OpProperty))
&& IsPrefixOp(opinfo, &opprio, &oprprio) && IsPrefixOp(opinfo, &opprio, &oprprio)
) { ) {
/* special rules apply for +1, -2.3, etc... */ /* special rules apply for +1, -2.3, etc... */
if (_YAP_tokptr->Tok == Number_tok) { if (Yap_tokptr->Tok == Number_tok) {
if ((Atom)t == AtomMinus) { if ((Atom)t == AtomMinus) {
t = _YAP_tokptr->TokInfo; t = Yap_tokptr->TokInfo;
if (IsIntTerm(t)) if (IsIntTerm(t))
t = MkIntTerm(-IntOfTerm(t)); t = MkIntTerm(-IntOfTerm(t));
else if (IsFloatTerm(t)) else if (IsFloatTerm(t))
t = MkFloatTerm(-FloatOfTerm(t)); t = MkFloatTerm(-FloatOfTerm(t));
#ifdef USE_GMP #ifdef USE_GMP
else if (IsBigIntTerm(t)) { else if (IsBigIntTerm(t)) {
MP_INT *new = _YAP_PreAllocBigNum(); MP_INT *new = Yap_PreAllocBigNum();
mpz_neg(new, _YAP_BigIntOfTerm(t)); mpz_neg(new, Yap_BigIntOfTerm(t));
t = _YAP_MkBigIntTerm(new); t = Yap_MkBigIntTerm(new);
} }
#endif #endif
else else
@ -421,12 +421,12 @@ ParseTerm(int prio)
NextToken; NextToken;
break; break;
} else if ((Atom)t == AtomPlus) { } else if ((Atom)t == AtomPlus) {
t = _YAP_tokptr->TokInfo; t = Yap_tokptr->TokInfo;
NextToken; NextToken;
break; break;
} }
} else if (_YAP_tokptr->Tok == Name_tok) { } else if (Yap_tokptr->Tok == Name_tok) {
Atom at = (Atom)_YAP_tokptr->TokInfo; Atom at = (Atom)Yap_tokptr->TokInfo;
#ifndef _MSC_VER #ifndef _MSC_VER
if ((Atom)t == AtomPlus) { if ((Atom)t == AtomPlus) {
if (at == AtomInf) { if (at == AtomInf) {
@ -455,12 +455,12 @@ ParseTerm(int prio)
/* try to parse as a prefix operator */ /* try to parse as a prefix operator */
TRY( TRY(
/* build appl on the heap */ /* build appl on the heap */
func = _YAP_MkFunctor((Atom) t, 1); func = Yap_MkFunctor((Atom) t, 1);
t = ParseTerm(oprprio); t = ParseTerm(oprprio);
t = _YAP_MkApplTerm(func, 1, &t); t = Yap_MkApplTerm(func, 1, &t);
/* check for possible overflow against local stack */ /* check for possible overflow against local stack */
if (H > ASP-4096) { if (H > ASP-4096) {
_YAP_ErrorMessage = "Stack Overflow"; Yap_ErrorMessage = "Stack Overflow";
FAIL; FAIL;
} }
curprio = opprio; curprio = opprio;
@ -469,35 +469,35 @@ ParseTerm(int prio)
) )
} }
} }
if (_YAP_tokptr->Tok == Ord(Ponctuation_tok) if (Yap_tokptr->Tok == Ord(Ponctuation_tok)
&& Unsigned(_YAP_tokptr->TokInfo) == 'l') && Unsigned(Yap_tokptr->TokInfo) == 'l')
t = ParseArgs((Atom) t); t = ParseArgs((Atom) t);
else else
t = MkAtomTerm((Atom)t); t = MkAtomTerm((Atom)t);
break; break;
case Number_tok: case Number_tok:
t = _YAP_tokptr->TokInfo; t = Yap_tokptr->TokInfo;
NextToken; NextToken;
break; break;
case String_tok: /* build list on the heap */ case String_tok: /* build list on the heap */
{ {
Volatile char *p = (char *) _YAP_tokptr->TokInfo; Volatile char *p = (char *) Yap_tokptr->TokInfo;
if (*p == 0) if (*p == 0)
t = MkAtomTerm(AtomNil); t = MkAtomTerm(AtomNil);
else if (yap_flags[YAP_DOUBLE_QUOTES_FLAG] == STRING_AS_CHARS) else if (yap_flags[YAP_DOUBLE_QUOTES_FLAG] == STRING_AS_CHARS)
t = _YAP_StringToListOfAtoms(p); t = Yap_StringToListOfAtoms(p);
else if (yap_flags[YAP_DOUBLE_QUOTES_FLAG] == STRING_AS_ATOM) else if (yap_flags[YAP_DOUBLE_QUOTES_FLAG] == STRING_AS_ATOM)
t = MkAtomTerm(_YAP_LookupAtom(p)); t = MkAtomTerm(Yap_LookupAtom(p));
else else
t = _YAP_StringToList(p); t = Yap_StringToList(p);
NextToken; NextToken;
} }
break; break;
case Var_tok: case Var_tok:
varinfo = (VarEntry *) (_YAP_tokptr->TokInfo); varinfo = (VarEntry *) (Yap_tokptr->TokInfo);
if ((t = varinfo->VarAdr) == TermNil) { if ((t = varinfo->VarAdr) == TermNil) {
t = varinfo->VarAdr = MkVarTerm(); t = varinfo->VarAdr = MkVarTerm();
} }
@ -505,7 +505,7 @@ ParseTerm(int prio)
break; break;
case Ponctuation_tok: case Ponctuation_tok:
switch ((int) _YAP_tokptr->TokInfo) { switch ((int) Yap_tokptr->TokInfo) {
case '(': case '(':
case 'l': /* non solo ( */ case 'l': /* non solo ( */
NextToken; NextToken;
@ -519,16 +519,16 @@ ParseTerm(int prio)
break; break;
case '{': case '{':
NextToken; NextToken;
if (_YAP_tokptr->Tok == Ord(Ponctuation_tok) && if (Yap_tokptr->Tok == Ord(Ponctuation_tok) &&
Unsigned(_YAP_tokptr->TokInfo) == '}') { Unsigned(Yap_tokptr->TokInfo) == '}') {
t = MkAtomTerm(NameOfFunctor(FunctorBraces)); t = MkAtomTerm(NameOfFunctor(FunctorBraces));
NextToken; NextToken;
} else { } else {
t = ParseTerm(1200); t = ParseTerm(1200);
t = _YAP_MkApplTerm(FunctorBraces, 1, &t); t = Yap_MkApplTerm(FunctorBraces, 1, &t);
/* check for possible overflow against local stack */ /* check for possible overflow against local stack */
if (H > ASP-4096) { if (H > ASP-4096) {
_YAP_ErrorMessage = "Stack Overflow"; Yap_ErrorMessage = "Stack Overflow";
FAIL; FAIL;
} }
checkfor((Term) '}'); checkfor((Term) '}');
@ -546,24 +546,24 @@ ParseTerm(int prio)
/* main loop to parse infix and posfix operators starts here */ /* main loop to parse infix and posfix operators starts here */
while (TRUE) { while (TRUE) {
if (_YAP_tokptr->Tok == Ord(Name_tok) if (Yap_tokptr->Tok == Ord(Name_tok)
&& (opinfo = _YAP_GetAProp((Atom)(_YAP_tokptr->TokInfo), OpProperty))) { && (opinfo = Yap_GetAProp((Atom)(Yap_tokptr->TokInfo), OpProperty))) {
Prop save_opinfo = opinfo; Prop save_opinfo = opinfo;
if (IsInfixOp(opinfo, &opprio, &oplprio, &oprprio) if (IsInfixOp(opinfo, &opprio, &oplprio, &oprprio)
&& opprio <= prio && oplprio >= curprio) { && opprio <= prio && oplprio >= curprio) {
/* try parsing as infix operator */ /* try parsing as infix operator */
Volatile int oldprio = curprio; Volatile int oldprio = curprio;
TRY3( TRY3(
func = _YAP_MkFunctor((Atom) _YAP_tokptr->TokInfo, 2); func = Yap_MkFunctor((Atom) Yap_tokptr->TokInfo, 2);
NextToken; NextToken;
{ {
Term args[2]; Term args[2];
args[0] = t; args[0] = t;
args[1] = ParseTerm(oprprio); args[1] = ParseTerm(oprprio);
t = _YAP_MkApplTerm(func, 2, args); t = Yap_MkApplTerm(func, 2, args);
/* check for possible overflow against local stack */ /* check for possible overflow against local stack */
if (H > ASP-4096) { if (H > ASP-4096) {
_YAP_ErrorMessage = "Stack Overflow"; Yap_ErrorMessage = "Stack Overflow";
FAIL; FAIL;
} }
}, },
@ -578,10 +578,10 @@ ParseTerm(int prio)
if (IsPosfixOp(opinfo, &opprio, &oplprio) if (IsPosfixOp(opinfo, &opprio, &oplprio)
&& opprio <= prio && oplprio >= curprio) { && opprio <= prio && oplprio >= curprio) {
/* parse as posfix operator */ /* parse as posfix operator */
t = _YAP_MkApplTerm(_YAP_MkFunctor((Atom) _YAP_tokptr->TokInfo, 1), 1, &t); t = Yap_MkApplTerm(Yap_MkFunctor((Atom) Yap_tokptr->TokInfo, 1), 1, &t);
/* check for possible overflow against local stack */ /* check for possible overflow against local stack */
if (H > ASP-4096) { if (H > ASP-4096) {
_YAP_ErrorMessage = "Stack Overflow"; Yap_ErrorMessage = "Stack Overflow";
FAIL; FAIL;
} }
curprio = opprio; curprio = opprio;
@ -590,38 +590,38 @@ ParseTerm(int prio)
} }
break; break;
} }
if (_YAP_tokptr->Tok == Ord(Ponctuation_tok)) { if (Yap_tokptr->Tok == Ord(Ponctuation_tok)) {
if (Unsigned(_YAP_tokptr->TokInfo) == ',' && if (Unsigned(Yap_tokptr->TokInfo) == ',' &&
prio >= 1000 && curprio <= 999) { prio >= 1000 && curprio <= 999) {
Volatile Term args[2]; Volatile Term args[2];
NextToken; NextToken;
args[0] = t; args[0] = t;
args[1] = ParseTerm(1000); args[1] = ParseTerm(1000);
t = _YAP_MkApplTerm(_YAP_MkFunctor(AtomComma, 2), 2, args); t = Yap_MkApplTerm(Yap_MkFunctor(AtomComma, 2), 2, args);
/* check for possible overflow against local stack */ /* check for possible overflow against local stack */
if (H > ASP-4096) { if (H > ASP-4096) {
_YAP_ErrorMessage = "Stack Overflow"; Yap_ErrorMessage = "Stack Overflow";
FAIL; FAIL;
} }
curprio = 1000; curprio = 1000;
continue; continue;
} else if (Unsigned(_YAP_tokptr->TokInfo) == '|' && prio >= 1100 && } else if (Unsigned(Yap_tokptr->TokInfo) == '|' && prio >= 1100 &&
curprio <= 1099) { curprio <= 1099) {
Volatile Term args[2]; Volatile Term args[2];
NextToken; NextToken;
args[0] = t; args[0] = t;
args[1] = ParseTerm(1100); args[1] = ParseTerm(1100);
t = _YAP_MkApplTerm(FunctorVBar, 2, args); t = Yap_MkApplTerm(FunctorVBar, 2, args);
/* check for possible overflow against local stack */ /* check for possible overflow against local stack */
if (H > ASP-4096) { if (H > ASP-4096) {
_YAP_ErrorMessage = "Stack Overflow"; Yap_ErrorMessage = "Stack Overflow";
FAIL; FAIL;
} }
curprio = 1100; curprio = 1100;
continue; continue;
} }
} }
if (_YAP_tokptr->Tok <= Ord(String_tok)) if (Yap_tokptr->Tok <= Ord(String_tok))
FAIL; FAIL;
break; break;
} }
@ -630,12 +630,12 @@ ParseTerm(int prio)
Term Term
_YAP_Parse(void) Yap_Parse(void)
{ {
Volatile Term t; Volatile Term t;
if (!setjmp(FailBuff.JmpBuff)) { if (!setjmp(FailBuff.JmpBuff)) {
t = ParseTerm(1200); t = ParseTerm(1200);
if (_YAP_tokptr->Tok != Ord(eot_tok)) if (Yap_tokptr->Tok != Ord(eot_tok))
return (0L); return (0L);
return (t); return (t);
} else } else

304
C/save.c
View File

@ -164,7 +164,7 @@ myread(int fd, char *buff, Int len)
while (len > 16000) { while (len > 16000) {
int nchars = read(fd, buff, 16000); int nchars = read(fd, buff, 16000);
if (nchars <= 0) if (nchars <= 0)
_YAP_Error(FATAL_ERROR,TermNil,"bad saved state, system corrupted"); Yap_Error(FATAL_ERROR,TermNil,"bad saved state, system corrupted");
len -= 16000; len -= 16000;
buff += 16000; buff += 16000;
} }
@ -191,7 +191,7 @@ void myread(int fd, char *buffer, Int len) {
while (len > 0) { while (len > 0) {
nread = read(fd, buffer, (int)len); nread = read(fd, buffer, (int)len);
if (nread < 1) { if (nread < 1) {
_YAP_Error(FATAL_ERROR,TermNil,"bad saved state, system corrupted"); Yap_Error(FATAL_ERROR,TermNil,"bad saved state, system corrupted");
} }
buffer += nread; buffer += nread;
len -= nread; len -= nread;
@ -205,7 +205,7 @@ void mywrite(int fd, char *buff, Int len) {
while (len > 0) { while (len > 0) {
nwritten = (Int)write(fd, buff, (int)len); nwritten = (Int)write(fd, buff, (int)len);
if (nwritten == -1) { if (nwritten == -1) {
_YAP_Error(SYSTEM_ERROR,TermNil,"write error while saving"); Yap_Error(SYSTEM_ERROR,TermNil,"write error while saving");
} }
buff += nwritten; buff += nwritten;
len -= nwritten; len -= nwritten;
@ -229,7 +229,7 @@ static int splfild = 0;
#ifdef DEBUG_RESTORE4 #ifdef DEBUG_RESTORE4
static FILE *errout; static FILE *errout;
#else #else
#define errout _YAP_stderr #define errout Yap_stderr
#endif #endif
#endif /* DEBUG */ #endif /* DEBUG */
@ -311,7 +311,7 @@ get_header_cell(void)
int count = 0, n; int count = 0, n;
while (count < sizeof(CELL)) { while (count < sizeof(CELL)) {
if ((n = read(splfild, &l, sizeof(CELL)-count)) < 0) { if ((n = read(splfild, &l, sizeof(CELL)-count)) < 0) {
_YAP_ErrorMessage = "corrupt saved state"; Yap_ErrorMessage = "corrupt saved state";
return(0L); return(0L);
} }
count += n; count += n;
@ -350,25 +350,25 @@ put_info(int info, int mode)
/* current state of stacks, to be used by SavedInfo */ /* current state of stacks, to be used by SavedInfo */
#if defined(YAPOR) || defined(TABLING) #if defined(YAPOR) || defined(TABLING)
/* space available in heap area */ /* space available in heap area */
putout(Unsigned(_YAP_GlobalBase)-Unsigned(_YAP_HeapBase)); putout(Unsigned(Yap_GlobalBase)-Unsigned(Yap_HeapBase));
/* space available for stacks */ /* space available for stacks */
putout(Unsigned(_YAP_LocalBase)-Unsigned(_YAP_GlobalBase)+CellSize); putout(Unsigned(Yap_LocalBase)-Unsigned(Yap_GlobalBase)+CellSize);
#else #else
/* space available in heap area */ /* space available in heap area */
putout(Unsigned(_YAP_GlobalBase)-Unsigned(_YAP_HeapBase)); putout(Unsigned(Yap_GlobalBase)-Unsigned(Yap_HeapBase));
/* space available for stacks */ /* space available for stacks */
putout(Unsigned(_YAP_LocalBase)-Unsigned(_YAP_GlobalBase)); putout(Unsigned(Yap_LocalBase)-Unsigned(Yap_GlobalBase));
#endif /* YAPOR || TABLING */ #endif /* YAPOR || TABLING */
/* space available for trail */ /* space available for trail */
putout(Unsigned(_YAP_TrailTop)-Unsigned(_YAP_TrailBase)); putout(Unsigned(Yap_TrailTop)-Unsigned(Yap_TrailBase));
/* Space used in heap area */ /* Space used in heap area */
putout(Unsigned(HeapTop)-Unsigned(_YAP_HeapBase)); putout(Unsigned(HeapTop)-Unsigned(Yap_HeapBase));
/* Space used for local stack */ /* Space used for local stack */
putout(Unsigned(LCL0)-Unsigned(ASP)); putout(Unsigned(LCL0)-Unsigned(ASP));
/* Space used for global stack */ /* Space used for global stack */
putout(Unsigned(H) - Unsigned(_YAP_GlobalBase)); putout(Unsigned(H) - Unsigned(Yap_GlobalBase));
/* Space used for trail */ /* Space used for trail */
putout(Unsigned(TR) - Unsigned(_YAP_TrailBase)); putout(Unsigned(TR) - Unsigned(Yap_TrailBase));
} }
static void static void
@ -413,7 +413,7 @@ save_regs(int mode)
putout(which_save); putout(which_save);
/* Now start by saving the code */ /* Now start by saving the code */
/* the heap boundaries */ /* the heap boundaries */
putcellptr(CellPtr(_YAP_HeapBase)); putcellptr(CellPtr(Yap_HeapBase));
putcellptr(CellPtr(HeapTop)); putcellptr(CellPtr(HeapTop));
/* and the space it ocuppies */ /* and the space it ocuppies */
putout(Unsigned(HeapUsed)); putout(Unsigned(HeapUsed));
@ -425,7 +425,7 @@ save_regs(int mode)
if (which_save == 2) { if (which_save == 2) {
putout(ARG2); putout(ARG2);
} }
putcellptr(CellPtr(_YAP_TrailBase)); putcellptr(CellPtr(Yap_TrailBase));
} }
} }
@ -439,7 +439,7 @@ save_code_info(void)
OPCODE my_ops[_std_top+1]; OPCODE my_ops[_std_top+1];
for (i = _Ystop; i <= _std_top; ++i) for (i = _Ystop; i <= _std_top; ++i)
my_ops[i] = _YAP_opcode(i); my_ops[i] = Yap_opcode(i);
mywrite(splfild, (char *)my_ops, sizeof(OPCODE)*(_std_top+1)); mywrite(splfild, (char *)my_ops, sizeof(OPCODE)*(_std_top+1));
} }
/* Then the c-functions */ /* Then the c-functions */
@ -447,19 +447,19 @@ save_code_info(void)
{ {
UInt i; UInt i;
for (i = 0; i < NumberOfCPreds; ++i) for (i = 0; i < NumberOfCPreds; ++i)
putcellptr(CellPtr(_YAP_c_predicates[i])); putcellptr(CellPtr(Yap_c_predicates[i]));
} }
/* Then the cmp-functions */ /* Then the cmp-functions */
putout(NumberOfCmpFuncs); putout(NumberOfCmpFuncs);
{ {
UInt i; UInt i;
for (i = 0; i < NumberOfCmpFuncs; ++i) { for (i = 0; i < NumberOfCmpFuncs; ++i) {
putcellptr(CellPtr(_YAP_cmp_funcs[i].p)); putcellptr(CellPtr(Yap_cmp_funcs[i].p));
putcellptr(CellPtr(_YAP_cmp_funcs[i].f)); putcellptr(CellPtr(Yap_cmp_funcs[i].f));
} }
} }
/* and the current character codes */ /* and the current character codes */
mywrite(splfild, _YAP_chtype, NUMBER_OF_CHARS); mywrite(splfild, Yap_chtype, NUMBER_OF_CHARS);
} }
static void static void
@ -469,9 +469,9 @@ save_heap(void)
/* Then save the whole heap */ /* Then save the whole heap */
#if defined(YAPOR) || defined(TABLING) #if defined(YAPOR) || defined(TABLING)
/* skip the local and global data structures */ /* skip the local and global data structures */
j = Unsigned(&GLOBAL) - Unsigned(_YAP_HeapBase); j = Unsigned(&GLOBAL) - Unsigned(Yap_HeapBase);
putout(j); putout(j);
mywrite(splfild, (char *) _YAP_HeapBase, j); mywrite(splfild, (char *) Yap_HeapBase, j);
#ifdef USE_HEAP #ifdef USE_HEAP
j = Unsigned(HeapTop) - Unsigned(&HashChain); j = Unsigned(HeapTop) - Unsigned(&HashChain);
putout(j); putout(j);
@ -485,9 +485,9 @@ save_heap(void)
mywrite(splfild, (char *) TopAllocBlockArea, j); mywrite(splfild, (char *) TopAllocBlockArea, j);
#endif #endif
#else #else
j = Unsigned(HeapTop) - Unsigned(_YAP_HeapBase); j = Unsigned(HeapTop) - Unsigned(Yap_HeapBase);
/* store 10 more cells because of the memory manager */ /* store 10 more cells because of the memory manager */
mywrite(splfild, (char *) _YAP_HeapBase, j); mywrite(splfild, (char *) Yap_HeapBase, j);
#endif #endif
} }
@ -503,16 +503,16 @@ save_stacks(int mode)
j = Unsigned(LCL0) - Unsigned(ASP); j = Unsigned(LCL0) - Unsigned(ASP);
mywrite(splfild, (char *) ASP, j); mywrite(splfild, (char *) ASP, j);
/* Save the global stack */ /* Save the global stack */
j = Unsigned(H) - Unsigned(_YAP_GlobalBase); j = Unsigned(H) - Unsigned(Yap_GlobalBase);
mywrite(splfild, (char *) _YAP_GlobalBase, j); mywrite(splfild, (char *) Yap_GlobalBase, j);
/* Save the trail */ /* Save the trail */
j = Unsigned(TR) - Unsigned(_YAP_TrailBase); j = Unsigned(TR) - Unsigned(Yap_TrailBase);
mywrite(splfild, (char *) _YAP_TrailBase, j); mywrite(splfild, (char *) Yap_TrailBase, j);
break; break;
case DO_ONLY_CODE: case DO_ONLY_CODE:
{ {
tr_fr_ptr tr_ptr = TR; tr_fr_ptr tr_ptr = TR;
while (tr_ptr != (tr_fr_ptr)_YAP_TrailBase) { while (tr_ptr != (tr_fr_ptr)Yap_TrailBase) {
CELL val = TrailTerm(tr_ptr-1); CELL val = TrailTerm(tr_ptr-1);
if (IsVarTerm(val)) { if (IsVarTerm(val)) {
CELL *d1 = VarOfTerm(val); CELL *d1 = VarOfTerm(val);
@ -550,13 +550,13 @@ do_save(int mode) {
NewFileInfo('YAPS', 'MYap'); NewFileInfo('YAPS', 'MYap');
#endif #endif
Term t1 = Deref(ARG1); Term t1 = Deref(ARG1);
if (!_YAP_GetName(_YAP_FileNameBuf, YAP_FILENAME_MAX, t1)) { if (!Yap_GetName(Yap_FileNameBuf, YAP_FILENAME_MAX, t1)) {
_YAP_Error(TYPE_ERROR_LIST,t1,"save/1"); Yap_Error(TYPE_ERROR_LIST,t1,"save/1");
return(FALSE); return(FALSE);
} }
_YAP_CloseStreams(TRUE); Yap_CloseStreams(TRUE);
if ((splfild = open_file(_YAP_FileNameBuf, O_WRONLY | O_CREAT)) < 0) { if ((splfild = open_file(Yap_FileNameBuf, O_WRONLY | O_CREAT)) < 0) {
_YAP_Error(SYSTEM_ERROR,MkAtomTerm(_YAP_LookupAtom(_YAP_FileNameBuf)), Yap_Error(SYSTEM_ERROR,MkAtomTerm(Yap_LookupAtom(Yap_FileNameBuf)),
"restore/1, open(%s)", strerror(errno)); "restore/1, open(%s)", strerror(errno));
return(FALSE); return(FALSE);
} }
@ -576,7 +576,7 @@ p_save(void)
{ {
#if defined(YAPOR) || defined(THREADS) #if defined(YAPOR) || defined(THREADS)
if (NOfThreads != 1) { if (NOfThreads != 1) {
_YAP_Error(SYSTEM_ERROR,TermNil,"cannot perform save: more than a worker/thread running"); Yap_Error(SYSTEM_ERROR,TermNil,"cannot perform save: more than a worker/thread running");
return(FALSE); return(FALSE);
} }
#endif #endif
@ -590,13 +590,13 @@ p_save2(void)
{ {
#if defined(YAPOR) || defined(THREADS) #if defined(YAPOR) || defined(THREADS)
if (NOfThreads != 1) { if (NOfThreads != 1) {
_YAP_Error(SYSTEM_ERROR,TermNil, Yap_Error(SYSTEM_ERROR,TermNil,
"cannot perform save: more than a worker/thread running"); "cannot perform save: more than a worker/thread running");
return(FALSE); return(FALSE);
} }
#endif #endif
which_save = 2; which_save = 2;
return(do_save(DO_EVERYTHING) && _YAP_unify(ARG2,MkIntTerm(1))); return(do_save(DO_EVERYTHING) && Yap_unify(ARG2,MkIntTerm(1)));
} }
/* Just save the program, not the stacks */ /* Just save the program, not the stacks */
@ -621,7 +621,7 @@ check_header(CELL *info, CELL *ATrail, CELL *AStack, CELL *AHeap)
/* skip the first line */ /* skip the first line */
do { do {
if (read(splfild, pp, 1) < 0) { if (read(splfild, pp, 1) < 0) {
_YAP_ErrorMessage = "corrupt saved state"; Yap_ErrorMessage = "corrupt saved state";
return(FAIL_RESTORE); return(FAIL_RESTORE);
} }
} while (pp[0] != 1); } while (pp[0] != 1);
@ -631,89 +631,89 @@ check_header(CELL *info, CELL *ATrail, CELL *AStack, CELL *AHeap)
int count = 0, n, to_read = Unsigned(strlen(msg) + 1); int count = 0, n, to_read = Unsigned(strlen(msg) + 1);
while (count < to_read) { while (count < to_read) {
if ((n = read(splfild, pp, to_read-count)) < 0) { if ((n = read(splfild, pp, to_read-count)) < 0) {
_YAP_ErrorMessage = "corrupt saved state"; Yap_ErrorMessage = "corrupt saved state";
return(FAIL_RESTORE); return(FAIL_RESTORE);
} }
count += n; count += n;
} }
} }
if (pp[0] != 'Y' && pp[1] != 'A' && pp[0] != 'P') { if (pp[0] != 'Y' && pp[1] != 'A' && pp[0] != 'P') {
_YAP_ErrorMessage = "corrupt saved state"; Yap_ErrorMessage = "corrupt saved state";
return(FAIL_RESTORE); return(FAIL_RESTORE);
} }
if (strcmp(pp, msg) != 0) { if (strcmp(pp, msg) != 0) {
_YAP_ErrorMessage = "saved state for different version of YAP"; Yap_ErrorMessage = "saved state for different version of YAP";
return(FAIL_RESTORE); return(FAIL_RESTORE);
} }
/* check info on header */ /* check info on header */
/* ignore info on saved state */ /* ignore info on saved state */
*info = get_header_cell(); *info = get_header_cell();
if (_YAP_ErrorMessage) if (Yap_ErrorMessage)
return(FAIL_RESTORE); return(FAIL_RESTORE);
/* check the restore mode */ /* check the restore mode */
mode = get_header_cell(); mode = get_header_cell();
if (_YAP_ErrorMessage) if (Yap_ErrorMessage)
return(FAIL_RESTORE); return(FAIL_RESTORE);
/* check the number of c-predicates */ /* check the number of c-predicates */
c_preds = get_header_cell(); c_preds = get_header_cell();
if (_YAP_ErrorMessage) if (Yap_ErrorMessage)
return(FAIL_RESTORE); return(FAIL_RESTORE);
if (_YAP_HeapBase != NULL && c_preds != NumberOfCPreds) { if (Yap_HeapBase != NULL && c_preds != NumberOfCPreds) {
_YAP_ErrorMessage = "saved state with different number of built-ins"; Yap_ErrorMessage = "saved state with different number of built-ins";
return(FAIL_RESTORE); return(FAIL_RESTORE);
} }
cmp_funcs = get_header_cell(); cmp_funcs = get_header_cell();
if (_YAP_ErrorMessage) if (Yap_ErrorMessage)
return(FAIL_RESTORE); return(FAIL_RESTORE);
if (_YAP_HeapBase != NULL && cmp_funcs != NumberOfCmpFuncs) { if (Yap_HeapBase != NULL && cmp_funcs != NumberOfCmpFuncs) {
_YAP_ErrorMessage = "saved state with different built-ins"; Yap_ErrorMessage = "saved state with different built-ins";
return(FAIL_RESTORE); return(FAIL_RESTORE);
} }
if (mode != DO_EVERYTHING && mode != DO_ONLY_CODE) { if (mode != DO_EVERYTHING && mode != DO_ONLY_CODE) {
_YAP_ErrorMessage = "corrupt saved state"; Yap_ErrorMessage = "corrupt saved state";
return(FAIL_RESTORE); return(FAIL_RESTORE);
} }
/* ignore info on stacks size */ /* ignore info on stacks size */
*AHeap = get_header_cell(); *AHeap = get_header_cell();
*AStack = get_header_cell(); *AStack = get_header_cell();
*ATrail = get_header_cell(); *ATrail = get_header_cell();
if (_YAP_ErrorMessage) if (Yap_ErrorMessage)
return(FAIL_RESTORE); return(FAIL_RESTORE);
/* now, check whether we got enough enough space to load the /* now, check whether we got enough enough space to load the
saved space */ saved space */
hp_size = get_cell(); hp_size = get_cell();
if (_YAP_ErrorMessage) if (Yap_ErrorMessage)
return(FAIL_RESTORE); return(FAIL_RESTORE);
while (_YAP_HeapBase != NULL && hp_size > Unsigned(AuxTop) - Unsigned(_YAP_HeapBase)) { while (Yap_HeapBase != NULL && hp_size > Unsigned(AuxTop) - Unsigned(Yap_HeapBase)) {
if(!_YAP_growheap(FALSE)) { if(!Yap_growheap(FALSE)) {
return(FAIL_RESTORE); return(FAIL_RESTORE);
} }
} }
if (mode == DO_EVERYTHING) { if (mode == DO_EVERYTHING) {
lc_size = get_cell(); lc_size = get_cell();
if (_YAP_ErrorMessage) if (Yap_ErrorMessage)
return(FAIL_RESTORE); return(FAIL_RESTORE);
gb_size=get_cell(); gb_size=get_cell();
if (_YAP_ErrorMessage) if (Yap_ErrorMessage)
return(FAIL_RESTORE); return(FAIL_RESTORE);
if (_YAP_HeapBase != NULL && lc_size+gb_size > Unsigned(_YAP_LocalBase) - Unsigned(_YAP_GlobalBase)) { if (Yap_HeapBase != NULL && lc_size+gb_size > Unsigned(Yap_LocalBase) - Unsigned(Yap_GlobalBase)) {
_YAP_ErrorMessage = "not enough stack space for restore"; Yap_ErrorMessage = "not enough stack space for restore";
return(FAIL_RESTORE); return(FAIL_RESTORE);
} }
if (_YAP_HeapBase != NULL && (tr_size = get_cell()) > Unsigned(_YAP_TrailTop) - Unsigned(_YAP_TrailBase)) { if (Yap_HeapBase != NULL && (tr_size = get_cell()) > Unsigned(Yap_TrailTop) - Unsigned(Yap_TrailBase)) {
_YAP_ErrorMessage = "not enough trail space for restore"; Yap_ErrorMessage = "not enough trail space for restore";
return(FAIL_RESTORE); return(FAIL_RESTORE);
} }
} else { } else {
/* skip cell size */ /* skip cell size */
get_header_cell(); get_header_cell();
if (_YAP_ErrorMessage) if (Yap_ErrorMessage)
return(FAIL_RESTORE); return(FAIL_RESTORE);
get_header_cell(); get_header_cell();
if (_YAP_ErrorMessage) if (Yap_ErrorMessage)
return(FAIL_RESTORE); return(FAIL_RESTORE);
get_header_cell(); get_header_cell();
if (_YAP_ErrorMessage) if (Yap_ErrorMessage)
return(FAIL_RESTORE); return(FAIL_RESTORE);
} }
return(mode); return(mode);
@ -727,7 +727,7 @@ get_heap_info(void)
OldHeapTop = (ADDR) get_cellptr(); OldHeapTop = (ADDR) get_cellptr();
OldHeapUsed = (Int) get_cell(); OldHeapUsed = (Int) get_cell();
FreeBlocks = (BlockHeader *) get_cellptr(); FreeBlocks = (BlockHeader *) get_cellptr();
HDiff = Unsigned(_YAP_HeapBase) - Unsigned(OldHeapBase); HDiff = Unsigned(Yap_HeapBase) - Unsigned(OldHeapBase);
} }
/* Gets the register array */ /* Gets the register array */
@ -736,7 +736,7 @@ get_heap_info(void)
static void static void
get_regs(int flag) get_regs(int flag)
{ {
CELL *NewGlobalBase = (CELL *)_YAP_GlobalBase; CELL *NewGlobalBase = (CELL *)Yap_GlobalBase;
CELL *NewLCL0 = LCL0; CELL *NewLCL0 = LCL0;
CELL *OldXREGS; CELL *OldXREGS;
@ -788,13 +788,13 @@ get_regs(int flag)
/* Save the old register where we can easily access them */ /* Save the old register where we can easily access them */
OldASP = ASP; OldASP = ASP;
OldLCL0 = LCL0; OldLCL0 = LCL0;
OldGlobalBase = (CELL *)_YAP_GlobalBase; OldGlobalBase = (CELL *)Yap_GlobalBase;
OldH = H; OldH = H;
OldTR = TR; OldTR = TR;
GDiff = Unsigned(NewGlobalBase) - Unsigned(_YAP_GlobalBase); GDiff = Unsigned(NewGlobalBase) - Unsigned(Yap_GlobalBase);
LDiff = Unsigned(NewLCL0) - Unsigned(LCL0); LDiff = Unsigned(NewLCL0) - Unsigned(LCL0);
TrDiff = LDiff; TrDiff = LDiff;
_YAP_GlobalBase = (ADDR)NewGlobalBase; Yap_GlobalBase = (ADDR)NewGlobalBase;
LCL0 = NewLCL0; LCL0 = NewLCL0;
} }
} }
@ -815,17 +815,17 @@ check_funcs(void)
int out = FALSE; int out = FALSE;
if ((old_NumberOfCPreds = get_cell()) != NumberOfCPreds) { if ((old_NumberOfCPreds = get_cell()) != NumberOfCPreds) {
_YAP_Error(SYSTEM_ERROR,TermNil,"bad saved state, different number of functions (%d vs %d), system corrupted, old_NumberOfCPreds, NumberOfCPreds"); Yap_Error(SYSTEM_ERROR,TermNil,"bad saved state, different number of functions (%d vs %d), system corrupted, old_NumberOfCPreds, NumberOfCPreds");
} }
{ {
unsigned int i; unsigned int i;
for (i = 0; i < old_NumberOfCPreds; ++i) { for (i = 0; i < old_NumberOfCPreds; ++i) {
CELL *old_pred = get_cellptr(); CELL *old_pred = get_cellptr();
out = (out || old_pred != CellPtr(_YAP_c_predicates[i])); out = (out || old_pred != CellPtr(Yap_c_predicates[i]));
} }
} }
if ((old_NumberOfCmpFuncs = get_cell()) != NumberOfCmpFuncs) { if ((old_NumberOfCmpFuncs = get_cell()) != NumberOfCmpFuncs) {
_YAP_Error(SYSTEM_ERROR,TermNil,"bad saved state, different number of comparison functions (%d vs %d), system corrupted", old_NumberOfCmpFuncs, NumberOfCmpFuncs); Yap_Error(SYSTEM_ERROR,TermNil,"bad saved state, different number of comparison functions (%d vs %d), system corrupted", old_NumberOfCmpFuncs, NumberOfCmpFuncs);
} }
{ {
unsigned int i; unsigned int i;
@ -834,11 +834,11 @@ check_funcs(void)
CELL *old_f = get_cellptr(); CELL *old_f = get_cellptr();
/* if (AddrAdjust((ADDR)old_p) != cmp_funcs[i].p) { /* if (AddrAdjust((ADDR)old_p) != cmp_funcs[i].p) {
_YAP_Error(SYSTEM_ERROR,TermNil,"bad saved state, comparison function is in wrong place (%p vs %p), system corrupted", AddrAdjust((ADDR)old_p), cmp_funcs[i].p); Yap_Error(SYSTEM_ERROR,TermNil,"bad saved state, comparison function is in wrong place (%p vs %p), system corrupted", AddrAdjust((ADDR)old_p), cmp_funcs[i].p);
} */ } */
_YAP_cmp_funcs[i].p = (PredEntry *)AddrAdjust((ADDR)old_p); Yap_cmp_funcs[i].p = (PredEntry *)AddrAdjust((ADDR)old_p);
out = (out || out = (out ||
old_f != CellPtr(_YAP_cmp_funcs[i].f)); old_f != CellPtr(Yap_cmp_funcs[i].f));
} }
} }
return(out); return(out);
@ -848,7 +848,7 @@ check_funcs(void)
static void static void
get_hash(void) get_hash(void)
{ {
myread(splfild, _YAP_chtype , NUMBER_OF_CHARS); myread(splfild, Yap_chtype , NUMBER_OF_CHARS);
} }
/* Copy all of the old code to the new Heap */ /* Copy all of the old code to the new Heap */
@ -858,24 +858,24 @@ CopyCode(void)
#if defined(YAPOR) || defined(TABLING) #if defined(YAPOR) || defined(TABLING)
/* skip the local and global data structures */ /* skip the local and global data structures */
CELL j = get_cell(); CELL j = get_cell();
if (j != Unsigned(&GLOBAL) - Unsigned(_YAP_HeapBase)) { if (j != Unsigned(&GLOBAL) - Unsigned(Yap_HeapBase)) {
_YAP_Error(FATAL_ERROR,TermNil,"bad saved state, system corrupted"); Yap_Error(FATAL_ERROR,TermNil,"bad saved state, system corrupted");
} }
myread(splfild, (char *) _YAP_HeapBase, j); myread(splfild, (char *) Yap_HeapBase, j);
#ifdef USE_HEAP #ifdef USE_HEAP
j = get_cell(); j = get_cell();
myread(splfild, (char *) &HashChain, j); myread(splfild, (char *) &HashChain, j);
#else #else
j = get_cell(); j = get_cell();
if (j != Unsigned(BaseAllocArea) - Unsigned(&HashChain)) { if (j != Unsigned(BaseAllocArea) - Unsigned(&HashChain)) {
_YAP_Error(FATAL_ERROR,TermNil,"bad saved state, system corrupted"); Yap_Error(FATAL_ERROR,TermNil,"bad saved state, system corrupted");
} }
myread(splfild, (char *) &HashChain, j); myread(splfild, (char *) &HashChain, j);
j = get_cell(); j = get_cell();
myread(splfild, (char *) TopAllocBlockArea, j); myread(splfild, (char *) TopAllocBlockArea, j);
#endif #endif
#else #else
myread(splfild, (char *) _YAP_HeapBase, myread(splfild, (char *) Yap_HeapBase,
(Unsigned(OldHeapTop) - Unsigned(OldHeapBase))); (Unsigned(OldHeapTop) - Unsigned(OldHeapBase)));
#endif #endif
} }
@ -892,9 +892,9 @@ CopyStacks(void)
NewASP = (char *) (Unsigned(ASP) + (Unsigned(LCL0) - Unsigned(OldLCL0))); NewASP = (char *) (Unsigned(ASP) + (Unsigned(LCL0) - Unsigned(OldLCL0)));
myread(splfild, (char *) NewASP, j); myread(splfild, (char *) NewASP, j);
j = Unsigned(H) - Unsigned(OldGlobalBase); j = Unsigned(H) - Unsigned(OldGlobalBase);
myread(splfild, (char *) _YAP_GlobalBase, j); myread(splfild, (char *) Yap_GlobalBase, j);
j = Unsigned(TR) - Unsigned(OldTrailBase); j = Unsigned(TR) - Unsigned(OldTrailBase);
myread(splfild, _YAP_TrailBase, j); myread(splfild, Yap_TrailBase, j);
} }
/* Copy the local and global stack and also the trail to their new home */ /* Copy the local and global stack and also the trail to their new home */
@ -904,7 +904,7 @@ CopyTrailEntries(void)
{ {
CELL entry, *Entries; CELL entry, *Entries;
Entries = (CELL *)_YAP_TrailBase; Entries = (CELL *)Yap_TrailBase;
do { do {
*Entries++ = entry = get_cell(); *Entries++ = entry = get_cell();
} while ((CODEADDR)entry != NULL); } while ((CODEADDR)entry != NULL);
@ -933,7 +933,7 @@ get_coded(int flag, OPCODE old_ops[])
/* Check CRC */ /* Check CRC */
myread(splfild, my_end_msg, 256); myread(splfild, my_end_msg, 256);
if (strcmp(end_msg,my_end_msg) != 0) if (strcmp(end_msg,my_end_msg) != 0)
_YAP_Error(FATAL_ERROR,TermNil,"bad saved state, system corrupted"); Yap_Error(FATAL_ERROR,TermNil,"bad saved state, system corrupted");
return(funcs_moved); return(funcs_moved);
} }
@ -980,7 +980,7 @@ static void
recompute_mask(DBRef dbr) recompute_mask(DBRef dbr)
{ {
if (dbr->Flags & DBNoVars) { if (dbr->Flags & DBNoVars) {
dbr->Mask = _YAP_EvalMasks((Term) dbr->Entry, &(dbr->Key)); dbr->Mask = Yap_EvalMasks((Term) dbr->Entry, &(dbr->Key));
} else if (dbr->Flags & DBComplex) { } else if (dbr->Flags & DBComplex) {
/* This is quite nasty, we want to recalculate the mask but /* This is quite nasty, we want to recalculate the mask but
we don't want to rebuild the whole term. We'll just build whatever we we don't want to rebuild the whole term. We'll just build whatever we
@ -1025,7 +1025,7 @@ recompute_mask(DBRef dbr)
} }
x++; x++;
} }
dbr->Mask = _YAP_EvalMasks(out, &(dbr->Key)); dbr->Mask = Yap_EvalMasks(out, &(dbr->Key));
} }
} }
@ -1053,11 +1053,11 @@ rehash(CELL *oldcode, int NOfE, int KindOfEntries)
basep = H; basep = H;
if (H + (NOfE*2) > ASP) { if (H + (NOfE*2) > ASP) {
basep = (CELL *)TR; basep = (CELL *)TR;
if (basep + (NOfE*2) > (CELL *)_YAP_TrailTop) { if (basep + (NOfE*2) > (CELL *)Yap_TrailTop) {
if (!_YAP_growtrail((ADDR)(basep + (NOfE*2))-_YAP_TrailTop)) { if (!Yap_growtrail((ADDR)(basep + (NOfE*2))-Yap_TrailTop)) {
_YAP_Error(SYSTEM_ERROR, TermNil, Yap_Error(SYSTEM_ERROR, TermNil,
"not enough space to restore hash tables for indexing"); "not enough space to restore hash tables for indexing");
_YAP_exit(1); Yap_exit(1);
} }
} }
} }
@ -1109,7 +1109,7 @@ CCodeAdjust(PredEntry *pe, CODEADDR c)
{ {
/* add this code to a list of ccalls that must be adjusted */ /* add this code to a list of ccalls that must be adjusted */
return ((CODEADDR)(_YAP_c_predicates[pe->StateOfPred])); return ((CODEADDR)(Yap_c_predicates[pe->StateOfPred]));
} }
static CODEADDR static CODEADDR
@ -1117,7 +1117,7 @@ NextCCodeAdjust(PredEntry *pe, CODEADDR c)
{ {
/* add this code to a list of ccalls that must be adjusted */ /* add this code to a list of ccalls that must be adjusted */
return ((CODEADDR)(_YAP_c_predicates[pe->StateOfPred+1])); return ((CODEADDR)(Yap_c_predicates[pe->StateOfPred+1]));
} }
@ -1127,11 +1127,11 @@ DirectCCodeAdjust(PredEntry *pe, CODEADDR c)
/* add this code to a list of ccalls that must be adjusted */ /* add this code to a list of ccalls that must be adjusted */
unsigned int i; unsigned int i;
for (i = 0; i < NumberOfCmpFuncs; i++) { for (i = 0; i < NumberOfCmpFuncs; i++) {
if (_YAP_cmp_funcs[i].p == pe) { if (Yap_cmp_funcs[i].p == pe) {
return((CODEADDR)(_YAP_cmp_funcs[i].f)); return((CODEADDR)(Yap_cmp_funcs[i].f));
} }
} }
_YAP_Error(FATAL_ERROR,TermNil,"bad saved state, ccalls corrupted"); Yap_Error(FATAL_ERROR,TermNil,"bad saved state, ccalls corrupted");
return(NULL); return(NULL);
} }
@ -1181,7 +1181,7 @@ RestoreForeignCodeStructure(void)
static void static void
RestoreIOStructures(void) RestoreIOStructures(void)
{ {
_YAP_InitStdStreams(); Yap_InitStdStreams();
} }
/* restores the list of free space, with its curious structure */ /* restores the list of free space, with its curious structure */
@ -1272,7 +1272,7 @@ ShowEntries(pp)
PropEntry *pp; PropEntry *pp;
{ {
while (!EndOfPAEntr(pp)) { while (!EndOfPAEntr(pp)) {
fprintf(_YAP_stderr,"Estou a ver a prop %x em %x\n", pp->KindOfPE, pp); fprintf(Yap_stderr,"Estou a ver a prop %x em %x\n", pp->KindOfPE, pp);
pp = RepProp(pp->NextOfPE); pp = RepProp(pp->NextOfPE);
} }
} }
@ -1287,7 +1287,7 @@ ShowAtoms()
AtomEntry *at; AtomEntry *at;
at = RepAtom(HashPtr->Entry); at = RepAtom(HashPtr->Entry);
do { do {
fprintf(_YAP_stderr,"Passei ao %s em %x\n", at->StrOfAE, at); fprintf(Yap_stderr,"Passei ao %s em %x\n", at->StrOfAE, at);
ShowEntries(RepProp(at->PropsOfAE)); ShowEntries(RepProp(at->PropsOfAE));
} while (!EndOfPAEntr(at = RepAtom(at->NextOfAE))); } while (!EndOfPAEntr(at = RepAtom(at->NextOfAE)));
} }
@ -1305,19 +1305,19 @@ commit_to_saved_state(char *s, CELL *Astate, CELL *ATrail, CELL *AStack, CELL *A
if ((mode = check_header(Astate,ATrail,AStack,AHeap)) == FAIL_RESTORE) if ((mode = check_header(Astate,ATrail,AStack,AHeap)) == FAIL_RESTORE)
return(FAIL_RESTORE); return(FAIL_RESTORE);
_YAP_PrologMode = BootMode; Yap_PrologMode = BootMode;
if (_YAP_HeapBase) { if (Yap_HeapBase) {
if (!yap_flags[HALT_AFTER_CONSULT_FLAG]) { if (!yap_flags[HALT_AFTER_CONSULT_FLAG]) {
_YAP_TrueFileName(s,_YAP_FileNameBuf2, YAP_FILENAME_MAX); Yap_TrueFileName(s,Yap_FileNameBuf2, YAP_FILENAME_MAX);
fprintf(_YAP_stderr, "[ Restoring file %s ]\n", _YAP_FileNameBuf2); fprintf(Yap_stderr, "[ Restoring file %s ]\n", Yap_FileNameBuf2);
} }
_YAP_CloseStreams(TRUE); Yap_CloseStreams(TRUE);
} }
#ifdef DEBUG_RESTORE4 #ifdef DEBUG_RESTORE4
/* /*
* This should be another file, like the log file * This should be another file, like the log file
*/ */
errout = _YAP_stderr; errout = Yap_stderr;
#endif #endif
return(mode); return(mode);
} }
@ -1339,22 +1339,22 @@ OpenRestore(char *inpf, char *YapLibDir, CELL *Astate, CELL *ATrail, CELL *AStac
{ {
int mode = FAIL_RESTORE; int mode = FAIL_RESTORE;
_YAP_ErrorMessage = NULL; Yap_ErrorMessage = NULL;
if (inpf == NULL) if (inpf == NULL)
inpf = StartUpFile; inpf = StartUpFile;
if (inpf != NULL && (splfild = open_file(inpf, O_RDONLY)) > 0) { if (inpf != NULL && (splfild = open_file(inpf, O_RDONLY)) > 0) {
if ((mode = commit_to_saved_state(inpf,Astate,ATrail,AStack,AHeap)) != FAIL_RESTORE) if ((mode = commit_to_saved_state(inpf,Astate,ATrail,AStack,AHeap)) != FAIL_RESTORE)
return(mode); return(mode);
} }
if (!_YAP_dir_separator(inpf[0]) && !_YAP_volume_header(inpf)) { if (!Yap_dir_separator(inpf[0]) && !Yap_volume_header(inpf)) {
/* /*
we have a relative path for the file, try to do somewhat better we have a relative path for the file, try to do somewhat better
using YAPLIBDIR or friends. using YAPLIBDIR or friends.
*/ */
if (YapLibDir != NULL) { if (YapLibDir != NULL) {
cat_file_name(_YAP_FileNameBuf, Yap_LibDir, inpf, YAP_FILENAME_MAX); cat_file_name(Yap_FileNameBuf, Yap_LibDir, inpf, YAP_FILENAME_MAX);
if ((splfild = open_file(_YAP_FileNameBuf, O_RDONLY)) > 0) { if ((splfild = open_file(Yap_FileNameBuf, O_RDONLY)) > 0) {
if ((mode = commit_to_saved_state(_YAP_FileNameBuf,Astate,ATrail,AStack,AHeap)) != FAIL_RESTORE) if ((mode = commit_to_saved_state(Yap_FileNameBuf,Astate,ATrail,AStack,AHeap)) != FAIL_RESTORE)
return(mode); return(mode);
} }
} }
@ -1362,24 +1362,24 @@ OpenRestore(char *inpf, char *YapLibDir, CELL *Astate, CELL *ATrail, CELL *AStac
{ {
char *yap_env = getenv("YAPLIBDIR"); char *yap_env = getenv("YAPLIBDIR");
if (yap_env != NULL) { if (yap_env != NULL) {
cat_file_name(_YAP_FileNameBuf, yap_env, inpf, YAP_FILENAME_MAX); cat_file_name(Yap_FileNameBuf, yap_env, inpf, YAP_FILENAME_MAX);
if ((splfild = open_file(_YAP_FileNameBuf, O_RDONLY)) > 0) { if ((splfild = open_file(Yap_FileNameBuf, O_RDONLY)) > 0) {
if ((mode = commit_to_saved_state(_YAP_FileNameBuf,Astate,ATrail,AStack,AHeap)) != FAIL_RESTORE) if ((mode = commit_to_saved_state(Yap_FileNameBuf,Astate,ATrail,AStack,AHeap)) != FAIL_RESTORE)
return(mode); return(mode);
} }
} }
} }
#endif #endif
if (LIB_DIR != NULL) { if (LIB_DIR != NULL) {
cat_file_name(_YAP_FileNameBuf, LIB_DIR, inpf, YAP_FILENAME_MAX); cat_file_name(Yap_FileNameBuf, LIB_DIR, inpf, YAP_FILENAME_MAX);
if ((splfild = open_file(_YAP_FileNameBuf, O_RDONLY)) > 0) { if ((splfild = open_file(Yap_FileNameBuf, O_RDONLY)) > 0) {
if ((mode = commit_to_saved_state(_YAP_FileNameBuf,Astate,ATrail,AStack,AHeap)) != FAIL_RESTORE) if ((mode = commit_to_saved_state(Yap_FileNameBuf,Astate,ATrail,AStack,AHeap)) != FAIL_RESTORE)
return(mode); return(mode);
} }
} }
} }
_YAP_Error(SYSTEM_ERROR, TermNil, _YAP_ErrorMessage); Yap_Error(SYSTEM_ERROR, TermNil, Yap_ErrorMessage);
_YAP_ErrorMessage = NULL; Yap_ErrorMessage = NULL;
return(FAIL_RESTORE); return(FAIL_RESTORE);
} }
@ -1390,7 +1390,7 @@ CloseRestore(void)
ShowAtoms(); ShowAtoms();
#endif #endif
close_file(); close_file();
_YAP_PrologMode = UserMode; Yap_PrologMode = UserMode;
} }
static int static int
@ -1400,7 +1400,7 @@ check_opcodes(OPCODE old_ops[])
int have_shifted = FALSE; int have_shifted = FALSE;
op_numbers op = _Ystop; op_numbers op = _Ystop;
for (op = _Ystop; op < _std_top; op++) { for (op = _Ystop; op < _std_top; op++) {
if (_YAP_opcode(op) != old_ops[op]) { if (Yap_opcode(op) != old_ops[op]) {
have_shifted = TRUE; have_shifted = TRUE;
break; break;
} }
@ -1414,7 +1414,7 @@ check_opcodes(OPCODE old_ops[])
static void static void
RestoreHeap(OPCODE old_ops[], int functions_moved) RestoreHeap(OPCODE old_ops[], int functions_moved)
{ {
int heap_moved = (OldHeapBase != _YAP_HeapBase), opcodes_moved; int heap_moved = (OldHeapBase != Yap_HeapBase), opcodes_moved;
opcodes_moved = check_opcodes(old_ops); opcodes_moved = check_opcodes(old_ops);
/* opcodes_moved has side-effects and should be tried first */ /* opcodes_moved has side-effects and should be tried first */
@ -1425,9 +1425,9 @@ RestoreHeap(OPCODE old_ops[], int functions_moved)
if (heap_moved) { if (heap_moved) {
RestoreFreeSpace(); RestoreFreeSpace();
} }
_YAP_InitAbsmi(); Yap_InitAbsmi();
if (!(_YAP_ReInitConstExps() && _YAP_ReInitUnaryExps() && _YAP_ReInitBinaryExps())) if (!(Yap_ReInitConstExps() && Yap_ReInitUnaryExps() && Yap_ReInitBinaryExps()))
_YAP_Error(SYSTEM_ERROR, TermNil, "arithmetic operator not in saved state"); Yap_Error(SYSTEM_ERROR, TermNil, "arithmetic operator not in saved state");
#ifdef DEBUG_RESTORE1 #ifdef DEBUG_RESTORE1
fprintf(errout, "phase 1 done\n"); fprintf(errout, "phase 1 done\n");
#endif #endif
@ -1438,7 +1438,7 @@ RestoreHeap(OPCODE old_ops[], int functions_moved)
* state * state
*/ */
int int
_YAP_SavedInfo(char *FileName, char *YapLibDir, CELL *ATrail, CELL *AStack, CELL *AHeap) Yap_SavedInfo(char *FileName, char *YapLibDir, CELL *ATrail, CELL *AStack, CELL *AHeap)
{ {
CELL MyTrail, MyStack, MyHeap, MyState; CELL MyTrail, MyStack, MyHeap, MyState;
int mode; int mode;
@ -1446,7 +1446,7 @@ _YAP_SavedInfo(char *FileName, char *YapLibDir, CELL *ATrail, CELL *AStack, CELL
mode = OpenRestore(FileName, YapLibDir, &MyState, &MyTrail, &MyStack, &MyHeap); mode = OpenRestore(FileName, YapLibDir, &MyState, &MyTrail, &MyStack, &MyHeap);
close_file(); close_file();
if (mode == FAIL_RESTORE) { if (mode == FAIL_RESTORE) {
_YAP_ErrorMessage = NULL; Yap_ErrorMessage = NULL;
return(0); return(0);
} }
if (! *AHeap) if (! *AHeap)
@ -1467,7 +1467,7 @@ UnmarkTrEntries(void)
B = (choiceptr)LCL0; B = (choiceptr)LCL0;
B--; B--;
B->cp_ap = NOCODE; B->cp_ap = NOCODE;
Entries = (CELL *)_YAP_TrailBase; Entries = (CELL *)Yap_TrailBase;
while ((entry = *Entries++) != (CELL)NULL) { while ((entry = *Entries++) != (CELL)NULL) {
if (IsVarTerm(entry)) { if (IsVarTerm(entry)) {
RESET_VARIABLE((CELL *)entry); RESET_VARIABLE((CELL *)entry);
@ -1480,9 +1480,9 @@ UnmarkTrEntries(void)
Flags(ent) = flags; Flags(ent) = flags;
if (FlagOn(ErasedMask, flags)) { if (FlagOn(ErasedMask, flags)) {
if (FlagOn(DBClMask, flags)) { if (FlagOn(DBClMask, flags)) {
_YAP_ErDBE((DBRef) (ent - (CELL) &(((DBRef) NIL)->Flags))); Yap_ErDBE((DBRef) (ent - (CELL) &(((DBRef) NIL)->Flags)));
} else { } else {
_YAP_ErCl(ClauseFlagsToClause(ent)); Yap_ErCl(ClauseFlagsToClause(ent));
} }
} }
} }
@ -1509,7 +1509,7 @@ Restore(char *s, char *lib_dir)
CELL MyTrail, MyStack, MyHeap, MyState; CELL MyTrail, MyStack, MyHeap, MyState;
if ((restore_mode = OpenRestore(s, lib_dir, &MyState, &MyTrail, &MyStack, &MyHeap)) == FAIL_RESTORE) if ((restore_mode = OpenRestore(s, lib_dir, &MyState, &MyTrail, &MyStack, &MyHeap)) == FAIL_RESTORE)
return(FALSE); return(FALSE);
_YAP_ShutdownLoadForeign(); Yap_ShutdownLoadForeign();
in_limbo = TRUE; in_limbo = TRUE;
funcs_moved = get_coded(restore_mode, old_ops); funcs_moved = get_coded(restore_mode, old_ops);
restore_regs(restore_mode); restore_regs(restore_mode);
@ -1518,15 +1518,15 @@ Restore(char *s, char *lib_dir)
RestoreHeap(old_ops, funcs_moved); RestoreHeap(old_ops, funcs_moved);
switch(restore_mode) { switch(restore_mode) {
case DO_EVERYTHING: case DO_EVERYTHING:
if (OldHeapBase != _YAP_HeapBase || if (OldHeapBase != Yap_HeapBase ||
OldLCL0 != LCL0 || OldLCL0 != LCL0 ||
OldGlobalBase != (CELL *)_YAP_GlobalBase || OldGlobalBase != (CELL *)Yap_GlobalBase ||
OldTrailBase != _YAP_TrailBase) { OldTrailBase != Yap_TrailBase) {
_YAP_AdjustStacksAndTrail(); Yap_AdjustStacksAndTrail();
if (which_save == 2) { if (which_save == 2) {
_YAP_AdjustRegs(2); Yap_AdjustRegs(2);
} else { } else {
_YAP_AdjustRegs(1); Yap_AdjustRegs(1);
} }
break; break;
#ifdef DEBUG_RESTORE2 #ifdef DEBUG_RESTORE2
@ -1536,22 +1536,22 @@ Restore(char *s, char *lib_dir)
break; break;
case DO_ONLY_CODE: case DO_ONLY_CODE:
UnmarkTrEntries(); UnmarkTrEntries();
_YAP_InitYaamRegs(); Yap_InitYaamRegs();
break; break;
} }
_YAP_ReOpenLoadForeign(); Yap_ReOpenLoadForeign();
_YAP_InitPlIO(); Yap_InitPlIO();
/* reset time */ /* reset time */
_YAP_ReInitWallTime(); Yap_ReInitWallTime();
CloseRestore(); CloseRestore();
if (which_save == 2) { if (which_save == 2) {
_YAP_unify(ARG2, MkIntTerm(0)); Yap_unify(ARG2, MkIntTerm(0));
} }
return(restore_mode); return(restore_mode);
} }
int int
_YAP_Restore(char *s, char *lib_dir) Yap_Restore(char *s, char *lib_dir)
{ {
return Restore(s, lib_dir); return Restore(s, lib_dir);
} }
@ -1564,29 +1564,29 @@ p_restore(void)
Term t1 = Deref(ARG1); Term t1 = Deref(ARG1);
#if defined(YAPOR) || defined(THREADS) #if defined(YAPOR) || defined(THREADS)
if (NOfThreads != 1) { if (NOfThreads != 1) {
_YAP_Error(SYSTEM_ERROR,TermNil,"cannot perform save: more than a worker/thread running"); Yap_Error(SYSTEM_ERROR,TermNil,"cannot perform save: more than a worker/thread running");
return(FALSE); return(FALSE);
} }
#endif #endif
if (!_YAP_GetName(_YAP_FileNameBuf, YAP_FILENAME_MAX, t1)) { if (!Yap_GetName(Yap_FileNameBuf, YAP_FILENAME_MAX, t1)) {
_YAP_Error(TYPE_ERROR_LIST,t1,"restore/1"); Yap_Error(TYPE_ERROR_LIST,t1,"restore/1");
return(FALSE); return(FALSE);
} }
if ((mode = Restore(_YAP_FileNameBuf, NULL)) == DO_ONLY_CODE) { if ((mode = Restore(Yap_FileNameBuf, NULL)) == DO_ONLY_CODE) {
#if PUSH_REGS #if PUSH_REGS
restore_absmi_regs(&_YAP_standard_regs); restore_absmi_regs(&Yap_standard_regs);
#endif #endif
/* back to the top level we go */ /* back to the top level we go */
siglongjmp(_YAP_RestartEnv,3); siglongjmp(Yap_RestartEnv,3);
} }
return(mode != FAIL_RESTORE); return(mode != FAIL_RESTORE);
} }
void void
_YAP_InitSavePreds(void) Yap_InitSavePreds(void)
{ {
_YAP_InitCPred("$save", 1, p_save, SafePredFlag|SyncPredFlag); Yap_InitCPred("$save", 1, p_save, SafePredFlag|SyncPredFlag);
_YAP_InitCPred("$save", 2, p_save2, SafePredFlag|SyncPredFlag); Yap_InitCPred("$save", 2, p_save2, SafePredFlag|SyncPredFlag);
_YAP_InitCPred("$save_program", 1, p_save_program, SafePredFlag|SyncPredFlag); Yap_InitCPred("$save_program", 1, p_save_program, SafePredFlag|SyncPredFlag);
_YAP_InitCPred("$restore", 1, p_restore, SyncPredFlag); Yap_InitCPred("$restore", 1, p_restore, SyncPredFlag);
} }

232
C/scanner.c
View File

@ -125,7 +125,7 @@ EF,
}; };
#define chtype (chtype0+1) #define chtype (chtype0+1)
char *_YAP_chtype = chtype0+1; char *Yap_chtype = chtype0+1;
static int ch, chbuff, o_ch; static int ch, chbuff, o_ch;
@ -150,8 +150,8 @@ AllocScannerMemory(unsigned int size)
size = AdjustSize(size); size = AdjustSize(size);
TR = (tr_fr_ptr)(AuxSpScan+size); TR = (tr_fr_ptr)(AuxSpScan+size);
#if !OS_HANDLES_TR_OVERFLOW #if !OS_HANDLES_TR_OVERFLOW
if (Unsigned(_YAP_TrailTop) == Unsigned(TR)) { if (Unsigned(Yap_TrailTop) == Unsigned(TR)) {
if(!_YAP_growtrail (sizeof(CELL) * 16 * 1024L)) { if(!Yap_growtrail (sizeof(CELL) * 16 * 1024L)) {
return(NULL); return(NULL);
} }
} }
@ -160,7 +160,7 @@ AllocScannerMemory(unsigned int size)
} }
char * char *
_YAP_AllocScannerMemory(unsigned int size) Yap_AllocScannerMemory(unsigned int size)
{ {
return AllocScannerMemory(size); return AllocScannerMemory(size);
} }
@ -182,11 +182,11 @@ my_getch(void)
ch = chbuff; ch = chbuff;
} }
else { else {
ch = (*Nextch) (_YAP_c_input_stream); ch = (*Nextch) (Yap_c_input_stream);
} }
#ifdef DEBUG #ifdef DEBUG
if (_YAP_Option[1]) if (Yap_Option[1])
fprintf(_YAP_stderr, "[getch %c]", ch); fprintf(Yap_stderr, "[getch %c]", ch);
#endif #endif
return(ch); return(ch);
} }
@ -200,11 +200,11 @@ my_get_quoted_ch(void)
ch = chbuff; ch = chbuff;
} }
else { else {
ch = (*QuotedNextch) (_YAP_c_input_stream); ch = (*QuotedNextch) (Yap_c_input_stream);
} }
#ifdef DEBUG #ifdef DEBUG
if (_YAP_Option[1]) if (Yap_Option[1])
fprintf(_YAP_stderr, "[getch %c]",ch); fprintf(Yap_stderr, "[getch %c]",ch);
#endif #endif
return (ch); return (ch);
} }
@ -218,7 +218,7 @@ float_send(char *s)
#if HAVE_FINITE #if HAVE_FINITE
if (yap_flags[LANGUAGE_MODE_FLAG] == 1) { /* iso */ if (yap_flags[LANGUAGE_MODE_FLAG] == 1) { /* iso */
if (!finite(f)) { if (!finite(f)) {
_YAP_ErrorMessage = "Float overflow while scanning"; Yap_ErrorMessage = "Float overflow while scanning";
return(MkEvalFl(0.0)); return(MkEvalFl(0.0));
} }
} }
@ -232,10 +232,10 @@ read_int_overflow(const char *s, Int base, Int val)
{ {
#ifdef USE_GMP #ifdef USE_GMP
/* try to scan it as a bignum */ /* try to scan it as a bignum */
MP_INT *new = _YAP_PreAllocBigNum(); MP_INT *new = Yap_PreAllocBigNum();
mpz_init_set_str (new, s, base); mpz_init_set_str (new, s, base);
return(_YAP_MkBigIntTerm(new)); return(Yap_MkBigIntTerm(new));
#else #else
/* try to scan it as a float */ /* try to scan it as a float */
return(MkIntegerTerm(val)); return(MkIntegerTerm(val));
@ -264,7 +264,7 @@ get_num(void)
} }
if (ch == '\'') { if (ch == '\'') {
if (base > 36) { if (base > 36) {
_YAP_ErrorMessage = "Admissible bases are 0..36"; Yap_ErrorMessage = "Admissible bases are 0..36";
return (TermNil); return (TermNil);
} }
might_be_float = FALSE; might_be_float = FALSE;
@ -333,17 +333,17 @@ get_num(void)
ascii = so_far*8+(ch-'0'); ascii = so_far*8+(ch-'0');
my_get_quoted_ch(); my_get_quoted_ch();
if (ch != '\\') { if (ch != '\\') {
_YAP_ErrorMessage = "invalid octal escape sequence"; Yap_ErrorMessage = "invalid octal escape sequence";
} }
} else if (ch == '\\') { } else if (ch == '\\') {
ascii = so_far; ascii = so_far;
} else { } else {
_YAP_ErrorMessage = "invalid octal escape sequence"; Yap_ErrorMessage = "invalid octal escape sequence";
} }
} else if (ch == '\\') { } else if (ch == '\\') {
ascii = so_far; ascii = so_far;
} else { } else {
_YAP_ErrorMessage = "invalid octal escape sequence"; Yap_ErrorMessage = "invalid octal escape sequence";
} }
} }
break; break;
@ -361,12 +361,12 @@ get_num(void)
(my_isupper(ch) ? ch - 'A' : ch - 'a') + 10); (my_isupper(ch) ? ch - 'A' : ch - 'a') + 10);
my_get_quoted_ch(); my_get_quoted_ch();
if (ch != '\\') { if (ch != '\\') {
_YAP_ErrorMessage = "invalid hexadecimal escape sequence"; Yap_ErrorMessage = "invalid hexadecimal escape sequence";
} }
} else if (ch == '\\') { } else if (ch == '\\') {
ascii = so_far; ascii = so_far;
} else { } else {
_YAP_ErrorMessage = "invalid hexadecimal escape sequence"; Yap_ErrorMessage = "invalid hexadecimal escape sequence";
} }
} else if (ch == '\\') { } else if (ch == '\\') {
ascii = so_far; ascii = so_far;
@ -378,7 +378,7 @@ get_num(void)
/* accept sequence. Note that the ISO standard does not /* accept sequence. Note that the ISO standard does not
consider this sequence legal, whereas SICStus would consider this sequence legal, whereas SICStus would
eat up the escape sequence. */ eat up the escape sequence. */
_YAP_ErrorMessage = "invalid escape sequence"; Yap_ErrorMessage = "invalid escape sequence";
} }
} }
/* a quick way to represent ASCII */ /* a quick way to represent ASCII */
@ -485,19 +485,19 @@ get_num(void)
/* given a function Nxtch scan until we either find the number /* given a function Nxtch scan until we either find the number
or end of file */ or end of file */
Term Term
_YAP_scan_num(int (*Nxtch) (int)) Yap_scan_num(int (*Nxtch) (int))
{ {
Term out; Term out;
int sign = 1; int sign = 1;
Nextch = Nxtch; Nextch = Nxtch;
_YAP_ErrorMessage = NULL; Yap_ErrorMessage = NULL;
ch = Nextch(_YAP_c_input_stream); ch = Nextch(Yap_c_input_stream);
if (ch == '-') { if (ch == '-') {
sign = -1; sign = -1;
ch = Nextch(_YAP_c_input_stream); ch = Nextch(Yap_c_input_stream);
} else if (ch == '+') { } else if (ch == '+') {
ch = Nextch(_YAP_c_input_stream); ch = Nextch(Yap_c_input_stream);
} }
if (chtype[ch] != NU) { if (chtype[ch] != NU) {
return(TermNil); return(TermNil);
@ -509,7 +509,7 @@ _YAP_scan_num(int (*Nxtch) (int))
else if (IsFloatTerm(out)) else if (IsFloatTerm(out))
out = MkFloatTerm(-FloatOfTerm(out)); out = MkFloatTerm(-FloatOfTerm(out));
} }
if (_YAP_ErrorMessage != NULL || ch != -1) if (Yap_ErrorMessage != NULL || ch != -1)
return(TermNil); return(TermNil);
return(out); return(out);
} }
@ -523,7 +523,7 @@ token(void)
char *charp, *mp; char *charp, *mp;
unsigned int len; unsigned int len;
TokImage = ((AtomEntry *) ( _YAP_PreAllocCodeSpace()))->StrOfAE; TokImage = ((AtomEntry *) ( Yap_PreAllocCodeSpace()))->StrOfAE;
charp = TokImage; charp = TokImage;
while (chtype[ch] == BS) while (chtype[ch] == BS)
my_getch(); my_getch();
@ -532,10 +532,10 @@ token(void)
case CC: case CC:
while (my_getch() != 10 && chtype[ch] != EF); while (my_getch() != 10 && chtype[ch] != EF);
if (chtype[ch] != EF) { if (chtype[ch] != EF) {
_YAP_ReleasePreAllocCodeSpace((CODEADDR)TokImage); Yap_ReleasePreAllocCodeSpace((CODEADDR)TokImage);
return (token()); return (token());
} else { } else {
_YAP_ReleasePreAllocCodeSpace((CODEADDR)TokImage); Yap_ReleasePreAllocCodeSpace((CODEADDR)TokImage);
return (eot_tok); return (eot_tok);
} }
case UC: case UC:
@ -548,19 +548,19 @@ token(void)
*charp++ = '\0'; *charp++ = '\0';
if (!isvar) { if (!isvar) {
/* don't do this in iso */ /* don't do this in iso */
TokenInfo = Unsigned(_YAP_LookupAtom(TokImage)); TokenInfo = Unsigned(Yap_LookupAtom(TokImage));
_YAP_ReleasePreAllocCodeSpace((CODEADDR)TokImage); Yap_ReleasePreAllocCodeSpace((CODEADDR)TokImage);
return (Name_tok); return (Name_tok);
} }
else { else {
TokenInfo = Unsigned(_YAP_LookupVar(TokImage)); TokenInfo = Unsigned(Yap_LookupVar(TokImage));
_YAP_ReleasePreAllocCodeSpace((CODEADDR)TokImage); Yap_ReleasePreAllocCodeSpace((CODEADDR)TokImage);
return (Var_tok); return (Var_tok);
} }
case NU: case NU:
TokenInfo = get_num(); TokenInfo = get_num();
_YAP_ReleasePreAllocCodeSpace((CODEADDR)TokImage); Yap_ReleasePreAllocCodeSpace((CODEADDR)TokImage);
return (Number_tok); return (Number_tok);
case QT: case QT:
@ -570,7 +570,7 @@ token(void)
my_get_quoted_ch(); my_get_quoted_ch();
while (1) { while (1) {
if (charp + 1024 > (char *)AuxSp) { if (charp + 1024 > (char *)AuxSp) {
_YAP_ErrorMessage = "Heap Overflow While Scanning: please increase code space (-h)"; Yap_ErrorMessage = "Heap Overflow While Scanning: please increase code space (-h)";
break; break;
} }
if (ch == quote) { if (ch == quote) {
@ -651,7 +651,7 @@ token(void)
*charp++ = so_far*8+(ch-'0'); *charp++ = so_far*8+(ch-'0');
my_get_quoted_ch(); my_get_quoted_ch();
if (ch != '\\') { if (ch != '\\') {
_YAP_ErrorMessage = "invalid octal escape sequence"; Yap_ErrorMessage = "invalid octal escape sequence";
} else { } else {
my_get_quoted_ch(); my_get_quoted_ch();
} }
@ -659,13 +659,13 @@ token(void)
*charp++ = so_far; *charp++ = so_far;
my_get_quoted_ch(); my_get_quoted_ch();
} else { } else {
_YAP_ErrorMessage = "invalid octal escape sequence"; Yap_ErrorMessage = "invalid octal escape sequence";
} }
} else if (ch == '\\') { } else if (ch == '\\') {
*charp++ = so_far; *charp++ = so_far;
my_get_quoted_ch(); my_get_quoted_ch();
} else { } else {
_YAP_ErrorMessage = "invalid octal escape sequence"; Yap_ErrorMessage = "invalid octal escape sequence";
} }
} }
break; break;
@ -683,7 +683,7 @@ token(void)
(my_isupper(ch) ? ch - 'A' : ch - 'a') + 10); (my_isupper(ch) ? ch - 'A' : ch - 'a') + 10);
my_get_quoted_ch(); my_get_quoted_ch();
if (ch != '\\') { if (ch != '\\') {
_YAP_ErrorMessage = "invalid hexadecimal escape sequence"; Yap_ErrorMessage = "invalid hexadecimal escape sequence";
} else { } else {
my_get_quoted_ch(); my_get_quoted_ch();
} }
@ -691,13 +691,13 @@ token(void)
*charp++ = so_far; *charp++ = so_far;
my_get_quoted_ch(); my_get_quoted_ch();
} else { } else {
_YAP_ErrorMessage = "invalid hexadecimal escape sequence"; Yap_ErrorMessage = "invalid hexadecimal escape sequence";
} }
} else if (ch == '\\') { } else if (ch == '\\') {
*charp++ = so_far; *charp++ = so_far;
my_get_quoted_ch(); my_get_quoted_ch();
} else { } else {
_YAP_ErrorMessage = "invalid hexadecimal escape sequence"; Yap_ErrorMessage = "invalid hexadecimal escape sequence";
} }
} }
break; break;
@ -705,10 +705,10 @@ token(void)
/* accept sequence. Note that the ISO standard does not /* accept sequence. Note that the ISO standard does not
consider this sequence legal, whereas SICStus would consider this sequence legal, whereas SICStus would
eat up the escape sequence. */ eat up the escape sequence. */
_YAP_ErrorMessage = "invalid escape sequence"; Yap_ErrorMessage = "invalid escape sequence";
} }
} else if (chtype[ch] == EF) { } else if (chtype[ch] == EF) {
_YAP_ReleasePreAllocCodeSpace((CODEADDR)TokImage); Yap_ReleasePreAllocCodeSpace((CODEADDR)TokImage);
return (eot_tok); return (eot_tok);
} else { } else {
*charp++ = ch; *charp++ = ch;
@ -717,9 +717,9 @@ token(void)
++len; ++len;
if (charp > (char *)AuxSp - 1024) { if (charp > (char *)AuxSp - 1024) {
/* Not enough space to read in the string. */ /* Not enough space to read in the string. */
_YAP_ErrorMessage = "not enough heap space to read in string or quoted atom"; Yap_ErrorMessage = "not enough heap space to read in string or quoted atom";
/* serious error now */ /* serious error now */
_YAP_ReleasePreAllocCodeSpace((CODEADDR)TokImage); Yap_ReleasePreAllocCodeSpace((CODEADDR)TokImage);
return(eot_tok); return(eot_tok);
} }
} }
@ -727,18 +727,18 @@ token(void)
if (quote == '"') { if (quote == '"') {
mp = AllocScannerMemory(len + 1); mp = AllocScannerMemory(len + 1);
if (mp == NULL) { if (mp == NULL) {
_YAP_ErrorMessage = "not enough stack space to read in string or quoted atom"; Yap_ErrorMessage = "not enough stack space to read in string or quoted atom";
_YAP_ReleasePreAllocCodeSpace((CODEADDR)TokImage); Yap_ReleasePreAllocCodeSpace((CODEADDR)TokImage);
return(eot_tok); return(eot_tok);
} }
strcpy(mp, TokImage); strcpy(mp, TokImage);
TokenInfo = Unsigned(mp); TokenInfo = Unsigned(mp);
_YAP_ReleasePreAllocCodeSpace((CODEADDR)TokImage); Yap_ReleasePreAllocCodeSpace((CODEADDR)TokImage);
return (String_tok); return (String_tok);
} }
else { else {
TokenInfo = Unsigned(_YAP_LookupAtom(TokImage)); TokenInfo = Unsigned(Yap_LookupAtom(TokImage));
_YAP_ReleasePreAllocCodeSpace((CODEADDR)TokImage); Yap_ReleasePreAllocCodeSpace((CODEADDR)TokImage);
return (Name_tok); return (Name_tok);
} }
@ -751,19 +751,19 @@ token(void)
my_getch(); my_getch();
} }
if (chtype[ch] == EF) { if (chtype[ch] == EF) {
_YAP_ReleasePreAllocCodeSpace((CODEADDR)TokImage); Yap_ReleasePreAllocCodeSpace((CODEADDR)TokImage);
return (eot_tok); return (eot_tok);
} }
my_getch(); my_getch();
_YAP_ReleasePreAllocCodeSpace((CODEADDR)TokImage); Yap_ReleasePreAllocCodeSpace((CODEADDR)TokImage);
return (token()); return (token());
} }
if (och == '.' && (chtype[ch] == BS || chtype[ch] == EF if (och == '.' && (chtype[ch] == BS || chtype[ch] == EF
|| chtype[ch] == CC)) { || chtype[ch] == CC)) {
_YAP_eot_before_eof = TRUE; Yap_eot_before_eof = TRUE;
if (chtype[ch] == CC) if (chtype[ch] == CC)
while (my_getch() != 10 && chtype[ch] != EF); while (my_getch() != 10 && chtype[ch] != EF);
_YAP_ReleasePreAllocCodeSpace((CODEADDR)TokImage); Yap_ReleasePreAllocCodeSpace((CODEADDR)TokImage);
return (eot_tok); return (eot_tok);
} }
else { else {
@ -771,8 +771,8 @@ token(void)
for (; chtype[ch] == SY; my_getch()) for (; chtype[ch] == SY; my_getch())
*charp++ = ch; *charp++ = ch;
*charp = '\0'; *charp = '\0';
TokenInfo = Unsigned(_YAP_LookupAtom(TokImage)); TokenInfo = Unsigned(Yap_LookupAtom(TokImage));
_YAP_ReleasePreAllocCodeSpace((CODEADDR)TokImage); Yap_ReleasePreAllocCodeSpace((CODEADDR)TokImage);
return (Name_tok); return (Name_tok);
} }
@ -780,8 +780,8 @@ token(void)
*charp++ = ch; *charp++ = ch;
*charp++ = '\0'; *charp++ = '\0';
my_getch(); my_getch();
TokenInfo = Unsigned(_YAP_LookupAtom(TokImage)); TokenInfo = Unsigned(Yap_LookupAtom(TokImage));
_YAP_ReleasePreAllocCodeSpace((CODEADDR)TokImage); Yap_ReleasePreAllocCodeSpace((CODEADDR)TokImage);
return (Name_tok); return (Name_tok);
case BK: case BK:
@ -792,44 +792,44 @@ token(void)
if (och == '[' && ch == ']') { if (och == '[' && ch == ']') {
TokenInfo = Unsigned(AtomNil); TokenInfo = Unsigned(AtomNil);
my_getch(); my_getch();
_YAP_ReleasePreAllocCodeSpace((CODEADDR)TokImage); Yap_ReleasePreAllocCodeSpace((CODEADDR)TokImage);
return (Name_tok); return (Name_tok);
} }
else { else {
TokenInfo = och; TokenInfo = och;
_YAP_ReleasePreAllocCodeSpace((CODEADDR)TokImage); Yap_ReleasePreAllocCodeSpace((CODEADDR)TokImage);
return (Ponctuation_tok); return (Ponctuation_tok);
} }
case EF: case EF:
_YAP_ReleasePreAllocCodeSpace((CODEADDR)TokImage); Yap_ReleasePreAllocCodeSpace((CODEADDR)TokImage);
return (eot_tok); return (eot_tok);
#ifdef DEBUG #ifdef DEBUG
default: default:
fprintf(_YAP_stderr, "\n++++ token: wrong char type %c %d\n", ch, chtype[ch]); fprintf(Yap_stderr, "\n++++ token: wrong char type %c %d\n", ch, chtype[ch]);
_YAP_ReleasePreAllocCodeSpace((CODEADDR)TokImage); Yap_ReleasePreAllocCodeSpace((CODEADDR)TokImage);
return (eot_tok); return (eot_tok);
#else #else
default: default:
_YAP_ReleasePreAllocCodeSpace((CODEADDR)TokImage); Yap_ReleasePreAllocCodeSpace((CODEADDR)TokImage);
return (eot_tok); /* Just to make lint happy */ return (eot_tok); /* Just to make lint happy */
#endif #endif
} }
} }
TokEntry * TokEntry *
_YAP_tokenizer(int (*Nxtch) (int), int (*QuotedNxtch) (int)) Yap_tokenizer(int (*Nxtch) (int), int (*QuotedNxtch) (int))
{ {
TokEntry *t, *l, *p; TokEntry *t, *l, *p;
enum TokenKinds kind; enum TokenKinds kind;
int solo_flag = TRUE; int solo_flag = TRUE;
_YAP_ErrorMessage = NULL; Yap_ErrorMessage = NULL;
_YAP_VarTable = NULL; Yap_VarTable = NULL;
_YAP_AnonVarTable = NULL; Yap_AnonVarTable = NULL;
Nextch = Nxtch; Nextch = Nxtch;
QuotedNextch = QuotedNxtch; QuotedNextch = QuotedNxtch;
_YAP_eot_before_eof = FALSE; Yap_eot_before_eof = FALSE;
l = NIL; l = NIL;
p = NIL; /* Just to make lint happy */ p = NIL; /* Just to make lint happy */
ch = ' '; ch = ' ';
@ -840,7 +840,7 @@ _YAP_tokenizer(int (*Nxtch) (int), int (*QuotedNxtch) (int))
do { do {
t = (TokEntry *) AllocScannerMemory(sizeof(TokEntry)); t = (TokEntry *) AllocScannerMemory(sizeof(TokEntry));
if (t == NULL) { if (t == NULL) {
_YAP_ErrorMessage = "not enough stack space to read in term"; Yap_ErrorMessage = "not enough stack space to read in term";
if (p != NIL) if (p != NIL)
p->TokInfo = eot_tok; p->TokInfo = eot_tok;
/* serious error now */ /* serious error now */
@ -860,7 +860,7 @@ _YAP_tokenizer(int (*Nxtch) (int), int (*QuotedNxtch) (int))
} }
t->Tok = Ord(kind); t->Tok = Ord(kind);
#ifdef DEBUG #ifdef DEBUG
if(_YAP_Option[2]) fprintf(_YAP_stderr,"[Token %d %ld]",Ord(kind),(unsigned long int)TokenInfo); if(Yap_Option[2]) fprintf(Yap_stderr,"[Token %d %ld]",Ord(kind),(unsigned long int)TokenInfo);
#endif #endif
t->TokInfo = (Term) TokenInfo; t->TokInfo = (Term) TokenInfo;
t->TokPos = TokenPos; t->TokPos = TokenPos;
@ -873,18 +873,18 @@ _YAP_tokenizer(int (*Nxtch) (int), int (*QuotedNxtch) (int))
static inline int static inline int
debug_fgetch(void) debug_fgetch(void)
{ {
int ch = _YAP_PlFGetchar(); int ch = Yap_PlFGetchar();
if (_YAP_Option[1]) if (Yap_Option[1])
fprintf(_YAP_stderr, "[getch %c,%d]", ch,ch); fprintf(Yap_stderr, "[getch %c,%d]", ch,ch);
return (ch); return (ch);
} }
#define my_fgetch() (ch = debug_fgetch()) #define my_fgetch() (ch = debug_fgetch())
#else #else
#define my_fgetch() (ch = _YAP_PlFGetchar()) #define my_fgetch() (ch = Yap_PlFGetchar())
#endif #endif
TokEntry * TokEntry *
_YAP_fast_tokenizer(void) Yap_fast_tokenizer(void)
{ {
/* I hope, a compressed version of the last /* I hope, a compressed version of the last
* three files */ * three files */
@ -894,10 +894,10 @@ _YAP_fast_tokenizer(void)
register int ch, och; register int ch, och;
int solo_flag = TRUE; int solo_flag = TRUE;
_YAP_ErrorMessage = NULL; Yap_ErrorMessage = NULL;
_YAP_VarTable = NULL; Yap_VarTable = NULL;
_YAP_AnonVarTable = NULL; Yap_AnonVarTable = NULL;
_YAP_eot_before_eof = FALSE; Yap_eot_before_eof = FALSE;
l = NIL; l = NIL;
p = NIL; /* Just to make lint happy */ p = NIL; /* Just to make lint happy */
my_fgetch(); my_fgetch();
@ -908,7 +908,7 @@ _YAP_fast_tokenizer(void)
do { do {
t = (TokEntry *) AllocScannerMemory(sizeof(TokEntry)); t = (TokEntry *) AllocScannerMemory(sizeof(TokEntry));
if (t == NULL) { if (t == NULL) {
_YAP_ErrorMessage = "not enough stack space to read in term"; Yap_ErrorMessage = "not enough stack space to read in term";
if (p != NIL) if (p != NIL)
p->TokInfo = eot_tok; p->TokInfo = eot_tok;
/* serious error now */ /* serious error now */
@ -928,7 +928,7 @@ _YAP_fast_tokenizer(void)
get_tok: get_tok:
charp = TokImage = ((AtomEntry *) ( _YAP_PreAllocCodeSpace()))->StrOfAE; charp = TokImage = ((AtomEntry *) ( Yap_PreAllocCodeSpace()))->StrOfAE;
while (chtype[ch] == BS) while (chtype[ch] == BS)
my_fgetch(); my_fgetch();
TokenPos = GetCurInpPos(); TokenPos = GetCurInpPos();
@ -937,7 +937,7 @@ _YAP_fast_tokenizer(void)
while (my_fgetch() != 10 && chtype[ch] != EF); while (my_fgetch() != 10 && chtype[ch] != EF);
if (chtype[ch] != EF) { if (chtype[ch] != EF) {
my_fgetch(); my_fgetch();
_YAP_ReleasePreAllocCodeSpace((CODEADDR)TokImage); Yap_ReleasePreAllocCodeSpace((CODEADDR)TokImage);
goto get_tok; goto get_tok;
} }
else else
@ -955,13 +955,13 @@ _YAP_fast_tokenizer(void)
*charp++ = ch; *charp++ = ch;
*charp++ = '\0'; *charp++ = '\0';
if (!isvar) { if (!isvar) {
TokenInfo = Unsigned(_YAP_LookupAtom(TokImage)); TokenInfo = Unsigned(Yap_LookupAtom(TokImage));
if (ch == '(') if (ch == '(')
solo_flag = FALSE; solo_flag = FALSE;
kind = Name_tok; kind = Name_tok;
} }
else { else {
TokenInfo = Unsigned(_YAP_LookupVar(TokImage)); TokenInfo = Unsigned(Yap_LookupVar(TokImage));
kind = Var_tok; kind = Var_tok;
} }
break; break;
@ -1056,17 +1056,17 @@ _YAP_fast_tokenizer(void)
ascii = so_far*8+(ch-'0'); ascii = so_far*8+(ch-'0');
my_fgetch(); my_fgetch();
if (ch != '\\') { if (ch != '\\') {
_YAP_ErrorMessage = "invalid octal escape sequence"; Yap_ErrorMessage = "invalid octal escape sequence";
} }
} else if (ch == '\\') { } else if (ch == '\\') {
ascii = so_far; ascii = so_far;
} else { } else {
_YAP_ErrorMessage = "invalid octal escape sequence"; Yap_ErrorMessage = "invalid octal escape sequence";
} }
} else if (ch == '\\') { } else if (ch == '\\') {
ascii = so_far; ascii = so_far;
} else { } else {
_YAP_ErrorMessage = "invalid octal escape sequence"; Yap_ErrorMessage = "invalid octal escape sequence";
} }
} }
break; break;
@ -1084,18 +1084,18 @@ _YAP_fast_tokenizer(void)
(my_isupper(ch) ? ch - 'A' : ch - 'a') + 10); (my_isupper(ch) ? ch - 'A' : ch - 'a') + 10);
my_fgetch(); my_fgetch();
if (ch != '\\') { if (ch != '\\') {
_YAP_ErrorMessage = "invalid hexadecimal escape sequence"; Yap_ErrorMessage = "invalid hexadecimal escape sequence";
} }
} else if (ch == '\\') { } else if (ch == '\\') {
ascii = so_far; ascii = so_far;
} else { } else {
_YAP_ErrorMessage = "invalid hexadecimal escape sequence"; Yap_ErrorMessage = "invalid hexadecimal escape sequence";
} }
} else if (ch == '\\') { } else if (ch == '\\') {
ascii = so_far; ascii = so_far;
my_fgetch(); my_fgetch();
} else { } else {
_YAP_ErrorMessage = "invalid hexadecimal escape sequence"; Yap_ErrorMessage = "invalid hexadecimal escape sequence";
} }
} }
break; break;
@ -1103,7 +1103,7 @@ _YAP_fast_tokenizer(void)
/* accept sequence. Note that the ISO standard does not /* accept sequence. Note that the ISO standard does not
consider this sequence legal, whereas SICStus would consider this sequence legal, whereas SICStus would
eat up the escape sequence. */ eat up the escape sequence. */
_YAP_ErrorMessage = "invalid escape sequence"; Yap_ErrorMessage = "invalid escape sequence";
} }
} }
my_fgetch(); my_fgetch();
@ -1170,9 +1170,9 @@ _YAP_fast_tokenizer(void)
t->Tok = Ord(Number_tok); t->Tok = Ord(Number_tok);
#ifdef DEBUG #ifdef DEBUG
/* /*
* if(_YAP_Option[2 * if(Yap_Option[2
* ]) * ])
* fprintf(_YAP_stderr,"[To * fprintf(Yap_stderr,"[To
* ken %d * ken %d
* %d]",Ord(ki * %d]",Ord(ki
* nd),TokenIn * nd),TokenIn
@ -1186,11 +1186,11 @@ _YAP_fast_tokenizer(void)
t->TokPos = TokenPos; t->TokPos = TokenPos;
t = (TokEntry *) AllocScannerMemory(sizeof(TokEntry)); t = (TokEntry *) AllocScannerMemory(sizeof(TokEntry));
if (t == NULL) { if (t == NULL) {
_YAP_ErrorMessage = "not enough stack space to read in term"; Yap_ErrorMessage = "not enough stack space to read in term";
if (p != NIL) if (p != NIL)
p->TokInfo = eot_tok; p->TokInfo = eot_tok;
/* serious error now */ /* serious error now */
_YAP_ReleasePreAllocCodeSpace((CODEADDR)TokImage); Yap_ReleasePreAllocCodeSpace((CODEADDR)TokImage);
return(l); return(l);
} }
@ -1241,11 +1241,11 @@ _YAP_fast_tokenizer(void)
t = t =
(TokEntry *) AllocScannerMemory(sizeof(TokEntry)); (TokEntry *) AllocScannerMemory(sizeof(TokEntry));
if (t == NULL) { if (t == NULL) {
_YAP_ErrorMessage = "not enough stack space to read in term"; Yap_ErrorMessage = "not enough stack space to read in term";
if (p != NIL) if (p != NIL)
p->TokInfo = eot_tok; p->TokInfo = eot_tok;
/* serious error now */ /* serious error now */
_YAP_ReleasePreAllocCodeSpace((CODEADDR)TokImage); Yap_ReleasePreAllocCodeSpace((CODEADDR)TokImage);
return(l); return(l);
} }
@ -1305,7 +1305,7 @@ _YAP_fast_tokenizer(void)
my_fgetch(); my_fgetch();
while (1) { while (1) {
if (charp + 1024 > (char *)AuxSp) { if (charp + 1024 > (char *)AuxSp) {
_YAP_ErrorMessage = "Heap Overflow While Scanning: please increase code space (-h)"; Yap_ErrorMessage = "Heap Overflow While Scanning: please increase code space (-h)";
break; break;
} }
if (ch == quote) { if (ch == quote) {
@ -1385,7 +1385,7 @@ _YAP_fast_tokenizer(void)
*charp++ = so_far*8+(ch-'0'); *charp++ = so_far*8+(ch-'0');
my_fgetch(); my_fgetch();
if (ch != '\\') { if (ch != '\\') {
_YAP_ErrorMessage = "invalid octal escape sequence"; Yap_ErrorMessage = "invalid octal escape sequence";
} else { } else {
my_fgetch(); my_fgetch();
} }
@ -1393,13 +1393,13 @@ _YAP_fast_tokenizer(void)
*charp++ = so_far; *charp++ = so_far;
my_fgetch(); my_fgetch();
} else { } else {
_YAP_ErrorMessage = "invalid octal escape sequence"; Yap_ErrorMessage = "invalid octal escape sequence";
} }
} else if (ch == '\\') { } else if (ch == '\\') {
*charp++ = so_far; *charp++ = so_far;
my_fgetch(); my_fgetch();
} else { } else {
_YAP_ErrorMessage = "invalid octal escape sequence"; Yap_ErrorMessage = "invalid octal escape sequence";
} }
} }
break; break;
@ -1417,7 +1417,7 @@ _YAP_fast_tokenizer(void)
(my_isupper(ch) ? ch - 'A' : ch - 'a') + 10); (my_isupper(ch) ? ch - 'A' : ch - 'a') + 10);
my_fgetch(); my_fgetch();
if (ch != '\\') { if (ch != '\\') {
_YAP_ErrorMessage = "invalid hexadecimal escape sequence"; Yap_ErrorMessage = "invalid hexadecimal escape sequence";
} else { } else {
my_fgetch(); my_fgetch();
} }
@ -1425,13 +1425,13 @@ _YAP_fast_tokenizer(void)
*charp++ = so_far; *charp++ = so_far;
my_fgetch(); my_fgetch();
} else { } else {
_YAP_ErrorMessage = "invalid hexadecimal escape sequence"; Yap_ErrorMessage = "invalid hexadecimal escape sequence";
} }
} else if (ch == '\\') { } else if (ch == '\\') {
*charp++ = so_far; *charp++ = so_far;
my_fgetch(); my_fgetch();
} else { } else {
_YAP_ErrorMessage = "invalid hexadecimal escape sequence"; Yap_ErrorMessage = "invalid hexadecimal escape sequence";
} }
} }
break; break;
@ -1439,7 +1439,7 @@ _YAP_fast_tokenizer(void)
/* accept sequence. Note that the ISO standard does not /* accept sequence. Note that the ISO standard does not
consider this sequence legal, whereas SICStus would consider this sequence legal, whereas SICStus would
eat up the escape sequence. */ eat up the escape sequence. */
_YAP_ErrorMessage = "invalid escape sequence"; Yap_ErrorMessage = "invalid escape sequence";
} }
} else { } else {
*charp++ = ch; *charp++ = ch;
@ -1452,7 +1452,7 @@ _YAP_fast_tokenizer(void)
++len; ++len;
if (charp > (char *)AuxSp - 1024) { if (charp > (char *)AuxSp - 1024) {
/* Not enough space to read in the string. */ /* Not enough space to read in the string. */
_YAP_ErrorMessage = "not enough heap space to read in string or quoted atom"; Yap_ErrorMessage = "not enough heap space to read in string or quoted atom";
/* serious error now */ /* serious error now */
kind = eot_tok; kind = eot_tok;
} }
@ -1461,7 +1461,7 @@ _YAP_fast_tokenizer(void)
if (quote == '"') { if (quote == '"') {
mp = AllocScannerMemory(len + 1); mp = AllocScannerMemory(len + 1);
if (mp == NULL) { if (mp == NULL) {
_YAP_ErrorMessage = "not enough stack space to read in string or quoted atom"; Yap_ErrorMessage = "not enough stack space to read in string or quoted atom";
/* serious error now */ /* serious error now */
kind = eot_tok; kind = eot_tok;
} }
@ -1470,7 +1470,7 @@ _YAP_fast_tokenizer(void)
kind = String_tok; kind = String_tok;
} }
else { else {
TokenInfo = Unsigned(_YAP_LookupAtom(TokImage)); TokenInfo = Unsigned(Yap_LookupAtom(TokImage));
if (ch == '(') if (ch == '(')
solo_flag = FALSE; solo_flag = FALSE;
kind = Name_tok; kind = Name_tok;
@ -1491,12 +1491,12 @@ _YAP_fast_tokenizer(void)
break; break;
} }
my_fgetch(); my_fgetch();
_YAP_ReleasePreAllocCodeSpace((CODEADDR)TokImage); Yap_ReleasePreAllocCodeSpace((CODEADDR)TokImage);
goto get_tok; goto get_tok;
} }
if (och == '.' && (chtype[ch] == BS || chtype[ch] == EF if (och == '.' && (chtype[ch] == BS || chtype[ch] == EF
|| chtype[ch] == CC)) { || chtype[ch] == CC)) {
_YAP_eot_before_eof = TRUE; Yap_eot_before_eof = TRUE;
if (chtype[ch] == CC) if (chtype[ch] == CC)
while (my_fgetch() != 10 && chtype[ch] != EF); while (my_fgetch() != 10 && chtype[ch] != EF);
kind = eot_tok; kind = eot_tok;
@ -1506,7 +1506,7 @@ _YAP_fast_tokenizer(void)
for (; chtype[ch] == SY; my_fgetch()) for (; chtype[ch] == SY; my_fgetch())
*charp++ = ch; *charp++ = ch;
*charp = '\0'; *charp = '\0';
TokenInfo = Unsigned(_YAP_LookupAtom(TokImage)); TokenInfo = Unsigned(Yap_LookupAtom(TokImage));
if (ch == '(') if (ch == '(')
solo_flag = FALSE; solo_flag = FALSE;
kind = Name_tok; kind = Name_tok;
@ -1517,7 +1517,7 @@ _YAP_fast_tokenizer(void)
*charp++ = ch; *charp++ = ch;
*charp++ = '\0'; *charp++ = '\0';
my_fgetch(); my_fgetch();
TokenInfo = Unsigned(_YAP_LookupAtom(TokImage)); TokenInfo = Unsigned(Yap_LookupAtom(TokImage));
if (ch == '(') if (ch == '(')
solo_flag = FALSE; solo_flag = FALSE;
kind = Name_tok; kind = Name_tok;
@ -1552,7 +1552,7 @@ _YAP_fast_tokenizer(void)
break; break;
#ifdef DEBUG #ifdef DEBUG
default: default:
fprintf(_YAP_stderr, "\n++++ token: wrong char type %c %d\n", ch, chtype[ch]); fprintf(Yap_stderr, "\n++++ token: wrong char type %c %d\n", ch, chtype[ch]);
kind = eot_tok; kind = eot_tok;
#else #else
default: default:
@ -1563,12 +1563,12 @@ _YAP_fast_tokenizer(void)
t->Tok = Ord(kind); t->Tok = Ord(kind);
#ifdef DEBUG #ifdef DEBUG
if(_YAP_Option[2]) fprintf(_YAP_stderr,"[Token %d %ld]\n",Ord(kind),(unsigned long int)TokenInfo); if(Yap_Option[2]) fprintf(Yap_stderr,"[Token %d %ld]\n",Ord(kind),(unsigned long int)TokenInfo);
#endif #endif
t->TokInfo = (Term) TokenInfo; t->TokInfo = (Term) TokenInfo;
t->TokPos = TokenPos; t->TokPos = TokenPos;
t->TokNext = NIL; t->TokNext = NIL;
_YAP_ReleasePreAllocCodeSpace((CODEADDR)TokImage); Yap_ReleasePreAllocCodeSpace((CODEADDR)TokImage);
} while (kind != eot_tok); } while (kind != eot_tok);
return (l); return (l);
} }

38
C/sort.c
View File

@ -58,8 +58,8 @@ build_new_list(CELL *pt, Term t)
} }
pt += 2; pt += 2;
if (pt > ASP - 4096) { if (pt > ASP - 4096) {
if (!_YAP_gc(2, ENV, P)) { if (!Yap_gc(2, ENV, P)) {
_YAP_Error(OUT_OF_STACK_ERROR, TermNil, _YAP_ErrorMessage); Yap_Error(OUT_OF_STACK_ERROR, TermNil, Yap_ErrorMessage);
return(FALSE); return(FALSE);
} }
t = Deref(ARG1); t = Deref(ARG1);
@ -101,7 +101,7 @@ void simple_mergesort(CELL *pt, Int size, int my_p)
/* while there are elements in the left or right vector do compares */ /* while there are elements in the left or right vector do compares */
while (pt_left < end_pt_left && pt_right < end_pt) { while (pt_left < end_pt_left && pt_right < end_pt) {
/* if the element to the left is larger than the one to the right */ /* if the element to the left is larger than the one to the right */
if (_YAP_compare_terms(pt_left[0], pt_right[0]) <= 0) { if (Yap_compare_terms(pt_left[0], pt_right[0]) <= 0) {
/* copy the one to the left */ /* copy the one to the left */
pt[0] = pt_left[0]; pt[0] = pt_left[0];
/* and avance the two pointers */ /* and avance the two pointers */
@ -130,7 +130,7 @@ void simple_mergesort(CELL *pt, Int size, int my_p)
} }
} }
} else { } else {
if (size > 1 && (_YAP_compare_terms(pt[0],pt[2]) > 0)) { if (size > 1 && (Yap_compare_terms(pt[0],pt[2]) > 0)) {
CELL t = pt[2]; CELL t = pt[2];
pt[2+my_p] = pt[0]; pt[2+my_p] = pt[0];
pt[my_p] = t; pt[my_p] = t;
@ -181,7 +181,7 @@ int key_mergesort(CELL *pt, Int size, int my_p, Functor FuncDMinus)
if (IsVarTerm(t1) || !IsApplTerm(t1) || FunctorOfTerm(t1) != FuncDMinus) if (IsVarTerm(t1) || !IsApplTerm(t1) || FunctorOfTerm(t1) != FuncDMinus)
return(FALSE); return(FALSE);
t1 = ArgOfTerm(1,t1); t1 = ArgOfTerm(1,t1);
if (_YAP_compare_terms(t0, t1) <= 0) { if (Yap_compare_terms(t0, t1) <= 0) {
/* copy the one to the left */ /* copy the one to the left */
pt[0] = pt_left[0]; pt[0] = pt_left[0];
/* and avance the two pointers */ /* and avance the two pointers */
@ -218,7 +218,7 @@ int key_mergesort(CELL *pt, Int size, int my_p, Functor FuncDMinus)
if (IsVarTerm(t1) || !IsApplTerm(t1) || FunctorOfTerm(t1) != FuncDMinus) if (IsVarTerm(t1) || !IsApplTerm(t1) || FunctorOfTerm(t1) != FuncDMinus)
return(FALSE); return(FALSE);
t1 = ArgOfTerm(1,t1); t1 = ArgOfTerm(1,t1);
if (_YAP_compare_terms(t0,t1) > 0) { if (Yap_compare_terms(t0,t1) > 0) {
CELL t = pt[2]; CELL t = pt[2];
pt[2+my_p] = pt[0]; pt[2+my_p] = pt[0];
pt[my_p] = t; pt[my_p] = t;
@ -266,7 +266,7 @@ Int compact_mergesort(CELL *pt, Int size, int my_p)
/* while there are elements in the left or right vector do compares */ /* while there are elements in the left or right vector do compares */
while (pt_left < end_pt_left && pt_right < end_pt_right) { while (pt_left < end_pt_left && pt_right < end_pt_right) {
/* if the element to the left is larger than the one to the right */ /* if the element to the left is larger than the one to the right */
Int cmp = _YAP_compare_terms(pt_left[0], pt_right[0]); Int cmp = Yap_compare_terms(pt_left[0], pt_right[0]);
if (cmp < 0) { if (cmp < 0) {
/* copy the one to the left */ /* copy the one to the left */
pt[0] = pt_left[0]; pt[0] = pt_left[0];
@ -302,7 +302,7 @@ Int compact_mergesort(CELL *pt, Int size, int my_p)
} }
return(size); return(size);
} else if (size == 2) { } else if (size == 2) {
Int cmp = _YAP_compare_terms(pt[0],pt[2]); Int cmp = Yap_compare_terms(pt[0],pt[2]);
if (cmp > 0) { if (cmp > 0) {
/* swap */ /* swap */
CELL t = pt[2]; CELL t = pt[2];
@ -354,7 +354,7 @@ p_sort(void)
if (size < 0) if (size < 0)
return(FALSE); return(FALSE);
if (size < 2) if (size < 2)
return(_YAP_unify(ARG1, ARG2)); return(Yap_unify(ARG1, ARG2));
pt = H; /* because of possible garbage collection */ pt = H; /* because of possible garbage collection */
/* make sure no one writes on our temp data structure */ /* make sure no one writes on our temp data structure */
H += size*2; H += size*2;
@ -364,7 +364,7 @@ p_sort(void)
H = pt+size*2; H = pt+size*2;
adjust_vector(pt, size); adjust_vector(pt, size);
out = AbsPair(pt); out = AbsPair(pt);
return(_YAP_unify(out, ARG2)); return(Yap_unify(out, ARG2));
} }
static Int static Int
@ -379,14 +379,14 @@ p_msort(void)
if (size < 0) if (size < 0)
return(FALSE); return(FALSE);
if (size < 2) if (size < 2)
return(_YAP_unify(ARG1, ARG2)); return(Yap_unify(ARG1, ARG2));
pt = H; /* because of possible garbage collection */ pt = H; /* because of possible garbage collection */
/* reserve the necessary space */ /* reserve the necessary space */
H += size*2; H += size*2;
simple_mergesort(pt, size, M_EVEN); simple_mergesort(pt, size, M_EVEN);
adjust_vector(pt, size); adjust_vector(pt, size);
out = AbsPair(pt); out = AbsPair(pt);
return(_YAP_unify(out, ARG2)); return(Yap_unify(out, ARG2));
} }
static Int static Int
@ -401,21 +401,21 @@ p_ksort(void)
if (size < 0) if (size < 0)
return(FALSE); return(FALSE);
if (size < 2) if (size < 2)
return(_YAP_unify(ARG1, ARG2)); return(Yap_unify(ARG1, ARG2));
/* reserve the necessary space */ /* reserve the necessary space */
pt = H; /* because of possible garbage collection */ pt = H; /* because of possible garbage collection */
H += size*2; H += size*2;
if (!key_mergesort(pt, size, M_EVEN, _YAP_MkFunctor(AtomMinus,2))) if (!key_mergesort(pt, size, M_EVEN, Yap_MkFunctor(AtomMinus,2)))
return(FALSE); return(FALSE);
adjust_vector(pt, size); adjust_vector(pt, size);
out = AbsPair(pt); out = AbsPair(pt);
return(_YAP_unify(out, ARG2)); return(Yap_unify(out, ARG2));
} }
void void
_YAP_InitSortPreds(void) Yap_InitSortPreds(void)
{ {
_YAP_InitCPred("$sort", 2, p_sort, 0); Yap_InitCPred("$sort", 2, p_sort, 0);
_YAP_InitCPred("$msort", 2, p_msort, 0); Yap_InitCPred("$msort", 2, p_msort, 0);
_YAP_InitCPred("$keysort", 2, p_ksort, 0); Yap_InitCPred("$keysort", 2, p_ksort, 0);
} }

790
C/stdpreds.c
View File

File diff suppressed because it is too large Load Diff

392
C/sysbits.c
View File

File diff suppressed because it is too large Load Diff

46
C/tracer.c
View File

@ -32,7 +32,7 @@ static int do_trace_primitives = TRUE;
static int static int
TracePutchar(int sno, int ch) TracePutchar(int sno, int ch)
{ {
return(putc(ch, _YAP_stderr)); /* use standard error stream, which is supposed to be 2*/ return(putc(ch, Yap_stderr)); /* use standard error stream, which is supposed to be 2*/
} }
static void static void
@ -40,35 +40,35 @@ send_tracer_message(char *start, char *name, Int arity, char *mname, CELL *args)
{ {
if (name == NULL) { if (name == NULL) {
#ifdef YAPOR #ifdef YAPOR
fprintf(_YAP_stderr, "(%d)%s", worker_id, start); fprintf(Yap_stderr, "(%d)%s", worker_id, start);
#else #else
fprintf(_YAP_stderr, "%s", start); fprintf(Yap_stderr, "%s", start);
#endif #endif
} else { } else {
int i; int i;
if (arity) { if (arity) {
fprintf(_YAP_stderr, "%s %s:%s(", start, mname, name); fprintf(Yap_stderr, "%s %s:%s(", start, mname, name);
} else { } else {
fprintf(_YAP_stderr, "%s %s:%s", start, mname, name); fprintf(Yap_stderr, "%s %s:%s", start, mname, name);
} }
for (i= 0; i < arity; i++) { for (i= 0; i < arity; i++) {
if (i > 0) fprintf(_YAP_stderr, ","); if (i > 0) fprintf(Yap_stderr, ",");
#if DEBUG #if DEBUG
#if COROUTINING #if COROUTINING
_YAP_Portray_delays = TRUE; Yap_Portray_delays = TRUE;
#endif #endif
#endif #endif
_YAP_plwrite(args[i], TracePutchar, Handle_vars_f); Yap_plwrite(args[i], TracePutchar, Handle_vars_f);
#if DEBUG #if DEBUG
#if COROUTINING #if COROUTINING
_YAP_Portray_delays = FALSE; Yap_Portray_delays = FALSE;
#endif #endif
#endif #endif
} }
if (arity) fprintf(_YAP_stderr, ")"); if (arity) fprintf(Yap_stderr, ")");
} }
fprintf(_YAP_stderr, "\n"); fprintf(Yap_stderr, "\n");
} }
#if defined(__GNUC__) #if defined(__GNUC__)
@ -81,7 +81,7 @@ unsigned long vsc_count;
static int static int
check_trail_consistency(void) { check_trail_consistency(void) {
tr_fr_ptr ptr = TR; tr_fr_ptr ptr = TR;
while (ptr > (CELL *)_YAP_TrailBase) { while (ptr > (CELL *)Yap_TrailBase) {
ptr = --ptr; ptr = --ptr;
if (!IsVarTerm(TrailTerm(ptr))) { if (!IsVarTerm(TrailTerm(ptr))) {
if (IsApplTerm(TrailTerm(ptr))) { if (IsApplTerm(TrailTerm(ptr))) {
@ -119,7 +119,7 @@ low_level_trace(yap_low_level_port port, PredEntry *pred, CELL *args)
/* if (vsc_count > 500000) exit(0); */ /* if (vsc_count > 500000) exit(0); */
/* if (gc_calls < 1) return; */ /* if (gc_calls < 1) return; */
#if defined(__GNUC__) #if defined(__GNUC__)
fprintf(_YAP_stderr,"%llu ", vsc_count); fprintf(Yap_stderr,"%llu ", vsc_count);
#endif #endif
/* check_trail_consistency(); */ /* check_trail_consistency(); */
if (pred == NULL) { if (pred == NULL) {
@ -130,7 +130,7 @@ low_level_trace(yap_low_level_port port, PredEntry *pred, CELL *args)
} }
switch (port) { switch (port) {
case enter_pred: case enter_pred:
mname = RepAtom(AtomOfTerm(_YAP_Module_Name((CODEADDR)pred)))->StrOfAE; mname = RepAtom(AtomOfTerm(Yap_Module_Name((CODEADDR)pred)))->StrOfAE;
arity = pred->ArityOfPE; arity = pred->ArityOfPE;
if (arity == 0) if (arity == 0)
s = RepAtom((Atom)pred->FunctorOfPred)->StrOfAE; s = RepAtom((Atom)pred->FunctorOfPred)->StrOfAE;
@ -153,7 +153,7 @@ low_level_trace(yap_low_level_port port, PredEntry *pred, CELL *args)
if (pred == NULL) { if (pred == NULL) {
send_tracer_message("RETRY TABLE: ", NULL, 0, NULL, args); send_tracer_message("RETRY TABLE: ", NULL, 0, NULL, args);
} else { } else {
mname = RepAtom(AtomOfTerm(_YAP_Module_Name((CODEADDR)pred)))->StrOfAE; mname = RepAtom(AtomOfTerm(Yap_Module_Name((CODEADDR)pred)))->StrOfAE;
arity = pred->ArityOfPE; arity = pred->ArityOfPE;
if (arity == 0) if (arity == 0)
s = RepAtom((Atom)pred->FunctorOfPred)->StrOfAE; s = RepAtom((Atom)pred->FunctorOfPred)->StrOfAE;
@ -170,7 +170,7 @@ low_level_trace(yap_low_level_port port, PredEntry *pred, CELL *args)
if (pred == NULL) { if (pred == NULL) {
send_tracer_message("RETRY TABLE: ", NULL, 0, NULL, args); send_tracer_message("RETRY TABLE: ", NULL, 0, NULL, args);
} else { } else {
mname = RepAtom(AtomOfTerm(_YAP_Module_Name((CODEADDR)pred)))->StrOfAE; mname = RepAtom(AtomOfTerm(Yap_Module_Name((CODEADDR)pred)))->StrOfAE;
arity = pred->ArityOfPE; arity = pred->ArityOfPE;
if (arity == 0) if (arity == 0)
s = RepAtom((Atom)pred->FunctorOfPred)->StrOfAE; s = RepAtom((Atom)pred->FunctorOfPred)->StrOfAE;
@ -182,7 +182,7 @@ low_level_trace(yap_low_level_port port, PredEntry *pred, CELL *args)
} }
break; break;
case retry_pred: case retry_pred:
mname = RepAtom(AtomOfTerm(_YAP_Module_Name((CODEADDR)pred)))->StrOfAE; mname = RepAtom(AtomOfTerm(Yap_Module_Name((CODEADDR)pred)))->StrOfAE;
arity = pred->ArityOfPE; arity = pred->ArityOfPE;
if (arity == 0) if (arity == 0)
s = RepAtom((Atom)pred->FunctorOfPred)->StrOfAE; s = RepAtom((Atom)pred->FunctorOfPred)->StrOfAE;
@ -199,27 +199,27 @@ low_level_trace(yap_low_level_port port, PredEntry *pred, CELL *args)
void void
toggle_low_level_trace(void) toggle_low_level_trace(void)
{ {
_YAP_do_low_level_trace = !_YAP_do_low_level_trace; Yap_do_low_level_trace = !Yap_do_low_level_trace;
} }
static Int p_start_low_level_trace(void) static Int p_start_low_level_trace(void)
{ {
_YAP_do_low_level_trace = TRUE; Yap_do_low_level_trace = TRUE;
return(TRUE); return(TRUE);
} }
static Int p_stop_low_level_trace(void) static Int p_stop_low_level_trace(void)
{ {
_YAP_do_low_level_trace = FALSE; Yap_do_low_level_trace = FALSE;
do_trace_primitives = TRUE; do_trace_primitives = TRUE;
return(TRUE); return(TRUE);
} }
void void
_YAP_InitLowLevelTrace(void) Yap_InitLowLevelTrace(void)
{ {
_YAP_InitCPred("start_low_level_trace", 0, p_start_low_level_trace, SafePredFlag); Yap_InitCPred("start_low_level_trace", 0, p_start_low_level_trace, SafePredFlag);
_YAP_InitCPred("stop_low_level_trace", 0, p_stop_low_level_trace, SafePredFlag); Yap_InitCPred("stop_low_level_trace", 0, p_stop_low_level_trace, SafePredFlag);
} }
#endif #endif

62
C/unify.c
View File

@ -199,7 +199,7 @@ OCUnify_complex(register CELL *pt0, register CELL *pt0_end,
goto cufail; goto cufail;
#ifdef USE_GMP #ifdef USE_GMP
case (CELL)FunctorBigInt: case (CELL)FunctorBigInt:
if (mpz_cmp(_YAP_BigIntOfTerm(d0),_YAP_BigIntOfTerm(d1)) == 0) continue; if (mpz_cmp(Yap_BigIntOfTerm(d0),Yap_BigIntOfTerm(d1)) == 0) continue;
goto cufail; goto cufail;
#endif /* USE_GMP */ #endif /* USE_GMP */
default: default:
@ -233,7 +233,7 @@ OCUnify_complex(register CELL *pt0, register CELL *pt0_end,
BIND_GLOBAL(ptd1, d0, bind_ocunify1); BIND_GLOBAL(ptd1, d0, bind_ocunify1);
#ifdef COROUTINING #ifdef COROUTINING
DO_TRAIL(ptd1, d0); DO_TRAIL(ptd1, d0);
if (ptd1 < H0) _YAP_WakeUp(ptd1); if (ptd1 < H0) Yap_WakeUp(ptd1);
bind_ocunify1: bind_ocunify1:
#endif #endif
if (rational_tree_loop(ptd1-1, ptd1, to_visit)) if (rational_tree_loop(ptd1-1, ptd1, to_visit))
@ -255,7 +255,7 @@ OCUnify_complex(register CELL *pt0, register CELL *pt0_end,
BIND_GLOBAL(ptd0, d1, bind_ocunify2); BIND_GLOBAL(ptd0, d1, bind_ocunify2);
#ifdef COROUTINING #ifdef COROUTINING
DO_TRAIL(ptd0, d1); DO_TRAIL(ptd0, d1);
if (ptd0 < H0) _YAP_WakeUp(ptd0); if (ptd0 < H0) Yap_WakeUp(ptd0);
bind_ocunify2: bind_ocunify2:
#endif #endif
if (rational_tree_loop(ptd0-1, ptd0, to_visit)) if (rational_tree_loop(ptd0-1, ptd0, to_visit))
@ -294,7 +294,7 @@ cufail:
return (FALSE); return (FALSE);
#if SHADOW_REGS #if SHADOW_REGS
#if defined(B) || defined(TR) #if defined(B) || defined(TR)
#undef _YAP_REGS #undef Yap_REGS
#endif /* defined(B) || defined(TR) */ #endif /* defined(B) || defined(TR) */
#endif #endif
} }
@ -350,7 +350,7 @@ oc_unify_nvar_nvar:
return(FloatOfTerm(AbsAppl(pt0)) == FloatOfTerm(AbsAppl(pt1))); return(FloatOfTerm(AbsAppl(pt0)) == FloatOfTerm(AbsAppl(pt1)));
#ifdef USE_GMP #ifdef USE_GMP
case (CELL)FunctorBigInt: case (CELL)FunctorBigInt:
return(mpz_cmp(_YAP_BigIntOfTerm(AbsAppl(pt0)),_YAP_BigIntOfTerm(AbsAppl(pt0))) == 0); return(mpz_cmp(Yap_BigIntOfTerm(AbsAppl(pt0)),Yap_BigIntOfTerm(AbsAppl(pt0))) == 0);
#endif /* USE_GMP */ #endif /* USE_GMP */
default: default:
return(FALSE); return(FALSE);
@ -368,7 +368,7 @@ oc_unify_nvar_nvar:
BIND(pt1, d0, bind_ocunify4); BIND(pt1, d0, bind_ocunify4);
#ifdef COROUTINING #ifdef COROUTINING
DO_TRAIL(pt1, d0); DO_TRAIL(pt1, d0);
if (pt1 < H0) _YAP_WakeUp(pt1); if (pt1 < H0) Yap_WakeUp(pt1);
bind_ocunify4: bind_ocunify4:
#endif #endif
if (rational_tree(d0)) if (rational_tree(d0))
@ -383,7 +383,7 @@ oc_unify_var_nvar:
BIND(pt0, d1, bind_ocunify5); BIND(pt0, d1, bind_ocunify5);
#ifdef COROUTINING #ifdef COROUTINING
DO_TRAIL(pt0, d1); DO_TRAIL(pt0, d1);
if (pt0 < H0) _YAP_WakeUp(pt0); if (pt0 < H0) Yap_WakeUp(pt0);
bind_ocunify5: bind_ocunify5:
#endif #endif
if (rational_tree(d1)) if (rational_tree(d1))
@ -395,7 +395,7 @@ oc_unify_var_nvar:
UnifyCells(pt0, pt1, uc1, uc2); UnifyCells(pt0, pt1, uc1, uc2);
#ifdef COROUTINING #ifdef COROUTINING
DO_TRAIL(pt0, (CELL)pt1); DO_TRAIL(pt0, (CELL)pt1);
if (pt0 < H0) _YAP_WakeUp(pt0); if (pt0 < H0) Yap_WakeUp(pt0);
uc1: uc1:
#endif #endif
return (TRUE); return (TRUE);
@ -403,7 +403,7 @@ oc_unify_var_nvar:
uc2: uc2:
DO_TRAIL(pt1, (CELL)pt0); DO_TRAIL(pt1, (CELL)pt0);
if (pt1 < H0) { if (pt1 < H0) {
_YAP_WakeUp(pt1); Yap_WakeUp(pt1);
} }
#endif #endif
return (TRUE); return (TRUE);
@ -434,13 +434,13 @@ p_acyclic(void)
} }
int int
_YAP_IUnify(register CELL d0, register CELL d1) Yap_IUnify(register CELL d0, register CELL d1)
{ {
#if SHADOW_REGS #if SHADOW_REGS
#if defined(B) || defined(TR) #if defined(B) || defined(TR)
register REGSTORE *regp = &_YAP_REGS; register REGSTORE *regp = &Yap_REGS;
#define _YAP_REGS (*regp) #define Yap_REGS (*regp)
#endif /* defined(B) || defined(TR) */ #endif /* defined(B) || defined(TR) */
#endif #endif
@ -487,7 +487,7 @@ unify_nvar_nvar:
return(FloatOfTerm(AbsAppl(pt0)) == FloatOfTerm(AbsAppl(pt1))); return(FloatOfTerm(AbsAppl(pt0)) == FloatOfTerm(AbsAppl(pt1)));
#ifdef USE_GMP #ifdef USE_GMP
case (CELL)FunctorBigInt: case (CELL)FunctorBigInt:
return(mpz_cmp(_YAP_BigIntOfTerm(AbsAppl(pt0)),_YAP_BigIntOfTerm(AbsAppl(pt0))) == 0); return(mpz_cmp(Yap_BigIntOfTerm(AbsAppl(pt0)),Yap_BigIntOfTerm(AbsAppl(pt0))) == 0);
#endif /* USE_GMP */ #endif /* USE_GMP */
default: default:
return(FALSE); return(FALSE);
@ -505,7 +505,7 @@ unify_nvar_nvar:
BIND(pt1, d0, bind_unify3); BIND(pt1, d0, bind_unify3);
#ifdef COROUTINING #ifdef COROUTINING
DO_TRAIL(pt1, d0); DO_TRAIL(pt1, d0);
if (pt1 < H0) _YAP_WakeUp(pt1); if (pt1 < H0) Yap_WakeUp(pt1);
bind_unify3: bind_unify3:
#endif #endif
return (TRUE); return (TRUE);
@ -518,7 +518,7 @@ unify_var_nvar:
BIND(pt0, d1, bind_unify4); BIND(pt0, d1, bind_unify4);
#ifdef COROUTINING #ifdef COROUTINING
DO_TRAIL(pt0, d1); DO_TRAIL(pt0, d1);
if (pt0 < H0) _YAP_WakeUp(pt0); if (pt0 < H0) Yap_WakeUp(pt0);
bind_unify4: bind_unify4:
#endif #endif
return (TRUE); return (TRUE);
@ -534,7 +534,7 @@ unify_var_nvar_trail:
UnifyCells(pt0, pt1, uc1, uc2); UnifyCells(pt0, pt1, uc1, uc2);
#ifdef COROUTINING #ifdef COROUTINING
DO_TRAIL(pt0, (CELL)pt1); DO_TRAIL(pt0, (CELL)pt1);
if (pt0 < H0) _YAP_WakeUp(pt0); if (pt0 < H0) Yap_WakeUp(pt0);
uc1: uc1:
#endif #endif
return (TRUE); return (TRUE);
@ -542,13 +542,13 @@ unify_var_nvar_trail:
uc2: uc2:
DO_TRAIL(pt1, (CELL)pt0); DO_TRAIL(pt1, (CELL)pt0);
if (pt1 < H0) { if (pt1 < H0) {
_YAP_WakeUp(pt1); Yap_WakeUp(pt1);
} }
return (TRUE); return (TRUE);
#endif #endif
#if SHADOW_REGS #if SHADOW_REGS
#if defined(B) || defined(TR) #if defined(B) || defined(TR)
#undef _YAP_REGS #undef Yap_REGS
#endif /* defined(B) || defined(TR) */ #endif /* defined(B) || defined(TR) */
#endif #endif
} }
@ -579,9 +579,9 @@ InitReverseLookupOpcode(void)
int hash_size_mask = OP_HASH_SIZE-1; int hash_size_mask = OP_HASH_SIZE-1;
if (OP_RTABLE == NULL) if (OP_RTABLE == NULL)
OP_RTABLE = (opentry *)_YAP_AllocCodeSpace(OP_HASH_SIZE*sizeof(struct opcode_tab_entry)); OP_RTABLE = (opentry *)Yap_AllocCodeSpace(OP_HASH_SIZE*sizeof(struct opcode_tab_entry));
if (OP_RTABLE == NULL) { if (OP_RTABLE == NULL) {
_YAP_Error(FATAL_ERROR, TermNil, Yap_Error(FATAL_ERROR, TermNil,
"Couldn't obtain space for the reverse translation opcode table"); "Couldn't obtain space for the reverse translation opcode table");
} }
opeptr = OP_RTABLE; opeptr = OP_RTABLE;
@ -594,11 +594,11 @@ InitReverseLookupOpcode(void)
} }
} }
opeptr = OP_RTABLE; opeptr = OP_RTABLE;
opeptr[rtable_hash_op(_YAP_opcode(_Ystop),hash_size_mask)].opc opeptr[rtable_hash_op(Yap_opcode(_Ystop),hash_size_mask)].opc
= _YAP_opcode(_Ystop); = Yap_opcode(_Ystop);
/* now place entries */ /* now place entries */
for (i = _std_top; i > _Ystop; i--) { for (i = _std_top; i > _Ystop; i--) {
OPCODE opc = _YAP_opcode(i); OPCODE opc = Yap_opcode(i);
int j = rtable_hash_op(opc,hash_size_mask); int j = rtable_hash_op(opc,hash_size_mask);
while (opeptr[j].opc != NIL) { while (opeptr[j].opc != NIL) {
@ -614,7 +614,7 @@ InitReverseLookupOpcode(void)
/* given an opcode find the corresponding opnumber. This should make /* given an opcode find the corresponding opnumber. This should make
switches on ops a much easier operation */ switches on ops a much easier operation */
op_numbers op_numbers
_YAP_op_from_opcode(OPCODE opc) Yap_op_from_opcode(OPCODE opc)
{ {
int j = rtable_hash_op(opc,OP_HASH_SIZE-1); int j = rtable_hash_op(opc,OP_HASH_SIZE-1);
@ -628,7 +628,7 @@ _YAP_op_from_opcode(OPCODE opc)
} }
#else #else
op_numbers op_numbers
_YAP_op_from_opcode(OPCODE opc) Yap_op_from_opcode(OPCODE opc)
{ {
return((op_numbers)opc); return((op_numbers)opc);
} }
@ -636,20 +636,20 @@ _YAP_op_from_opcode(OPCODE opc)
void void
_YAP_InitUnify(void) Yap_InitUnify(void)
{ {
_YAP_InitCPred("unify_with_occurs_check", 2, p_ocunify, SafePredFlag); Yap_InitCPred("unify_with_occurs_check", 2, p_ocunify, SafePredFlag);
_YAP_InitCPred("cyclic_term", 1, p_cyclic, SafePredFlag|TestPredFlag); Yap_InitCPred("cyclic_term", 1, p_cyclic, SafePredFlag|TestPredFlag);
_YAP_InitCPred("acyclic_term", 1, p_acyclic, SafePredFlag|TestPredFlag); Yap_InitCPred("acyclic_term", 1, p_acyclic, SafePredFlag|TestPredFlag);
} }
void void
_YAP_InitAbsmi(void) Yap_InitAbsmi(void)
{ {
/* initialise access to abstract machine instructions */ /* initialise access to abstract machine instructions */
#if USE_THREADED_CODE #if USE_THREADED_CODE
_YAP_absmi(1); Yap_absmi(1);
InitReverseLookupOpcode(); InitReverseLookupOpcode();
#endif #endif
} }

122
C/userpreds.c
View File

@ -139,14 +139,14 @@ Term T1, T2;
Term t2 = Deref(T2); Term t2 = Deref(T2);
if (IsVarTerm(t1)) { /* Testing for variables should be done first */ if (IsVarTerm(t1)) { /* Testing for variables should be done first */
if (IsVarTerm(t2) || IsPrimitiveTerm(t2)) if (IsVarTerm(t2) || IsPrimitiveTerm(t2))
return (_YAP_unify(T1, t2)); return (Yap_unify(T1, t2));
if (occurs_check(t1, t2)) if (occurs_check(t1, t2))
return (_YAP_unify(T1, t2)); return (Yap_unify(T1, t2));
return (FALSE); return (FALSE);
} }
if (IsVarTerm(t2)) { if (IsVarTerm(t2)) {
if (occurs_check(t2, t1)) if (occurs_check(t2, t1))
return (_YAP_unify(T2, t1)); return (Yap_unify(T2, t1));
return (FALSE); return (FALSE);
} }
if (IsPrimitiveTerm(t1)) { if (IsPrimitiveTerm(t1)) {
@ -220,10 +220,10 @@ p_counter()
return (FALSE); return (FALSE);
a = AtomOfTerm(T1); a = AtomOfTerm(T1);
if (IsVarTerm(T2)) { if (IsVarTerm(T2)) {
TCount = _YAP_GetValue(a); TCount = Yap_GetValue(a);
if (!IsIntTerm(TCount)) if (!IsIntTerm(TCount))
return (FALSE); return (FALSE);
_YAP_unify_constant(ARG2, TCount); /* always succeeds */ Yap_unify_constant(ARG2, TCount); /* always succeeds */
val = IntOfTerm(TCount); val = IntOfTerm(TCount);
} else { } else {
if (!IsIntTerm(T2)) if (!IsIntTerm(T2))
@ -232,8 +232,8 @@ p_counter()
} }
val++; val++;
/* The atom will now take the incremented value */ /* The atom will now take the incremented value */
_YAP_PutValue(a, TNext = MkIntTerm(val)); Yap_PutValue(a, TNext = MkIntTerm(val));
return (_YAP_unify_constant(ARG3, TNext)); return (Yap_unify_constant(ARG3, TNext));
} }
/* /*
@ -272,7 +272,7 @@ p_iconcat()
while (L0 = *--Tkp) while (L0 = *--Tkp)
L1 = MkPairTerm(L0, L1); L1 = MkPairTerm(L0, L1);
T2 = L1; T2 = L1;
return (_YAP_unify(T2, ARG3)); return (Yap_unify(T2, ARG3));
} }
#endif /* COMMENT */ #endif /* COMMENT */
@ -295,7 +295,7 @@ p_iconcat()
*Tkp++ = Deref(ARG2); *Tkp++ = Deref(ARG2);
T2 = *H; T2 = *H;
H = Tkp; H = Tkp;
return (_YAP_unify(T2, ARG3)); return (Yap_unify(T2, ARG3));
} }
#endif /* USERPREDS */ #endif /* USERPREDS */
@ -333,7 +333,7 @@ p_clean() /* predicate clean for ets */
if ((*pt++ = *ntp++) == MkAtomTerm(AtomDollarUndef)) if ((*pt++ = *ntp++) == MkAtomTerm(AtomDollarUndef))
pt -= 2; pt -= 2;
H = pt; H = pt;
return (_YAP_unify(tn, ARG2)); return (Yap_unify(tn, ARG2));
} }
#endif #endif
for (i = 1; i <= arity; ++i) { for (i = 1; i <= arity; ++i) {
@ -341,8 +341,8 @@ p_clean() /* predicate clean for ets */
t = MkVarTerm(); t = MkVarTerm();
Args[i - 1] = t; Args[i - 1] = t;
} }
t = _YAP_MkApplTerm(FunctorOfTerm(t1), arity, Args); t = Yap_MkApplTerm(FunctorOfTerm(t1), arity, Args);
return (_YAP_unify(ARG2, t)); return (Yap_unify(ARG2, t));
} }
static Term *subs_table; static Term *subs_table;
@ -364,7 +364,7 @@ Term T1, T2;
if (subs_table[i] == T2) if (subs_table[i] == T2)
return (FALSE); return (FALSE);
if (T2 < T1) { /* T1 gets instantiated with T2 */ if (T2 < T1) { /* T1 gets instantiated with T2 */
_YAP_unify(T1, T2); Yap_unify(T1, T2);
for (i = 0; i < subs_entries; ++i) for (i = 0; i < subs_entries; ++i)
if (subs_table[i] == T1) { if (subs_table[i] == T1) {
subs_table[i] = T2; subs_table[i] = T2;
@ -374,7 +374,7 @@ Term T1, T2;
return (TRUE); return (TRUE);
} }
/* T2 gets instantiated with T1 */ /* T2 gets instantiated with T1 */
_YAP_unify(T1, T2); Yap_unify(T1, T2);
for (i = 0; i < subs_entries; ++i) for (i = 0; i < subs_entries; ++i)
if (subs_table[i] == T1) if (subs_table[i] == T1)
return (TRUE); return (TRUE);
@ -385,7 +385,7 @@ Term T1, T2;
for (i = 0; i < subs_entries; ++i) for (i = 0; i < subs_entries; ++i)
if (subs_table[i] == T2) if (subs_table[i] == T2)
return (FALSE); return (FALSE);
return (_YAP_unify(T1, T2)); return (Yap_unify(T1, T2));
} }
if (IsPrimitiveTerm(T1)) { if (IsPrimitiveTerm(T1)) {
if (IsFloatTerm(T1)) if (IsFloatTerm(T1))
@ -506,7 +506,7 @@ p_namelength()
} }
if (IsAtomTerm(t)) { if (IsAtomTerm(t)) {
Term tf = MkIntTerm(strlen(RepAtom(AtomOfTerm(t))->StrOfAE)); Term tf = MkIntTerm(strlen(RepAtom(AtomOfTerm(t))->StrOfAE));
return (_YAP_unify_constant(ARG2, tf)); return (Yap_unify_constant(ARG2, tf));
} else if (IsIntTerm(t)) { } else if (IsIntTerm(t)) {
register int i = 1, k = IntOfTerm(t); register int i = 1, k = IntOfTerm(t);
if (k < 0) if (k < 0)
@ -514,7 +514,7 @@ p_namelength()
while (k > 10) while (k > 10)
++i, k /= 10; ++i, k /= 10;
tf = MkIntTerm(i); tf = MkIntTerm(i);
return (_YAP_unify_constant(ARG2, tf)); return (Yap_unify_constant(ARG2, tf));
} else } else
return (FALSE); return (FALSE);
} }
@ -527,7 +527,7 @@ p_getpid()
#else #else
Term t = MkIntTerm(1); Term t = MkIntTerm(1);
#endif #endif
return (_YAP_unify_constant(ARG1, t)); return (Yap_unify_constant(ARG1, t));
} }
static int static int
@ -536,7 +536,7 @@ p_exit()
register Term t = Deref(ARG1); register Term t = Deref(ARG1);
if (IsVarTerm(t) || !IsIntTerm(t)) if (IsVarTerm(t) || !IsIntTerm(t))
return (FALSE); return (FALSE);
_YAP_exit((int) IntOfTerm(t)); Yap_exit((int) IntOfTerm(t));
return(FALSE); return(FALSE);
} }
@ -557,7 +557,7 @@ p_setcounter()
{ {
register Term t = Deref(ARG1); register Term t = Deref(ARG1);
if (IsVarTerm(t) || !IsIntTerm(t)) { if (IsVarTerm(t) || !IsIntTerm(t)) {
return (_YAP_unify_constant(ARG1, MkIntTerm(current_pos))); return (Yap_unify_constant(ARG1, MkIntTerm(current_pos)));
} else { } else {
current_pos = IntOfTerm(t); current_pos = IntOfTerm(t);
return (TRUE); return (TRUE);
@ -596,34 +596,34 @@ p_grab_tokens()
Functor IdFunctor, VarFunctor; Functor IdFunctor, VarFunctor;
char ch, IdChars[255], *chp; char ch, IdChars[255], *chp;
IdAtom = _YAP_LookupAtom("id"); IdAtom = Yap_LookupAtom("id");
IdFunctor = _YAP_MkFunctor(IdAtom, 1); IdFunctor = Yap_MkFunctor(IdAtom, 1);
VarAtom = _YAP_LookupAtom("var"); VarAtom = Yap_LookupAtom("var");
VarFunctor = _YAP_MkFunctor(VarAtom, 1); VarFunctor = Yap_MkFunctor(VarAtom, 1);
p0 = p; p0 = p;
ch = _YAP_PlGetchar(); ch = Yap_PlGetchar();
while (1) { while (1) {
while (ch <= ' ' && ch != EOF) while (ch <= ' ' && ch != EOF)
ch = _YAP_PlGetchar(); ch = Yap_PlGetchar();
if (ch == '.' || ch == EOF) if (ch == '.' || ch == EOF)
break; break;
if (ch == '%') { if (ch == '%') {
while ((ch = _YAP_PlGetchar()) != 10); while ((ch = Yap_PlGetchar()) != 10);
ch = _YAP_PlGetchar(); ch = Yap_PlGetchar();
continue; continue;
} }
if (ch == '\'') { if (ch == '\'') {
chp = IdChars; chp = IdChars;
while (1) { while (1) {
ch = _YAP_PlGetchar(); ch = Yap_PlGetchar();
if (ch == '\'') if (ch == '\'')
break; break;
*chp++ = ch; *chp++ = ch;
} }
*chp = 0; *chp = 0;
t = MkAtomTerm(_YAP_LookupAtom(IdChars)); t = MkAtomTerm(Yap_LookupAtom(IdChars));
*p-- = _YAP_MkApplTerm(IdFunctor, 1, &t); *p-- = Yap_MkApplTerm(IdFunctor, 1, &t);
ch = _YAP_PlGetchar(); ch = Yap_PlGetchar();
continue; continue;
} }
@ -631,40 +631,40 @@ p_grab_tokens()
chp = IdChars; chp = IdChars;
*chp++ = ch; *chp++ = ch;
while (1) { while (1) {
ch = _YAP_PlGetchar(); ch = Yap_PlGetchar();
if (!idchar(ch)) if (!idchar(ch))
break; break;
*chp++ = ch; *chp++ = ch;
} }
*chp = 0; *chp = 0;
t = MkAtomTerm(_YAP_LookupAtom(IdChars)); t = MkAtomTerm(Yap_LookupAtom(IdChars));
*p-- = _YAP_MkApplTerm(VarFunctor, 1, &t); *p-- = Yap_MkApplTerm(VarFunctor, 1, &t);
continue; continue;
} }
if (idstarter(ch)) { if (idstarter(ch)) {
chp = IdChars; chp = IdChars;
*chp++ = ch; *chp++ = ch;
while (1) { while (1) {
ch = _YAP_PlGetchar(); ch = Yap_PlGetchar();
if (!idchar(ch)) if (!idchar(ch))
break; break;
*chp++ = ch; *chp++ = ch;
} }
*chp = 0; *chp = 0;
t = MkAtomTerm(_YAP_LookupAtom(IdChars)); t = MkAtomTerm(Yap_LookupAtom(IdChars));
*p-- = _YAP_MkApplTerm(IdFunctor, 1, &t); *p-- = Yap_MkApplTerm(IdFunctor, 1, &t);
continue; continue;
} }
IdChars[0] = ch; IdChars[0] = ch;
IdChars[1] = 0; IdChars[1] = 0;
*p-- = MkAtomTerm(_YAP_LookupAtom(IdChars)); *p-- = MkAtomTerm(Yap_LookupAtom(IdChars));
ch = _YAP_PlGetchar(); ch = Yap_PlGetchar();
} }
t = MkAtomTerm(AtomNil); t = MkAtomTerm(AtomNil);
while (p != p0) { while (p != p0) {
t = MkPairTerm(*++p, t); t = MkPairTerm(*++p, t);
} }
return (_YAP_unify(ARG1, t)); return (Yap_unify(ARG1, t));
} }
#endif /* EUROTRA */ #endif /* EUROTRA */
@ -687,8 +687,8 @@ p_softfunctor()
return (FALSE); return (FALSE);
a = AtomOfTerm(t1); a = AtomOfTerm(t1);
WRITE_LOCK(RepAtom(a)->ARWLock); WRITE_LOCK(RepAtom(a)->ARWLock);
if ((p0 = _YAP_GetAProp(a, SFProperty)) == NIL) { if ((p0 = Yap_GetAProp(a, SFProperty)) == NIL) {
pe = (SFEntry *) _YAP_AllocAtomSpace(sizeof(*pe)); pe = (SFEntry *) Yap_AllocAtomSpace(sizeof(*pe));
pe->NextOfPE = RepAtom(a)->PropsOfAE; pe->NextOfPE = RepAtom(a)->PropsOfAE;
pe->KindOfPE = SFProperty; pe->KindOfPE = SFProperty;
RepAtom(a)->PropsOfAE = AbsSFProp(pe); RepAtom(a)->PropsOfAE = AbsSFProp(pe);
@ -712,34 +712,34 @@ p_matching_distances(void)
*/ */
void void
_YAP_InitUserCPreds(void) Yap_InitUserCPreds(void)
{ {
#ifdef XINTERFACE #ifdef XINTERFACE
_YAP_InitXPreds(); Yap_InitXPreds();
#endif #endif
#ifdef EUROTRA #ifdef EUROTRA
_YAP_InitCPred("clean", 2, p_clean, SafePredFlag|SyncPredFlag); Yap_InitCPred("clean", 2, p_clean, SafePredFlag|SyncPredFlag);
_YAP_InitCPred("name_length", 2, p_namelength, SafePredFlag|SyncPredFlag); Yap_InitCPred("name_length", 2, p_namelength, SafePredFlag|SyncPredFlag);
_YAP_InitCPred("get_pid", 1, p_getpid, SafePredFlag); Yap_InitCPred("get_pid", 1, p_getpid, SafePredFlag);
_YAP_InitCPred("exit", 1, p_exit, SafePredFlag|SyncPredFlag); Yap_InitCPred("exit", 1, p_exit, SafePredFlag|SyncPredFlag);
_YAP_InitCPred("incr_counter", 1, p_incrcounter, SafePredFlag|SyncPredFlag); Yap_InitCPred("incr_counter", 1, p_incrcounter, SafePredFlag|SyncPredFlag);
_YAP_InitCPred("set_counter", 1, p_setcounter, SafePredFlag|SyncPredFlag); Yap_InitCPred("set_counter", 1, p_setcounter, SafePredFlag|SyncPredFlag);
_YAP_InitCPred("trap_signal", 0, p_trapsignal, SafePredFlag|SyncPredFlag); Yap_InitCPred("trap_signal", 0, p_trapsignal, SafePredFlag|SyncPredFlag);
_YAP_InitCPred("mark2_grab_tokens", 1, p_grab_tokens, SafePredFlag|SyncPredFlag); Yap_InitCPred("mark2_grab_tokens", 1, p_grab_tokens, SafePredFlag|SyncPredFlag);
_YAP_InitCPred("subsumes", 2, p_subsumes, SafePredFlag); Yap_InitCPred("subsumes", 2, p_subsumes, SafePredFlag);
#endif #endif
#ifdef SFUNC #ifdef SFUNC
_YAP_InitCPred("sparse_functor", 2, p_softfunctor, SafePredFlag); Yap_InitCPred("sparse_functor", 2, p_softfunctor, SafePredFlag);
#endif /* SFUNC */ #endif /* SFUNC */
/* _YAP_InitCPred("match_distances", 3, p_matching_distances, SafePredFlag); */ /* Yap_InitCPred("match_distances", 3, p_matching_distances, SafePredFlag); */
/* _YAP_InitCPred("unify",2,p_unify,SafePredFlag); */ /* Yap_InitCPred("unify",2,p_unify,SafePredFlag); */
/* _YAP_InitCPred("occurs_check",2,p_occurs_check,SafePredFlag); */ /* Yap_InitCPred("occurs_check",2,p_occurs_check,SafePredFlag); */
/* _YAP_InitCPred("counter",3,p_counter,SafePredFlag); */ /* Yap_InitCPred("counter",3,p_counter,SafePredFlag); */
/* _YAP_InitCPred("iconcat",3,p_iconcat,SafePredFlag); */ /* Yap_InitCPred("iconcat",3,p_iconcat,SafePredFlag); */
} }
void void
_YAP_InitUserBacks(void) Yap_InitUserBacks(void)
{ {
} }

116
C/utilpreds.c
View File

@ -86,7 +86,7 @@ copy_complex_term(register CELL *pt0, register CELL *pt0_end, CELL *ptf, CELL *H
*ptf = AbsPair(H); *ptf = AbsPair(H);
ptf++; ptf++;
#ifdef RATIONAL_TREES #ifdef RATIONAL_TREES
if (to_visit + 4 >= (CELL **)_YAP_GlobalBase) { if (to_visit + 4 >= (CELL **)Yap_GlobalBase) {
goto heap_overflow; goto heap_overflow;
} }
to_visit[0] = pt0; to_visit[0] = pt0;
@ -98,7 +98,7 @@ copy_complex_term(register CELL *pt0, register CELL *pt0_end, CELL *ptf, CELL *H
to_visit += 4; to_visit += 4;
#else #else
if (pt0 < pt0_end) { if (pt0 < pt0_end) {
if (to_visit + 3 >= (CELL **)_YAP_GlobalBase) { if (to_visit + 3 >= (CELL **)Yap_GlobalBase) {
goto heap_overflow; goto heap_overflow;
} }
to_visit[0] = pt0; to_visit[0] = pt0;
@ -136,7 +136,7 @@ copy_complex_term(register CELL *pt0, register CELL *pt0_end, CELL *ptf, CELL *H
ptf++; ptf++;
/* store the terms to visit */ /* store the terms to visit */
#ifdef RATIONAL_TREES #ifdef RATIONAL_TREES
if (to_visit + 4 >= (CELL **)_YAP_GlobalBase) { if (to_visit + 4 >= (CELL **)Yap_GlobalBase) {
goto heap_overflow; goto heap_overflow;
} }
to_visit[0] = pt0; to_visit[0] = pt0;
@ -148,7 +148,7 @@ copy_complex_term(register CELL *pt0, register CELL *pt0_end, CELL *ptf, CELL *H
to_visit += 4; to_visit += 4;
#else #else
if (pt0 < pt0_end) { if (pt0 < pt0_end) {
if (to_visit + 3 >= (CELL **)_YAP_GlobalBase) { if (to_visit + 3 >= (CELL **)Yap_GlobalBase) {
goto heap_overflow; goto heap_overflow;
} }
to_visit[0] = pt0; to_visit[0] = pt0;
@ -189,7 +189,7 @@ copy_complex_term(register CELL *pt0, register CELL *pt0_end, CELL *ptf, CELL *H
*ptf++ = (CELL) ptd0; *ptf++ = (CELL) ptd0;
} else { } else {
if (dvars == NULL) { if (dvars == NULL) {
dvars = (CELL *)_YAP_ReadTimedVar(DelayedVars); dvars = (CELL *)Yap_ReadTimedVar(DelayedVars);
} }
bp[0] = to_visit; bp[0] = to_visit;
CurTR = TR; CurTR = TR;
@ -309,15 +309,15 @@ CopyTerm(Term inp) {
if ((res = copy_complex_term(Hi-2, Hi-1, Hi, Hi)) < 0) { if ((res = copy_complex_term(Hi-2, Hi-1, Hi, Hi)) < 0) {
ARG1 = t; ARG1 = t;
if (res == -1) { /* handle overflow */ if (res == -1) { /* handle overflow */
if (!_YAP_gc(2, ENV, P)) { if (!Yap_gc(2, ENV, P)) {
_YAP_Error(OUT_OF_STACK_ERROR, TermNil, _YAP_ErrorMessage); Yap_Error(OUT_OF_STACK_ERROR, TermNil, Yap_ErrorMessage);
return(FALSE); return(FALSE);
} }
t = Deref(ARG1); t = Deref(ARG1);
goto restart_attached; goto restart_attached;
} else { /* handle overflow */ } else { /* handle overflow */
if (!_YAP_growheap(FALSE)) { if (!Yap_growheap(FALSE)) {
_YAP_Error(SYSTEM_ERROR, TermNil, _YAP_ErrorMessage); Yap_Error(SYSTEM_ERROR, TermNil, Yap_ErrorMessage);
return(FALSE); return(FALSE);
} }
t = Deref(ARG1); t = Deref(ARG1);
@ -345,15 +345,15 @@ CopyTerm(Term inp) {
if ((res = copy_complex_term(ap-1, ap+1, Hi, Hi)) < 0) { if ((res = copy_complex_term(ap-1, ap+1, Hi, Hi)) < 0) {
ARG1 = t; ARG1 = t;
if (res == -1) { /* handle overflow */ if (res == -1) { /* handle overflow */
if (!_YAP_gc(2, ENV, P)) { if (!Yap_gc(2, ENV, P)) {
_YAP_Error(OUT_OF_STACK_ERROR, TermNil, _YAP_ErrorMessage); Yap_Error(OUT_OF_STACK_ERROR, TermNil, Yap_ErrorMessage);
return(FALSE); return(FALSE);
} }
t = Deref(ARG1); t = Deref(ARG1);
goto restart_list; goto restart_list;
} else { /* handle overflow */ } else { /* handle overflow */
if (!_YAP_growheap(FALSE)) { if (!Yap_growheap(FALSE)) {
_YAP_Error(SYSTEM_ERROR, TermNil, _YAP_ErrorMessage); Yap_Error(SYSTEM_ERROR, TermNil, Yap_ErrorMessage);
return(FALSE); return(FALSE);
} }
t = Deref(ARG1); t = Deref(ARG1);
@ -380,15 +380,15 @@ CopyTerm(Term inp) {
if ((res = copy_complex_term(ap, ap+ArityOfFunctor(f), HB0+1, HB0)) < 0) { if ((res = copy_complex_term(ap, ap+ArityOfFunctor(f), HB0+1, HB0)) < 0) {
ARG1 = t; ARG1 = t;
if (res == -1) { if (res == -1) {
if (!_YAP_gc(2, ENV, P)) { if (!Yap_gc(2, ENV, P)) {
_YAP_Error(OUT_OF_STACK_ERROR, TermNil, _YAP_ErrorMessage); Yap_Error(OUT_OF_STACK_ERROR, TermNil, Yap_ErrorMessage);
return(FALSE); return(FALSE);
} }
t = Deref(ARG1); t = Deref(ARG1);
goto restart_appl; goto restart_appl;
} else { /* handle overflow */ } else { /* handle overflow */
if (!_YAP_growheap(FALSE)) { if (!Yap_growheap(FALSE)) {
_YAP_Error(SYSTEM_ERROR, TermNil, _YAP_ErrorMessage); Yap_Error(SYSTEM_ERROR, TermNil, Yap_ErrorMessage);
return(FALSE); return(FALSE);
} }
t = Deref(ARG1); t = Deref(ARG1);
@ -401,14 +401,14 @@ CopyTerm(Term inp) {
} }
Term Term
_YAP_CopyTerm(Term inp) { Yap_CopyTerm(Term inp) {
return CopyTerm(inp); return CopyTerm(inp);
} }
static Int static Int
p_copy_term(void) /* copy term t to a new instance */ p_copy_term(void) /* copy term t to a new instance */
{ {
return(_YAP_unify(ARG2,CopyTerm(ARG1))); return(Yap_unify(ARG2,CopyTerm(ARG1)));
} }
static int copy_complex_term_no_delays(register CELL *pt0, register CELL *pt0_end, CELL *ptf, CELL *HLow) static int copy_complex_term_no_delays(register CELL *pt0, register CELL *pt0_end, CELL *ptf, CELL *HLow)
@ -439,7 +439,7 @@ static int copy_complex_term_no_delays(register CELL *pt0, register CELL *pt0_en
*ptf = AbsPair(H); *ptf = AbsPair(H);
ptf++; ptf++;
#ifdef RATIONAL_TREES #ifdef RATIONAL_TREES
if (to_visit + 4 >= (CELL **)_YAP_GlobalBase) { if (to_visit + 4 >= (CELL **)Yap_GlobalBase) {
goto heap_overflow; goto heap_overflow;
} }
to_visit[0] = pt0; to_visit[0] = pt0;
@ -451,7 +451,7 @@ static int copy_complex_term_no_delays(register CELL *pt0, register CELL *pt0_en
to_visit += 4; to_visit += 4;
#else #else
if (pt0 < pt0_end) { if (pt0 < pt0_end) {
if (to_visit + 3 >= (CELL **)_YAP_GlobalBase) { if (to_visit + 3 >= (CELL **)Yap_GlobalBase) {
goto heap_overflow; goto heap_overflow;
} }
to_visit[0] = pt0; to_visit[0] = pt0;
@ -487,7 +487,7 @@ static int copy_complex_term_no_delays(register CELL *pt0, register CELL *pt0_en
ptf++; ptf++;
/* store the terms to visit */ /* store the terms to visit */
#ifdef RATIONAL_TREES #ifdef RATIONAL_TREES
if (to_visit + 4 >= (CELL **)_YAP_GlobalBase) { if (to_visit + 4 >= (CELL **)Yap_GlobalBase) {
goto heap_overflow; goto heap_overflow;
} }
to_visit[0] = pt0; to_visit[0] = pt0;
@ -498,7 +498,7 @@ static int copy_complex_term_no_delays(register CELL *pt0, register CELL *pt0_en
*pt0 = AbsAppl(H); *pt0 = AbsAppl(H);
to_visit += 4; to_visit += 4;
#else #else
if (to_visit + 3 >= (CELL **)_YAP_GlobalBase) { if (to_visit + 3 >= (CELL **)Yap_GlobalBase) {
goto heap_overflow; goto heap_overflow;
} }
if (pt0 < pt0_end) { if (pt0 < pt0_end) {
@ -618,15 +618,15 @@ CopyTermNoDelays(Term inp) {
res = copy_complex_term_no_delays(ap-1, ap+1, H-2, H-2); res = copy_complex_term_no_delays(ap-1, ap+1, H-2, H-2);
if (res) { if (res) {
if (res == -1) { /* handle overflow */ if (res == -1) { /* handle overflow */
if (!_YAP_gc(2, ENV, P)) { if (!Yap_gc(2, ENV, P)) {
_YAP_Error(OUT_OF_STACK_ERROR, TermNil, _YAP_ErrorMessage); Yap_Error(OUT_OF_STACK_ERROR, TermNil, Yap_ErrorMessage);
return(FALSE); return(FALSE);
} }
t = Deref(ARG1); t = Deref(ARG1);
goto restart_list; goto restart_list;
} else { /* handle overflow */ } else { /* handle overflow */
if (!_YAP_growheap(FALSE)) { if (!Yap_growheap(FALSE)) {
_YAP_Error(SYSTEM_ERROR, TermNil, _YAP_ErrorMessage); Yap_Error(SYSTEM_ERROR, TermNil, Yap_ErrorMessage);
return(FALSE); return(FALSE);
} }
t = Deref(ARG1); t = Deref(ARG1);
@ -650,15 +650,15 @@ CopyTermNoDelays(Term inp) {
res = copy_complex_term_no_delays(ap, ap+ArityOfFunctor(f), HB0+1, HB0); res = copy_complex_term_no_delays(ap, ap+ArityOfFunctor(f), HB0+1, HB0);
if (res) { if (res) {
if (res == -1) { if (res == -1) {
if (!_YAP_gc(2, ENV, P)) { if (!Yap_gc(2, ENV, P)) {
_YAP_Error(OUT_OF_STACK_ERROR, TermNil, _YAP_ErrorMessage); Yap_Error(OUT_OF_STACK_ERROR, TermNil, Yap_ErrorMessage);
return(FALSE); return(FALSE);
} }
t = Deref(ARG1); t = Deref(ARG1);
goto restart_appl; goto restart_appl;
} else { /* handle overflow */ } else { /* handle overflow */
if (!_YAP_growheap(FALSE)) { if (!Yap_growheap(FALSE)) {
_YAP_Error(SYSTEM_ERROR, TermNil, _YAP_ErrorMessage); Yap_Error(SYSTEM_ERROR, TermNil, Yap_ErrorMessage);
return(FALSE); return(FALSE);
} }
t = Deref(ARG1); t = Deref(ARG1);
@ -672,7 +672,7 @@ CopyTermNoDelays(Term inp) {
static Int static Int
p_copy_term_no_delays(void) /* copy term t to a new instance */ p_copy_term_no_delays(void) /* copy term t to a new instance */
{ {
return(_YAP_unify(ARG2,CopyTermNoDelays(ARG1))); return(Yap_unify(ARG2,CopyTermNoDelays(ARG1)));
} }
@ -773,7 +773,7 @@ static Term vars_in_complex_term(register CELL *pt0, register CELL *pt0_end)
Term t2 = Deref(ARG2); Term t2 = Deref(ARG2);
if (IsVarTerm(t2)) { if (IsVarTerm(t2)) {
RESET_VARIABLE(H-1); RESET_VARIABLE(H-1);
_YAP_unify((CELL)(H-1),ARG2); Yap_unify((CELL)(H-1),ARG2);
} else { } else {
H[-1] = t2; /* don't need to trail */ H[-1] = t2; /* don't need to trail */
} }
@ -794,8 +794,8 @@ p_variables_in_term(void) /* variables in term t */
H += 2; H += 2;
RESET_VARIABLE(H-2); RESET_VARIABLE(H-2);
RESET_VARIABLE(H-1); RESET_VARIABLE(H-1);
_YAP_unify((CELL)(H-2),ARG1); Yap_unify((CELL)(H-2),ARG1);
_YAP_unify((CELL)(H-1),ARG2); Yap_unify((CELL)(H-1),ARG2);
} else if (IsPrimitiveTerm(t)) } else if (IsPrimitiveTerm(t))
out = ARG2; out = ARG2;
else if (IsPairTerm(t)) { else if (IsPairTerm(t)) {
@ -808,7 +808,7 @@ p_variables_in_term(void) /* variables in term t */
RepAppl(t)+ RepAppl(t)+
ArityOfFunctor(f)); ArityOfFunctor(f));
} }
return(_YAP_unify(ARG3,out)); return(Yap_unify(ARG3,out));
} }
static Term non_singletons_in_complex_term(register CELL *pt0, register CELL *pt0_end) static Term non_singletons_in_complex_term(register CELL *pt0, register CELL *pt0_end)
@ -911,7 +911,7 @@ static Term non_singletons_in_complex_term(register CELL *pt0, register CELL *pt
if (H != InitialH) { if (H != InitialH) {
/* close the list */ /* close the list */
RESET_VARIABLE(H-1); RESET_VARIABLE(H-1);
_YAP_unify((CELL)(H-1),ARG2); Yap_unify((CELL)(H-1),ARG2);
return(output); return(output);
} else { } else {
return(ARG2); return(ARG2);
@ -934,7 +934,7 @@ p_non_singletons_in_term(void) /* non_singletons in term t */
else out = non_singletons_in_complex_term(RepAppl(t), else out = non_singletons_in_complex_term(RepAppl(t),
RepAppl(t)+ RepAppl(t)+
ArityOfFunctor(FunctorOfTerm(t))); ArityOfFunctor(FunctorOfTerm(t)));
return(_YAP_unify(ARG3,out)); return(Yap_unify(ARG3,out));
} }
static Int ground_complex_term(register CELL *pt0, register CELL *pt0_end) static Int ground_complex_term(register CELL *pt0, register CELL *pt0_end)
@ -1251,24 +1251,24 @@ GvNTermHash(void)
if (IsVarTerm(t2)) { if (IsVarTerm(t2)) {
_YAP_Error(INSTANTIATION_ERROR,t2,"term_hash/4"); Yap_Error(INSTANTIATION_ERROR,t2,"term_hash/4");
return(FALSE); return(FALSE);
} }
if (!IsIntegerTerm(t2)) { if (!IsIntegerTerm(t2)) {
_YAP_Error(TYPE_ERROR_INTEGER,t2,"term_hash/4"); Yap_Error(TYPE_ERROR_INTEGER,t2,"term_hash/4");
return(FALSE); return(FALSE);
} }
depth = IntegerOfTerm(t2); depth = IntegerOfTerm(t2);
if (depth == 0) { if (depth == 0) {
if (IsVarTerm(t1)) return(TRUE); if (IsVarTerm(t1)) return(TRUE);
return(_YAP_unify(ARG4,MkIntTerm(0))); return(Yap_unify(ARG4,MkIntTerm(0)));
} }
if (IsVarTerm(t3)) { if (IsVarTerm(t3)) {
_YAP_Error(INSTANTIATION_ERROR,t3,"term_hash/4"); Yap_Error(INSTANTIATION_ERROR,t3,"term_hash/4");
return(FALSE); return(FALSE);
} }
if (!IsIntegerTerm(t3)) { if (!IsIntegerTerm(t3)) {
_YAP_Error(TYPE_ERROR_INTEGER,t3,"term_hash/4"); Yap_Error(TYPE_ERROR_INTEGER,t3,"term_hash/4");
return(FALSE); return(FALSE);
} }
size = IntegerOfTerm(t3); size = IntegerOfTerm(t3);
@ -1283,7 +1283,7 @@ GvNTermHash(void)
i3 = GvNht[2]; i3 = GvNht[2];
i2 ^= i3; i1 ^= i2; i1 = (((i3 << 7) + i2) << 7) + i1; i2 ^= i3; i1 ^= i2; i1 = (((i3 << 7) + i2) << 7) + i1;
result = MkIntegerTerm(i1 % size); result = MkIntegerTerm(i1 % size);
return(_YAP_unify(ARG4,result)); return(Yap_unify(ARG4,result));
} }
static int variant_complex(register CELL *pt0, register CELL *pt0_end, register static int variant_complex(register CELL *pt0, register CELL *pt0_end, register
@ -1685,30 +1685,30 @@ camacho_dum(void)
/* build output list */ /* build output list */
t1 = MkAtomTerm(_YAP_LookupAtom("[]")); t1 = MkAtomTerm(Yap_LookupAtom("[]"));
t2 = MkPairTerm(MkIntegerTerm(max), t1); t2 = MkPairTerm(MkIntegerTerm(max), t1);
return(_YAP_unify(t2, ARG1)); return(Yap_unify(t2, ARG1));
} }
#endif /* DEBUG */ #endif /* DEBUG */
void _YAP_InitUtilCPreds(void) void Yap_InitUtilCPreds(void)
{ {
_YAP_InitCPred("copy_term", 2, p_copy_term, 0); Yap_InitCPred("copy_term", 2, p_copy_term, 0);
_YAP_InitCPred("$copy_term_but_not_constraints", 2, p_copy_term_no_delays, 0); Yap_InitCPred("$copy_term_but_not_constraints", 2, p_copy_term_no_delays, 0);
_YAP_InitCPred("ground", 1, p_ground, SafePredFlag); Yap_InitCPred("ground", 1, p_ground, SafePredFlag);
_YAP_InitCPred("$variables_in_term", 3, p_variables_in_term, SafePredFlag); Yap_InitCPred("$variables_in_term", 3, p_variables_in_term, SafePredFlag);
_YAP_InitCPred("variable_in_term", 2, p_var_in_term, SafePredFlag); Yap_InitCPred("variable_in_term", 2, p_var_in_term, SafePredFlag);
_YAP_InitCPred("$non_singletons_in_term", 3, p_non_singletons_in_term, SafePredFlag); Yap_InitCPred("$non_singletons_in_term", 3, p_non_singletons_in_term, SafePredFlag);
_YAP_InitCPred("term_hash", 4, GvNTermHash, SafePredFlag); Yap_InitCPred("term_hash", 4, GvNTermHash, SafePredFlag);
_YAP_InitCPred("variant", 2, p_variant, SafePredFlag); Yap_InitCPred("variant", 2, p_variant, SafePredFlag);
_YAP_InitCPred("subsumes", 2, p_subsumes, SafePredFlag); Yap_InitCPred("subsumes", 2, p_subsumes, SafePredFlag);
#ifdef DEBUG #ifdef DEBUG
_YAP_InitCPred("$force_trail_expansion", 1, p_force_trail_expansion, SafePredFlag); Yap_InitCPred("$force_trail_expansion", 1, p_force_trail_expansion, SafePredFlag);
_YAP_InitCPred("dum", 1, camacho_dum, SafePredFlag); Yap_InitCPred("dum", 1, camacho_dum, SafePredFlag);
#endif #endif
} }

130
C/write.c
View File

@ -60,7 +60,7 @@ static int Quote_illegal, Ignore_ops, Handle_vars, Use_portray;
static int keep_terms; static int keep_terms;
#define wrputc(X) ((*writech)(_YAP_c_output_stream,X)) /* writes a character */ #define wrputc(X) ((*writech)(Yap_c_output_stream,X)) /* writes a character */
static void static void
wrputn(Int n) /* writes an integer */ wrputn(Int n) /* writes an integer */
@ -154,24 +154,24 @@ legalAtom(char *s) /* Is this a legal atom ? */
register int ch = *s; register int ch = *s;
if (ch == '\0') if (ch == '\0')
return(FALSE); return(FALSE);
if (_YAP_chtype[ch] != LC) { if (Yap_chtype[ch] != LC) {
if (ch == '[') if (ch == '[')
return (*++s == ']' && !(*++s)); return (*++s == ']' && !(*++s));
else if (ch == '{') else if (ch == '{')
return (*++s == '}' && !(*++s)); return (*++s == '}' && !(*++s));
else if (_YAP_chtype[ch] == SL) else if (Yap_chtype[ch] == SL)
return (!*++s); return (!*++s);
else if ((ch == ',' || ch == '.') && !s[1]) else if ((ch == ',' || ch == '.') && !s[1])
return (FALSE); return (FALSE);
else else
while (ch) { while (ch) {
if (_YAP_chtype[ch] != SY) return (FALSE); if (Yap_chtype[ch] != SY) return (FALSE);
ch = *++s; ch = *++s;
} }
return (TRUE); return (TRUE);
} else } else
while ((ch = *++s) != 0) while ((ch = *++s) != 0)
if (_YAP_chtype[ch] > NU) if (Yap_chtype[ch] > NU)
return (FALSE); return (FALSE);
return (TRUE); return (TRUE);
} }
@ -179,25 +179,25 @@ legalAtom(char *s) /* Is this a legal atom ? */
static int LeftOpToProtect(Atom at, int p) static int LeftOpToProtect(Atom at, int p)
{ {
int op, rp; int op, rp;
Prop opinfo = _YAP_GetAProp(at, OpProperty); Prop opinfo = Yap_GetAProp(at, OpProperty);
return(opinfo && _YAP_IsPrefixOp(opinfo, &op, &rp) ); return(opinfo && Yap_IsPrefixOp(opinfo, &op, &rp) );
} }
static int RightOpToProtect(Atom at, int p) static int RightOpToProtect(Atom at, int p)
{ {
int op, lp; int op, lp;
Prop opinfo = _YAP_GetAProp(at, OpProperty); Prop opinfo = Yap_GetAProp(at, OpProperty);
return(opinfo && _YAP_IsPosfixOp(opinfo, &op, &lp) ); return(opinfo && Yap_IsPosfixOp(opinfo, &op, &lp) );
} }
static wtype static wtype
AtomIsSymbols(char *s) /* Is this atom just formed by symbols ? */ AtomIsSymbols(char *s) /* Is this atom just formed by symbols ? */
{ {
int ch; int ch;
if (_YAP_chtype[(int)s[0]] == SL && s[1] == '\0') if (Yap_chtype[(int)s[0]] == SL && s[1] == '\0')
return(separator); return(separator);
while ((ch = *s++) != '\0') { while ((ch = *s++) != '\0') {
if (_YAP_chtype[ch] != SY) if (Yap_chtype[ch] != SY)
return(alphanum); return(alphanum);
} }
return(symbol); return(symbol);
@ -212,7 +212,7 @@ putAtom(Atom atom) /* writes an atom */
/* #define CRYPT_FOR_STEVE 1*/ /* #define CRYPT_FOR_STEVE 1*/
#ifdef CRYPT_FOR_STEVE #ifdef CRYPT_FOR_STEVE
if (_YAP_GetValue(_YAP_LookupAtom("crypt_atoms")) != TermNil && _YAP_GetAProp(atom, OpProperty) == NIL) { if (Yap_GetValue(Yap_LookupAtom("crypt_atoms")) != TermNil && Yap_GetAProp(atom, OpProperty) == NIL) {
char s[16]; char s[16];
sprintf(s,"x%x", (CELL)s); sprintf(s,"x%x", (CELL)s);
wrputs(s); wrputs(s);
@ -302,10 +302,10 @@ write_var(CELL *t)
if (CellPtr(t) < H0) { if (CellPtr(t) < H0) {
#if COROUTINING #if COROUTINING
#if DEBUG #if DEBUG
if (_YAP_Portray_delays) { if (Yap_Portray_delays) {
exts ext = ExtFromCell(t); exts ext = ExtFromCell(t);
_YAP_Portray_delays = FALSE; Yap_Portray_delays = FALSE;
if (ext == susp_ext) { if (ext == susp_ext) {
wrputs("$DL("); wrputs("$DL(");
write_var(t); write_var(t);
@ -321,12 +321,12 @@ write_var(CELL *t)
wrputc(','); wrputc(',');
if (keep_terms) { if (keep_terms) {
/* garbage collection may be called */ /* garbage collection may be called */
sl = _YAP_InitSlot((CELL)attv); sl = Yap_InitSlot((CELL)attv);
} }
writeTerm((Term)&(attv->Value), 999, 1, FALSE); writeTerm((Term)&(attv->Value), 999, 1, FALSE);
if (keep_terms) { if (keep_terms) {
attv = (attvar_record *)_YAP_GetFromSlot(sl); attv = (attvar_record *)Yap_GetFromSlot(sl);
_YAP_RecoverSlots(1); Yap_RecoverSlots(1);
} }
for (i = 0; i < NUM_OF_ATTS; i ++) { for (i = 0; i < NUM_OF_ATTS; i ++) {
if (!IsVarTerm(attv->Atts[2*i+1])) { if (!IsVarTerm(attv->Atts[2*i+1])) {
@ -335,24 +335,24 @@ write_var(CELL *t)
wrputc(','); wrputc(',');
if (keep_terms) { if (keep_terms) {
/* garbage collection may be called */ /* garbage collection may be called */
sl = _YAP_InitSlot((CELL)attv); sl = Yap_InitSlot((CELL)attv);
} }
writeTerm((Term)&(attv->Atts[2*i+1]), 999, 1, FALSE); writeTerm((Term)&(attv->Atts[2*i+1]), 999, 1, FALSE);
if (keep_terms) { if (keep_terms) {
attv = (attvar_record *)_YAP_GetFromSlot(sl); attv = (attvar_record *)Yap_GetFromSlot(sl);
_YAP_RecoverSlots(1); Yap_RecoverSlots(1);
} }
} }
} }
wrputc(')'); wrputc(')');
} }
_YAP_Portray_delays = TRUE; Yap_Portray_delays = TRUE;
return; return;
} }
#endif #endif
#endif #endif
wrputc('D'); wrputc('D');
wrputn(((Int) (t- CellPtr(_YAP_GlobalBase)))); wrputn(((Int) (t- CellPtr(Yap_GlobalBase))));
} else { } else {
wrputn(((Int) (t- H0))); wrputn(((Int) (t- H0)));
} }
@ -365,7 +365,7 @@ writeTerm(Term t, int p, int depth, int rinfixarg)
{ {
if (*max_depth != 0 && depth > *max_depth) { if (*max_depth != 0 && depth > *max_depth) {
putAtom(_YAP_LookupAtom("...")); putAtom(Yap_LookupAtom("..."));
return; return;
} }
if (EX != 0) if (EX != 0)
@ -386,9 +386,9 @@ writeTerm(Term t, int p, int depth, int rinfixarg)
#ifdef USE_GMP #ifdef USE_GMP
} else if (IsBigIntTerm(t)) { } else if (IsBigIntTerm(t)) {
char *s = (char *)TR; char *s = (char *)TR;
while (s+2+mpz_sizeinbase(_YAP_BigIntOfTerm(t), 10) > (char *)_YAP_TrailTop) while (s+2+mpz_sizeinbase(Yap_BigIntOfTerm(t), 10) > (char *)Yap_TrailTop)
_YAP_growtrail(64*1024); Yap_growtrail(64*1024);
mpz_get_str(s, 10, _YAP_BigIntOfTerm(t)); mpz_get_str(s, 10, Yap_BigIntOfTerm(t));
wrputs(s); wrputs(s);
#endif #endif
} else if (IsPairTerm(t)) { } else if (IsPairTerm(t)) {
@ -401,17 +401,17 @@ writeTerm(Term t, int p, int depth, int rinfixarg)
long sl = 0; long sl = 0;
targs[0] = t; targs[0] = t;
_YAP_PutValue(AtomPortray, MkAtomTerm(AtomNil)); Yap_PutValue(AtomPortray, MkAtomTerm(AtomNil));
if (EX != 0L) old_EX = EX; if (EX != 0L) old_EX = EX;
/* *--ASP = MkIntTerm(0); */ /* *--ASP = MkIntTerm(0); */
sl = _YAP_InitSlot(t); sl = Yap_InitSlot(t);
_YAP_execute_goal(_YAP_MkApplTerm(FunctorPortray, 1, targs), 0, 1); Yap_execute_goal(Yap_MkApplTerm(FunctorPortray, 1, targs), 0, 1);
t = _YAP_GetFromSlot(sl); t = Yap_GetFromSlot(sl);
_YAP_RecoverSlots(1); Yap_RecoverSlots(1);
if (old_EX != 0L) EX = old_EX; if (old_EX != 0L) EX = old_EX;
Use_portray = TRUE; Use_portray = TRUE;
Use_portray = TRUE; Use_portray = TRUE;
if (_YAP_GetValue(AtomPortray) == MkAtomTerm(AtomTrue)) if (Yap_GetValue(AtomPortray) == MkAtomTerm(AtomTrue))
return; return;
} }
if (yap_flags[WRITE_QUOTED_STRING_FLAG] && IsStringTerm(t)) { if (yap_flags[WRITE_QUOTED_STRING_FLAG] && IsStringTerm(t)) {
@ -424,7 +424,7 @@ writeTerm(Term t, int p, int depth, int rinfixarg)
long sl= 0; long sl= 0;
if (*max_list && eldepth > *max_list) { if (*max_list && eldepth > *max_list) {
putAtom(_YAP_LookupAtom("...")); putAtom(Yap_LookupAtom("..."));
wrputc(']'); wrputc(']');
lastw = separator; lastw = separator;
return; return;
@ -432,12 +432,12 @@ writeTerm(Term t, int p, int depth, int rinfixarg)
eldepth++; eldepth++;
if (keep_terms) { if (keep_terms) {
/* garbage collection may be called */ /* garbage collection may be called */
sl = _YAP_InitSlot(t); sl = Yap_InitSlot(t);
} }
writeTerm(HeadOfTermCell(t), 999, new_depth, FALSE); writeTerm(HeadOfTermCell(t), 999, new_depth, FALSE);
if (keep_terms) { if (keep_terms) {
t = _YAP_GetFromSlot(sl); t = Yap_GetFromSlot(sl);
_YAP_RecoverSlots(1); Yap_RecoverSlots(1);
} }
ti = TailOfTerm(t); ti = TailOfTerm(t);
if (IsVarTerm(ti)) if (IsVarTerm(ti))
@ -465,7 +465,7 @@ writeTerm(Term t, int p, int depth, int rinfixarg)
Arity = ArityOfFunctor(functor); Arity = ArityOfFunctor(functor);
atom = NameOfFunctor(functor); atom = NameOfFunctor(functor);
opinfo = _YAP_GetAProp(atom, OpProperty); opinfo = Yap_GetAProp(atom, OpProperty);
#ifdef SFUNC #ifdef SFUNC
if (Arity == SFArity) { if (Arity == SFArity) {
int argno = 1; int argno = 1;
@ -485,13 +485,13 @@ writeTerm(Term t, int p, int depth, int rinfixarg)
/* cannot use the term directly with the SBA */ /* cannot use the term directly with the SBA */
if (keep_terms) { if (keep_terms) {
/* garbage collection may be called */ /* garbage collection may be called */
sl = _YAP_InitSlot((CELL)p); sl = Yap_InitSlot((CELL)p);
} }
writeTerm(Deref(p++), 999, depth + 1, FALSE); writeTerm(Deref(p++), 999, depth + 1, FALSE);
if (keep_terms) { if (keep_terms) {
/* garbage collection may be called */ /* garbage collection may be called */
p = (CELL *)_YAP_GetFromSlot(sl); p = (CELL *)Yap_GetFromSlot(sl);
_YAP_RecoverSlots(1); Yap_RecoverSlots(1);
} }
if (*p) if (*p)
wrputc(','); wrputc(',');
@ -508,19 +508,19 @@ writeTerm(Term t, int p, int depth, int rinfixarg)
long sl = 0; long sl = 0;
targs[0] = t; targs[0] = t;
_YAP_PutValue(AtomPortray, MkAtomTerm(AtomNil)); Yap_PutValue(AtomPortray, MkAtomTerm(AtomNil));
if (EX != 0L) old_EX = EX; if (EX != 0L) old_EX = EX;
sl = _YAP_InitSlot(t); sl = Yap_InitSlot(t);
_YAP_execute_goal(_YAP_MkApplTerm(FunctorPortray, 1, targs),0, 1); Yap_execute_goal(Yap_MkApplTerm(FunctorPortray, 1, targs),0, 1);
t = _YAP_GetFromSlot(sl); t = Yap_GetFromSlot(sl);
_YAP_RecoverSlots(1); Yap_RecoverSlots(1);
if (old_EX != 0L) EX = old_EX; if (old_EX != 0L) EX = old_EX;
Use_portray = TRUE; Use_portray = TRUE;
if (_YAP_GetValue(AtomPortray) == MkAtomTerm(AtomTrue) || EX != 0L) if (Yap_GetValue(AtomPortray) == MkAtomTerm(AtomTrue) || EX != 0L)
return; return;
} }
if (!Ignore_ops && if (!Ignore_ops &&
Arity == 1 && opinfo && _YAP_IsPrefixOp(opinfo, &op, Arity == 1 && opinfo && Yap_IsPrefixOp(opinfo, &op,
&rp) &rp)
#ifdef DO_NOT_WRITE_PLUS_AND_MINUS_AS_PREFIX #ifdef DO_NOT_WRITE_PLUS_AND_MINUS_AS_PREFIX
&& &&
@ -557,7 +557,7 @@ writeTerm(Term t, int p, int depth, int rinfixarg)
lastw = separator; lastw = separator;
} }
} else if (!Ignore_ops && } else if (!Ignore_ops &&
Arity == 1 && opinfo && _YAP_IsPosfixOp(opinfo, &op, &lp)) { Arity == 1 && opinfo && Yap_IsPosfixOp(opinfo, &op, &lp)) {
Term tleft = ArgOfTerm(1, t); Term tleft = ArgOfTerm(1, t);
long sl = 0; long sl = 0;
int bracket_left = int bracket_left =
@ -576,13 +576,13 @@ writeTerm(Term t, int p, int depth, int rinfixarg)
} }
if (keep_terms) { if (keep_terms) {
/* garbage collection may be called */ /* garbage collection may be called */
sl = _YAP_InitSlot(t); sl = Yap_InitSlot(t);
} }
writeTerm(ArgOfTermCell(1,t), lp, depth + 1, rinfixarg); writeTerm(ArgOfTermCell(1,t), lp, depth + 1, rinfixarg);
if (keep_terms) { if (keep_terms) {
/* garbage collection may be called */ /* garbage collection may be called */
t = _YAP_GetFromSlot(sl); t = Yap_GetFromSlot(sl);
_YAP_RecoverSlots(1); Yap_RecoverSlots(1);
} }
if (bracket_left) { if (bracket_left) {
wrputc(')'); wrputc(')');
@ -594,7 +594,7 @@ writeTerm(Term t, int p, int depth, int rinfixarg)
lastw = separator; lastw = separator;
} }
} else if (!Ignore_ops && } else if (!Ignore_ops &&
Arity == 2 && opinfo && _YAP_IsInfixOp(opinfo, &op, &lp, Arity == 2 && opinfo && Yap_IsInfixOp(opinfo, &op, &lp,
&rp) ) { &rp) ) {
Term tleft = ArgOfTerm(1, t); Term tleft = ArgOfTerm(1, t);
Term tright = ArgOfTerm(2, t); Term tright = ArgOfTerm(2, t);
@ -619,13 +619,13 @@ writeTerm(Term t, int p, int depth, int rinfixarg)
} }
if (keep_terms) { if (keep_terms) {
/* garbage collection may be called */ /* garbage collection may be called */
sl = _YAP_InitSlot(t); sl = Yap_InitSlot(t);
} }
writeTerm(ArgOfTermCell(1, t), lp, depth + 1, rinfixarg); writeTerm(ArgOfTermCell(1, t), lp, depth + 1, rinfixarg);
if (keep_terms) { if (keep_terms) {
/* garbage collection may be called */ /* garbage collection may be called */
t = _YAP_GetFromSlot(sl); t = Yap_GetFromSlot(sl);
_YAP_RecoverSlots(1); Yap_RecoverSlots(1);
} }
if (bracket_left) { if (bracket_left) {
wrputc(')'); wrputc(')');
@ -682,13 +682,13 @@ writeTerm(Term t, int p, int depth, int rinfixarg)
lastw = separator; lastw = separator;
if (keep_terms) { if (keep_terms) {
/* garbage collection may be called */ /* garbage collection may be called */
sl = _YAP_InitSlot(t); sl = Yap_InitSlot(t);
} }
writeTerm(ArgOfTermCell(1,t), 999, depth + 1, FALSE); writeTerm(ArgOfTermCell(1,t), 999, depth + 1, FALSE);
if (keep_terms) { if (keep_terms) {
/* garbage collection may be called */ /* garbage collection may be called */
t = _YAP_GetFromSlot(sl); t = Yap_GetFromSlot(sl);
_YAP_RecoverSlots(1); Yap_RecoverSlots(1);
} }
wrputc(')'); wrputc(')');
lastw = separator; lastw = separator;
@ -707,13 +707,13 @@ writeTerm(Term t, int p, int depth, int rinfixarg)
for (op = 1; op <= Arity; ++op) { for (op = 1; op <= Arity; ++op) {
if (keep_terms) { if (keep_terms) {
/* garbage collection may be called */ /* garbage collection may be called */
sl = _YAP_InitSlot(t); sl = Yap_InitSlot(t);
} }
writeTerm(ArgOfTermCell(op, t), 999, depth + 1, FALSE); writeTerm(ArgOfTermCell(op, t), 999, depth + 1, FALSE);
if (keep_terms) { if (keep_terms) {
/* garbage collection may be called */ /* garbage collection may be called */
t = _YAP_GetFromSlot(sl); t = Yap_GetFromSlot(sl);
_YAP_RecoverSlots(1); Yap_RecoverSlots(1);
} }
if (op != Arity) { if (op != Arity) {
wrputc(','); wrputc(',');
@ -731,13 +731,13 @@ writeTerm(Term t, int p, int depth, int rinfixarg)
if (keep_terms) { if (keep_terms) {
/* garbage collection may be called */ /* garbage collection may be called */
sl = _YAP_InitSlot(t); sl = Yap_InitSlot(t);
} }
writeTerm(ArgOfTermCell(op, t), 999, depth + 1, FALSE); writeTerm(ArgOfTermCell(op, t), 999, depth + 1, FALSE);
if (keep_terms) { if (keep_terms) {
/* garbage collection may be called */ /* garbage collection may be called */
t = _YAP_GetFromSlot(sl); t = Yap_GetFromSlot(sl);
_YAP_RecoverSlots(1); Yap_RecoverSlots(1);
} }
if (op != Arity) { if (op != Arity) {
wrputc(','); wrputc(',');
@ -751,7 +751,7 @@ writeTerm(Term t, int p, int depth, int rinfixarg)
} }
void void
_YAP_plwrite(Term t, int (*mywrite) (int, int), int flags) Yap_plwrite(Term t, int (*mywrite) (int, int), int flags)
/* term to be written */ /* term to be written */
/* consumer */ /* consumer */
/* write options */ /* write options */

302
C/ypsocks.c
View File

@ -191,7 +191,7 @@ crash(char *msg)
} }
void void
_YAP_init_socks(char *host, long interface_port) Yap_init_socks(char *host, long interface_port)
{ {
int s; int s;
int r; int r;
@ -230,57 +230,57 @@ _YAP_init_socks(char *host, long interface_port)
r = connect ( s, (struct sockaddr *) &soadr, sizeof(soadr)); r = connect ( s, (struct sockaddr *) &soadr, sizeof(soadr));
if (r<0) { if (r<0) {
fprintf(_YAP_stderr,"connect failed with %d\n",r); fprintf(Yap_stderr,"connect failed with %d\n",r);
crash("[ could not connect to interface]"); crash("[ could not connect to interface]");
} }
/* now reopen stdin stdout and stderr */ /* now reopen stdin stdout and stderr */
#if HAVE_DUP2 && !defined(__MINGW32__) #if HAVE_DUP2 && !defined(__MINGW32__)
if(dup2(s,0)<0) { if(dup2(s,0)<0) {
fprintf(_YAP_stderr,"could not dup2 stdin\n"); fprintf(Yap_stderr,"could not dup2 stdin\n");
return; return;
} }
if(dup2(s,1)<0) { if(dup2(s,1)<0) {
fprintf(_YAP_stderr,"could not dup2 stdout\n"); fprintf(Yap_stderr,"could not dup2 stdout\n");
return; return;
} }
if(dup2(s,2)<0) { if(dup2(s,2)<0) {
fprintf(_YAP_stderr,"could not dup2 stderr\n"); fprintf(Yap_stderr,"could not dup2 stderr\n");
return; return;
} }
#elif _MSC_VER || defined(__MINGW32__) #elif _MSC_VER || defined(__MINGW32__)
if(_dup2(s,0)<0) { if(_dup2(s,0)<0) {
fprintf(_YAP_stderr,"could not dup2 stdin\n"); fprintf(Yap_stderr,"could not dup2 stdin\n");
return; return;
} }
if(_dup2(s,1)<0) { if(_dup2(s,1)<0) {
fprintf(_YAP_stderr,"could not dup2 stdout\n"); fprintf(Yap_stderr,"could not dup2 stdout\n");
return; return;
} }
if(_dup2(s,2)<0) { if(_dup2(s,2)<0) {
fprintf(_YAP_stderr,"could not dup2 stderr\n"); fprintf(Yap_stderr,"could not dup2 stderr\n");
return; return;
} }
#else #else
if(dup2(s,0)<0) { if(dup2(s,0)<0) {
fprintf(_YAP_stderr,"could not dup2 stdin\n"); fprintf(Yap_stderr,"could not dup2 stdin\n");
return; return;
} }
yp_iob[0].cnt = 0; yp_iob[0].cnt = 0;
yp_iob[0].flags = _YP_IO_SOCK | _YP_IO_READ; yp_iob[0].flags = _YP_IO_SOCK | _YP_IO_READ;
if(dup2(s,1)<0) { if(dup2(s,1)<0) {
fprintf(_YAP_stderr,"could not dup2 stdout\n"); fprintf(Yap_stderr,"could not dup2 stdout\n");
return; return;
} }
yp_iob[1].cnt = 0; yp_iob[1].cnt = 0;
yp_iob[1].flags = _YP_IO_SOCK | _YP_IO_WRITE; yp_iob[1].flags = _YP_IO_SOCK | _YP_IO_WRITE;
if(dup2(s,2)<0) { if(dup2(s,2)<0) {
fprintf(_YAP_stderr,"could not dup2 stderr\n"); fprintf(Yap_stderr,"could not dup2 stderr\n");
return; return;
} }
yp_iob[2].cnt = 0; yp_iob[2].cnt = 0;
yp_iob[2].flags = _YP_IO_SOCK | _YP_IO_WRITE; yp_iob[2].flags = _YP_IO_SOCK | _YP_IO_WRITE;
#endif #endif
_YAP_sockets_io = 1; Yap_sockets_io = 1;
#if _MSC_VER || defined(__MINGW32__) #if _MSC_VER || defined(__MINGW32__)
_close(s); _close(s);
#else #else
@ -300,27 +300,27 @@ p_socket(void)
Term out; Term out;
if (IsVarTerm(t1)) { if (IsVarTerm(t1)) {
_YAP_Error(INSTANTIATION_ERROR,t1,"socket/4"); Yap_Error(INSTANTIATION_ERROR,t1,"socket/4");
return(FALSE); return(FALSE);
} }
if (!IsAtomTerm(t1)) { if (!IsAtomTerm(t1)) {
_YAP_Error(TYPE_ERROR_ATOM,t1,"socket/4"); Yap_Error(TYPE_ERROR_ATOM,t1,"socket/4");
return(FALSE); return(FALSE);
} }
if (IsVarTerm(t2)) { if (IsVarTerm(t2)) {
_YAP_Error(INSTANTIATION_ERROR,t2,"socket/4"); Yap_Error(INSTANTIATION_ERROR,t2,"socket/4");
return(FALSE); return(FALSE);
} }
if (!IsAtomTerm(t2)) { if (!IsAtomTerm(t2)) {
_YAP_Error(TYPE_ERROR_ATOM,t2,"socket/4"); Yap_Error(TYPE_ERROR_ATOM,t2,"socket/4");
return(FALSE); return(FALSE);
} }
if (IsVarTerm(t3)) { if (IsVarTerm(t3)) {
_YAP_Error(INSTANTIATION_ERROR,t3,"socket/4"); Yap_Error(INSTANTIATION_ERROR,t3,"socket/4");
return(FALSE); return(FALSE);
} }
if (!IsIntTerm(t3)) { if (!IsIntTerm(t3)) {
_YAP_Error(TYPE_ERROR_ATOM,t3,"socket/4"); Yap_Error(TYPE_ERROR_ATOM,t3,"socket/4");
return(FALSE); return(FALSE);
} }
sdomain = RepAtom(AtomOfTerm(t1))->StrOfAE; sdomain = RepAtom(AtomOfTerm(t1))->StrOfAE;
@ -421,18 +421,18 @@ p_socket(void)
fd = socket(domain, type, protocol); fd = socket(domain, type, protocol);
if (invalid_socket_fd(fd)) { if (invalid_socket_fd(fd)) {
#if HAVE_STRERROR #if HAVE_STRERROR
_YAP_Error(SYSTEM_ERROR, TermNil, Yap_Error(SYSTEM_ERROR, TermNil,
"socket/4 (socket: %s)", strerror(socket_errno)); "socket/4 (socket: %s)", strerror(socket_errno));
#else #else
_YAP_Error(SYSTEM_ERROR, TermNil, Yap_Error(SYSTEM_ERROR, TermNil,
"socket/4 (socket)"); "socket/4 (socket)");
#endif #endif
return(FALSE); return(FALSE);
} }
if (domain == AF_UNIX || domain == AF_LOCAL ) if (domain == AF_UNIX || domain == AF_LOCAL )
out = _YAP_InitSocketStream(fd, new_socket, af_unix); out = Yap_InitSocketStream(fd, new_socket, af_unix);
else if (domain == AF_INET ) else if (domain == AF_INET )
out = _YAP_InitSocketStream(fd, new_socket, af_inet); out = Yap_InitSocketStream(fd, new_socket, af_inet);
else { else {
/* ok, we currently don't support these sockets */ /* ok, we currently don't support these sockets */
#if _MSC_VER || defined(__MINGW32__) #if _MSC_VER || defined(__MINGW32__)
@ -443,11 +443,11 @@ p_socket(void)
return(FALSE); return(FALSE);
} }
if (out == TermNil) return(FALSE); if (out == TermNil) return(FALSE);
return(_YAP_unify(out,ARG4)); return(Yap_unify(out,ARG4));
} }
Int Int
_YAP_CloseSocket(int fd, socket_info status, socket_domain domain) Yap_CloseSocket(int fd, socket_info status, socket_domain domain)
{ {
#if _MSC_VER || defined(__MINGW32__) #if _MSC_VER || defined(__MINGW32__)
/* prevent further writing /* prevent further writing
@ -457,7 +457,7 @@ _YAP_CloseSocket(int fd, socket_info status, socket_domain domain)
char bfr; char bfr;
if (shutdown(fd, 1) != 0) { if (shutdown(fd, 1) != 0) {
_YAP_Error(SYSTEM_ERROR, TermNil, Yap_Error(SYSTEM_ERROR, TermNil,
"socket_close/1 (close)"); "socket_close/1 (close)");
return(FALSE); return(FALSE);
} }
@ -467,7 +467,7 @@ _YAP_CloseSocket(int fd, socket_info status, socket_domain domain)
/* prevent further reading /* prevent further reading
from the socket */ from the socket */
if (shutdown(fd, 0) < 0) { if (shutdown(fd, 0) < 0) {
_YAP_Error(SYSTEM_ERROR, TermNil, Yap_Error(SYSTEM_ERROR, TermNil,
"socket_close/1 (close)"); "socket_close/1 (close)");
return(FALSE); return(FALSE);
} }
@ -475,10 +475,10 @@ _YAP_CloseSocket(int fd, socket_info status, socket_domain domain)
/* close the socket */ /* close the socket */
if (closesocket(fd) != 0) { if (closesocket(fd) != 0) {
#if HAVE_STRERROR #if HAVE_STRERROR
_YAP_Error(SYSTEM_ERROR, TermNil, Yap_Error(SYSTEM_ERROR, TermNil,
"socket_close/1 (close: %s)", strerror(socket_errno)); "socket_close/1 (close: %s)", strerror(socket_errno));
#else #else
_YAP_Error(SYSTEM_ERROR, TermNil, Yap_Error(SYSTEM_ERROR, TermNil,
"socket_close/1 (close)"); "socket_close/1 (close)");
#endif #endif
} }
@ -487,10 +487,10 @@ _YAP_CloseSocket(int fd, socket_info status, socket_domain domain)
status == client_socket) { status == client_socket) {
if (shutdown(fd,2) < 0) { if (shutdown(fd,2) < 0) {
#if HAVE_STRERROR #if HAVE_STRERROR
_YAP_Error(SYSTEM_ERROR, TermNil, Yap_Error(SYSTEM_ERROR, TermNil,
"socket_close/1 (shutdown: %s)", strerror(socket_errno)); "socket_close/1 (shutdown: %s)", strerror(socket_errno));
#else #else
_YAP_Error(SYSTEM_ERROR, TermNil, Yap_Error(SYSTEM_ERROR, TermNil,
"socket_close/1 (shutdown)"); "socket_close/1 (shutdown)");
#endif #endif
return(FALSE); return(FALSE);
@ -498,10 +498,10 @@ _YAP_CloseSocket(int fd, socket_info status, socket_domain domain)
} }
if (close(fd) != 0) { if (close(fd) != 0) {
#if HAVE_STRERROR #if HAVE_STRERROR
_YAP_Error(SYSTEM_ERROR, TermNil, Yap_Error(SYSTEM_ERROR, TermNil,
"socket_close/1 (close: %s)", strerror(socket_errno)); "socket_close/1 (close: %s)", strerror(socket_errno));
#else #else
_YAP_Error(SYSTEM_ERROR, TermNil, Yap_Error(SYSTEM_ERROR, TermNil,
"socket_close/1 (close)"); "socket_close/1 (close)");
#endif #endif
#endif #endif
@ -516,10 +516,10 @@ p_socket_close(void)
Term t1 = Deref(ARG1); Term t1 = Deref(ARG1);
int sno; int sno;
if ((sno = _YAP_CheckSocketStream(t1, "socket_close/1")) < 0) { if ((sno = Yap_CheckSocketStream(t1, "socket_close/1")) < 0) {
return (FALSE); return (FALSE);
} }
_YAP_CloseStream(sno); Yap_CloseStream(sno);
return(TRUE); return(TRUE);
} }
@ -533,21 +533,21 @@ p_socket_bind(void)
socket_info status; socket_info status;
int fd; int fd;
if ((sno = _YAP_CheckSocketStream(t1, "socket_bind/2")) < 0) { if ((sno = Yap_CheckSocketStream(t1, "socket_bind/2")) < 0) {
return (FALSE); return (FALSE);
} }
status = _YAP_GetSocketStatus(sno); status = Yap_GetSocketStatus(sno);
fd = _YAP_GetStreamFd(sno); fd = Yap_GetStreamFd(sno);
if (status != new_socket) { if (status != new_socket) {
/* ok, this should be an error, as you are trying to bind */ /* ok, this should be an error, as you are trying to bind */
return(FALSE); return(FALSE);
} }
if (IsVarTerm(t2)) { if (IsVarTerm(t2)) {
_YAP_Error(INSTANTIATION_ERROR,t2,"socket_bind/2"); Yap_Error(INSTANTIATION_ERROR,t2,"socket_bind/2");
return(FALSE); return(FALSE);
} }
if (!IsApplTerm(t2)) { if (!IsApplTerm(t2)) {
_YAP_Error(DOMAIN_ERROR_STREAM,t2,"socket_bind/2"); Yap_Error(DOMAIN_ERROR_STREAM,t2,"socket_bind/2");
return(FALSE); return(FALSE);
} }
fun = FunctorOfTerm(t2); fun = FunctorOfTerm(t2);
@ -559,17 +559,17 @@ p_socket_bind(void)
int len; int len;
if (IsVarTerm(taddr)) { if (IsVarTerm(taddr)) {
_YAP_Error(INSTANTIATION_ERROR,t2,"socket_bind/2"); Yap_Error(INSTANTIATION_ERROR,t2,"socket_bind/2");
return(FALSE); return(FALSE);
} }
if (!IsAtomTerm(taddr)) { if (!IsAtomTerm(taddr)) {
_YAP_Error(TYPE_ERROR_ATOM,taddr,"socket_bind/2"); Yap_Error(TYPE_ERROR_ATOM,taddr,"socket_bind/2");
return(FALSE); return(FALSE);
} }
s = RepAtom(AtomOfTerm(taddr))->StrOfAE; s = RepAtom(AtomOfTerm(taddr))->StrOfAE;
sock.sun_family = AF_UNIX; sock.sun_family = AF_UNIX;
if ((len = strlen(s)) > 107) /* hit me with a broomstick */ { if ((len = strlen(s)) > 107) /* hit me with a broomstick */ {
_YAP_Error(DOMAIN_ERROR_STREAM,taddr,"socket_bind/2"); Yap_Error(DOMAIN_ERROR_STREAM,taddr,"socket_bind/2");
return(FALSE); return(FALSE);
} }
sock.sun_family=AF_UNIX; sock.sun_family=AF_UNIX;
@ -579,15 +579,15 @@ p_socket_bind(void)
((size_t) (((struct sockaddr_un *) 0)->sun_path) + len)) ((size_t) (((struct sockaddr_un *) 0)->sun_path) + len))
< 0) { < 0) {
#if HAVE_STRERROR #if HAVE_STRERROR
_YAP_Error(SYSTEM_ERROR, TermNil, Yap_Error(SYSTEM_ERROR, TermNil,
"socket_bind/2 (bind: %s)", strerror(socket_errno)); "socket_bind/2 (bind: %s)", strerror(socket_errno));
#else #else
_YAP_Error(SYSTEM_ERROR, TermNil, Yap_Error(SYSTEM_ERROR, TermNil,
"socket_bind/2 (bind)"); "socket_bind/2 (bind)");
#endif #endif
return(FALSE); return(FALSE);
} }
_YAP_UpdateSocketStream(sno, server_socket, af_unix); Yap_UpdateSocketStream(sno, server_socket, af_unix);
return(TRUE); return(TRUE);
} else } else
#endif #endif
@ -603,16 +603,16 @@ p_socket_bind(void)
if (IsVarTerm(thost)) { if (IsVarTerm(thost)) {
saddr.sin_addr.s_addr = INADDR_ANY; saddr.sin_addr.s_addr = INADDR_ANY;
} else if (!IsAtomTerm(thost)) { } else if (!IsAtomTerm(thost)) {
_YAP_Error(TYPE_ERROR_ATOM,thost,"socket_bind/2"); Yap_Error(TYPE_ERROR_ATOM,thost,"socket_bind/2");
return(FALSE); return(FALSE);
} else { } else {
shost = RepAtom(AtomOfTerm(thost))->StrOfAE; shost = RepAtom(AtomOfTerm(thost))->StrOfAE;
if((he=gethostbyname(shost))==NULL) { if((he=gethostbyname(shost))==NULL) {
#if HAVE_STRERROR #if HAVE_STRERROR
_YAP_Error(SYSTEM_ERROR, TermNil, Yap_Error(SYSTEM_ERROR, TermNil,
"socket_bind/2 (gethostbyname: %s)", strerror(socket_errno)); "socket_bind/2 (gethostbyname: %s)", strerror(socket_errno));
#else #else
_YAP_Error(SYSTEM_ERROR, TermNil, Yap_Error(SYSTEM_ERROR, TermNil,
"socket_bind/2 (gethostbyname)"); "socket_bind/2 (gethostbyname)");
#endif #endif
return(FALSE); return(FALSE);
@ -628,10 +628,10 @@ p_socket_bind(void)
saddr.sin_family = AF_INET; saddr.sin_family = AF_INET;
if(bind(fd,(struct sockaddr *)&saddr, sizeof(saddr))==-1) { if(bind(fd,(struct sockaddr *)&saddr, sizeof(saddr))==-1) {
#if HAVE_STRERROR #if HAVE_STRERROR
_YAP_Error(SYSTEM_ERROR, TermNil, Yap_Error(SYSTEM_ERROR, TermNil,
"socket_bind/2 (bind: %s)", strerror(socket_errno)); "socket_bind/2 (bind: %s)", strerror(socket_errno));
#else #else
_YAP_Error(SYSTEM_ERROR, TermNil, Yap_Error(SYSTEM_ERROR, TermNil,
"socket_bind/2 (bind)"); "socket_bind/2 (bind)");
#endif #endif
return(FALSE); return(FALSE);
@ -643,18 +643,18 @@ p_socket_bind(void)
Term t; Term t;
if (getsockname(fd, (struct sockaddr *)&saddr, &namelen) < 0) { if (getsockname(fd, (struct sockaddr *)&saddr, &namelen) < 0) {
#if HAVE_STRERROR #if HAVE_STRERROR
_YAP_Error(SYSTEM_ERROR, TermNil, Yap_Error(SYSTEM_ERROR, TermNil,
"socket_bind/2 (getsockname: %s)", strerror(socket_errno)); "socket_bind/2 (getsockname: %s)", strerror(socket_errno));
#else #else
_YAP_Error(SYSTEM_ERROR, TermNil, Yap_Error(SYSTEM_ERROR, TermNil,
"socket_bind/2 (getsockname)"); "socket_bind/2 (getsockname)");
#endif #endif
return(FALSE); return(FALSE);
} }
t = MkIntTerm(ntohs(saddr.sin_port)); t = MkIntTerm(ntohs(saddr.sin_port));
_YAP_unify(ArgOfTermCell(2, t2),t); Yap_unify(ArgOfTermCell(2, t2),t);
} }
_YAP_UpdateSocketStream(sno, server_socket, af_inet); Yap_UpdateSocketStream(sno, server_socket, af_inet);
return(TRUE); return(TRUE);
} else } else
return(FALSE); return(FALSE);
@ -672,20 +672,20 @@ p_socket_connect(void)
int flag; int flag;
Term out; Term out;
if ((sno = _YAP_CheckSocketStream(t1, "socket_connect/3")) < 0) { if ((sno = Yap_CheckSocketStream(t1, "socket_connect/3")) < 0) {
return (FALSE); return (FALSE);
} }
if (IsVarTerm(t2)) { if (IsVarTerm(t2)) {
_YAP_Error(INSTANTIATION_ERROR,t2,"socket_connect/3"); Yap_Error(INSTANTIATION_ERROR,t2,"socket_connect/3");
return(FALSE); return(FALSE);
} }
if (!IsApplTerm(t2)) { if (!IsApplTerm(t2)) {
_YAP_Error(DOMAIN_ERROR_STREAM,t2,"socket_connect/3"); Yap_Error(DOMAIN_ERROR_STREAM,t2,"socket_connect/3");
return(FALSE); return(FALSE);
} }
fun = FunctorOfTerm(t2); fun = FunctorOfTerm(t2);
fd = _YAP_GetStreamFd(sno); fd = Yap_GetStreamFd(sno);
status = _YAP_GetSocketStatus(sno); status = Yap_GetSocketStatus(sno);
if (status != new_socket) { if (status != new_socket) {
/* ok, this should be an error, as you are trying to bind */ /* ok, this should be an error, as you are trying to bind */
return(FALSE); return(FALSE);
@ -698,17 +698,17 @@ p_socket_connect(void)
int len; int len;
if (IsVarTerm(taddr)) { if (IsVarTerm(taddr)) {
_YAP_Error(INSTANTIATION_ERROR,t2,"socket_connect/3"); Yap_Error(INSTANTIATION_ERROR,t2,"socket_connect/3");
return(FALSE); return(FALSE);
} }
if (!IsAtomTerm(taddr)) { if (!IsAtomTerm(taddr)) {
_YAP_Error(TYPE_ERROR_ATOM,taddr,"socket_connect/3"); Yap_Error(TYPE_ERROR_ATOM,taddr,"socket_connect/3");
return(FALSE); return(FALSE);
} }
s = RepAtom(AtomOfTerm(taddr))->StrOfAE; s = RepAtom(AtomOfTerm(taddr))->StrOfAE;
sock.sun_family = AF_UNIX; sock.sun_family = AF_UNIX;
if ((len = strlen(s)) > 107) /* beat me with a broomstick */ { if ((len = strlen(s)) > 107) /* beat me with a broomstick */ {
_YAP_Error(DOMAIN_ERROR_STREAM,taddr,"socket_connect/3"); Yap_Error(DOMAIN_ERROR_STREAM,taddr,"socket_connect/3");
return(FALSE); return(FALSE);
} }
sock.sun_family=AF_UNIX; sock.sun_family=AF_UNIX;
@ -718,15 +718,15 @@ p_socket_connect(void)
((size_t) (((struct sockaddr_un *) 0)->sun_path) + len))) ((size_t) (((struct sockaddr_un *) 0)->sun_path) + len)))
< 0) { < 0) {
#if HAVE_STRERROR #if HAVE_STRERROR
_YAP_Error(SYSTEM_ERROR, TermNil, Yap_Error(SYSTEM_ERROR, TermNil,
"socket_connect/3 (connect: %s)", strerror(socket_errno)); "socket_connect/3 (connect: %s)", strerror(socket_errno));
#else #else
_YAP_Error(SYSTEM_ERROR, TermNil, Yap_Error(SYSTEM_ERROR, TermNil,
"socket_connect/3 (connect)"); "socket_connect/3 (connect)");
#endif #endif
return(FALSE); return(FALSE);
} }
_YAP_UpdateSocketStream(sno, client_socket, af_unix); Yap_UpdateSocketStream(sno, client_socket, af_unix);
} else } else
#endif #endif
if (fun == FunctorAfInet) { if (fun == FunctorAfInet) {
@ -740,19 +740,19 @@ p_socket_connect(void)
memset((void *)&saddr,(int) 0, sizeof(saddr)); memset((void *)&saddr,(int) 0, sizeof(saddr));
if (IsVarTerm(thost)) { if (IsVarTerm(thost)) {
_YAP_Error(INSTANTIATION_ERROR,thost,"socket_connect/3"); Yap_Error(INSTANTIATION_ERROR,thost,"socket_connect/3");
return(FALSE); return(FALSE);
} else if (!IsAtomTerm(thost)) { } else if (!IsAtomTerm(thost)) {
_YAP_Error(TYPE_ERROR_ATOM,thost,"socket_connect/3"); Yap_Error(TYPE_ERROR_ATOM,thost,"socket_connect/3");
return(FALSE); return(FALSE);
} else { } else {
shost = RepAtom(AtomOfTerm(thost))->StrOfAE; shost = RepAtom(AtomOfTerm(thost))->StrOfAE;
if((he=gethostbyname(shost))==NULL) { if((he=gethostbyname(shost))==NULL) {
#if HAVE_STRERROR #if HAVE_STRERROR
_YAP_Error(SYSTEM_ERROR, TermNil, Yap_Error(SYSTEM_ERROR, TermNil,
"socket_connect/3 (gethostbyname: %s)", strerror(socket_errno)); "socket_connect/3 (gethostbyname: %s)", strerror(socket_errno));
#else #else
_YAP_Error(SYSTEM_ERROR, TermNil, Yap_Error(SYSTEM_ERROR, TermNil,
"socket_connect/3 (gethostbyname)"); "socket_connect/3 (gethostbyname)");
#endif #endif
return(FALSE); return(FALSE);
@ -760,10 +760,10 @@ p_socket_connect(void)
memcpy((void *)&saddr.sin_addr, (void *)he->h_addr_list[0], he->h_length); memcpy((void *)&saddr.sin_addr, (void *)he->h_addr_list[0], he->h_length);
} }
if (IsVarTerm(tport)) { if (IsVarTerm(tport)) {
_YAP_Error(INSTANTIATION_ERROR,tport,"socket_connect/3"); Yap_Error(INSTANTIATION_ERROR,tport,"socket_connect/3");
return(FALSE); return(FALSE);
} else if (!IsIntegerTerm(tport)) { } else if (!IsIntegerTerm(tport)) {
_YAP_Error(TYPE_ERROR_INTEGER,tport,"socket_connect/3"); Yap_Error(TYPE_ERROR_INTEGER,tport,"socket_connect/3");
return(FALSE); return(FALSE);
} else { } else {
port = (unsigned short int)IntegerOfTerm(tport); port = (unsigned short int)IntegerOfTerm(tport);
@ -775,10 +775,10 @@ p_socket_connect(void)
if (setsockopt(fd, SOL_SOCKET, SO_LINGER, (char *) &ling, if (setsockopt(fd, SOL_SOCKET, SO_LINGER, (char *) &ling,
sizeof(ling)) < 0) { sizeof(ling)) < 0) {
#if HAVE_STRERROR #if HAVE_STRERROR
_YAP_Error(SYSTEM_ERROR, TermNil, Yap_Error(SYSTEM_ERROR, TermNil,
"socket_connect/3 (setsockopt_linger: %s)", strerror(socket_errno)); "socket_connect/3 (setsockopt_linger: %s)", strerror(socket_errno));
#else #else
_YAP_Error(SYSTEM_ERROR, TermNil, Yap_Error(SYSTEM_ERROR, TermNil,
"socket_connect/3 (setsockopt_linger)"); "socket_connect/3 (setsockopt_linger)");
#endif #endif
return(FALSE); return(FALSE);
@ -786,19 +786,19 @@ p_socket_connect(void)
flag = connect(fd,(struct sockaddr *)&saddr, sizeof(saddr)); flag = connect(fd,(struct sockaddr *)&saddr, sizeof(saddr));
if(flag<0) { if(flag<0) {
#if HAVE_STRERROR #if HAVE_STRERROR
_YAP_Error(SYSTEM_ERROR, TermNil, Yap_Error(SYSTEM_ERROR, TermNil,
"socket_connect/3 (connect: %s)", strerror(socket_errno)); "socket_connect/3 (connect: %s)", strerror(socket_errno));
#else #else
_YAP_Error(SYSTEM_ERROR, TermNil, Yap_Error(SYSTEM_ERROR, TermNil,
"socket_connect/3 (connect)"); "socket_connect/3 (connect)");
#endif #endif
return(FALSE); return(FALSE);
} }
_YAP_UpdateSocketStream(sno, client_socket, af_inet); Yap_UpdateSocketStream(sno, client_socket, af_inet);
} else } else
return(FALSE); return(FALSE);
out = t1; out = t1;
return(_YAP_unify(out,ARG3)); return(Yap_unify(out,ARG3));
} }
static Int static Int
@ -811,34 +811,34 @@ p_socket_listen(void)
int fd; int fd;
Int j; Int j;
if ((sno = _YAP_CheckSocketStream(t1, "socket_listen/2")) < 0) { if ((sno = Yap_CheckSocketStream(t1, "socket_listen/2")) < 0) {
return (FALSE); return (FALSE);
} }
if (IsVarTerm(t2)) { if (IsVarTerm(t2)) {
_YAP_Error(INSTANTIATION_ERROR,t2,"socket_listen/2"); Yap_Error(INSTANTIATION_ERROR,t2,"socket_listen/2");
return(FALSE); return(FALSE);
} }
if (!IsIntTerm(t2)) { if (!IsIntTerm(t2)) {
_YAP_Error(TYPE_ERROR_INTEGER,t2,"socket_listen/2"); Yap_Error(TYPE_ERROR_INTEGER,t2,"socket_listen/2");
return(FALSE); return(FALSE);
} }
j = IntOfTerm(t2); j = IntOfTerm(t2);
if (j < 0) { if (j < 0) {
_YAP_Error(DOMAIN_ERROR_STREAM,t1,"socket_listen/2"); Yap_Error(DOMAIN_ERROR_STREAM,t1,"socket_listen/2");
return(FALSE); return(FALSE);
} }
fd = _YAP_GetStreamFd(sno); fd = Yap_GetStreamFd(sno);
status = _YAP_GetSocketStatus(sno); status = Yap_GetSocketStatus(sno);
if (status != server_socket) { if (status != server_socket) {
/* ok, this should be an error, as you are trying to bind */ /* ok, this should be an error, as you are trying to bind */
return(FALSE); return(FALSE);
} }
if (listen(fd,j) < 0) { if (listen(fd,j) < 0) {
#if HAVE_STRERROR #if HAVE_STRERROR
_YAP_Error(SYSTEM_ERROR, TermNil, Yap_Error(SYSTEM_ERROR, TermNil,
"socket_listen/2 (listen: %s)", strerror(socket_errno)); "socket_listen/2 (listen: %s)", strerror(socket_errno));
#else #else
_YAP_Error(SYSTEM_ERROR, TermNil, Yap_Error(SYSTEM_ERROR, TermNil,
"socket_listen/2 (listen)"); "socket_listen/2 (listen)");
#endif #endif
} }
@ -855,16 +855,16 @@ p_socket_accept(void)
int ofd, fd; int ofd, fd;
Term out; Term out;
if ((sno = _YAP_CheckSocketStream(t1, "socket_accept/3")) < 0) { if ((sno = Yap_CheckSocketStream(t1, "socket_accept/3")) < 0) {
return (FALSE); return (FALSE);
} }
ofd = _YAP_GetStreamFd(sno); ofd = Yap_GetStreamFd(sno);
status = _YAP_GetSocketStatus(sno); status = Yap_GetSocketStatus(sno);
if (status != server_socket) { if (status != server_socket) {
/* ok, this should be an error, as you are trying to bind */ /* ok, this should be an error, as you are trying to bind */
return(FALSE); return(FALSE);
} }
domain = _YAP_GetSocketDomain(sno); domain = Yap_GetSocketDomain(sno);
#if HAVE_SYS_UN_H #if HAVE_SYS_UN_H
if (domain == af_unix) { if (domain == af_unix) {
char tmp[sizeof(struct sockaddr_un)+107]; /* hit me with a broomstick */ char tmp[sizeof(struct sockaddr_un)+107]; /* hit me with a broomstick */
@ -875,15 +875,15 @@ p_socket_accept(void)
memset((void *)&caddr,(int) 0, len); memset((void *)&caddr,(int) 0, len);
if ((fd=accept(ofd, (struct sockaddr *)tmp, &len)) < 0) { if ((fd=accept(ofd, (struct sockaddr *)tmp, &len)) < 0) {
#if HAVE_STRERROR #if HAVE_STRERROR
_YAP_Error(SYSTEM_ERROR, TermNil, Yap_Error(SYSTEM_ERROR, TermNil,
"socket_accept/3 (accept: %s)", strerror(socket_errno)); "socket_accept/3 (accept: %s)", strerror(socket_errno));
#else #else
_YAP_Error(SYSTEM_ERROR, TermNil, Yap_Error(SYSTEM_ERROR, TermNil,
"socket_accept/3 (accept)"); "socket_accept/3 (accept)");
#endif #endif
} }
/* ignore 2nd argument */ /* ignore 2nd argument */
out = _YAP_InitSocketStream(fd, server_session_socket, af_unix ); out = Yap_InitSocketStream(fd, server_session_socket, af_unix );
} else } else
#endif #endif
if (domain == af_inet) { if (domain == af_inet) {
@ -896,31 +896,31 @@ p_socket_accept(void)
memset((void *)&caddr,(int) 0, sizeof(caddr)); memset((void *)&caddr,(int) 0, sizeof(caddr));
if (invalid_socket_fd(fd=accept(ofd, (struct sockaddr *)&caddr, &len))) { if (invalid_socket_fd(fd=accept(ofd, (struct sockaddr *)&caddr, &len))) {
#if HAVE_STRERROR #if HAVE_STRERROR
_YAP_Error(SYSTEM_ERROR, TermNil, Yap_Error(SYSTEM_ERROR, TermNil,
"socket_accept/3 (accept: %s)", strerror(socket_errno)); "socket_accept/3 (accept: %s)", strerror(socket_errno));
#else #else
_YAP_Error(SYSTEM_ERROR, TermNil, Yap_Error(SYSTEM_ERROR, TermNil,
"socket_accept/3 (accept)"); "socket_accept/3 (accept)");
#endif #endif
return(FALSE); return(FALSE);
} }
if ((s = inet_ntoa(caddr.sin_addr)) == NULL) { if ((s = inet_ntoa(caddr.sin_addr)) == NULL) {
#if HAVE_STRERROR #if HAVE_STRERROR
_YAP_Error(SYSTEM_ERROR, TermNil, Yap_Error(SYSTEM_ERROR, TermNil,
"socket_accept/3 (inet_ntoa: %s)", strerror(socket_errno)); "socket_accept/3 (inet_ntoa: %s)", strerror(socket_errno));
#else #else
_YAP_Error(SYSTEM_ERROR, TermNil, Yap_Error(SYSTEM_ERROR, TermNil,
"socket_accept/3 (inet_ntoa)"); "socket_accept/3 (inet_ntoa)");
#endif #endif
} }
tcli = MkAtomTerm(_YAP_LookupAtom(s)); tcli = MkAtomTerm(Yap_LookupAtom(s));
if (!_YAP_unify(ARG2,tcli)) if (!Yap_unify(ARG2,tcli))
return(FALSE); return(FALSE);
out = _YAP_InitSocketStream(fd, server_session_socket, af_inet ); out = Yap_InitSocketStream(fd, server_session_socket, af_inet );
} else } else
return(FALSE); return(FALSE);
if (out == TermNil) return(FALSE); if (out == TermNil) return(FALSE);
return(_YAP_unify(out,ARG3)); return(Yap_unify(out,ARG3));
} }
static Int static Int
@ -935,15 +935,15 @@ p_socket_buffering(void)
unsigned int bufsize, len; unsigned int bufsize, len;
int sno; int sno;
if ((sno = _YAP_CheckSocketStream(t1, "socket_buffering/4")) < 0) { if ((sno = Yap_CheckSocketStream(t1, "socket_buffering/4")) < 0) {
return (FALSE); return (FALSE);
} }
if (IsVarTerm(t2)) { if (IsVarTerm(t2)) {
_YAP_Error(INSTANTIATION_ERROR,t2,"socket_buffering/4"); Yap_Error(INSTANTIATION_ERROR,t2,"socket_buffering/4");
return(FALSE); return(FALSE);
} }
if (!IsAtomTerm(t2)) { if (!IsAtomTerm(t2)) {
_YAP_Error(TYPE_ERROR_ATOM,t2,"socket_buffering/4"); Yap_Error(TYPE_ERROR_ATOM,t2,"socket_buffering/4");
return(FALSE); return(FALSE);
} }
mode = AtomOfTerm(t2); mode = AtomOfTerm(t2);
@ -952,28 +952,28 @@ p_socket_buffering(void)
else if (mode == AtomWrite) else if (mode == AtomWrite)
writing = TRUE; writing = TRUE;
else { else {
_YAP_Error(DOMAIN_ERROR_IO_MODE,t2,"socket_buffering/4"); Yap_Error(DOMAIN_ERROR_IO_MODE,t2,"socket_buffering/4");
return(FALSE); return(FALSE);
} }
fd = _YAP_GetStreamFd(sno); fd = Yap_GetStreamFd(sno);
if (writing) { if (writing) {
getsockopt(fd, SOL_SOCKET, SO_SNDBUF, &bufsize, &len); getsockopt(fd, SOL_SOCKET, SO_SNDBUF, &bufsize, &len);
} else { } else {
getsockopt(fd, SOL_SOCKET, SO_RCVBUF, &bufsize, &len); getsockopt(fd, SOL_SOCKET, SO_RCVBUF, &bufsize, &len);
} }
if (!_YAP_unify(ARG3,MkIntegerTerm(bufsize))) if (!Yap_unify(ARG3,MkIntegerTerm(bufsize)))
return(FALSE); return(FALSE);
if (IsVarTerm(t4)) { if (IsVarTerm(t4)) {
bufsize = BUFSIZ; bufsize = BUFSIZ;
} else { } else {
Int siz; Int siz;
if (!IsIntegerTerm(t4)) { if (!IsIntegerTerm(t4)) {
_YAP_Error(TYPE_ERROR_INTEGER,t4,"socket_buffering/4"); Yap_Error(TYPE_ERROR_INTEGER,t4,"socket_buffering/4");
return(FALSE); return(FALSE);
} }
siz = IntegerOfTerm(t4); siz = IntegerOfTerm(t4);
if (siz < 0) { if (siz < 0) {
_YAP_Error(DOMAIN_ERROR_NOT_LESS_THAN_ZERO,t4,"socket_buffering/4"); Yap_Error(DOMAIN_ERROR_NOT_LESS_THAN_ZERO,t4,"socket_buffering/4");
return(FALSE); return(FALSE);
} }
bufsize = siz; bufsize = siz;
@ -997,8 +997,8 @@ select_out_list(Term t1, fd_set *readfds_ptr)
Term next = select_out_list(TailOfTerm(t1), readfds_ptr); Term next = select_out_list(TailOfTerm(t1), readfds_ptr);
Term Head = HeadOfTerm(t1); Term Head = HeadOfTerm(t1);
sno = _YAP_CheckIOStream(Head,"stream_select/5"); sno = Yap_CheckIOStream(Head,"stream_select/5");
fd = _YAP_GetStreamFd(sno); fd = Yap_GetStreamFd(sno);
if (FD_ISSET(fd, readfds_ptr)) if (FD_ISSET(fd, readfds_ptr))
return(MkPairTerm(Head,next)); return(MkPairTerm(Head,next));
else else
@ -1024,27 +1024,27 @@ p_socket_select(void)
Term tout = TermNil, ti, Head; Term tout = TermNil, ti, Head;
if (IsVarTerm(t1)) { if (IsVarTerm(t1)) {
_YAP_Error(INSTANTIATION_ERROR,t1,"socket_select/5"); Yap_Error(INSTANTIATION_ERROR,t1,"socket_select/5");
return(FALSE); return(FALSE);
} }
if (!IsPairTerm(t1)) { if (!IsPairTerm(t1)) {
_YAP_Error(TYPE_ERROR_LIST,t1,"socket_select/5"); Yap_Error(TYPE_ERROR_LIST,t1,"socket_select/5");
return(FALSE); return(FALSE);
} }
if (IsVarTerm(t2)) { if (IsVarTerm(t2)) {
_YAP_Error(INSTANTIATION_ERROR,t2,"socket_select/5"); Yap_Error(INSTANTIATION_ERROR,t2,"socket_select/5");
return(FALSE); return(FALSE);
} }
if (!IsIntegerTerm(t2)) { if (!IsIntegerTerm(t2)) {
_YAP_Error(TYPE_ERROR_INTEGER,t2,"socket_select/5"); Yap_Error(TYPE_ERROR_INTEGER,t2,"socket_select/5");
return(FALSE); return(FALSE);
} }
if (IsVarTerm(t3)) { if (IsVarTerm(t3)) {
_YAP_Error(INSTANTIATION_ERROR,t3,"socket_select/5"); Yap_Error(INSTANTIATION_ERROR,t3,"socket_select/5");
return(FALSE); return(FALSE);
} }
if (!IsIntegerTerm(t3)) { if (!IsIntegerTerm(t3)) {
_YAP_Error(TYPE_ERROR_INTEGER,t3,"socket_select/5"); Yap_Error(TYPE_ERROR_INTEGER,t3,"socket_select/5");
return(FALSE); return(FALSE);
} }
FD_ZERO(&readfds); FD_ZERO(&readfds);
@ -1061,10 +1061,10 @@ p_socket_select(void)
int sno; int sno;
Head = HeadOfTerm(ti); Head = HeadOfTerm(ti);
sno = _YAP_CheckIOStream(Head,"stream_select/5"); sno = Yap_CheckIOStream(Head,"stream_select/5");
if (sno < 0) if (sno < 0)
return(FALSE); return(FALSE);
fd = _YAP_GetStreamFd(sno); fd = Yap_GetStreamFd(sno);
FD_SET(fd, &readfds); FD_SET(fd, &readfds);
if (fd > fdmax) if (fd > fdmax)
fdmax = fd; fdmax = fd;
@ -1083,16 +1083,16 @@ p_socket_select(void)
/* do the real work */ /* do the real work */
if (select(fdmax+1, &readfds, &writefds, &exceptfds, ptime) < 0) { if (select(fdmax+1, &readfds, &writefds, &exceptfds, ptime) < 0) {
#if HAVE_STRERROR #if HAVE_STRERROR
_YAP_Error(SYSTEM_ERROR, TermNil, Yap_Error(SYSTEM_ERROR, TermNil,
"socket_select/5 (select: %s)", strerror(socket_errno)); "socket_select/5 (select: %s)", strerror(socket_errno));
#else #else
_YAP_Error(SYSTEM_ERROR, TermNil, Yap_Error(SYSTEM_ERROR, TermNil,
"socket_select/5 (select)"); "socket_select/5 (select)");
#endif #endif
} }
tout = select_out_list(t1, &readfds); tout = select_out_list(t1, &readfds);
/* we're done, just pass the info back */ /* we're done, just pass the info back */
return(_YAP_unify(ARG4,tout)); return(Yap_unify(ARG4,tout));
} }
@ -1102,16 +1102,16 @@ p_current_host(void) {
Term t1 = Deref(ARG1), out; Term t1 = Deref(ARG1), out;
if (!IsVarTerm(t1) && !IsAtomTerm(t1)) { if (!IsVarTerm(t1) && !IsAtomTerm(t1)) {
_YAP_Error(TYPE_ERROR_ATOM,t1,"current_host/2"); Yap_Error(TYPE_ERROR_ATOM,t1,"current_host/2");
return(FALSE); return(FALSE);
} }
name = oname; name = oname;
if (gethostname(name, sizeof(oname)) < 0) { if (gethostname(name, sizeof(oname)) < 0) {
#if HAVE_STRERROR #if HAVE_STRERROR
_YAP_Error(SYSTEM_ERROR, TermNil, Yap_Error(SYSTEM_ERROR, TermNil,
"current_host/2 (gethostname: %s)", strerror(socket_errno)); "current_host/2 (gethostname: %s)", strerror(socket_errno));
#else #else
_YAP_Error(SYSTEM_ERROR, TermNil, Yap_Error(SYSTEM_ERROR, TermNil,
"current_host/2 (gethostname)"); "current_host/2 (gethostname)");
#endif #endif
return(FALSE); return(FALSE);
@ -1122,10 +1122,10 @@ p_current_host(void) {
/* not a fully qualified name, ask the name server */ /* not a fully qualified name, ask the name server */
if((he=gethostbyname(name))==NULL) { if((he=gethostbyname(name))==NULL) {
#if HAVE_STRERROR #if HAVE_STRERROR
_YAP_Error(SYSTEM_ERROR, TermNil, Yap_Error(SYSTEM_ERROR, TermNil,
"current_host/2 (gethostbyname: %s)", strerror(socket_errno)); "current_host/2 (gethostbyname: %s)", strerror(socket_errno));
#else #else
_YAP_Error(SYSTEM_ERROR, TermNil, Yap_Error(SYSTEM_ERROR, TermNil,
"current_host/2 (gethostbyname)"); "current_host/2 (gethostbyname)");
#endif #endif
return(FALSE); return(FALSE);
@ -1145,7 +1145,7 @@ p_current_host(void) {
else { else {
int isize = strlen(sin); int isize = strlen(sin);
if (isize >= 256) { if (isize >= 256) {
_YAP_Error(SYSTEM_ERROR, ARG1, Yap_Error(SYSTEM_ERROR, ARG1,
"current_host/2 (input longer than longest FAQ host name)"); "current_host/2 (input longer than longest FAQ host name)");
return(FALSE); return(FALSE);
} }
@ -1158,8 +1158,8 @@ p_current_host(void) {
#endif #endif
} }
} else { } else {
out = MkAtomTerm(_YAP_LookupAtom(name)); out = MkAtomTerm(Yap_LookupAtom(name));
return(_YAP_unify(ARG1,out)); return(Yap_unify(ARG1,out));
} }
} }
@ -1173,62 +1173,62 @@ p_hostname_address(void) {
if (!IsVarTerm(t1)) { if (!IsVarTerm(t1)) {
if (!IsAtomTerm(t1)) { if (!IsAtomTerm(t1)) {
_YAP_Error(TYPE_ERROR_ATOM,t1,"hostname_address/2"); Yap_Error(TYPE_ERROR_ATOM,t1,"hostname_address/2");
return(FALSE); return(FALSE);
} else tin = t1; } else tin = t1;
} else if (IsVarTerm(t2)) { } else if (IsVarTerm(t2)) {
_YAP_Error(INSTANTIATION_ERROR,t1,"hostname_address/5"); Yap_Error(INSTANTIATION_ERROR,t1,"hostname_address/5");
return(FALSE); return(FALSE);
} else if (!IsAtomTerm(t2)) { } else if (!IsAtomTerm(t2)) {
_YAP_Error(TYPE_ERROR_ATOM,t2,"hostname_address/2"); Yap_Error(TYPE_ERROR_ATOM,t2,"hostname_address/2");
return(FALSE); return(FALSE);
} else tin = t2; } else tin = t2;
s = RepAtom(AtomOfTerm(tin))->StrOfAE; s = RepAtom(AtomOfTerm(tin))->StrOfAE;
if (IsVarTerm(t1)) { if (IsVarTerm(t1)) {
if ((he = gethostbyaddr(s, strlen(s), AF_INET)) == NULL) { if ((he = gethostbyaddr(s, strlen(s), AF_INET)) == NULL) {
#if HAVE_STRERROR #if HAVE_STRERROR
_YAP_Error(SYSTEM_ERROR, TermNil, Yap_Error(SYSTEM_ERROR, TermNil,
"hostname_address/2 (gethostbyname: %s)", strerror(socket_errno)); "hostname_address/2 (gethostbyname: %s)", strerror(socket_errno));
#else #else
_YAP_Error(SYSTEM_ERROR, TermNil, Yap_Error(SYSTEM_ERROR, TermNil,
"hostname_address/2 (gethostbyname)"); "hostname_address/2 (gethostbyname)");
#endif #endif
} }
out = MkAtomTerm(_YAP_LookupAtom((char *)(he->h_name))); out = MkAtomTerm(Yap_LookupAtom((char *)(he->h_name)));
return(_YAP_unify(out, ARG1)); return(Yap_unify(out, ARG1));
} else { } else {
struct in_addr adr; struct in_addr adr;
if ((he = gethostbyname(s)) == NULL) { if ((he = gethostbyname(s)) == NULL) {
#if HAVE_STRERROR #if HAVE_STRERROR
_YAP_Error(SYSTEM_ERROR, TermNil, Yap_Error(SYSTEM_ERROR, TermNil,
"hostname_address/2 (gethostbyname: %s)", strerror(socket_errno)); "hostname_address/2 (gethostbyname: %s)", strerror(socket_errno));
#else #else
_YAP_Error(SYSTEM_ERROR, TermNil, Yap_Error(SYSTEM_ERROR, TermNil,
"hostname_address/2 (gethostbyname)"); "hostname_address/2 (gethostbyname)");
#endif #endif
} }
memcpy((char *) &adr, memcpy((char *) &adr,
(char *) he->h_addr_list[0], (size_t) he->h_length); (char *) he->h_addr_list[0], (size_t) he->h_length);
out = MkAtomTerm(_YAP_LookupAtom(inet_ntoa(adr))); out = MkAtomTerm(Yap_LookupAtom(inet_ntoa(adr)));
return(_YAP_unify(out, ARG2)); return(Yap_unify(out, ARG2));
} }
} }
#endif #endif
void void
_YAP_InitSockets(void) Yap_InitSockets(void)
{ {
#ifdef USE_SOCKET #ifdef USE_SOCKET
_YAP_InitCPred("socket", 4, p_socket, SafePredFlag|SyncPredFlag); Yap_InitCPred("socket", 4, p_socket, SafePredFlag|SyncPredFlag);
_YAP_InitCPred("socket_close", 1, p_socket_close, SafePredFlag|SyncPredFlag); Yap_InitCPred("socket_close", 1, p_socket_close, SafePredFlag|SyncPredFlag);
_YAP_InitCPred("socket_bind", 2, p_socket_bind, SafePredFlag|SyncPredFlag); Yap_InitCPred("socket_bind", 2, p_socket_bind, SafePredFlag|SyncPredFlag);
_YAP_InitCPred("socket_connect", 3, p_socket_connect, SafePredFlag|SyncPredFlag); Yap_InitCPred("socket_connect", 3, p_socket_connect, SafePredFlag|SyncPredFlag);
_YAP_InitCPred("socket_listen", 2, p_socket_listen, SafePredFlag|SyncPredFlag); Yap_InitCPred("socket_listen", 2, p_socket_listen, SafePredFlag|SyncPredFlag);
_YAP_InitCPred("socket_accept", 3, p_socket_accept, SafePredFlag|SyncPredFlag); Yap_InitCPred("socket_accept", 3, p_socket_accept, SafePredFlag|SyncPredFlag);
_YAP_InitCPred("$socket_buffering", 4, p_socket_buffering, SafePredFlag|SyncPredFlag); Yap_InitCPred("$socket_buffering", 4, p_socket_buffering, SafePredFlag|SyncPredFlag);
_YAP_InitCPred("$socket_select", 4, p_socket_select, SafePredFlag|SyncPredFlag); Yap_InitCPred("$socket_select", 4, p_socket_select, SafePredFlag|SyncPredFlag);
_YAP_InitCPred("current_host", 1, p_current_host, SafePredFlag); Yap_InitCPred("current_host", 1, p_current_host, SafePredFlag);
_YAP_InitCPred("hostname_address", 2, p_hostname_address, SafePredFlag); Yap_InitCPred("hostname_address", 2, p_hostname_address, SafePredFlag);
#if _MSC_VER || defined(__MINGW32__) #if _MSC_VER || defined(__MINGW32__)
{ {
WSADATA info; WSADATA info;

10
H/Foreign.h
View File

@ -103,11 +103,11 @@ typedef void (*YapInitProc)(void);
#define STD_PROTO(F,A) F A #define STD_PROTO(F,A) F A
#endif #endif
void STD_PROTO(_YAP_FindExecutable,(char *)); void STD_PROTO(Yap_FindExecutable,(char *));
Int STD_PROTO(_YAP_LoadForeign,(StringList, StringList, char *, YapInitProc *)); Int STD_PROTO(Yap_LoadForeign,(StringList, StringList, char *, YapInitProc *));
Int STD_PROTO(_YAP_ReLoadForeign,(StringList, StringList, char *, YapInitProc *)); Int STD_PROTO(Yap_ReLoadForeign,(StringList, StringList, char *, YapInitProc *));
void STD_PROTO(_YAP_ReOpenLoadForeign,(void)); void STD_PROTO(Yap_ReOpenLoadForeign,(void));
void STD_PROTO(_YAP_ShutdownLoadForeign,(void)); void STD_PROTO(Yap_ShutdownLoadForeign,(void));

280
H/Regs.h
View File

@ -10,7 +10,7 @@
* File: Regs.h * * File: Regs.h *
* mods: * * mods: *
* comments: YAP abstract machine registers * * comments: YAP abstract machine registers *
* version: $Id: Regs.h,v 1.17 2002-11-11 17:37:58 vsc Exp $ * * version: $Id: Regs.h,v 1.18 2002-11-18 18:13:14 vsc Exp $ *
*************************************************************************/ *************************************************************************/
@ -132,73 +132,73 @@ typedef struct
REGSTORE; REGSTORE;
extern REGSTORE *_YAP_regp; extern REGSTORE *Yap_regp;
#if !PUSH_X #if !PUSH_X
/* keep X as a global variable */ /* keep X as a global variable */
Term _YAP_XREGS[MaxTemps]; /* 29 */ Term Yap_XREGS[MaxTemps]; /* 29 */
#define XREGS _YAP_XREGS #define XREGS Yap_XREGS
#endif #endif
#define _YAP_REGS (*_YAP_regp) #define Yap_REGS (*Yap_regp)
#else /* PUSH_REGS */ #else /* PUSH_REGS */
Term X[MaxTemps]; /* 29 */ Term X[MaxTemps]; /* 29 */
#define XREGS _YAP_REGS.X #define XREGS Yap_REGS.X
} }
REGSTORE; REGSTORE;
extern REGSTORE _YAP_REGS; extern REGSTORE Yap_REGS;
#endif /* PUSH_REGS */ #endif /* PUSH_REGS */
#define MinTrailGap (sizeof(CELL)*1024) #define MinTrailGap (sizeof(CELL)*1024)
#define MinHeapGap (sizeof(CELL)*4096) #define MinHeapGap (sizeof(CELL)*4096)
#define MinStackGap (sizeof(CELL)*8*1024) #define MinStackGap (sizeof(CELL)*8*1024)
extern int _YAP_stack_overflows; extern int Yap_stack_overflows;
#define ENV _YAP_REGS.ENV_ /* current environment */ #define ENV Yap_REGS.ENV_ /* current environment */
#define ASP _YAP_REGS.ASP_ /* top of local stack */ #define ASP Yap_REGS.ASP_ /* top of local stack */
#define H0 _YAP_REGS.H0_ /* base of heap (global) stack */ #define H0 Yap_REGS.H0_ /* base of heap (global) stack */
#define LCL0 _YAP_REGS.LCL0_ /* local stack base */ #define LCL0 Yap_REGS.LCL0_ /* local stack base */
#if defined(__GNUC__) && defined(sparc) && !defined(__NetBSD__) #if defined(__GNUC__) && defined(sparc) && !defined(__NetBSD__)
#define P _YAP_REGS.P_ /* prolog machine program counter */ #define P Yap_REGS.P_ /* prolog machine program counter */
#define YENV _YAP_REGS.YENV_ /* current environment (may differ from ENV)*/ #define YENV Yap_REGS.YENV_ /* current environment (may differ from ENV)*/
#define S _YAP_REGS.S_ /* structure pointer */ #define S Yap_REGS.S_ /* structure pointer */
register CELL *H asm ("g6"); register CELL *H asm ("g6");
register tr_fr_ptr TR asm ("g7"); register tr_fr_ptr TR asm ("g7");
#ifdef __svr4__ #ifdef __svr4__
register choiceptr B asm ("g5"); register choiceptr B asm ("g5");
#else #else
#define B _YAP_REGS.B_ /* latest choice point */ #define B Yap_REGS.B_ /* latest choice point */
#endif #endif
#define CP _YAP_REGS.CP_ /* continuation program counter */ #define CP Yap_REGS.CP_ /* continuation program counter */
#define HB _YAP_REGS.HB_ /* heap (global) stack top at time of latest c.p. */ #define HB Yap_REGS.HB_ /* heap (global) stack top at time of latest c.p. */
#define CreepFlag _YAP_REGS.CreepFlag_ #define CreepFlag Yap_REGS.CreepFlag_
EXTERN inline void save_machine_regs(void) { EXTERN inline void save_machine_regs(void) {
_YAP_REGS.H_ = H; Yap_REGS.H_ = H;
_YAP_REGS.TR_ = TR; Yap_REGS.TR_ = TR;
#ifdef __svr4__ #ifdef __svr4__
_YAP_REGS.B_ = B; Yap_REGS.B_ = B;
#endif #endif
} }
EXTERN inline void restore_machine_regs(void) { EXTERN inline void restore_machine_regs(void) {
H = _YAP_REGS.H_; H = Yap_REGS.H_;
TR = _YAP_REGS.TR_; TR = Yap_REGS.TR_;
#ifdef __svr4__ #ifdef __svr4__
B = _YAP_REGS.B_; B = Yap_REGS.B_;
#endif #endif
} }
@ -215,11 +215,11 @@ EXTERN inline void restore_machine_regs(void) {
TR = BK_TR TR = BK_TR
EXTERN inline void save_H(void) { EXTERN inline void save_H(void) {
_YAP_REGS.H_ = H; Yap_REGS.H_ = H;
} }
EXTERN inline void restore_H(void) { EXTERN inline void restore_H(void) {
H = _YAP_REGS.H_; H = Yap_REGS.H_;
} }
#define BACKUP_H() CELL *BK_H = H; restore_H() #define BACKUP_H() CELL *BK_H = H; restore_H()
@ -228,13 +228,13 @@ EXTERN inline void restore_H(void) {
EXTERN inline void save_B(void) { EXTERN inline void save_B(void) {
#ifdef __svr4__ #ifdef __svr4__
_YAP_REGS.B_ = B; Yap_REGS.B_ = B;
#endif #endif
} }
EXTERN inline void restore_B(void) { EXTERN inline void restore_B(void) {
#ifdef __svr4__ #ifdef __svr4__
B = _YAP_REGS.B_; B = Yap_REGS.B_;
#endif #endif
} }
@ -250,8 +250,8 @@ EXTERN inline void restore_B(void) {
#elif defined(__GNUC__) && defined(__alpha) #elif defined(__GNUC__) && defined(__alpha)
#define P _YAP_REGS.P_ /* prolog machine program counter */ #define P Yap_REGS.P_ /* prolog machine program counter */
#define YENV _YAP_REGS.YENV_ /* current environment (may differ from ENV) */ #define YENV Yap_REGS.YENV_ /* current environment (may differ from ENV) */
register CELL *H asm ("$9"); register CELL *H asm ("$9");
register CELL *HB asm ("$10"); register CELL *HB asm ("$10");
register choiceptr B asm ("$11"); register choiceptr B asm ("$11");
@ -260,7 +260,7 @@ register CELL *S asm ("$13");
register tr_fr_ptr TR asm ("$14"); register tr_fr_ptr TR asm ("$14");
/* gcc+debug chokes if $15 is in use on alphas */ /* gcc+debug chokes if $15 is in use on alphas */
#ifdef DEBUG #ifdef DEBUG
#define CreepFlag _YAP_REGS.CreepFlag_ #define CreepFlag Yap_REGS.CreepFlag_
#else #else
register CELL CreepFlag asm ("$15"); register CELL CreepFlag asm ("$15");
#endif #endif
@ -268,25 +268,25 @@ register CELL CreepFlag asm ("$15");
/* Interface with foreign code, make sure the foreign code sees all the /* Interface with foreign code, make sure the foreign code sees all the
registers the way they used to be */ registers the way they used to be */
EXTERN inline void save_machine_regs(void) { EXTERN inline void save_machine_regs(void) {
_YAP_REGS.H_ = H; Yap_REGS.H_ = H;
_YAP_REGS.HB_ = HB; Yap_REGS.HB_ = HB;
_YAP_REGS.B_ = B; Yap_REGS.B_ = B;
_YAP_REGS.CP_ = CP; Yap_REGS.CP_ = CP;
#ifndef DEBUG #ifndef DEBUG
_YAP_REGS.CreepFlag_ = CreepFlag; Yap_REGS.CreepFlag_ = CreepFlag;
#endif #endif
_YAP_REGS.TR_ = TR; Yap_REGS.TR_ = TR;
} }
EXTERN inline void restore_machine_regs(void) { EXTERN inline void restore_machine_regs(void) {
H = _YAP_REGS.H_; H = Yap_REGS.H_;
HB = _YAP_REGS.HB_; HB = Yap_REGS.HB_;
B = _YAP_REGS.B_; B = Yap_REGS.B_;
CP = _YAP_REGS.CP_; CP = Yap_REGS.CP_;
#ifndef DEBUG #ifndef DEBUG
CreepFlag = _YAP_REGS.CreepFlag_; CreepFlag = Yap_REGS.CreepFlag_;
#endif #endif
TR = _YAP_REGS.TR_; TR = Yap_REGS.TR_;
} }
#define BACKUP_MACHINE_REGS() \ #define BACKUP_MACHINE_REGS() \
@ -308,11 +308,11 @@ EXTERN inline void restore_machine_regs(void) {
TR = BK_TR TR = BK_TR
EXTERN inline void save_H(void) { EXTERN inline void save_H(void) {
_YAP_REGS.H_ = H; Yap_REGS.H_ = H;
} }
EXTERN inline void restore_H(void) { EXTERN inline void restore_H(void) {
H = _YAP_REGS.H_; H = Yap_REGS.H_;
} }
#define BACKUP_H() CELL *BK_H = H; restore_H() #define BACKUP_H() CELL *BK_H = H; restore_H()
@ -320,11 +320,11 @@ EXTERN inline void restore_H(void) {
#define RECOVER_H() save_H(); H = BK_H #define RECOVER_H() save_H(); H = BK_H
EXTERN inline void save_B(void) { EXTERN inline void save_B(void) {
_YAP_REGS.B_ = B; Yap_REGS.B_ = B;
} }
EXTERN inline void restore_B(void) { EXTERN inline void restore_B(void) {
B = _YAP_REGS.B_; B = Yap_REGS.B_;
} }
#define BACKUP_B() choiceptr BK_B = B; restore_B() #define BACKUP_B() choiceptr BK_B = B; restore_B()
@ -332,17 +332,17 @@ EXTERN inline void restore_B(void) {
#define RECOVER_B() save_B(); B = BK_B #define RECOVER_B() save_B(); B = BK_B
EXTERN inline void save_TR(void) { EXTERN inline void save_TR(void) {
_YAP_REGS.TR_ = TR; Yap_REGS.TR_ = TR;
} }
EXTERN inline void restore_TR(void) { EXTERN inline void restore_TR(void) {
TR = _YAP_REGS.TR_; TR = Yap_REGS.TR_;
} }
#elif defined(__GNUC__) && defined(mips) #elif defined(__GNUC__) && defined(mips)
#define P _YAP_REGS.P_ /* prolog machine program counter */ #define P Yap_REGS.P_ /* prolog machine program counter */
#define YENV _YAP_REGS.YENV_ /* current environment (may differ from ENV) */ #define YENV Yap_REGS.YENV_ /* current environment (may differ from ENV) */
register CELL *H asm ("$16"); register CELL *H asm ("$16");
register CELL *HB asm ("$17"); register CELL *HB asm ("$17");
register choiceptr B asm ("$18"); register choiceptr B asm ("$18");
@ -352,21 +352,21 @@ register CELL CreepFlag asm ("$21");
register tr_fr_ptr TR asm ("$22"); register tr_fr_ptr TR asm ("$22");
EXTERN inline void save_machine_regs(void) { EXTERN inline void save_machine_regs(void) {
_YAP_REGS.H_ = H; Yap_REGS.H_ = H;
_YAP_REGS.HB_ = HB; Yap_REGS.HB_ = HB;
_YAP_REGS.B_ = B; Yap_REGS.B_ = B;
_YAP_REGS.CP_ = CP; Yap_REGS.CP_ = CP;
_YAP_REGS.CreepFlag_ = CreepFlag; Yap_REGS.CreepFlag_ = CreepFlag;
_YAP_REGS.TR_ = TR; Yap_REGS.TR_ = TR;
} }
EXTERN inline void restore_machine_regs(void) { EXTERN inline void restore_machine_regs(void) {
H = _YAP_REGS.H_; H = Yap_REGS.H_;
HB = _YAP_REGS.HB_; HB = Yap_REGS.HB_;
B = _YAP_REGS.B_; B = Yap_REGS.B_;
CP = _YAP_REGS.CP_; CP = Yap_REGS.CP_;
CreepFlag = _YAP_REGS.CreepFlag_; CreepFlag = Yap_REGS.CreepFlag_;
TR = _YAP_REGS.TR_; TR = Yap_REGS.TR_;
} }
#define BACKUP_MACHINE_REGS() \ #define BACKUP_MACHINE_REGS() \
@ -388,11 +388,11 @@ EXTERN inline void restore_machine_regs(void) {
TR = BK_TR TR = BK_TR
EXTERN inline void save_H(void) { EXTERN inline void save_H(void) {
_YAP_REGS.H_ = H; Yap_REGS.H_ = H;
} }
EXTERN inline void restore_H(void) { EXTERN inline void restore_H(void) {
H = _YAP_REGS.H_; H = Yap_REGS.H_;
} }
#define BACKUP_H() CELL *BK_H = H; restore_H() #define BACKUP_H() CELL *BK_H = H; restore_H()
@ -400,11 +400,11 @@ EXTERN inline void restore_H(void) {
#define RECOVER_H() save_H(); H = BK_H #define RECOVER_H() save_H(); H = BK_H
EXTERN inline void save_B(void) { EXTERN inline void save_B(void) {
_YAP_REGS.B_ = B; Yap_REGS.B_ = B;
} }
EXTERN inline void restore_B(void) { EXTERN inline void restore_B(void) {
B = _YAP_REGS.B_; B = Yap_REGS.B_;
} }
#define BACKUP_B() choiceptr BK_B = B; restore_B() #define BACKUP_B() choiceptr BK_B = B; restore_B()
@ -413,8 +413,8 @@ EXTERN inline void restore_B(void) {
#elif defined(__GNUC__) && defined(hppa) #elif defined(__GNUC__) && defined(hppa)
#define P _YAP_REGS.P_ /* prolog machine program counter */ #define P Yap_REGS.P_ /* prolog machine program counter */
#define YENV _YAP_REGS.YENV_ /* current environment (may differ from ENV) */ #define YENV Yap_REGS.YENV_ /* current environment (may differ from ENV) */
register CELL *H asm ("r12"); register CELL *H asm ("r12");
register CELL *HB asm ("r13"); register CELL *HB asm ("r13");
register choiceptr B asm ("r14"); register choiceptr B asm ("r14");
@ -424,21 +424,21 @@ register CELL CreepFlag asm ("r17");
register tr_fr_ptr TR asm ("r18"); register tr_fr_ptr TR asm ("r18");
EXTERN inline void save_machine_regs(void) { EXTERN inline void save_machine_regs(void) {
_YAP_REGS.H_ = H; Yap_REGS.H_ = H;
_YAP_REGS.HB_ = HB; Yap_REGS.HB_ = HB;
_YAP_REGS.B_ = B; Yap_REGS.B_ = B;
_YAP_REGS.CP_ = CP; Yap_REGS.CP_ = CP;
_YAP_REGS.CreepFlag_ = CreepFlag; Yap_REGS.CreepFlag_ = CreepFlag;
_YAP_REGS.TR_ = TR; Yap_REGS.TR_ = TR;
} }
EXTERN inline void restore_machine_regs(void) { EXTERN inline void restore_machine_regs(void) {
H = _YAP_REGS.H_; H = Yap_REGS.H_;
HB = _YAP_REGS.HB_; HB = Yap_REGS.HB_;
B = _YAP_REGS.B_; B = Yap_REGS.B_;
CP = _YAP_REGS.CP_; CP = Yap_REGS.CP_;
CreepFlag = _YAP_REGS.CreepFlag_; CreepFlag = Yap_REGS.CreepFlag_;
TR = _YAP_REGS.TR_; TR = Yap_REGS.TR_;
} }
#define BACKUP_MACHINE_REGS() \ #define BACKUP_MACHINE_REGS() \
@ -460,11 +460,11 @@ EXTERN inline void restore_machine_regs(void) {
TR = BK_TR TR = BK_TR
EXTERN inline void save_H(void) { EXTERN inline void save_H(void) {
_YAP_REGS.H_ = H; Yap_REGS.H_ = H;
} }
EXTERN inline void restore_H(void) { EXTERN inline void restore_H(void) {
H = _YAP_REGS.H_; H = Yap_REGS.H_;
} }
#define BACKUP_H() CELL *BK_H = H; restore_H() #define BACKUP_H() CELL *BK_H = H; restore_H()
@ -472,11 +472,11 @@ EXTERN inline void restore_H(void) {
#define RECOVER_H() save_H(); H = BK_H #define RECOVER_H() save_H(); H = BK_H
EXTERN inline void save_B(void) { EXTERN inline void save_B(void) {
_YAP_REGS.B_ = B; Yap_REGS.B_ = B;
} }
EXTERN inline void restore_B(void) { EXTERN inline void restore_B(void) {
B = _YAP_REGS.B_; B = Yap_REGS.B_;
} }
#define BACKUP_B() choiceptr BK_B = B; restore_B() #define BACKUP_B() choiceptr BK_B = B; restore_B()
@ -484,11 +484,11 @@ EXTERN inline void restore_B(void) {
#define RECOVER_B() save_B(); B = BK_B #define RECOVER_B() save_B(); B = BK_B
EXTERN inline void save_TR(void) { EXTERN inline void save_TR(void) {
_YAP_REGS.TR_ = TR; Yap_REGS.TR_ = TR;
} }
EXTERN inline void restore_TR(void) { EXTERN inline void restore_TR(void) {
TR = _YAP_REGS.TR_; TR = Yap_REGS.TR_;
} }
#elif defined(__GNUC__) && defined(_POWER) #elif defined(__GNUC__) && defined(_POWER)
@ -516,26 +516,26 @@ register yamop *CP asm ("r17");
register CELL *S asm ("r18"); register CELL *S asm ("r18");
register CELL *YENV asm ("r19"); register CELL *YENV asm ("r19");
register tr_fr_ptr TR asm ("r20"); register tr_fr_ptr TR asm ("r20");
#define P _YAP_REGS.P_ /* prolog machine program counter */ #define P Yap_REGS.P_ /* prolog machine program counter */
EXTERN inline void save_machine_regs(void) { EXTERN inline void save_machine_regs(void) {
_YAP_REGS.CreepFlag_ = CreepFlag; Yap_REGS.CreepFlag_ = CreepFlag;
_YAP_REGS.H_ = H; Yap_REGS.H_ = H;
_YAP_REGS.HB_ = HB; Yap_REGS.HB_ = HB;
_YAP_REGS.B_ = B; Yap_REGS.B_ = B;
_YAP_REGS.CP_ = CP; Yap_REGS.CP_ = CP;
_YAP_REGS.YENV_ = YENV; Yap_REGS.YENV_ = YENV;
_YAP_REGS.TR_ = TR; Yap_REGS.TR_ = TR;
} }
EXTERN inline void restore_machine_regs(void) { EXTERN inline void restore_machine_regs(void) {
CreepFlag = _YAP_REGS.CreepFlag_; CreepFlag = Yap_REGS.CreepFlag_;
H = _YAP_REGS.H_; H = Yap_REGS.H_;
HB = _YAP_REGS.HB_; HB = Yap_REGS.HB_;
B = _YAP_REGS.B_; B = Yap_REGS.B_;
CP = _YAP_REGS.CP_; CP = Yap_REGS.CP_;
YENV = _YAP_REGS.YENV_; YENV = Yap_REGS.YENV_;
TR = _YAP_REGS.TR_; TR = Yap_REGS.TR_;
} }
#define BACKUP_MACHINE_REGS() \ #define BACKUP_MACHINE_REGS() \
@ -557,11 +557,11 @@ EXTERN inline void restore_machine_regs(void) {
TR = BK_TR TR = BK_TR
EXTERN inline void save_H(void) { EXTERN inline void save_H(void) {
_YAP_REGS.H_ = H; Yap_REGS.H_ = H;
} }
EXTERN inline void restore_H(void) { EXTERN inline void restore_H(void) {
H = _YAP_REGS.H_; H = Yap_REGS.H_;
} }
#define BACKUP_H() CELL *BK_H = H; restore_H() #define BACKUP_H() CELL *BK_H = H; restore_H()
@ -569,11 +569,11 @@ EXTERN inline void restore_H(void) {
#define RECOVER_H() save_H(); H = BK_H #define RECOVER_H() save_H(); H = BK_H
EXTERN inline void save_B(void) { EXTERN inline void save_B(void) {
_YAP_REGS.B_ = B; Yap_REGS.B_ = B;
} }
EXTERN inline void restore_B(void) { EXTERN inline void restore_B(void) {
B = _YAP_REGS.B_; B = Yap_REGS.B_;
} }
#define BACKUP_B() choiceptr BK_B = B; restore_B() #define BACKUP_B() choiceptr BK_B = B; restore_B()
@ -582,15 +582,15 @@ EXTERN inline void restore_B(void) {
#else #else
#define CP _YAP_REGS.CP_ /* continuation program counter */ #define CP Yap_REGS.CP_ /* continuation program counter */
#define P _YAP_REGS.P_ /* prolog machine program counter */ #define P Yap_REGS.P_ /* prolog machine program counter */
#define YENV _YAP_REGS.YENV_ /* current environment (may differ from ENV) */ #define YENV Yap_REGS.YENV_ /* current environment (may differ from ENV) */
#define S _YAP_REGS.S_ /* structure pointer */ #define S Yap_REGS.S_ /* structure pointer */
#define H _YAP_REGS.H_ /* top of heap (global) stack */ #define H Yap_REGS.H_ /* top of heap (global) stack */
#define B _YAP_REGS.B_ /* latest choice point */ #define B Yap_REGS.B_ /* latest choice point */
#define TR _YAP_REGS.TR_ /* top of trail */ #define TR Yap_REGS.TR_ /* top of trail */
#define HB _YAP_REGS.HB_ /* heap (global) stack top at time of latest c.p. */ #define HB Yap_REGS.HB_ /* heap (global) stack top at time of latest c.p. */
#define CreepFlag _YAP_REGS.CreepFlag_ #define CreepFlag Yap_REGS.CreepFlag_
EXTERN inline void save_machine_regs(void) { EXTERN inline void save_machine_regs(void) {
} }
@ -624,36 +624,36 @@ EXTERN inline void restore_B(void) {
#endif #endif
#define AuxSp _YAP_REGS.AuxSp_ #define AuxSp Yap_REGS.AuxSp_
#define AuxTop _YAP_REGS.AuxTop_ #define AuxTop Yap_REGS.AuxTop_
#define HeapPlus _YAP_REGS.HeapPlus_ /*To avoid any chock with HeapTop */ #define HeapPlus Yap_REGS.HeapPlus_ /*To avoid any chock with HeapTop */
#define MyTR _YAP_REGS.MyTR_ #define MyTR Yap_REGS.MyTR_
#define TopB _YAP_REGS.TopB_ #define TopB Yap_REGS.TopB_
#define DelayedB _YAP_REGS.DelayedB_ #define DelayedB Yap_REGS.DelayedB_
#define FlipFlop _YAP_REGS.FlipFlop_ #define FlipFlop Yap_REGS.FlipFlop_
#define EX _YAP_REGS.EX_ #define EX Yap_REGS.EX_
#define DEPTH _YAP_REGS.DEPTH_ #define DEPTH Yap_REGS.DEPTH_
#if (defined(YAPOR) && defined(SBA)) || defined(TABLING) #if (defined(YAPOR) && defined(SBA)) || defined(TABLING)
#define H_FZ _YAP_REGS.H_FZ_ #define H_FZ Yap_REGS.H_FZ_
#define B_FZ _YAP_REGS.B_FZ_ #define B_FZ Yap_REGS.B_FZ_
#define TR_FZ _YAP_REGS.TR_FZ_ #define TR_FZ Yap_REGS.TR_FZ_
#endif #endif
#if defined(YAPOR) || defined(THREADS) #if defined(YAPOR) || defined(THREADS)
#define worker_id (_YAP_REGS.worker_id_) #define worker_id (Yap_REGS.worker_id_)
#ifdef SBA #ifdef SBA
#define BSEG _YAP_REGS.BSEG_ #define BSEG Yap_REGS.BSEG_
#define binding_array _YAP_REGS.binding_array_ #define binding_array Yap_REGS.binding_array_
#define sba_offset _YAP_REGS.sba_offset_ #define sba_offset Yap_REGS.sba_offset_
#define sba_end _YAP_REGS.sba_end_ #define sba_end Yap_REGS.sba_end_
#define sba_size _YAP_REGS.sba_size_ #define sba_size Yap_REGS.sba_size_
#define frame_head _YAP_REGS.frame_head_ #define frame_head Yap_REGS.frame_head_
#define frame_tail _YAP_REGS.frame_tail_ #define frame_tail Yap_REGS.frame_tail_
#endif /* SBA */ #endif /* SBA */
#endif /* YAPOR */ #endif /* YAPOR */
#ifdef COROUTINING #ifdef COROUTINING
#define DelayedVars _YAP_REGS.DelayedVars_ #define DelayedVars Yap_REGS.DelayedVars_
#endif #endif
#define CurrentModule _YAP_REGS.CurrentModule_ #define CurrentModule Yap_REGS.CurrentModule_
#define REG_SIZE sizeof(REGS)/sizeof(CELL *) #define REG_SIZE sizeof(REGS)/sizeof(CELL *)
@ -683,7 +683,7 @@ EXTERN inline void restore_B(void) {
#define HBREG HB #define HBREG HB
#if (defined(YAPOR) && defined(SBA)) || defined(TABLING) #if (defined(YAPOR) && defined(SBA)) || defined(TABLING)
#define BB _YAP_REGS.BB_ #define BB Yap_REGS.BB_
#define BBREG BB #define BBREG BB
#endif #endif
@ -700,7 +700,7 @@ EXTERN inline void restore_B(void) {
when we come from a longjmp */ when we come from a longjmp */
#if PUSH_REGS #if PUSH_REGS
/* In this case we need to initialise the abstract registers */ /* In this case we need to initialise the abstract registers */
REGSTORE _YAP_standard_regs; REGSTORE Yap_standard_regs;
#endif /* PUSH_REGS */ #endif /* PUSH_REGS */
/******************* controlling debugging ****************************/ /******************* controlling debugging ****************************/

310
H/Yapproto.h
View File

@ -10,7 +10,7 @@
* File: Yap.proto * * File: Yap.proto *
* mods: * * mods: *
* comments: Function declarations for YAP * * comments: Function declarations for YAP *
* version: $Id: Yapproto.h,v 1.28 2002-11-11 17:37:58 vsc Exp $ * * version: $Id: Yapproto.h,v 1.29 2002-11-18 18:13:25 vsc Exp $ *
*************************************************************************/ *************************************************************************/
/* prototype file for Yap */ /* prototype file for Yap */
@ -25,32 +25,32 @@ typedef Int (*CmpPredicate)(Term, Term);
/* absmi.c */ /* absmi.c */
Int STD_PROTO(_YAP_absmi,(int)); Int STD_PROTO(Yap_absmi,(int));
/* adtdefs.c */ /* adtdefs.c */
Term STD_PROTO(_YAP_ArrayToList,(Term *,int)); Term STD_PROTO(Yap_ArrayToList,(Term *,int));
int STD_PROTO(_YAP_GetName,(char *,UInt,Term)); int STD_PROTO(Yap_GetName,(char *,UInt,Term));
Term STD_PROTO(_YAP_GetValue,(Atom)); Term STD_PROTO(Yap_GetValue,(Atom));
Atom STD_PROTO(_YAP_LookupAtom,(char *)); Atom STD_PROTO(Yap_LookupAtom,(char *));
Atom STD_PROTO(_YAP_FullLookupAtom,(char *)); Atom STD_PROTO(Yap_FullLookupAtom,(char *));
void STD_PROTO(_YAP_LookupAtomWithAddress,(char *,AtomEntry *)); void STD_PROTO(Yap_LookupAtomWithAddress,(char *,AtomEntry *));
Prop STD_PROTO(_YAP_NewPredPropByFunctor,(struct FunctorEntryStruct *, SMALLUNSGN)); Prop STD_PROTO(Yap_NewPredPropByFunctor,(struct FunctorEntryStruct *, SMALLUNSGN));
Prop STD_PROTO(_YAP_NewPredPropByAtom,(struct AtomEntryStruct *, SMALLUNSGN)); Prop STD_PROTO(Yap_NewPredPropByAtom,(struct AtomEntryStruct *, SMALLUNSGN));
Functor STD_PROTO(_YAP_UnlockedMkFunctor,(AtomEntry *,unsigned int)); Functor STD_PROTO(Yap_UnlockedMkFunctor,(AtomEntry *,unsigned int));
Functor STD_PROTO(_YAP_MkFunctor,(Atom,unsigned int)); Functor STD_PROTO(Yap_MkFunctor,(Atom,unsigned int));
void STD_PROTO(_YAP_MkFunctorWithAddress,(Atom,unsigned int,FunctorEntry *)); void STD_PROTO(Yap_MkFunctorWithAddress,(Atom,unsigned int,FunctorEntry *));
void STD_PROTO(_YAP_PutValue,(Atom,Term)); void STD_PROTO(Yap_PutValue,(Atom,Term));
void STD_PROTO(_YAP_ReleaseAtom,(Atom)); void STD_PROTO(Yap_ReleaseAtom,(Atom));
Term STD_PROTO(_YAP_StringToList,(char *)); Term STD_PROTO(Yap_StringToList,(char *));
Term STD_PROTO(_YAP_StringToListOfAtoms,(char *)); Term STD_PROTO(Yap_StringToListOfAtoms,(char *));
long STD_PROTO(_YAP_InitSlot,(Term)); long STD_PROTO(Yap_InitSlot,(Term));
long STD_PROTO(_YAP_NewSlots,(int)); long STD_PROTO(Yap_NewSlots,(int));
Term STD_PROTO(_YAP_GetFromSlot,(long)); Term STD_PROTO(Yap_GetFromSlot,(long));
void STD_PROTO(_YAP_RecoverSlots,(int)); void STD_PROTO(Yap_RecoverSlots,(int));
Term STD_PROTO(_YAP_GetFromSlot,(long)); Term STD_PROTO(Yap_GetFromSlot,(long));
Term *STD_PROTO(_YAP_AddressFromSlot,(long)); Term *STD_PROTO(Yap_AddressFromSlot,(long));
void STD_PROTO(_YAP_PutInSlot,(long, Term)); void STD_PROTO(Yap_PutInSlot,(long, Term));
#if SFUNC #if SFUNC
@ -58,246 +58,246 @@ Term STD_PROTO(MkSFTerm,(Functor,int,Term *,Term));
CELL STD_PROTO(*ArgsOfSFTerm,(Term)); CELL STD_PROTO(*ArgsOfSFTerm,(Term));
#endif #endif
Prop STD_PROTO(_YAP_GetPredPropByAtom,(Atom, SMALLUNSGN)); Prop STD_PROTO(Yap_GetPredPropByAtom,(Atom, SMALLUNSGN));
Prop STD_PROTO(_YAP_GetPredPropByFunc,(Functor, SMALLUNSGN)); Prop STD_PROTO(Yap_GetPredPropByFunc,(Functor, SMALLUNSGN));
Prop STD_PROTO(_YAP_GetPredPropHavingLock,(Atom,unsigned int,SMALLUNSGN)); Prop STD_PROTO(Yap_GetPredPropHavingLock,(Atom,unsigned int,SMALLUNSGN));
Prop STD_PROTO(_YAP_GetExpProp,(Atom,unsigned int)); Prop STD_PROTO(Yap_GetExpProp,(Atom,unsigned int));
Prop STD_PROTO(_YAP_GetExpPropHavingLock,(AtomEntry *,unsigned int)); Prop STD_PROTO(Yap_GetExpPropHavingLock,(AtomEntry *,unsigned int));
/* agc.c */ /* agc.c */
void STD_PROTO(_YAP_atom_gc, (void)); void STD_PROTO(Yap_atom_gc, (void));
void STD_PROTO(_YAP_init_agc, (void)); void STD_PROTO(Yap_init_agc, (void));
/* alloc.c */ /* alloc.c */
int STD_PROTO(_YAP_SizeOfBlock,(CODEADDR)); int STD_PROTO(Yap_SizeOfBlock,(CODEADDR));
void STD_PROTO(_YAP_FreeCodeSpace,(char *)); void STD_PROTO(Yap_FreeCodeSpace,(char *));
char *STD_PROTO(_YAP_AllocAtomSpace,(unsigned int)); char *STD_PROTO(Yap_AllocAtomSpace,(unsigned int));
char *STD_PROTO(_YAP_AllocCodeSpace,(unsigned int)); char *STD_PROTO(Yap_AllocCodeSpace,(unsigned int));
ADDR STD_PROTO(_YAP_AllocFromForeignArea,(Int)); ADDR STD_PROTO(Yap_AllocFromForeignArea,(Int));
int STD_PROTO(_YAP_ExtendWorkSpace,(Int)); int STD_PROTO(Yap_ExtendWorkSpace,(Int));
void STD_PROTO(_YAP_FreeAtomSpace,(char *)); void STD_PROTO(Yap_FreeAtomSpace,(char *));
int STD_PROTO(_YAP_FreeWorkSpace, (void)); int STD_PROTO(Yap_FreeWorkSpace, (void));
void STD_PROTO(_YAP_InitMemory,(int,int,int)); void STD_PROTO(Yap_InitMemory,(int,int,int));
/* amasm.c */ /* amasm.c */
OPCODE STD_PROTO(_YAP_opcode,(op_numbers)); OPCODE STD_PROTO(Yap_opcode,(op_numbers));
/* analyst.c */ /* analyst.c */
#ifdef ANALYST #ifdef ANALYST
void STD_PROTO(_YAP_InitAnalystPreds,(void)); void STD_PROTO(Yap_InitAnalystPreds,(void));
#endif /* ANALYST */ #endif /* ANALYST */
/* arrays.c */ /* arrays.c */
void STD_PROTO(_YAP_InitArrayPreds,(void)); void STD_PROTO(Yap_InitArrayPreds,(void));
/* attvar.c */ /* attvar.c */
Term STD_PROTO(_YAP_CurrentAttVars,(void)); Term STD_PROTO(Yap_CurrentAttVars,(void));
void STD_PROTO(_YAP_InitAttVarPreds,(void)); void STD_PROTO(Yap_InitAttVarPreds,(void));
/* bb.c */ /* bb.c */
void STD_PROTO(_YAP_InitBBPreds,(void)); void STD_PROTO(Yap_InitBBPreds,(void));
/* bignum.c */ /* bignum.c */
void STD_PROTO(_YAP_InitBigNums,(void)); void STD_PROTO(Yap_InitBigNums,(void));
/* c_interface.c */ /* c_interface.c */
Int STD_PROTO(YAP_Execute,(struct pred_entry *, CPredicate)); Int STD_PROTO(YAP_Execute,(struct pred_entry *, CPredicate));
/* cdmgr.c */ /* cdmgr.c */
void STD_PROTO(_YAP_addclause,(Term,CODEADDR,int,int)); void STD_PROTO(Yap_addclause,(Term,CODEADDR,int,int));
Term STD_PROTO(_YAP_all_calls,(void)); Term STD_PROTO(Yap_all_calls,(void));
Atom STD_PROTO(_YAP_ConsultingFile,(void)); Atom STD_PROTO(Yap_ConsultingFile,(void));
Int STD_PROTO(_YAP_PredForCode,(CODEADDR, Atom *, Int *, SMALLUNSGN *)); Int STD_PROTO(Yap_PredForCode,(CODEADDR, Atom *, Int *, SMALLUNSGN *));
void STD_PROTO(_YAP_InitCdMgr,(void)); void STD_PROTO(Yap_InitCdMgr,(void));
#if EMACS #if EMACS
int STD_PROTO(where_new_clause, (Prop, int)); int STD_PROTO(where_new_clause, (Prop, int));
#endif #endif
void STD_PROTO(_YAP_init_consult,(int, char *)); void STD_PROTO(Yap_init_consult,(int, char *));
void STD_PROTO(_YAP_end_consult,(void)); void STD_PROTO(Yap_end_consult,(void));
/* cmppreds.c */ /* cmppreds.c */
int STD_PROTO(_YAP_compare_terms,(Term,Term)); int STD_PROTO(Yap_compare_terms,(Term,Term));
void STD_PROTO(_YAP_InitCmpPreds,(void)); void STD_PROTO(Yap_InitCmpPreds,(void));
/* compiler.c */ /* compiler.c */
CODEADDR STD_PROTO(_YAP_cclause,(Term, int, int)); CODEADDR STD_PROTO(Yap_cclause,(Term, int, int));
/* computils.c */ /* computils.c */
/* corout.c */ /* corout.c */
void STD_PROTO(_YAP_InitCoroutPreds,(void)); void STD_PROTO(Yap_InitCoroutPreds,(void));
#ifdef COROUTINING #ifdef COROUTINING
Term STD_PROTO(_YAP_ListOfWokenGoals,(void)); Term STD_PROTO(Yap_ListOfWokenGoals,(void));
void STD_PROTO(_YAP_WakeUp,(CELL *)); void STD_PROTO(Yap_WakeUp,(CELL *));
void STD_PROTO(_YAP_mark_all_suspended_goals,(void)); void STD_PROTO(Yap_mark_all_suspended_goals,(void));
#endif #endif
/* dbase.c */ /* dbase.c */
int STD_PROTO(_YAP_DBTrailOverflow,(void)); int STD_PROTO(Yap_DBTrailOverflow,(void));
CELL STD_PROTO(_YAP_EvalMasks,(Term,CELL *)); CELL STD_PROTO(Yap_EvalMasks,(Term,CELL *));
void STD_PROTO(_YAP_InitBackDB,(void)); void STD_PROTO(Yap_InitBackDB,(void));
void STD_PROTO(_YAP_InitDBPreds,(void)); void STD_PROTO(Yap_InitDBPreds,(void));
/* errors.c */ /* errors.c */
void STD_PROTO(_YAP_exit,(int)); void STD_PROTO(Yap_exit,(int));
yamop *STD_PROTO(_YAP_Error,(yap_error_number,Term,char *msg, ...)); yamop *STD_PROTO(Yap_Error,(yap_error_number,Term,char *msg, ...));
/* eval.c */ /* eval.c */
void STD_PROTO(_YAP_InitEval,(void)); void STD_PROTO(Yap_InitEval,(void));
/* exec.c */ /* exec.c */
Term STD_PROTO(_YAP_ExecuteCallMetaCall,(SMALLUNSGN mod)); Term STD_PROTO(Yap_ExecuteCallMetaCall,(SMALLUNSGN mod));
void STD_PROTO(_YAP_InitExecFs,(void)); void STD_PROTO(Yap_InitExecFs,(void));
Int STD_PROTO(_YAP_JumpToEnv,(Term)); Int STD_PROTO(Yap_JumpToEnv,(Term));
int STD_PROTO(_YAP_RunTopGoal,(Term)); int STD_PROTO(Yap_RunTopGoal,(Term));
Int STD_PROTO(_YAP_execute_goal,(Term, int, SMALLUNSGN)); Int STD_PROTO(Yap_execute_goal,(Term, int, SMALLUNSGN));
int STD_PROTO(_YAP_exec_absmi,(int)); int STD_PROTO(Yap_exec_absmi,(int));
void STD_PROTO(_YAP_trust_last,(void)); void STD_PROTO(Yap_trust_last,(void));
/* grow.c */ /* grow.c */
Int STD_PROTO(_YAP_total_stack_shift_time,(void)); Int STD_PROTO(Yap_total_stack_shift_time,(void));
void STD_PROTO(_YAP_InitGrowPreds, (void)); void STD_PROTO(Yap_InitGrowPreds, (void));
int STD_PROTO(_YAP_growheap, (int)); int STD_PROTO(Yap_growheap, (int));
int STD_PROTO(_YAP_growstack, (long)); int STD_PROTO(Yap_growstack, (long));
int STD_PROTO(_YAP_growtrail, (long)); int STD_PROTO(Yap_growtrail, (long));
int STD_PROTO(_YAP_growglobal, (CELL **)); int STD_PROTO(Yap_growglobal, (CELL **));
/* heapgc.c */ /* heapgc.c */
Int STD_PROTO(_YAP_total_gc_time,(void)); Int STD_PROTO(Yap_total_gc_time,(void));
void STD_PROTO(_YAP_init_gc,(void)); void STD_PROTO(Yap_init_gc,(void));
int STD_PROTO(_YAP_is_gc_verbose, (void)); int STD_PROTO(Yap_is_gc_verbose, (void));
int STD_PROTO(_YAP_gc, (Int, CELL *, yamop *)); int STD_PROTO(Yap_gc, (Int, CELL *, yamop *));
/* init.c */ /* init.c */
#ifdef DEBUG #ifdef DEBUG
int STD_PROTO(_YAP_DebugPutc,(int,int)); int STD_PROTO(Yap_DebugPutc,(int,int));
void STD_PROTO(_YAP_DebugSetIFile,(char *)); void STD_PROTO(Yap_DebugSetIFile,(char *));
void STD_PROTO(_YAP_DebugEndline,(void)); void STD_PROTO(Yap_DebugEndline,(void));
int STD_PROTO(_YAP_DebugGetc,(void)); int STD_PROTO(Yap_DebugGetc,(void));
#endif #endif
int STD_PROTO(_YAP_IsOpType,(char *)); int STD_PROTO(Yap_IsOpType,(char *));
void STD_PROTO(_YAP_InitStacks,(int,int,int,int,int,int)); void STD_PROTO(Yap_InitStacks,(int,int,int,int,int,int));
void STD_PROTO(_YAP_InitCPred,(char *, unsigned long int, CPredicate, int)); void STD_PROTO(Yap_InitCPred,(char *, unsigned long int, CPredicate, int));
void STD_PROTO(_YAP_InitAsmPred,(char *, unsigned long int, int, CPredicate, int)); void STD_PROTO(Yap_InitAsmPred,(char *, unsigned long int, int, CPredicate, int));
void STD_PROTO(_YAP_InitCmpPred,(char *, unsigned long int, CmpPredicate, CPredicate, int)); void STD_PROTO(Yap_InitCmpPred,(char *, unsigned long int, CmpPredicate, CPredicate, int));
void STD_PROTO(_YAP_InitCPredBack,(char *, unsigned long int, unsigned int, CPredicate,CPredicate,int)); void STD_PROTO(Yap_InitCPredBack,(char *, unsigned long int, unsigned int, CPredicate,CPredicate,int));
void STD_PROTO(_YAP_InitYaamRegs,(void)); void STD_PROTO(Yap_InitYaamRegs,(void));
void STD_PROTO(_YAP_ReInitWallTime, (void)); void STD_PROTO(Yap_ReInitWallTime, (void));
int STD_PROTO(_YAP_OpDec,(int,char *,Atom)); int STD_PROTO(Yap_OpDec,(int,char *,Atom));
/* inlines.c */ /* inlines.c */
void STD_PROTO(_YAP_InitInlines,(void)); void STD_PROTO(Yap_InitInlines,(void));
/* iopreds.c */ /* iopreds.c */
void STD_PROTO(_YAP_InitPlIO,(void)); void STD_PROTO(Yap_InitPlIO,(void));
void STD_PROTO(_YAP_InitBackIO,(void)); void STD_PROTO(Yap_InitBackIO,(void));
void STD_PROTO(_YAP_InitIOPreds,(void)); void STD_PROTO(Yap_InitIOPreds,(void));
/* depth_lim.c */ /* depth_lim.c */
void STD_PROTO(_YAP_InitItDeepenPreds,(void)); void STD_PROTO(Yap_InitItDeepenPreds,(void));
/* load_foreign.c */ /* load_foreign.c */
void STD_PROTO(_YAP_InitLoadForeign,(void)); void STD_PROTO(Yap_InitLoadForeign,(void));
/* mavar.c */ /* mavar.c */
void STD_PROTO(_YAP_InitMaVarCPreds,(void)); void STD_PROTO(Yap_InitMaVarCPreds,(void));
Term STD_PROTO(_YAP_NewTimedVar,(Term)); Term STD_PROTO(Yap_NewTimedVar,(Term));
Term STD_PROTO(_YAP_NewEmptyTimedVar,(void)); Term STD_PROTO(Yap_NewEmptyTimedVar,(void));
Term STD_PROTO(_YAP_ReadTimedVar,(Term)); Term STD_PROTO(Yap_ReadTimedVar,(Term));
Term STD_PROTO(_YAP_UpdateTimedVar,(Term, Term)); Term STD_PROTO(Yap_UpdateTimedVar,(Term, Term));
/* modules.c */ /* modules.c */
SMALLUNSGN STD_PROTO(_YAP_LookupModule,(Term)); SMALLUNSGN STD_PROTO(Yap_LookupModule,(Term));
Term STD_PROTO(_YAP_Module_Name, (CODEADDR)); Term STD_PROTO(Yap_Module_Name, (CODEADDR));
void STD_PROTO(_YAP_InitModules, (void)); void STD_PROTO(Yap_InitModules, (void));
#if HAVE_MPI #if HAVE_MPI
/* mpi.c */ /* mpi.c */
void STD_PROTO(_YAP_InitMPI,(void)); void STD_PROTO(Yap_InitMPI,(void));
#endif #endif
#if HAVE_MPE #if HAVE_MPE
/* mpe.c */ /* mpe.c */
void STD_PROTO(_YAP_InitMPE,(void)); void STD_PROTO(Yap_InitMPE,(void));
#endif #endif
/* other.c */ /* other.c */
Term STD_PROTO(_YAP_MkApplTerm,(Functor,unsigned int,Term *)); Term STD_PROTO(Yap_MkApplTerm,(Functor,unsigned int,Term *));
Term STD_PROTO(_YAP_MkNewApplTerm,(Functor,unsigned int)); Term STD_PROTO(Yap_MkNewApplTerm,(Functor,unsigned int));
Term STD_PROTO(_YAP_MkNewPairTerm,(void)); Term STD_PROTO(Yap_MkNewPairTerm,(void));
/* parser.c */ /* parser.c */
int STD_PROTO(_YAP_IsPrefixOp,(Prop,int *,int *)); int STD_PROTO(Yap_IsPrefixOp,(Prop,int *,int *));
int STD_PROTO(_YAP_IsInfixOp,(Prop,int *,int *,int *)); int STD_PROTO(Yap_IsInfixOp,(Prop,int *,int *,int *));
int STD_PROTO(_YAP_IsPosfixOp,(Prop,int *,int *)); int STD_PROTO(Yap_IsPosfixOp,(Prop,int *,int *));
Term STD_PROTO(_YAP_Parse,(void)); Term STD_PROTO(Yap_Parse,(void));
/* save.c */ /* save.c */
int STD_PROTO(_YAP_SavedInfo,(char *,char *,CELL *,CELL *,CELL *)); int STD_PROTO(Yap_SavedInfo,(char *,char *,CELL *,CELL *,CELL *));
int STD_PROTO(_YAP_Restore,(char *, char *)); int STD_PROTO(Yap_Restore,(char *, char *));
void STD_PROTO(_YAP_InitSavePreds,(void)); void STD_PROTO(Yap_InitSavePreds,(void));
/* scanner.c */ /* scanner.c */
/* sort.c */ /* sort.c */
void STD_PROTO(_YAP_InitSortPreds,(void)); void STD_PROTO(Yap_InitSortPreds,(void));
/* stdpreds.c */ /* stdpreds.c */
void STD_PROTO(_YAP_InitBackCPreds,(void)); void STD_PROTO(Yap_InitBackCPreds,(void));
void STD_PROTO(_YAP_InitCPreds,(void)); void STD_PROTO(Yap_InitCPreds,(void));
void STD_PROTO(_YAP_show_statistics,(void)); void STD_PROTO(Yap_show_statistics,(void));
Int STD_PROTO(_YAP_creep,(void)); Int STD_PROTO(Yap_creep,(void));
/* sysbits.c */ /* sysbits.c */
void STD_PROTO(_YAP_set_fpu_exceptions,(int)); void STD_PROTO(Yap_set_fpu_exceptions,(int));
Int STD_PROTO(_YAP_cputime,(void)); Int STD_PROTO(Yap_cputime,(void));
Int STD_PROTO(_YAP_walltime,(void)); Int STD_PROTO(Yap_walltime,(void));
int STD_PROTO(_YAP_dir_separator,(int)); int STD_PROTO(Yap_dir_separator,(int));
int STD_PROTO(_YAP_volume_header,(char *)); int STD_PROTO(Yap_volume_header,(char *));
void STD_PROTO(_YAP_InitSysPath,(void)); void STD_PROTO(Yap_InitSysPath,(void));
#if MAC #if MAC
void STD_PROTO(_YAP_SetTextFile,(char *)); void STD_PROTO(Yap_SetTextFile,(char *));
#endif #endif
void STD_PROTO(_YAP_cputime_interval,(Int *,Int *)); void STD_PROTO(Yap_cputime_interval,(Int *,Int *));
void STD_PROTO(_YAP_walltime_interval,(Int *,Int *)); void STD_PROTO(Yap_walltime_interval,(Int *,Int *));
void STD_PROTO(_YAP_InitSysbits,(void)); void STD_PROTO(Yap_InitSysbits,(void));
void STD_PROTO(_YAP_InitSysPreds,(void)); void STD_PROTO(Yap_InitSysPreds,(void));
int STD_PROTO(_YAP_TrueFileName, (char *, char *, int)); int STD_PROTO(Yap_TrueFileName, (char *, char *, int));
int STD_PROTO(_YAP_ProcessSIGINT,(void)); int STD_PROTO(Yap_ProcessSIGINT,(void));
double STD_PROTO(_YAP_random, (void)); double STD_PROTO(Yap_random, (void));
/* tracer.c */ /* tracer.c */
#ifdef LOW_LEVEL_TRACER #ifdef LOW_LEVEL_TRACER
void STD_PROTO(_YAP_InitLowLevelTrace,(void)); void STD_PROTO(Yap_InitLowLevelTrace,(void));
#endif #endif
/* unify.c */ /* unify.c */
void STD_PROTO(_YAP_InitAbsmi,(void)); void STD_PROTO(Yap_InitAbsmi,(void));
void STD_PROTO(_YAP_InitUnify,(void)); void STD_PROTO(Yap_InitUnify,(void));
int STD_PROTO(_YAP_IUnify,(register CELL d0,register CELL d1)); int STD_PROTO(Yap_IUnify,(register CELL d0,register CELL d1));
op_numbers STD_PROTO(_YAP_op_from_opcode,(OPCODE)); op_numbers STD_PROTO(Yap_op_from_opcode,(OPCODE));
/* userpreds.c */ /* userpreds.c */
void STD_PROTO(_YAP_InitUserCPreds,(void)); void STD_PROTO(Yap_InitUserCPreds,(void));
void STD_PROTO(_YAP_InitUserBacks,(void)); void STD_PROTO(Yap_InitUserBacks,(void));
/* utilpreds.c */ /* utilpreds.c */
Term STD_PROTO(_YAP_CopyTerm,(Term)); Term STD_PROTO(Yap_CopyTerm,(Term));
void STD_PROTO(_YAP_InitUtilCPreds,(void)); void STD_PROTO(Yap_InitUtilCPreds,(void));
/* yap.c */ /* yap.c */
/* ypsocks.c */ /* ypsocks.c */
void STD_PROTO(_YAP_InitSockets,(void)); void STD_PROTO(Yap_InitSockets,(void));
#ifdef USE_SOCKET #ifdef USE_SOCKET
void STD_PROTO(_YAP_init_socks,(char *, long)); void STD_PROTO(Yap_init_socks,(char *, long));
#endif #endif
/* opt.preds.c */ /* opt.preds.c */
void STD_PROTO(_YAP_init_optyap_preds,(void)); void STD_PROTO(Yap_init_optyap_preds,(void));

16
H/absmi.h
View File

@ -168,14 +168,14 @@ static char *op_names[_std_top + 1] =
inline EXTERN void inline EXTERN void
init_absmi_regs(REGSTORE * absmi_regs) init_absmi_regs(REGSTORE * absmi_regs)
{ {
memcpy(absmi_regs, _YAP_regp, sizeof(REGSTORE)); memcpy(absmi_regs, Yap_regp, sizeof(REGSTORE));
} }
inline EXTERN void inline EXTERN void
restore_absmi_regs(REGSTORE * old_regs) restore_absmi_regs(REGSTORE * old_regs)
{ {
memcpy(old_regs, _YAP_regp, sizeof(REGSTORE)); memcpy(old_regs, Yap_regp, sizeof(REGSTORE));
_YAP_regp = old_regs; Yap_regp = old_regs;
} }
#endif /* PUSH_REGS */ #endif /* PUSH_REGS */
@ -681,7 +681,7 @@ Macros to check the limits of stacks
#else #else
#define check_trail() if (Unsigned(_YAP_TrailTop) - Unsigned(TR) < MinTrailGap) \ #define check_trail() if (Unsigned(Yap_TrailTop) - Unsigned(TR) < MinTrailGap) \
goto notrailleft goto notrailleft
#endif #endif
@ -1154,9 +1154,9 @@ IUnify_complex(CELL *pt0, CELL *pt0_end, CELL *pt1)
{ {
#if SHADOW_REGS #if SHADOW_REGS
#if defined(B) || defined(TR) #if defined(B) || defined(TR)
register REGSTORE *regp = &_YAP_REGS; register REGSTORE *regp = &Yap_REGS;
#define _YAP_REGS (*regp) #define Yap_REGS (*regp)
#endif /* defined(B) || defined(TR) || defined(HB) */ #endif /* defined(B) || defined(TR) || defined(HB) */
#endif #endif
@ -1311,7 +1311,7 @@ cufail:
return (FALSE); return (FALSE);
#if SHADOW_REGS #if SHADOW_REGS
#if defined(B) || defined(TR) #if defined(B) || defined(TR)
#undef _YAP_REGS #undef Yap_REGS
#endif /* defined(B) || defined(TR) */ #endif /* defined(B) || defined(TR) */
#endif #endif
} }
@ -1405,7 +1405,7 @@ loop:
return (FALSE); return (FALSE);
#ifdef USE_GMP #ifdef USE_GMP
case (CELL)FunctorBigInt: case (CELL)FunctorBigInt:
if (IsBigIntTerm(d1) && mpz_cmp((MP_INT *)(ap2+1),_YAP_BigIntOfTerm(d1)) == 0) continue; if (IsBigIntTerm(d1) && mpz_cmp((MP_INT *)(ap2+1),Yap_BigIntOfTerm(d1)) == 0) continue;
UNWIND_CUNIF(); UNWIND_CUNIF();
return (FALSE); return (FALSE);
#endif /* USE_GMP */ #endif /* USE_GMP */

8
H/alloc.h
View File

@ -77,8 +77,8 @@ typedef struct FREEB {
#define ALIGN_YAPTYPE(X,TYPE) (((CELL)(X)+(sizeof(TYPE)-1)) & ~(sizeof(TYPE)-1)) #define ALIGN_YAPTYPE(X,TYPE) (((CELL)(X)+(sizeof(TYPE)-1)) & ~(sizeof(TYPE)-1))
/* I'll assume page size is always a power of two */ /* I'll assume page size is always a power of two */
#define AdjustPageSize(X) ((X) & (_YAP_page_size-1) ? \ #define AdjustPageSize(X) ((X) & (Yap_page_size-1) ? \
((X) + _YAP_page_size) & (~(_YAP_page_size-1)) : \ ((X) + Yap_page_size) & (~(Yap_page_size-1)) : \
(X) ) (X) )
#define BlockTrailer(b) ((YAP_SEG_SIZE *)b)[((BlockHeader *) b)->b_size] #define BlockTrailer(b) ((YAP_SEG_SIZE *)b)[((BlockHeader *) b)->b_size]
@ -86,9 +86,9 @@ typedef struct FREEB {
#define FreeBlocks heap_regs->free_blocks #define FreeBlocks heap_regs->free_blocks
/* Operating system and architecture dependent page size */ /* Operating system and architecture dependent page size */
extern int _YAP_page_size; extern int Yap_page_size;
void STD_PROTO(_YAP_InitHeap, (void *)); void STD_PROTO(Yap_InitHeap, (void *));
#if USE_MMAP #if USE_MMAP

6
H/amidefs.h
View File

@ -554,16 +554,16 @@ typedef struct choicept {
/* access to instructions */ /* access to instructions */
#if USE_THREADED_CODE #if USE_THREADED_CODE
extern void **_YAP_ABSMI_OPCODES; extern void **Yap_ABSMI_OPCODES;
#define absmadr(i) ((OPCODE)(_YAP_ABSMI_OPCODES[(i)])) #define absmadr(i) ((OPCODE)(Yap_ABSMI_OPCODES[(i)]))
#else #else
#define absmadr(i) ((OPCODE)(i)) #define absmadr(i) ((OPCODE)(i))
#endif #endif
/* used to find out how many instructions of each kind are executed */ /* used to find out how many instructions of each kind are executed */
#ifdef ANALYST #ifdef ANALYST
extern int _YAP_opcount[_std_top+1]; extern int Yap_opcount[_std_top+1];
#endif /* ANALYST */ #endif /* ANALYST */
#if DEPTH_LIMIT #if DEPTH_LIMIT

16
H/amiops.h
View File

@ -324,7 +324,7 @@ Binding Macros for Multiple Assignment Variables.
#define BIND_GLOBALCELL(A,D) *(A) = (D); \ #define BIND_GLOBALCELL(A,D) *(A) = (D); \
if ((A) >= HBREG) continue; \ if ((A) >= HBREG) continue; \
TRAIL_GLOBAL(A,D); if ((A) >= H0) continue; \ TRAIL_GLOBAL(A,D); if ((A) >= H0) continue; \
_YAP_WakeUp((A)); continue Yap_WakeUp((A)); continue
#else #else
#define BIND_GLOBAL2(A,D,LAB,LAB1) BIND_GLOBAL(A,D,LAB) #define BIND_GLOBAL2(A,D,LAB,LAB1) BIND_GLOBAL(A,D,LAB)
@ -365,14 +365,14 @@ Unification Routines
*************************************************************/ *************************************************************/
EXTERN Int STD_PROTO(_YAP_unify,(Term,Term)); EXTERN Int STD_PROTO(Yap_unify,(Term,Term));
EXTERN inline EXTERN inline
Int _YAP_unify(Term t0, Term t1) Int Yap_unify(Term t0, Term t1)
{ {
tr_fr_ptr TR0 = TR; tr_fr_ptr TR0 = TR;
if (_YAP_IUnify(t0,t1)) { if (Yap_IUnify(t0,t1)) {
return(TRUE); return(TRUE);
} else { } else {
while(TR != TR0) { while(TR != TR0) {
@ -403,10 +403,10 @@ Int _YAP_unify(Term t0, Term t1)
} }
} }
EXTERN Int STD_PROTO(_YAP_unify_constant,(Term,Term)); EXTERN Int STD_PROTO(Yap_unify_constant,(Term,Term));
EXTERN inline Int EXTERN inline Int
_YAP_unify_constant(register Term a, register Term cons) Yap_unify_constant(register Term a, register Term cons)
{ {
CELL *pt; CELL *pt;
deref_head(a,unify_cons_unk); deref_head(a,unify_cons_unk);
@ -430,7 +430,7 @@ _YAP_unify_constant(register Term a, register Term cons)
return(FloatOfTerm(a) == FloatOfTerm(cons)); return(FloatOfTerm(a) == FloatOfTerm(cons));
#ifdef USE_GMP #ifdef USE_GMP
case (CELL)FunctorBigInt: case (CELL)FunctorBigInt:
return(mpz_cmp(_YAP_BigIntOfTerm(a),_YAP_BigIntOfTerm(cons)) == 0); return(mpz_cmp(Yap_BigIntOfTerm(a),Yap_BigIntOfTerm(cons)) == 0);
#endif /* USE_GMP */ #endif /* USE_GMP */
default: default:
return(FALSE); return(FALSE);
@ -444,7 +444,7 @@ _YAP_unify_constant(register Term a, register Term cons)
BIND(pt,cons,wake_for_cons); BIND(pt,cons,wake_for_cons);
#ifdef COROUTINING #ifdef COROUTINING
DO_TRAIL(pt, cons); DO_TRAIL(pt, cons);
if (pt < H0) _YAP_WakeUp(pt); if (pt < H0) Yap_WakeUp(pt);
wake_for_cons: wake_for_cons:
#endif #endif
return(TRUE); return(TRUE);

272
H/arith2.h
View File

@ -25,7 +25,7 @@ add_int(Int i, Int j E_ARGS)
Int x = i+j; Int x = i+j;
#if USE_GMP #if USE_GMP
if ((i^j) >= 0 && (i^x) < 0) { if ((i^j) >= 0 && (i^x) < 0) {
MP_INT *new = _YAP_InitBigNum(i); MP_INT *new = Yap_InitBigNum(i);
if (j > 0) { if (j > 0) {
mpz_add_ui(new, new, j); mpz_add_ui(new, new, j);
RBIG(new); RBIG(new);
@ -69,16 +69,16 @@ p_plus(Term t1, Term t2 E_ARGS)
case big_int_e: case big_int_e:
{ {
Int i1 = IntegerOfTerm(t1); Int i1 = IntegerOfTerm(t1);
MP_INT *l2 = _YAP_BigIntOfTerm(t2); MP_INT *l2 = Yap_BigIntOfTerm(t2);
if (i1 > 0) { if (i1 > 0) {
MP_INT *new = _YAP_PreAllocBigNum(); MP_INT *new = Yap_PreAllocBigNum();
mpz_add_ui(new, l2, i1); mpz_add_ui(new, l2, i1);
RBIG(new); RBIG(new);
} else if (i1 == 0) { } else if (i1 == 0) {
RBIG(l2); RBIG(l2);
} else { } else {
MP_INT *new = _YAP_PreAllocBigNum(); MP_INT *new = Yap_PreAllocBigNum();
mpz_sub_ui(new, l2, -i1); mpz_sub_ui(new, l2, -i1);
RBIG(new); RBIG(new);
@ -103,7 +103,7 @@ p_plus(Term t1, Term t2 E_ARGS)
RFLOAT(FloatOfTerm(t1)+FloatOfTerm(t2)); RFLOAT(FloatOfTerm(t1)+FloatOfTerm(t2));
#ifdef USE_GMP #ifdef USE_GMP
case big_int_e: case big_int_e:
RFLOAT(FloatOfTerm(t1)+mpz_get_d(_YAP_BigIntOfTerm(t2))); RFLOAT(FloatOfTerm(t1)+mpz_get_d(Yap_BigIntOfTerm(t2)));
#endif #endif
default: default:
/* we've got a full term, need to evaluate it first */ /* we've got a full term, need to evaluate it first */
@ -120,17 +120,17 @@ p_plus(Term t1, Term t2 E_ARGS)
case long_int_e: case long_int_e:
{ {
Int i2 = IntegerOfTerm(t2); Int i2 = IntegerOfTerm(t2);
MP_INT *l1 = _YAP_BigIntOfTerm(t1); MP_INT *l1 = Yap_BigIntOfTerm(t1);
if (i2 > 0) { if (i2 > 0) {
MP_INT *new = _YAP_PreAllocBigNum(); MP_INT *new = Yap_PreAllocBigNum();
mpz_add_ui(new, l1, i2); mpz_add_ui(new, l1, i2);
RBIG(new); RBIG(new);
} else if (i2 == 0) { } else if (i2 == 0) {
RBIG(l1); RBIG(l1);
} else { } else {
MP_INT *new = _YAP_PreAllocBigNum(); MP_INT *new = Yap_PreAllocBigNum();
mpz_sub_ui(new, l1, -i2); mpz_sub_ui(new, l1, -i2);
RBIG(new); RBIG(new);
@ -139,16 +139,16 @@ p_plus(Term t1, Term t2 E_ARGS)
case big_int_e: case big_int_e:
/* two bignums */ /* two bignums */
{ {
MP_INT *new = _YAP_PreAllocBigNum(); MP_INT *new = Yap_PreAllocBigNum();
mpz_add(new, _YAP_BigIntOfTerm(t1), _YAP_BigIntOfTerm(t2)); mpz_add(new, Yap_BigIntOfTerm(t1), Yap_BigIntOfTerm(t2));
RBIG(new); RBIG(new);
} }
case double_e: case double_e:
RFLOAT(mpz_get_d(_YAP_BigIntOfTerm(t1))+FloatOfTerm(t2)); RFLOAT(mpz_get_d(Yap_BigIntOfTerm(t1))+FloatOfTerm(t2));
default: default:
/* we've got a full term, need to evaluate it first */ /* we've got a full term, need to evaluate it first */
v1.big = _YAP_BigIntOfTerm(t1); v1.big = Yap_BigIntOfTerm(t1);
bt1 = big_int_e; bt1 = big_int_e;
bt2 = ArithIEval(t2, &v2); bt2 = ArithIEval(t2, &v2);
break; break;
@ -174,14 +174,14 @@ p_plus(Term t1, Term t2 E_ARGS)
case big_int_e: case big_int_e:
{ {
if (v1.Int > 0) { if (v1.Int > 0) {
MP_INT *new = _YAP_PreAllocBigNum(); MP_INT *new = Yap_PreAllocBigNum();
mpz_add_ui(new, v2.big, v1.Int); mpz_add_ui(new, v2.big, v1.Int);
RBIG(new); RBIG(new);
} else if (v1.Int == 0) { } else if (v1.Int == 0) {
RBIG(v2.big); RBIG(v2.big);
} else { } else {
MP_INT *new = _YAP_PreAllocBigNum(); MP_INT *new = Yap_PreAllocBigNum();
mpz_add_ui(new, v2.big, -v1.Int); mpz_add_ui(new, v2.big, -v1.Int);
RBIG(new); RBIG(new);
@ -215,14 +215,14 @@ p_plus(Term t1, Term t2 E_ARGS)
case long_int_e: case long_int_e:
/* big * integer */ /* big * integer */
if (v2.Int > 0) { if (v2.Int > 0) {
MP_INT *new = _YAP_PreAllocBigNum(); MP_INT *new = Yap_PreAllocBigNum();
mpz_add_ui(new, v1.big, v2.Int); mpz_add_ui(new, v1.big, v2.Int);
RBIG(new); RBIG(new);
} else if (v2.Int == 0) { } else if (v2.Int == 0) {
RBIG(v1.big); RBIG(v1.big);
} else { } else {
MP_INT *new = _YAP_PreAllocBigNum(); MP_INT *new = Yap_PreAllocBigNum();
mpz_sub_ui(new, v2.big, -v1.Int); mpz_sub_ui(new, v2.big, -v1.Int);
RBIG(new); RBIG(new);
@ -233,7 +233,7 @@ p_plus(Term t1, Term t2 E_ARGS)
case big_int_e: case big_int_e:
/* big * big */ /* big * big */
{ {
MP_INT *new = _YAP_PreAllocBigNum(); MP_INT *new = Yap_PreAllocBigNum();
mpz_add(new, v1.big, v2.big); mpz_add(new, v1.big, v2.big);
RBIG(new); RBIG(new);
@ -279,20 +279,20 @@ p_minus(Term t1, Term t2 E_ARGS)
case big_int_e: case big_int_e:
{ {
Int i1 = IntegerOfTerm(t1); Int i1 = IntegerOfTerm(t1);
MP_INT *l2 = _YAP_BigIntOfTerm(t2); MP_INT *l2 = Yap_BigIntOfTerm(t2);
if (i1 > 0) { if (i1 > 0) {
MP_INT *new = _YAP_PreAllocBigNum(); MP_INT *new = Yap_PreAllocBigNum();
mpz_sub_ui(new, l2, i1); mpz_sub_ui(new, l2, i1);
mpz_neg(new, new); mpz_neg(new, new);
RBIG(new); RBIG(new);
} else if (i1 == 0) { } else if (i1 == 0) {
MP_INT *new = _YAP_PreAllocBigNum(); MP_INT *new = Yap_PreAllocBigNum();
mpz_neg(new, l2); mpz_neg(new, l2);
RBIG(new); RBIG(new);
} else { } else {
MP_INT *new = _YAP_PreAllocBigNum(); MP_INT *new = Yap_PreAllocBigNum();
mpz_add_ui(new, l2, -i1); mpz_add_ui(new, l2, -i1);
mpz_neg(new,new); mpz_neg(new,new);
@ -321,7 +321,7 @@ p_minus(Term t1, Term t2 E_ARGS)
#ifdef USE_GMP #ifdef USE_GMP
case big_int_e: case big_int_e:
{ {
RFLOAT(FloatOfTerm(t1)-mpz_get_d(_YAP_BigIntOfTerm(t2))); RFLOAT(FloatOfTerm(t1)-mpz_get_d(Yap_BigIntOfTerm(t2)));
} }
#endif #endif
default: default:
@ -339,17 +339,17 @@ p_minus(Term t1, Term t2 E_ARGS)
case long_int_e: case long_int_e:
{ {
Int i2 = IntegerOfTerm(t2); Int i2 = IntegerOfTerm(t2);
MP_INT *l1 = _YAP_BigIntOfTerm(t1); MP_INT *l1 = Yap_BigIntOfTerm(t1);
if (i2 > 0) { if (i2 > 0) {
MP_INT *new = _YAP_PreAllocBigNum(); MP_INT *new = Yap_PreAllocBigNum();
mpz_sub_ui(new, l1, i2); mpz_sub_ui(new, l1, i2);
RBIG(new); RBIG(new);
} else if (i2 == 0) { } else if (i2 == 0) {
RBIG(l1); RBIG(l1);
} else { } else {
MP_INT *new = _YAP_PreAllocBigNum(); MP_INT *new = Yap_PreAllocBigNum();
mpz_add_ui(new, l1, -i2); mpz_add_ui(new, l1, -i2);
RBIG(new); RBIG(new);
@ -358,18 +358,18 @@ p_minus(Term t1, Term t2 E_ARGS)
case big_int_e: case big_int_e:
/* two bignums */ /* two bignums */
{ {
MP_INT *new = _YAP_PreAllocBigNum(); MP_INT *new = Yap_PreAllocBigNum();
mpz_sub(new, _YAP_BigIntOfTerm(t1), _YAP_BigIntOfTerm(t2)); mpz_sub(new, Yap_BigIntOfTerm(t1), Yap_BigIntOfTerm(t2));
RBIG(new); RBIG(new);
} }
case double_e: case double_e:
{ {
RFLOAT(mpz_get_d(_YAP_BigIntOfTerm(t1))-FloatOfTerm(t2)); RFLOAT(mpz_get_d(Yap_BigIntOfTerm(t1))-FloatOfTerm(t2));
} }
default: default:
/* we've got a full term, need to evaluate it first */ /* we've got a full term, need to evaluate it first */
v1.big = _YAP_BigIntOfTerm(t1); v1.big = Yap_BigIntOfTerm(t1);
bt1 = big_int_e; bt1 = big_int_e;
bt2 = ArithIEval(t2, &v2); bt2 = ArithIEval(t2, &v2);
break; break;
@ -397,17 +397,17 @@ p_minus(Term t1, Term t2 E_ARGS)
case big_int_e: case big_int_e:
{ {
if (v1.Int > 0) { if (v1.Int > 0) {
MP_INT *new = _YAP_PreAllocBigNum(); MP_INT *new = Yap_PreAllocBigNum();
mpz_sub_ui(new, v2.big, v1.Int); mpz_sub_ui(new, v2.big, v1.Int);
mpz_neg(new, new); mpz_neg(new, new);
RBIG(new); RBIG(new);
} else if (v1.Int == 0) { } else if (v1.Int == 0) {
MP_INT *new = _YAP_PreAllocBigNum(); MP_INT *new = Yap_PreAllocBigNum();
mpz_neg(new, v2.big); mpz_neg(new, v2.big);
RBIG(new); RBIG(new);
} else { } else {
MP_INT *new = _YAP_PreAllocBigNum(); MP_INT *new = Yap_PreAllocBigNum();
mpz_add_ui(new, v2.big, -v1.Int); mpz_add_ui(new, v2.big, -v1.Int);
mpz_neg(new, new); mpz_neg(new, new);
@ -442,14 +442,14 @@ p_minus(Term t1, Term t2 E_ARGS)
case long_int_e: case long_int_e:
/* big * integer */ /* big * integer */
if (v2.Int > 0) { if (v2.Int > 0) {
MP_INT *new = _YAP_PreAllocBigNum(); MP_INT *new = Yap_PreAllocBigNum();
mpz_sub_ui(new, v1.big, v2.Int); mpz_sub_ui(new, v1.big, v2.Int);
RBIG(new); RBIG(new);
} else if (v2.Int == 0) { } else if (v2.Int == 0) {
RBIG(v1.big); RBIG(v1.big);
} else { } else {
MP_INT *new = _YAP_PreAllocBigNum(); MP_INT *new = Yap_PreAllocBigNum();
mpz_add_ui(new, v2.big, -v1.Int); mpz_add_ui(new, v2.big, -v1.Int);
RBIG(new); RBIG(new);
@ -460,7 +460,7 @@ p_minus(Term t1, Term t2 E_ARGS)
case big_int_e: case big_int_e:
/* big * big */ /* big * big */
{ {
MP_INT *new = _YAP_PreAllocBigNum(); MP_INT *new = Yap_PreAllocBigNum();
mpz_sub(new, v1.big, v2.big); mpz_sub(new, v1.big, v2.big);
RBIG(new); RBIG(new);
@ -504,7 +504,7 @@ times_int(Int i1, Int i2 E_ARGS) {
RINT(z); RINT(z);
overflow: overflow:
{ {
MP_INT *new = _YAP_InitBigNum(i1); MP_INT *new = Yap_InitBigNum(i1);
if (i2 > 0) { if (i2 > 0) {
mpz_mul_ui(new, new, i2); mpz_mul_ui(new, new, i2);
RBIG(new); RBIG(new);
@ -549,16 +549,16 @@ p_times(Term t1, Term t2 E_ARGS)
case big_int_e: case big_int_e:
{ {
Int i1 = IntegerOfTerm(t1); Int i1 = IntegerOfTerm(t1);
MP_INT *l2 = _YAP_BigIntOfTerm(t2); MP_INT *l2 = Yap_BigIntOfTerm(t2);
if (i1 > 0) { if (i1 > 0) {
MP_INT *new = _YAP_PreAllocBigNum(); MP_INT *new = Yap_PreAllocBigNum();
mpz_mul_ui(new, l2, i1); mpz_mul_ui(new, l2, i1);
RBIG(new); RBIG(new);
} else if (i1 == 0) { } else if (i1 == 0) {
RINT(0); RINT(0);
} else { } else {
MP_INT *new = _YAP_PreAllocBigNum(); MP_INT *new = Yap_PreAllocBigNum();
mpz_mul_ui(new, l2, -i1); mpz_mul_ui(new, l2, -i1);
mpz_neg(new, new); mpz_neg(new, new);
@ -587,7 +587,7 @@ p_times(Term t1, Term t2 E_ARGS)
#ifdef USE_GMP #ifdef USE_GMP
case big_int_e: case big_int_e:
{ {
RFLOAT(FloatOfTerm(t1)*mpz_get_d(_YAP_BigIntOfTerm(t2))); RFLOAT(FloatOfTerm(t1)*mpz_get_d(Yap_BigIntOfTerm(t2)));
} }
#endif #endif
default: default:
@ -605,17 +605,17 @@ p_times(Term t1, Term t2 E_ARGS)
case long_int_e: case long_int_e:
{ {
Int i2 = IntegerOfTerm(t2); Int i2 = IntegerOfTerm(t2);
MP_INT *l1 = _YAP_BigIntOfTerm(t1); MP_INT *l1 = Yap_BigIntOfTerm(t1);
if (i2 > 0) { if (i2 > 0) {
MP_INT *new = _YAP_PreAllocBigNum(); MP_INT *new = Yap_PreAllocBigNum();
mpz_mul_ui(new, l1, i2); mpz_mul_ui(new, l1, i2);
RBIG(new); RBIG(new);
} else if (i2 == 0) { } else if (i2 == 0) {
RINT(0); RINT(0);
} else { } else {
MP_INT *new = _YAP_PreAllocBigNum(); MP_INT *new = Yap_PreAllocBigNum();
mpz_mul_ui(new, l1, -i2); mpz_mul_ui(new, l1, -i2);
mpz_neg(new, new); mpz_neg(new, new);
@ -625,18 +625,18 @@ p_times(Term t1, Term t2 E_ARGS)
case big_int_e: case big_int_e:
/* two bignums */ /* two bignums */
{ {
MP_INT *new = _YAP_PreAllocBigNum(); MP_INT *new = Yap_PreAllocBigNum();
mpz_mul(new, _YAP_BigIntOfTerm(t1), _YAP_BigIntOfTerm(t2)); mpz_mul(new, Yap_BigIntOfTerm(t1), Yap_BigIntOfTerm(t2));
RBIG(new); RBIG(new);
} }
case double_e: case double_e:
{ {
RFLOAT(mpz_get_d(_YAP_BigIntOfTerm(t1))*FloatOfTerm(t2)); RFLOAT(mpz_get_d(Yap_BigIntOfTerm(t1))*FloatOfTerm(t2));
} }
default: default:
/* we've got a full term, need to evaluate it first */ /* we've got a full term, need to evaluate it first */
v1.big = _YAP_BigIntOfTerm(t1); v1.big = Yap_BigIntOfTerm(t1);
bt1 = big_int_e; bt1 = big_int_e;
bt2 = ArithIEval(t2, &v2); bt2 = ArithIEval(t2, &v2);
break; break;
@ -664,14 +664,14 @@ p_times(Term t1, Term t2 E_ARGS)
case big_int_e: case big_int_e:
{ {
if (v1.Int > 0) { if (v1.Int > 0) {
MP_INT *new = _YAP_PreAllocBigNum(); MP_INT *new = Yap_PreAllocBigNum();
mpz_mul_ui(new, v2.big, v1.Int); mpz_mul_ui(new, v2.big, v1.Int);
RBIG(new); RBIG(new);
} else if (v1.Int == 0) { } else if (v1.Int == 0) {
RINT(0); RINT(0);
} else { } else {
MP_INT *new = _YAP_PreAllocBigNum(); MP_INT *new = Yap_PreAllocBigNum();
mpz_mul_ui(new, v2.big, -v1.Int); mpz_mul_ui(new, v2.big, -v1.Int);
mpz_neg(new, new); mpz_neg(new, new);
@ -706,14 +706,14 @@ p_times(Term t1, Term t2 E_ARGS)
case long_int_e: case long_int_e:
/* big * integer */ /* big * integer */
if (v2.Int > 0) { if (v2.Int > 0) {
MP_INT *new = _YAP_PreAllocBigNum(); MP_INT *new = Yap_PreAllocBigNum();
mpz_mul_ui(new, v1.big, v2.Int); mpz_mul_ui(new, v1.big, v2.Int);
RBIG(new); RBIG(new);
} else if (v2.Int == 0) { } else if (v2.Int == 0) {
RINT(0); RINT(0);
} else { } else {
MP_INT *new = _YAP_PreAllocBigNum(); MP_INT *new = Yap_PreAllocBigNum();
mpz_mul_ui(new, v2.big, -v1.Int); mpz_mul_ui(new, v2.big, -v1.Int);
mpz_neg(new, new); mpz_neg(new, new);
@ -725,7 +725,7 @@ p_times(Term t1, Term t2 E_ARGS)
case big_int_e: case big_int_e:
/* big * big */ /* big * big */
{ {
MP_INT *new = _YAP_PreAllocBigNum(); MP_INT *new = Yap_PreAllocBigNum();
mpz_mul(new, v1.big, v2.big); mpz_mul(new, v1.big, v2.big);
RBIG(new); RBIG(new);
@ -762,7 +762,7 @@ p_div(Term t1, Term t2 E_ARGS)
Int i2 = IntegerOfTerm(t2); Int i2 = IntegerOfTerm(t2);
if (i2 == 0) { if (i2 == 0) {
_YAP_Error(EVALUATION_ERROR_ZERO_DIVISOR, t2, "// /2"); Yap_Error(EVALUATION_ERROR_ZERO_DIVISOR, t2, "// /2");
/* make GCC happy */ /* make GCC happy */
P = (yamop *)FAILCODE; P = (yamop *)FAILCODE;
RERROR(); RERROR();
@ -770,7 +770,7 @@ p_div(Term t1, Term t2 E_ARGS)
RINT(IntegerOfTerm(t1) / i2); RINT(IntegerOfTerm(t1) / i2);
} }
case double_e: case double_e:
_YAP_Error(TYPE_ERROR_INTEGER, t2, "// /2"); Yap_Error(TYPE_ERROR_INTEGER, t2, "// /2");
/* make GCC happy */ /* make GCC happy */
P = (yamop *)FAILCODE; P = (yamop *)FAILCODE;
RERROR(); RERROR();
@ -787,7 +787,7 @@ p_div(Term t1, Term t2 E_ARGS)
} }
break; break;
case double_e: case double_e:
_YAP_Error(TYPE_ERROR_INTEGER, t1, "// /2"); Yap_Error(TYPE_ERROR_INTEGER, t1, "// /2");
P = (yamop *)FAILCODE; P = (yamop *)FAILCODE;
RERROR(); RERROR();
#ifdef USE_GMP #ifdef USE_GMP
@ -799,20 +799,20 @@ p_div(Term t1, Term t2 E_ARGS)
/* dividing a bignum by an integer */ /* dividing a bignum by an integer */
{ {
Int i2 = IntegerOfTerm(t2); Int i2 = IntegerOfTerm(t2);
MP_INT *l1 = _YAP_BigIntOfTerm(t1); MP_INT *l1 = Yap_BigIntOfTerm(t1);
if (i2 > 0) { if (i2 > 0) {
MP_INT *new = _YAP_PreAllocBigNum(); MP_INT *new = Yap_PreAllocBigNum();
mpz_tdiv_q_ui(new, l1, i2); mpz_tdiv_q_ui(new, l1, i2);
RBIG(new); RBIG(new);
} else if (i2 == 0) { } else if (i2 == 0) {
_YAP_Error(EVALUATION_ERROR_ZERO_DIVISOR, t2, "// /2"); Yap_Error(EVALUATION_ERROR_ZERO_DIVISOR, t2, "// /2");
/* make GCC happy */ /* make GCC happy */
P = (yamop *)FAILCODE; P = (yamop *)FAILCODE;
RERROR(); RERROR();
} else { } else {
MP_INT *new = _YAP_PreAllocBigNum(); MP_INT *new = Yap_PreAllocBigNum();
mpz_tdiv_q_ui(new, l1, -i2); mpz_tdiv_q_ui(new, l1, -i2);
mpz_neg(new, new); mpz_neg(new, new);
@ -822,19 +822,19 @@ p_div(Term t1, Term t2 E_ARGS)
case big_int_e: case big_int_e:
/* two bignums */ /* two bignums */
{ {
MP_INT *new = _YAP_PreAllocBigNum(); MP_INT *new = Yap_PreAllocBigNum();
mpz_tdiv_q(new, _YAP_BigIntOfTerm(t1), _YAP_BigIntOfTerm(t2)); mpz_tdiv_q(new, Yap_BigIntOfTerm(t1), Yap_BigIntOfTerm(t2));
RBIG(new); RBIG(new);
} }
case double_e: case double_e:
_YAP_Error(TYPE_ERROR_INTEGER, t2, "// /2"); Yap_Error(TYPE_ERROR_INTEGER, t2, "// /2");
/* make GCC happy */ /* make GCC happy */
P = (yamop *)FAILCODE; P = (yamop *)FAILCODE;
RERROR(); RERROR();
default: default:
/* we've got a full term, need to evaluate it first */ /* we've got a full term, need to evaluate it first */
v1.big = _YAP_BigIntOfTerm(t1); v1.big = Yap_BigIntOfTerm(t1);
bt1 = big_int_e; bt1 = big_int_e;
bt2 = ArithIEval(t2, &v2); bt2 = ArithIEval(t2, &v2);
break; break;
@ -853,14 +853,14 @@ p_div(Term t1, Term t2 E_ARGS)
case long_int_e: case long_int_e:
/* two integers */ /* two integers */
if (v2.Int == 0) { if (v2.Int == 0) {
_YAP_Error(EVALUATION_ERROR_ZERO_DIVISOR, t2, "// /2"); Yap_Error(EVALUATION_ERROR_ZERO_DIVISOR, t2, "// /2");
/* make GCC happy */ /* make GCC happy */
P = (yamop *)FAILCODE; P = (yamop *)FAILCODE;
RERROR(); RERROR();
} }
RINT(v1.Int / v2.Int); RINT(v1.Int / v2.Int);
case double_e: case double_e:
_YAP_Error(TYPE_ERROR_INTEGER, MkFloatTerm(v2.dbl), "// /2"); Yap_Error(TYPE_ERROR_INTEGER, MkFloatTerm(v2.dbl), "// /2");
/* make GCC happy */ /* make GCC happy */
P = (yamop *)FAILCODE; P = (yamop *)FAILCODE;
RERROR(); RERROR();
@ -870,11 +870,11 @@ p_div(Term t1, Term t2 E_ARGS)
RINT(0); RINT(0);
#endif #endif
default: default:
/* _YAP_Error */ /* Yap_Error */
RERROR(); RERROR();
} }
case double_e: case double_e:
_YAP_Error(TYPE_ERROR_INTEGER, MkFloatTerm(v1.dbl), "// /2"); Yap_Error(TYPE_ERROR_INTEGER, MkFloatTerm(v1.dbl), "// /2");
P = (yamop *)FAILCODE; P = (yamop *)FAILCODE;
RERROR(); RERROR();
#ifdef USE_GMP #ifdef USE_GMP
@ -883,17 +883,17 @@ p_div(Term t1, Term t2 E_ARGS)
case long_int_e: case long_int_e:
/* big // integer */ /* big // integer */
if (v2.Int > 0) { if (v2.Int > 0) {
MP_INT *new = _YAP_PreAllocBigNum(); MP_INT *new = Yap_PreAllocBigNum();
mpz_tdiv_q_ui(new, v1.big, v2.Int); mpz_tdiv_q_ui(new, v1.big, v2.Int);
RBIG(new); RBIG(new);
} else if (v2.Int == 0) { } else if (v2.Int == 0) {
_YAP_Error(EVALUATION_ERROR_ZERO_DIVISOR, t2, "// /2"); Yap_Error(EVALUATION_ERROR_ZERO_DIVISOR, t2, "// /2");
/* make GCC happy */ /* make GCC happy */
P = (yamop *)FAILCODE; P = (yamop *)FAILCODE;
RERROR(); RERROR();
} else { } else {
MP_INT *new = _YAP_PreAllocBigNum(); MP_INT *new = Yap_PreAllocBigNum();
mpz_tdiv_q_ui(new, v2.big, -v1.Int); mpz_tdiv_q_ui(new, v2.big, -v1.Int);
mpz_neg(new, new); mpz_neg(new, new);
@ -901,14 +901,14 @@ p_div(Term t1, Term t2 E_ARGS)
} }
case double_e: case double_e:
/* big // float */ /* big // float */
_YAP_Error(TYPE_ERROR_INTEGER, MkFloatTerm(v2.dbl), "// /2"); Yap_Error(TYPE_ERROR_INTEGER, MkFloatTerm(v2.dbl), "// /2");
/* make GCC happy */ /* make GCC happy */
P = (yamop *)FAILCODE; P = (yamop *)FAILCODE;
RERROR(); RERROR();
case big_int_e: case big_int_e:
/* big * big */ /* big * big */
{ {
MP_INT *new = _YAP_PreAllocBigNum(); MP_INT *new = Yap_PreAllocBigNum();
mpz_tdiv_q(new, v1.big, v2.big); mpz_tdiv_q(new, v1.big, v2.big);
RBIG(new); RBIG(new);
@ -943,13 +943,13 @@ p_and(Term t1, Term t2 E_ARGS)
/* two integers */ /* two integers */
RINT(IntegerOfTerm(t1) & IntegerOfTerm(t2)); RINT(IntegerOfTerm(t1) & IntegerOfTerm(t2));
case double_e: case double_e:
_YAP_Error(TYPE_ERROR_INTEGER, t2, "/\\ /2"); Yap_Error(TYPE_ERROR_INTEGER, t2, "/\\ /2");
P = (yamop *)FAILCODE; P = (yamop *)FAILCODE;
RERROR(); RERROR();
#ifdef USE_GMP #ifdef USE_GMP
case big_int_e: case big_int_e:
{ {
unsigned long int i2 = mpz_get_ui(_YAP_BigIntOfTerm(t2)); unsigned long int i2 = mpz_get_ui(Yap_BigIntOfTerm(t2));
RINT(IntegerOfTerm(t1) & i2); RINT(IntegerOfTerm(t1) & i2);
} }
#endif #endif
@ -961,7 +961,7 @@ p_and(Term t1, Term t2 E_ARGS)
} }
break; break;
case double_e: case double_e:
_YAP_Error(TYPE_ERROR_INTEGER, t1, "/\\ /2"); Yap_Error(TYPE_ERROR_INTEGER, t1, "/\\ /2");
P = (yamop *)FAILCODE; P = (yamop *)FAILCODE;
RERROR(); RERROR();
#ifdef USE_GMP #ifdef USE_GMP
@ -972,25 +972,25 @@ p_and(Term t1, Term t2 E_ARGS)
case long_int_e: case long_int_e:
/* anding a bignum with an integer is easy */ /* anding a bignum with an integer is easy */
{ {
unsigned long int i1 = mpz_get_ui(_YAP_BigIntOfTerm(t1)); unsigned long int i1 = mpz_get_ui(Yap_BigIntOfTerm(t1));
RINT(i1 & IntegerOfTerm(t2)); RINT(i1 & IntegerOfTerm(t2));
} }
case big_int_e: case big_int_e:
/* two bignums */ /* two bignums */
{ {
MP_INT *new = _YAP_PreAllocBigNum(); MP_INT *new = Yap_PreAllocBigNum();
mpz_and(new, _YAP_BigIntOfTerm(t1), _YAP_BigIntOfTerm(t2)); mpz_and(new, Yap_BigIntOfTerm(t1), Yap_BigIntOfTerm(t2));
RBIG(new); RBIG(new);
} }
case double_e: case double_e:
_YAP_Error(TYPE_ERROR_INTEGER, t2, "/\\ /2"); Yap_Error(TYPE_ERROR_INTEGER, t2, "/\\ /2");
/* make GCC happy */ /* make GCC happy */
P = (yamop *)FAILCODE; P = (yamop *)FAILCODE;
RERROR(); RERROR();
default: default:
/* we've got a full term, need to evaluate it first */ /* we've got a full term, need to evaluate it first */
v1.big = _YAP_BigIntOfTerm(t1); v1.big = Yap_BigIntOfTerm(t1);
bt1 = big_int_e; bt1 = big_int_e;
bt2 = ArithIEval(t2, &v2); bt2 = ArithIEval(t2, &v2);
break; break;
@ -1009,7 +1009,7 @@ p_and(Term t1, Term t2 E_ARGS)
case long_int_e: case long_int_e:
RINT(v1.Int & v2.Int); RINT(v1.Int & v2.Int);
case double_e: case double_e:
_YAP_Error(TYPE_ERROR_INTEGER, MkFloatTerm(v2.dbl), "/\\ /2"); Yap_Error(TYPE_ERROR_INTEGER, MkFloatTerm(v2.dbl), "/\\ /2");
/* make GCC happy */ /* make GCC happy */
P = (yamop *)FAILCODE; P = (yamop *)FAILCODE;
RERROR(); RERROR();
@ -1021,11 +1021,11 @@ p_and(Term t1, Term t2 E_ARGS)
} }
#endif #endif
default: default:
/* _YAP_Error */ /* Yap_Error */
RERROR(); RERROR();
} }
case double_e: case double_e:
_YAP_Error(TYPE_ERROR_INTEGER, MkFloatTerm(v1.dbl), "/\\ /2"); Yap_Error(TYPE_ERROR_INTEGER, MkFloatTerm(v1.dbl), "/\\ /2");
P = (yamop *)FAILCODE; P = (yamop *)FAILCODE;
RERROR(); RERROR();
#ifdef USE_GMP #ifdef USE_GMP
@ -1039,14 +1039,14 @@ p_and(Term t1, Term t2 E_ARGS)
} }
case double_e: case double_e:
/* big // float */ /* big // float */
_YAP_Error(TYPE_ERROR_INTEGER, MkFloatTerm(v2.dbl), "/\\ /2"); Yap_Error(TYPE_ERROR_INTEGER, MkFloatTerm(v2.dbl), "/\\ /2");
/* make GCC happy */ /* make GCC happy */
P = (yamop *)FAILCODE; P = (yamop *)FAILCODE;
RERROR(); RERROR();
case big_int_e: case big_int_e:
/* big * big */ /* big * big */
{ {
MP_INT *new = _YAP_PreAllocBigNum(); MP_INT *new = Yap_PreAllocBigNum();
mpz_and(new, v1.big, v2.big); mpz_and(new, v1.big, v2.big);
RBIG(new); RBIG(new);
@ -1081,16 +1081,16 @@ p_or(Term t1, Term t2 E_ARGS)
/* two integers */ /* two integers */
RINT(IntegerOfTerm(t1) | IntegerOfTerm(t2)); RINT(IntegerOfTerm(t1) | IntegerOfTerm(t2));
case double_e: case double_e:
_YAP_Error(TYPE_ERROR_INTEGER, t2, "\\/ /2"); Yap_Error(TYPE_ERROR_INTEGER, t2, "\\/ /2");
P = (yamop *)FAILCODE; P = (yamop *)FAILCODE;
RERROR(); RERROR();
#ifdef USE_GMP #ifdef USE_GMP
case big_int_e: case big_int_e:
{ {
MP_INT *new = _YAP_PreAllocBigNum(); MP_INT *new = Yap_PreAllocBigNum();
mpz_set_si(new,IntOfTerm(t1)); mpz_set_si(new,IntOfTerm(t1));
mpz_ior(new, new, _YAP_BigIntOfTerm(t2)); mpz_ior(new, new, Yap_BigIntOfTerm(t2));
RBIG(new); RBIG(new);
} }
#endif #endif
@ -1102,7 +1102,7 @@ p_or(Term t1, Term t2 E_ARGS)
} }
break; break;
case double_e: case double_e:
_YAP_Error(TYPE_ERROR_INTEGER, t1, "\\/ /2"); Yap_Error(TYPE_ERROR_INTEGER, t1, "\\/ /2");
P = (yamop *)FAILCODE; P = (yamop *)FAILCODE;
RERROR(); RERROR();
#ifdef USE_GMP #ifdef USE_GMP
@ -1112,28 +1112,28 @@ p_or(Term t1, Term t2 E_ARGS)
switch (BlobOfFunctor(f2)) { switch (BlobOfFunctor(f2)) {
case long_int_e: case long_int_e:
{ {
MP_INT *new = _YAP_PreAllocBigNum(); MP_INT *new = Yap_PreAllocBigNum();
mpz_set_si(new,IntOfTerm(t2)); mpz_set_si(new,IntOfTerm(t2));
mpz_ior(new, _YAP_BigIntOfTerm(t1), new); mpz_ior(new, Yap_BigIntOfTerm(t1), new);
RBIG(new); RBIG(new);
} }
case big_int_e: case big_int_e:
/* two bignums */ /* two bignums */
{ {
MP_INT *new = _YAP_PreAllocBigNum(); MP_INT *new = Yap_PreAllocBigNum();
mpz_ior(new, _YAP_BigIntOfTerm(t1), _YAP_BigIntOfTerm(t2)); mpz_ior(new, Yap_BigIntOfTerm(t1), Yap_BigIntOfTerm(t2));
RBIG(new); RBIG(new);
} }
case double_e: case double_e:
_YAP_Error(TYPE_ERROR_INTEGER, t2, "\\/ /2"); Yap_Error(TYPE_ERROR_INTEGER, t2, "\\/ /2");
/* make GCC happy */ /* make GCC happy */
P = (yamop *)FAILCODE; P = (yamop *)FAILCODE;
RERROR(); RERROR();
default: default:
/* we've got a full term, need to evaluate it first */ /* we've got a full term, need to evaluate it first */
v1.big = _YAP_BigIntOfTerm(t1); v1.big = Yap_BigIntOfTerm(t1);
bt1 = big_int_e; bt1 = big_int_e;
bt2 = ArithIEval(t2, &v2); bt2 = ArithIEval(t2, &v2);
break; break;
@ -1152,14 +1152,14 @@ p_or(Term t1, Term t2 E_ARGS)
case long_int_e: case long_int_e:
RINT(v1.Int | v2.Int); RINT(v1.Int | v2.Int);
case double_e: case double_e:
_YAP_Error(TYPE_ERROR_INTEGER, MkFloatTerm(v2.dbl), "\\/ /2"); Yap_Error(TYPE_ERROR_INTEGER, MkFloatTerm(v2.dbl), "\\/ /2");
/* make GCC happy */ /* make GCC happy */
P = (yamop *)FAILCODE; P = (yamop *)FAILCODE;
RERROR(); RERROR();
#ifdef USE_GMP #ifdef USE_GMP
case big_int_e: case big_int_e:
{ {
MP_INT *new = _YAP_PreAllocBigNum(); MP_INT *new = Yap_PreAllocBigNum();
mpz_set_si(new,v1.Int); mpz_set_si(new,v1.Int);
@ -1168,11 +1168,11 @@ p_or(Term t1, Term t2 E_ARGS)
} }
#endif #endif
default: default:
/* _YAP_Error */ /* Yap_Error */
RERROR(); RERROR();
} }
case double_e: case double_e:
_YAP_Error(TYPE_ERROR_INTEGER, MkFloatTerm(v1.dbl), "\\/ /2"); Yap_Error(TYPE_ERROR_INTEGER, MkFloatTerm(v1.dbl), "\\/ /2");
P = (yamop *)FAILCODE; P = (yamop *)FAILCODE;
RERROR(); RERROR();
#ifdef USE_GMP #ifdef USE_GMP
@ -1181,7 +1181,7 @@ p_or(Term t1, Term t2 E_ARGS)
case long_int_e: case long_int_e:
/* anding a bignum with an integer is easy */ /* anding a bignum with an integer is easy */
{ {
MP_INT *new = _YAP_PreAllocBigNum(); MP_INT *new = Yap_PreAllocBigNum();
mpz_set_si(new, v2.Int); mpz_set_si(new, v2.Int);
mpz_ior(new, v1.big, new); mpz_ior(new, v1.big, new);
@ -1189,14 +1189,14 @@ p_or(Term t1, Term t2 E_ARGS)
} }
case double_e: case double_e:
/* big // float */ /* big // float */
_YAP_Error(TYPE_ERROR_INTEGER, MkFloatTerm(v2.dbl), "\\/ /2"); Yap_Error(TYPE_ERROR_INTEGER, MkFloatTerm(v2.dbl), "\\/ /2");
/* make GCC happy */ /* make GCC happy */
P = (yamop *)FAILCODE; P = (yamop *)FAILCODE;
RERROR(); RERROR();
case big_int_e: case big_int_e:
/* big * big */ /* big * big */
{ {
MP_INT *new = _YAP_PreAllocBigNum(); MP_INT *new = Yap_PreAllocBigNum();
mpz_ior(new, v1.big, v2.big); mpz_ior(new, v1.big, v2.big);
RBIG(new); RBIG(new);
@ -1234,12 +1234,12 @@ p_sll(Term t1, Term t2 E_ARGS)
/* two integers */ /* two integers */
RINT(IntegerOfTerm(t1) << IntegerOfTerm(t2)); RINT(IntegerOfTerm(t1) << IntegerOfTerm(t2));
case double_e: case double_e:
_YAP_Error(TYPE_ERROR_INTEGER, t2, "<</2"); Yap_Error(TYPE_ERROR_INTEGER, t2, "<</2");
P = (yamop *)FAILCODE; P = (yamop *)FAILCODE;
RERROR(); RERROR();
#ifdef USE_GMP #ifdef USE_GMP
case big_int_e: case big_int_e:
_YAP_Error(DOMAIN_ERROR_SHIFT_COUNT_OVERFLOW, t2, "<</2"); Yap_Error(DOMAIN_ERROR_SHIFT_COUNT_OVERFLOW, t2, "<</2");
P = (yamop *)FAILCODE; P = (yamop *)FAILCODE;
RERROR(); RERROR();
#endif #endif
@ -1251,7 +1251,7 @@ p_sll(Term t1, Term t2 E_ARGS)
} }
break; break;
case double_e: case double_e:
_YAP_Error(TYPE_ERROR_INTEGER, t1, "<< /2"); Yap_Error(TYPE_ERROR_INTEGER, t1, "<< /2");
P = (yamop *)FAILCODE; P = (yamop *)FAILCODE;
RERROR(); RERROR();
#ifdef USE_GMP #ifdef USE_GMP
@ -1262,33 +1262,33 @@ p_sll(Term t1, Term t2 E_ARGS)
case long_int_e: case long_int_e:
{ {
Int i2 = IntegerOfTerm(t2); Int i2 = IntegerOfTerm(t2);
MP_INT *l1 = _YAP_BigIntOfTerm(t1); MP_INT *l1 = Yap_BigIntOfTerm(t1);
if (i2 > 0) { if (i2 > 0) {
MP_INT *new = _YAP_PreAllocBigNum(); MP_INT *new = Yap_PreAllocBigNum();
mpz_mul_2exp(new, l1, i2); mpz_mul_2exp(new, l1, i2);
RBIG(new); RBIG(new);
} else if (i2 == 0) { } else if (i2 == 0) {
RBIG(l1); RBIG(l1);
} else { } else {
MP_INT *new = _YAP_PreAllocBigNum(); MP_INT *new = Yap_PreAllocBigNum();
mpz_tdiv_q_2exp(new, l1, -i2); mpz_tdiv_q_2exp(new, l1, -i2);
RBIG(new); RBIG(new);
} }
} }
case big_int_e: case big_int_e:
_YAP_Error(DOMAIN_ERROR_SHIFT_COUNT_OVERFLOW, t2, "<</2"); Yap_Error(DOMAIN_ERROR_SHIFT_COUNT_OVERFLOW, t2, "<</2");
P = (yamop *)FAILCODE; P = (yamop *)FAILCODE;
RERROR(); RERROR();
case double_e: case double_e:
_YAP_Error(TYPE_ERROR_INTEGER, t2, "<</2"); Yap_Error(TYPE_ERROR_INTEGER, t2, "<</2");
/* make GCC happy */ /* make GCC happy */
P = (yamop *)FAILCODE; P = (yamop *)FAILCODE;
RERROR(); RERROR();
default: default:
/* we've got a full term, need to evaluate it first */ /* we've got a full term, need to evaluate it first */
v1.big = _YAP_BigIntOfTerm(t1); v1.big = Yap_BigIntOfTerm(t1);
bt1 = big_int_e; bt1 = big_int_e;
bt2 = ArithIEval(t2, &v2); bt2 = ArithIEval(t2, &v2);
break; break;
@ -1307,22 +1307,22 @@ p_sll(Term t1, Term t2 E_ARGS)
case long_int_e: case long_int_e:
RINT(v1.Int << v2.Int); RINT(v1.Int << v2.Int);
case double_e: case double_e:
_YAP_Error(TYPE_ERROR_INTEGER, MkFloatTerm(v2.dbl), "<</2"); Yap_Error(TYPE_ERROR_INTEGER, MkFloatTerm(v2.dbl), "<</2");
/* make GCC happy */ /* make GCC happy */
P = (yamop *)FAILCODE; P = (yamop *)FAILCODE;
RERROR(); RERROR();
#ifdef USE_GMP #ifdef USE_GMP
case big_int_e: case big_int_e:
_YAP_Error(DOMAIN_ERROR_SHIFT_COUNT_OVERFLOW, t2, "<</2"); Yap_Error(DOMAIN_ERROR_SHIFT_COUNT_OVERFLOW, t2, "<</2");
P = (yamop *)FAILCODE; P = (yamop *)FAILCODE;
RERROR(); RERROR();
#endif #endif
default: default:
/* _YAP_Error */ /* Yap_Error */
RERROR(); RERROR();
} }
case double_e: case double_e:
_YAP_Error(TYPE_ERROR_INTEGER, MkFloatTerm(v1.dbl), "<</2"); Yap_Error(TYPE_ERROR_INTEGER, MkFloatTerm(v1.dbl), "<</2");
P = (yamop *)FAILCODE; P = (yamop *)FAILCODE;
RERROR(); RERROR();
#ifdef USE_GMP #ifdef USE_GMP
@ -1332,13 +1332,13 @@ p_sll(Term t1, Term t2 E_ARGS)
/* big << int */ /* big << int */
{ {
if (v2.Int > 0) { if (v2.Int > 0) {
MP_INT *new = _YAP_PreAllocBigNum(); MP_INT *new = Yap_PreAllocBigNum();
mpz_mul_2exp(new, v1.big, v2.Int); mpz_mul_2exp(new, v1.big, v2.Int);
RBIG(new); RBIG(new);
} else if (v2.Int == 0) { } else if (v2.Int == 0) {
RBIG(v1.big); RBIG(v1.big);
} else { } else {
MP_INT *new = _YAP_PreAllocBigNum(); MP_INT *new = Yap_PreAllocBigNum();
mpz_tdiv_q_2exp(new, v1.big, -v2.Int); mpz_tdiv_q_2exp(new, v1.big, -v2.Int);
RBIG(new); RBIG(new);
@ -1346,13 +1346,13 @@ p_sll(Term t1, Term t2 E_ARGS)
} }
case double_e: case double_e:
/* big << float */ /* big << float */
_YAP_Error(TYPE_ERROR_INTEGER, MkFloatTerm(v2.dbl), "<</2"); Yap_Error(TYPE_ERROR_INTEGER, MkFloatTerm(v2.dbl), "<</2");
/* make GCC happy */ /* make GCC happy */
P = (yamop *)FAILCODE; P = (yamop *)FAILCODE;
RERROR(); RERROR();
case big_int_e: case big_int_e:
/* big << big */ /* big << big */
_YAP_Error(DOMAIN_ERROR_SHIFT_COUNT_OVERFLOW, t2, "<</2"); Yap_Error(DOMAIN_ERROR_SHIFT_COUNT_OVERFLOW, t2, "<</2");
P = (yamop *)FAILCODE; P = (yamop *)FAILCODE;
RERROR(); RERROR();
default: default:
@ -1388,12 +1388,12 @@ p_slr(Term t1, Term t2 E_ARGS)
/* two integers */ /* two integers */
RINT(IntegerOfTerm(t1) >> IntegerOfTerm(t2)); RINT(IntegerOfTerm(t1) >> IntegerOfTerm(t2));
case double_e: case double_e:
_YAP_Error(TYPE_ERROR_INTEGER, t2, ">>/2"); Yap_Error(TYPE_ERROR_INTEGER, t2, ">>/2");
P = (yamop *)FAILCODE; P = (yamop *)FAILCODE;
RERROR(); RERROR();
#ifdef USE_GMP #ifdef USE_GMP
case big_int_e: case big_int_e:
_YAP_Error(DOMAIN_ERROR_SHIFT_COUNT_OVERFLOW, t2, ">>/2"); Yap_Error(DOMAIN_ERROR_SHIFT_COUNT_OVERFLOW, t2, ">>/2");
P = (yamop *)FAILCODE; P = (yamop *)FAILCODE;
RERROR(); RERROR();
#endif #endif
@ -1405,7 +1405,7 @@ p_slr(Term t1, Term t2 E_ARGS)
} }
break; break;
case double_e: case double_e:
_YAP_Error(TYPE_ERROR_INTEGER, t1, ">>/2"); Yap_Error(TYPE_ERROR_INTEGER, t1, ">>/2");
P = (yamop *)FAILCODE; P = (yamop *)FAILCODE;
RERROR(); RERROR();
#ifdef USE_GMP #ifdef USE_GMP
@ -1416,33 +1416,33 @@ p_slr(Term t1, Term t2 E_ARGS)
case long_int_e: case long_int_e:
{ {
Int i2 = IntegerOfTerm(t2); Int i2 = IntegerOfTerm(t2);
MP_INT *l1 = _YAP_BigIntOfTerm(t1); MP_INT *l1 = Yap_BigIntOfTerm(t1);
if (i2 > 0) { if (i2 > 0) {
MP_INT *new = _YAP_PreAllocBigNum(); MP_INT *new = Yap_PreAllocBigNum();
mpz_tdiv_q_2exp(new, l1, i2); mpz_tdiv_q_2exp(new, l1, i2);
RBIG(new); RBIG(new);
} else if (i2 == 0) { } else if (i2 == 0) {
RBIG(l1); RBIG(l1);
} else { } else {
MP_INT *new = _YAP_PreAllocBigNum(); MP_INT *new = Yap_PreAllocBigNum();
mpz_mul_2exp(new, l1, -i2); mpz_mul_2exp(new, l1, -i2);
RBIG(new); RBIG(new);
} }
} }
case big_int_e: case big_int_e:
_YAP_Error(DOMAIN_ERROR_SHIFT_COUNT_OVERFLOW, t2, ">>/2"); Yap_Error(DOMAIN_ERROR_SHIFT_COUNT_OVERFLOW, t2, ">>/2");
P = (yamop *)FAILCODE; P = (yamop *)FAILCODE;
RERROR(); RERROR();
case double_e: case double_e:
_YAP_Error(TYPE_ERROR_INTEGER, t2, ">>/2"); Yap_Error(TYPE_ERROR_INTEGER, t2, ">>/2");
/* make GCC happy */ /* make GCC happy */
P = (yamop *)FAILCODE; P = (yamop *)FAILCODE;
RERROR(); RERROR();
default: default:
/* we've got a full term, need to evaluate it first */ /* we've got a full term, need to evaluate it first */
v1.big = _YAP_BigIntOfTerm(t1); v1.big = Yap_BigIntOfTerm(t1);
bt1 = big_int_e; bt1 = big_int_e;
bt2 = ArithIEval(t2, &v2); bt2 = ArithIEval(t2, &v2);
break; break;
@ -1461,22 +1461,22 @@ p_slr(Term t1, Term t2 E_ARGS)
case long_int_e: case long_int_e:
RINT(v1.Int >> v2.Int); RINT(v1.Int >> v2.Int);
case double_e: case double_e:
_YAP_Error(TYPE_ERROR_INTEGER, MkFloatTerm(v2.dbl), ">>/2"); Yap_Error(TYPE_ERROR_INTEGER, MkFloatTerm(v2.dbl), ">>/2");
/* make GCC happy */ /* make GCC happy */
P = (yamop *)FAILCODE; P = (yamop *)FAILCODE;
RERROR(); RERROR();
#ifdef USE_GMP #ifdef USE_GMP
case big_int_e: case big_int_e:
_YAP_Error(DOMAIN_ERROR_SHIFT_COUNT_OVERFLOW, t2, ">>/2"); Yap_Error(DOMAIN_ERROR_SHIFT_COUNT_OVERFLOW, t2, ">>/2");
P = (yamop *)FAILCODE; P = (yamop *)FAILCODE;
RERROR(); RERROR();
#endif #endif
default: default:
/* _YAP_Error */ /* Yap_Error */
RERROR(); RERROR();
} }
case double_e: case double_e:
_YAP_Error(TYPE_ERROR_INTEGER, MkFloatTerm(v1.dbl), ">>/2"); Yap_Error(TYPE_ERROR_INTEGER, MkFloatTerm(v1.dbl), ">>/2");
P = (yamop *)FAILCODE; P = (yamop *)FAILCODE;
RERROR(); RERROR();
#ifdef USE_GMP #ifdef USE_GMP
@ -1486,13 +1486,13 @@ p_slr(Term t1, Term t2 E_ARGS)
/* big >> int */ /* big >> int */
{ {
if (v2.Int > 0) { if (v2.Int > 0) {
MP_INT *new = _YAP_PreAllocBigNum(); MP_INT *new = Yap_PreAllocBigNum();
mpz_tdiv_q_2exp(new, v1.big, v2.Int); mpz_tdiv_q_2exp(new, v1.big, v2.Int);
RBIG(new); RBIG(new);
} else if (v2.Int == 0) { } else if (v2.Int == 0) {
RBIG(v1.big); RBIG(v1.big);
} else { } else {
MP_INT *new = _YAP_PreAllocBigNum(); MP_INT *new = Yap_PreAllocBigNum();
mpz_mul_2exp(new, v1.big, -v2.Int); mpz_mul_2exp(new, v1.big, -v2.Int);
RBIG(new); RBIG(new);
@ -1500,13 +1500,13 @@ p_slr(Term t1, Term t2 E_ARGS)
} }
case double_e: case double_e:
/* big >> float */ /* big >> float */
_YAP_Error(TYPE_ERROR_INTEGER, MkFloatTerm(v2.dbl), ">>/2"); Yap_Error(TYPE_ERROR_INTEGER, MkFloatTerm(v2.dbl), ">>/2");
/* make GCC happy */ /* make GCC happy */
P = (yamop *)FAILCODE; P = (yamop *)FAILCODE;
RERROR(); RERROR();
case big_int_e: case big_int_e:
/* big >> big */ /* big >> big */
_YAP_Error(DOMAIN_ERROR_SHIFT_COUNT_OVERFLOW, t2, ">>/2"); Yap_Error(DOMAIN_ERROR_SHIFT_COUNT_OVERFLOW, t2, ">>/2");
P = (yamop *)FAILCODE; P = (yamop *)FAILCODE;
RERROR(); RERROR();
default: default:

6
H/clause.h
View File

@ -117,8 +117,8 @@ typedef struct clause_struct {
#endif #endif
/* cdmgr.c */ /* cdmgr.c */
void STD_PROTO(_YAP_RemoveLogUpdIndex,(Clause *)); void STD_PROTO(Yap_RemoveLogUpdIndex,(Clause *));
void STD_PROTO(_YAP_IPred,(CODEADDR sp)); void STD_PROTO(Yap_IPred,(CODEADDR sp));
/* dbase.c */ /* dbase.c */
void STD_PROTO(_YAP_ErCl,(Clause *)); void STD_PROTO(Yap_ErCl,(Clause *));

18
H/compile.h
View File

@ -250,17 +250,17 @@ typedef struct CEXPENTRY {
#define Two 2 #define Two 2
CODEADDR STD_PROTO(_YAP_assemble,(int)); CODEADDR STD_PROTO(Yap_assemble,(int));
void STD_PROTO(_YAP_emit,(compiler_vm_op,Int,CELL)); void STD_PROTO(Yap_emit,(compiler_vm_op,Int,CELL));
void STD_PROTO(_YAP_emit_3ops,(compiler_vm_op,CELL,CELL,CELL)); void STD_PROTO(Yap_emit_3ops,(compiler_vm_op,CELL,CELL,CELL));
CELL *STD_PROTO(_YAP_emit_extra_size,(compiler_vm_op,CELL,int)); CELL *STD_PROTO(Yap_emit_extra_size,(compiler_vm_op,CELL,int));
char *STD_PROTO(_YAP_AllocCMem,(int)); char *STD_PROTO(Yap_AllocCMem,(int));
int STD_PROTO(_YAP_is_a_test_pred,(Term, SMALLUNSGN)); int STD_PROTO(Yap_is_a_test_pred,(Term, SMALLUNSGN));
void STD_PROTO(_YAP_bip_name,(Int, char *)); void STD_PROTO(Yap_bip_name,(Int, char *));
#ifdef DEBUG #ifdef DEBUG
void STD_PROTO(_YAP_ShowCode,(void)); void STD_PROTO(Yap_ShowCode,(void));
#endif /* DEBUG */ #endif /* DEBUG */
extern jmp_buf _YAP_CompilerBotch; extern jmp_buf Yap_CompilerBotch;

20
H/eval.h
View File

@ -50,8 +50,8 @@ typedef union arith_ret {
/* /*
#define RINT(v) return(MkIntegerTerm(v)) #define RINT(v) return(MkIntegerTerm(v))
#define RFLOAT(v) return(MkFloatTerm(v)) #define RFLOAT(v) return(MkFloatTerm(v))
#define RBIG(v) return(_YAP_MkBigIntTerm(v)) #define RBIG(v) return(Yap_MkBigIntTerm(v))
#define RBIG_FL(v) return(_YAP_MkBigIntTerm((MP_INT *)(Int)v)) #define RBIG_FL(v) return(Yap_MkBigIntTerm((MP_INT *)(Int)v))
#define RERROR() return(MkIntTerm(0)) #define RERROR() return(MkIntTerm(0))
*/ */
@ -88,14 +88,14 @@ Functor STD_PROTO(EvalArg,(Term,arith_retptr));
#define FL(X) ((double)(X)) #define FL(X) ((double)(X))
#endif #endif
extern yap_error_number _YAP_matherror; extern yap_error_number Yap_matherror;
void STD_PROTO(_YAP_InitConstExps,(void)); void STD_PROTO(Yap_InitConstExps,(void));
void STD_PROTO(_YAP_InitUnaryExps,(void)); void STD_PROTO(Yap_InitUnaryExps,(void));
void STD_PROTO(_YAP_InitBinaryExps,(void)); void STD_PROTO(Yap_InitBinaryExps,(void));
int STD_PROTO(_YAP_ReInitConstExps,(void)); int STD_PROTO(Yap_ReInitConstExps,(void));
int STD_PROTO(_YAP_ReInitUnaryExps,(void)); int STD_PROTO(Yap_ReInitUnaryExps,(void));
int STD_PROTO(_YAP_ReInitBinaryExps,(void)); int STD_PROTO(Yap_ReInitBinaryExps,(void));
blob_type STD_PROTO(_YAP_Eval,(Term, union arith_ret *)); blob_type STD_PROTO(Yap_Eval,(Term, union arith_ret *));

8
H/heapgc.h
View File

@ -51,7 +51,7 @@
#define ONHEAP(ptr) (CellPtr(ptr) >= H0 && CellPtr(ptr) < H) #define ONHEAP(ptr) (CellPtr(ptr) >= H0 && CellPtr(ptr) < H)
/* is ptr a pointer to code space? */ /* is ptr a pointer to code space? */
#define ONCODE(ptr) (Addr(ptr) < HeapTop && Addr(ptr) >= _YAP_HeapBase) #define ONCODE(ptr) (Addr(ptr) < HeapTop && Addr(ptr) >= Yap_HeapBase)
/* is val pointing to something bound to the heap? */ /* is val pointing to something bound to the heap? */
@ -138,9 +138,9 @@ typedef CELL *CELL_PTR;
#define ENVSIZE(E) EnvSize(((CELL *)E)[E_CP]) #define ENVSIZE(E) EnvSize(((CELL *)E)[E_CP])
void STD_PROTO(_YAP_mark_variable, (CELL *)); void STD_PROTO(Yap_mark_variable, (CELL *));
void STD_PROTO(_YAP_mark_external_reference, (CELL *)); void STD_PROTO(Yap_mark_external_reference, (CELL *));
void STD_PROTO(_YAP_inc_mark_variable, (void)); void STD_PROTO(Yap_inc_mark_variable, (void));

4
H/iopreds.h
View File

@ -103,11 +103,11 @@ StreamDesc;
#define ALIASES_BLOCK_SIZE 8 #define ALIASES_BLOCK_SIZE 8
void STD_PROTO (_YAP_InitStdStreams, (void)); void STD_PROTO (Yap_InitStdStreams, (void));
EXTERN inline int EXTERN inline int
GetCurInpPos (void) GetCurInpPos (void)
{ {
return (Stream[_YAP_c_input_stream].linecount); return (Stream[Yap_c_input_stream].linecount);
} }

70
H/rheap.h
View File

@ -39,37 +39,37 @@ restore_codes(void)
{ {
heap_regs->heap_top = AddrAdjust(OldHeapTop); heap_regs->heap_top = AddrAdjust(OldHeapTop);
#ifdef YAPOR #ifdef YAPOR
heap_regs->getworkfirsttimecode.opc = _YAP_opcode(_getwork_first_time); heap_regs->getworkfirsttimecode.opc = Yap_opcode(_getwork_first_time);
heap_regs->getworkcode.opc = _YAP_opcode(_getwork); heap_regs->getworkcode.opc = Yap_opcode(_getwork);
INIT_YAMOP_LTT(&(heap_regs->getworkcode), 0); INIT_YAMOP_LTT(&(heap_regs->getworkcode), 0);
heap_regs->getworkcode_seq.opc = _YAP_opcode(_getwork_seq); heap_regs->getworkcode_seq.opc = Yap_opcode(_getwork_seq);
INIT_YAMOP_LTT(&(heap_regs->getworkcode_seq), 0); INIT_YAMOP_LTT(&(heap_regs->getworkcode_seq), 0);
#endif /* YAPOR */ #endif /* YAPOR */
#ifdef TABLING #ifdef TABLING
heap_regs->tablecompletioncode.opc = _YAP_opcode(_table_completion); heap_regs->tablecompletioncode.opc = Yap_opcode(_table_completion);
heap_regs->tableanswerresolutioncode.opc = _YAP_opcode(_table_answer_resolution); heap_regs->tableanswerresolutioncode.opc = Yap_opcode(_table_answer_resolution);
#ifdef YAPOR #ifdef YAPOR
INIT_YAMOP_LTT(&(heap_regs->tablecompletioncode), 0); INIT_YAMOP_LTT(&(heap_regs->tablecompletioncode), 0);
INIT_YAMOP_LTT(&(heap_regs->tableanswerresolutioncode), 0); INIT_YAMOP_LTT(&(heap_regs->tableanswerresolutioncode), 0);
#endif /* YAPOR */ #endif /* YAPOR */
#endif /* TABLING */ #endif /* TABLING */
heap_regs->failcode = _YAP_opcode(_op_fail); heap_regs->failcode = Yap_opcode(_op_fail);
heap_regs->failcode_1 = _YAP_opcode(_op_fail); heap_regs->failcode_1 = Yap_opcode(_op_fail);
heap_regs->failcode_2 = _YAP_opcode(_op_fail); heap_regs->failcode_2 = Yap_opcode(_op_fail);
heap_regs->failcode_3 = _YAP_opcode(_op_fail); heap_regs->failcode_3 = Yap_opcode(_op_fail);
heap_regs->failcode_4 = _YAP_opcode(_op_fail); heap_regs->failcode_4 = Yap_opcode(_op_fail);
heap_regs->failcode_5 = _YAP_opcode(_op_fail); heap_regs->failcode_5 = Yap_opcode(_op_fail);
heap_regs->failcode_6 = _YAP_opcode(_op_fail); heap_regs->failcode_6 = Yap_opcode(_op_fail);
heap_regs->env_for_trustfail_code.op = _YAP_opcode(_call); heap_regs->env_for_trustfail_code.op = Yap_opcode(_call);
heap_regs->trustfailcode = _YAP_opcode(_trust_fail); heap_regs->trustfailcode = Yap_opcode(_trust_fail);
heap_regs->env_for_yes_code.op = _YAP_opcode(_call); heap_regs->env_for_yes_code.op = Yap_opcode(_call);
heap_regs->yescode.opc = _YAP_opcode(_Ystop); heap_regs->yescode.opc = Yap_opcode(_Ystop);
heap_regs->undef_op = _YAP_opcode(_undef_p); heap_regs->undef_op = Yap_opcode(_undef_p);
heap_regs->index_op = _YAP_opcode(_index_pred); heap_regs->index_op = Yap_opcode(_index_pred);
heap_regs->fail_op = _YAP_opcode(_op_fail); heap_regs->fail_op = Yap_opcode(_op_fail);
heap_regs->nocode.opc = _YAP_opcode(_Nstop); heap_regs->nocode.opc = Yap_opcode(_Nstop);
#ifdef YAPOR #ifdef YAPOR
INIT_YAMOP_LTT(&(heap_regs->nocode), 1); INIT_YAMOP_LTT(&(heap_regs->nocode), 1);
#endif /* YAPOR */ #endif /* YAPOR */
@ -77,7 +77,7 @@ restore_codes(void)
#ifdef YAPOR #ifdef YAPOR
INIT_YAMOP_LTT(&(heap_regs->rtrycode), 1); INIT_YAMOP_LTT(&(heap_regs->rtrycode), 1);
#endif /* YAPOR */ #endif /* YAPOR */
((yamop *)(&heap_regs->rtrycode))->opc = _YAP_opcode(_retry_and_mark); ((yamop *)(&heap_regs->rtrycode))->opc = Yap_opcode(_retry_and_mark);
if (((yamop *)(&heap_regs->rtrycode))->u.ld.d != NIL) if (((yamop *)(&heap_regs->rtrycode))->u.ld.d != NIL)
((yamop *)(&heap_regs->rtrycode))->u.ld.d = ((yamop *)(&heap_regs->rtrycode))->u.ld.d =
CodeAddrAdjust(((yamop *)(&heap_regs->rtrycode))->u.ld.d); CodeAddrAdjust(((yamop *)(&heap_regs->rtrycode))->u.ld.d);
@ -490,7 +490,7 @@ RestoreDBEntry(DBRef dbr)
if (dbr->Flags & DBWithRefs) { if (dbr->Flags & DBWithRefs) {
DBRef *cp; DBRef *cp;
DBRef tm; DBRef tm;
cp = (DBRef *) ((CODEADDR) dbr + _YAP_SizeOfBlock(CodePtr(dbr))); cp = (DBRef *) ((CODEADDR) dbr + Yap_SizeOfBlock(CodePtr(dbr)));
while ((tm = *--cp) != 0) while ((tm = *--cp) != 0)
*cp = DBRefAdjust(tm); *cp = DBRefAdjust(tm);
} }
@ -588,8 +588,8 @@ RestoreClause(Clause *Cl, int mode)
/* Get the stored operator */ /* Get the stored operator */
pc = Cl->ClCode; pc = Cl->ClCode;
do { do {
op_numbers op = _YAP_op_from_opcode(pc->opc); op_numbers op = Yap_op_from_opcode(pc->opc);
pc->opc = _YAP_opcode(op); pc->opc = Yap_opcode(op);
#ifdef DEBUG_RESTORE2 #ifdef DEBUG_RESTORE2
YP_fprintf(errout, "%s\n", op_names[op]); YP_fprintf(errout, "%s\n", op_names[op]);
#endif #endif
@ -868,7 +868,7 @@ RestoreClause(Clause *Cl, int mode)
case _save_pair_x: case _save_pair_x:
case _save_appl_x_write: case _save_appl_x_write:
case _save_appl_x: case _save_appl_x:
pc->u.ox.opcw = _YAP_opcode(_YAP_op_from_opcode(pc->u.ox.opcw)); pc->u.ox.opcw = Yap_opcode(Yap_op_from_opcode(pc->u.ox.opcw));
pc->u.ox.x = XAdjust(pc->u.ox.x); pc->u.ox.x = XAdjust(pc->u.ox.x);
pc = NEXTOP(pc,ox); pc = NEXTOP(pc,ox);
break; break;
@ -877,7 +877,7 @@ RestoreClause(Clause *Cl, int mode)
case _unify_x_var2_write: case _unify_x_var2_write:
case _unify_l_x_var2: case _unify_l_x_var2:
case _unify_l_x_var2_write: case _unify_l_x_var2_write:
pc->u.oxx.opcw = _YAP_opcode(_YAP_op_from_opcode(pc->u.oxx.opcw)); pc->u.oxx.opcw = Yap_opcode(Yap_op_from_opcode(pc->u.oxx.opcw));
pc->u.oxx.xl = XAdjust(pc->u.oxx.xl); pc->u.oxx.xl = XAdjust(pc->u.oxx.xl);
pc->u.oxx.xr = XAdjust(pc->u.oxx.xr); pc->u.oxx.xr = XAdjust(pc->u.oxx.xr);
pc = NEXTOP(pc,oxx); pc = NEXTOP(pc,oxx);
@ -899,7 +899,7 @@ RestoreClause(Clause *Cl, int mode)
case _save_pair_y: case _save_pair_y:
case _save_appl_y_write: case _save_appl_y_write:
case _save_appl_y: case _save_appl_y:
pc->u.oy.opcw = _YAP_opcode(_YAP_op_from_opcode(pc->u.oy.opcw)); pc->u.oy.opcw = Yap_opcode(Yap_op_from_opcode(pc->u.oy.opcw));
pc->u.oy.y = YAdjust(pc->u.oy.y); pc->u.oy.y = YAdjust(pc->u.oy.y);
pc = NEXTOP(pc,oy); pc = NEXTOP(pc,oy);
break; break;
@ -912,7 +912,7 @@ RestoreClause(Clause *Cl, int mode)
case _unify_list: case _unify_list:
case _unify_l_list_write: case _unify_l_list_write:
case _unify_l_list: case _unify_l_list:
pc->u.o.opcw = _YAP_opcode(_YAP_op_from_opcode(pc->u.o.opcw)); pc->u.o.opcw = Yap_opcode(Yap_op_from_opcode(pc->u.o.opcw));
pc = NEXTOP(pc,o); pc = NEXTOP(pc,o);
break; break;
/* instructions type os */ /* instructions type os */
@ -920,7 +920,7 @@ RestoreClause(Clause *Cl, int mode)
case _unify_n_voids: case _unify_n_voids:
case _unify_l_n_voids_write: case _unify_l_n_voids_write:
case _unify_l_n_voids: case _unify_l_n_voids:
pc->u.os.opcw = _YAP_opcode(_YAP_op_from_opcode(pc->u.os.opcw)); pc->u.os.opcw = Yap_opcode(Yap_op_from_opcode(pc->u.os.opcw));
pc = NEXTOP(pc,os); pc = NEXTOP(pc,os);
break; break;
/* instructions type oc */ /* instructions type oc */
@ -934,7 +934,7 @@ RestoreClause(Clause *Cl, int mode)
case _unify_l_longint: case _unify_l_longint:
case _unify_bigint: case _unify_bigint:
case _unify_l_bigint: case _unify_l_bigint:
pc->u.oc.opcw = _YAP_opcode(_YAP_op_from_opcode(pc->u.oc.opcw)); pc->u.oc.opcw = Yap_opcode(Yap_op_from_opcode(pc->u.oc.opcw));
{ {
Term t = pc->u.oc.c; Term t = pc->u.oc.c;
if (IsAtomTerm(t)) if (IsAtomTerm(t))
@ -947,7 +947,7 @@ RestoreClause(Clause *Cl, int mode)
/* instructions type osc */ /* instructions type osc */
case _unify_n_atoms_write: case _unify_n_atoms_write:
case _unify_n_atoms: case _unify_n_atoms:
pc->u.osc.opcw = _YAP_opcode(_YAP_op_from_opcode(pc->u.osc.opcw)); pc->u.osc.opcw = Yap_opcode(Yap_op_from_opcode(pc->u.osc.opcw));
{ {
Term t = pc->u.osc.c; Term t = pc->u.osc.c;
if (IsAtomTerm(t)) if (IsAtomTerm(t))
@ -960,7 +960,7 @@ RestoreClause(Clause *Cl, int mode)
case _unify_struct: case _unify_struct:
case _unify_l_struc_write: case _unify_l_struc_write:
case _unify_l_struc: case _unify_l_struc:
pc->u.of.opcw = _YAP_opcode(_YAP_op_from_opcode(pc->u.of.opcw)); pc->u.of.opcw = Yap_opcode(Yap_op_from_opcode(pc->u.of.opcw));
pc->u.of.f = FuncAdjust(pc->u.of.f); pc->u.of.f = FuncAdjust(pc->u.of.f);
pc = NEXTOP(pc,of); pc = NEXTOP(pc,of);
break; break;
@ -1063,7 +1063,7 @@ RestoreClause(Clause *Cl, int mode)
break; break;
/* instructions type ollll */ /* instructions type ollll */
case _switch_list_nl_prefetch: case _switch_list_nl_prefetch:
pc->u.ollll.pop = _YAP_opcode(_YAP_op_from_opcode(pc->u.ollll.pop)); pc->u.ollll.pop = Yap_opcode(Yap_op_from_opcode(pc->u.ollll.pop));
pc->u.ollll.l1 = CodeAddrAdjust(pc->u.ollll.l1); pc->u.ollll.l1 = CodeAddrAdjust(pc->u.ollll.l1);
pc->u.ollll.l2 = CodeAddrAdjust(pc->u.ollll.l2); pc->u.ollll.l2 = CodeAddrAdjust(pc->u.ollll.l2);
pc->u.ollll.l3 = CodeAddrAdjust(pc->u.ollll.l3); pc->u.ollll.l3 = CodeAddrAdjust(pc->u.ollll.l3);
@ -1458,7 +1458,7 @@ CleanCode(PredEntry *pp)
pp->FunctorOfPred = (Functor)AtomAdjust((Atom)(pp->FunctorOfPred)); pp->FunctorOfPred = (Functor)AtomAdjust((Atom)(pp->FunctorOfPred));
if (pp->OwnerFile) if (pp->OwnerFile)
pp->OwnerFile = AtomAdjust(pp->OwnerFile); pp->OwnerFile = AtomAdjust(pp->OwnerFile);
pp->OpcodeOfPred = _YAP_opcode(_YAP_op_from_opcode(pp->OpcodeOfPred)); pp->OpcodeOfPred = Yap_opcode(Yap_op_from_opcode(pp->OpcodeOfPred));
if (pp->PredFlags & CPredFlag) { if (pp->PredFlags & CPredFlag) {
if (pp->PredFlags & BinaryTestPredFlag) { if (pp->PredFlags & BinaryTestPredFlag) {
pp->TrueCodeOfPred = DirectCCodeAdjust(pp,pp->TrueCodeOfPred); pp->TrueCodeOfPred = DirectCCodeAdjust(pp,pp->TrueCodeOfPred);
@ -1619,7 +1619,7 @@ RestoreEntries(PropEntry *pp)
break; break;
default: default:
/* OOPS */ /* OOPS */
_YAP_Error(SYSTEM_ERROR, TermNil, Yap_Error(SYSTEM_ERROR, TermNil,
"Invalid Atom Property %d at %p", pp->KindOfPE, pp); "Invalid Atom Property %d at %p", pp->KindOfPE, pp);
return; return;
} }

4
H/tracer.h
View File

@ -27,10 +27,10 @@ typedef enum {
} yap_low_level_port; } yap_low_level_port;
void STD_PROTO(low_level_trace,(yap_low_level_port, PredEntry *, CELL *)); void STD_PROTO(low_level_trace,(yap_low_level_port, PredEntry *, CELL *));
void STD_PROTO(_YAP_InitLowLevelTrace,(void)); void STD_PROTO(Yap_InitLowLevelTrace,(void));
void STD_PROTO(toggle_low_level_trace,(void)); void STD_PROTO(toggle_low_level_trace,(void));
extern int _YAP_do_low_level_trace; extern int Yap_do_low_level_trace;
#endif #endif

78
H/yapio.h
View File

@ -62,9 +62,9 @@
#endif #endif
#define YP_FILE FILE #define YP_FILE FILE
extern YP_FILE *_YAP_stdin; extern YP_FILE *Yap_stdin;
extern YP_FILE *_YAP_stdout; extern YP_FILE *Yap_stdout;
extern YP_FILE *_YAP_stderr; extern YP_FILE *Yap_stderr;
int STD_PROTO(YP_putc,(int, int)); int STD_PROTO(YP_putc,(int, int));
@ -168,7 +168,7 @@ extern YP_FILE yp_iob[YP_MAX_FILES];
#define YAP_FILENAME_MAX 1024 /* This is ok for Linux, should be ok for everyone */ #define YAP_FILENAME_MAX 1024 /* This is ok for Linux, should be ok for everyone */
#endif #endif
extern char _YAP_FileNameBuf[YAP_FILENAME_MAX], _YAP_FileNameBuf2[YAP_FILENAME_MAX]; extern char Yap_FileNameBuf[YAP_FILENAME_MAX], Yap_FileNameBuf2[YAP_FILENAME_MAX];
typedef YP_FILE *YP_File; typedef YP_FILE *YP_File;
@ -227,14 +227,14 @@ typedef enum{ /* we accept two domains for the moment, IPV6 may follow */
af_unix /* or AF_FILE */ af_unix /* or AF_FILE */
} socket_domain; } socket_domain;
Term STD_PROTO(_YAP_InitSocketStream,(int, socket_info, socket_domain)); Term STD_PROTO(Yap_InitSocketStream,(int, socket_info, socket_domain));
int STD_PROTO(_YAP_CheckSocketStream,(Term, char *)); int STD_PROTO(Yap_CheckSocketStream,(Term, char *));
socket_domain STD_PROTO(_YAP_GetSocketDomain,(int)); socket_domain STD_PROTO(Yap_GetSocketDomain,(int));
socket_info STD_PROTO(_YAP_GetSocketStatus,(int)); socket_info STD_PROTO(Yap_GetSocketStatus,(int));
void STD_PROTO(_YAP_UpdateSocketStream,(int, socket_info, socket_domain)); void STD_PROTO(Yap_UpdateSocketStream,(int, socket_info, socket_domain));
/* routines in ypsocks.c */ /* routines in ypsocks.c */
Int STD_PROTO(_YAP_CloseSocket,(int, socket_info, socket_domain)); Int STD_PROTO(Yap_CloseSocket,(int, socket_info, socket_domain));
#endif /* USE_SOCKET */ #endif /* USE_SOCKET */
@ -246,42 +246,42 @@ typedef struct AliasDescS {
/****************** character definition table **************************/ /****************** character definition table **************************/
#define NUMBER_OF_CHARS 256 #define NUMBER_OF_CHARS 256
extern char *_YAP_chtype; extern char *Yap_chtype;
/*************** variables concerned with parsing *********************/ /*************** variables concerned with parsing *********************/
extern TokEntry *_YAP_tokptr, *_YAP_toktide; extern TokEntry *Yap_tokptr, *Yap_toktide;
extern VarEntry *_YAP_VarTable, *_YAP_AnonVarTable; extern VarEntry *Yap_VarTable, *Yap_AnonVarTable;
extern int _YAP_eot_before_eof; extern int Yap_eot_before_eof;
/* parser stack, used to be AuxSp, now is ASP */ /* parser stack, used to be AuxSp, now is ASP */
#define ParserAuxSp (TR) #define ParserAuxSp (TR)
/* routines in parser.c */ /* routines in parser.c */
VarEntry STD_PROTO(*_YAP_LookupVar,(char *)); VarEntry STD_PROTO(*Yap_LookupVar,(char *));
Term STD_PROTO(_YAP_VarNames,(VarEntry *,Term)); Term STD_PROTO(Yap_VarNames,(VarEntry *,Term));
/* routines ins scanner.c */ /* routines ins scanner.c */
TokEntry STD_PROTO(*_YAP_tokenizer,(int (*)(int), int (*)(int))); TokEntry STD_PROTO(*Yap_tokenizer,(int (*)(int), int (*)(int)));
TokEntry STD_PROTO(*_YAP_fast_tokenizer,(void)); TokEntry STD_PROTO(*Yap_fast_tokenizer,(void));
Term STD_PROTO(_YAP_scan_num,(int (*)(int))); Term STD_PROTO(Yap_scan_num,(int (*)(int)));
char STD_PROTO(*_YAP_AllocScannerMemory,(unsigned int)); char STD_PROTO(*Yap_AllocScannerMemory,(unsigned int));
/* routines in iopreds.c */ /* routines in iopreds.c */
Int STD_PROTO(_YAP_FirstLineInParse,(void)); Int STD_PROTO(Yap_FirstLineInParse,(void));
int STD_PROTO(_YAP_CheckIOStream,(Term, char *)); int STD_PROTO(Yap_CheckIOStream,(Term, char *));
int STD_PROTO(_YAP_GetStreamFd,(int)); int STD_PROTO(Yap_GetStreamFd,(int));
void STD_PROTO(_YAP_CloseStreams,(int)); void STD_PROTO(Yap_CloseStreams,(int));
void STD_PROTO(_YAP_CloseStream,(int)); void STD_PROTO(Yap_CloseStream,(int));
int STD_PROTO(_YAP_PlGetchar,(void)); int STD_PROTO(Yap_PlGetchar,(void));
int STD_PROTO(_YAP_PlFGetchar,(void)); int STD_PROTO(Yap_PlFGetchar,(void));
int STD_PROTO(_YAP_GetCharForSIGINT,(void)); int STD_PROTO(Yap_GetCharForSIGINT,(void));
int STD_PROTO(_YAP_StreamToFileNo,(Term)); int STD_PROTO(Yap_StreamToFileNo,(Term));
Term STD_PROTO(_YAP_OpenStream,(FILE *,char *,Term,int)); Term STD_PROTO(Yap_OpenStream,(FILE *,char *,Term,int));
extern int extern int
_YAP_c_input_stream, Yap_c_input_stream,
_YAP_c_output_stream, Yap_c_output_stream,
_YAP_c_error_stream; Yap_c_error_stream;
#define YAP_INPUT_STREAM 0x01 #define YAP_INPUT_STREAM 0x01
#define YAP_OUTPUT_STREAM 0x02 #define YAP_OUTPUT_STREAM 0x02
@ -299,10 +299,10 @@ extern int
#define Use_portray_f 8 #define Use_portray_f 8
/* write.c */ /* write.c */
void STD_PROTO(_YAP_plwrite,(Term,int (*)(int, int),int)); void STD_PROTO(Yap_plwrite,(Term,int (*)(int, int),int));
/* grow.c */ /* grow.c */
int STD_PROTO(_YAP_growstack_in_parser, (tr_fr_ptr *, TokEntry **, VarEntry **)); int STD_PROTO(Yap_growstack_in_parser, (tr_fr_ptr *, TokEntry **, VarEntry **));
@ -314,7 +314,7 @@ extern int errno;
#if DEBUG #if DEBUG
#if COROUTINING #if COROUTINING
extern int _YAP_Portray_delays; extern int Yap_Portray_delays;
#endif #endif
#endif #endif
@ -325,13 +325,13 @@ extern int _YAP_Portray_delays;
#define CONTINUE_ON_PARSER_ERROR 2 #define CONTINUE_ON_PARSER_ERROR 2
#define EXCEPTION_ON_PARSER_ERROR 3 #define EXCEPTION_ON_PARSER_ERROR 3
extern jmp_buf _YAP_IOBotch; extern jmp_buf Yap_IOBotch;
#ifdef DEBUG #ifdef DEBUG
extern YP_FILE *_YAP_logfile; extern YP_FILE *Yap_logfile;
#endif #endif
#if USE_SOCKET #if USE_SOCKET
extern int _YAP_sockets_io; extern int Yap_sockets_io;
#endif #endif

18
library/mpi/mpe.c
View File

@ -9,14 +9,14 @@
************************************************************************** **************************************************************************
* * * *
* File: mpe.c * * File: mpe.c *
* Last rev: $Date: 2002-11-11 17:38:03 $ * * Last rev: $Date: 2002-11-18 18:16:43 $ *
* mods: * * mods: *
* comments: Interface to an MPE library * * comments: Interface to an MPE library *
* * * *
*************************************************************************/ *************************************************************************/
#ifndef lint #ifndef lint
static char *rcsid = "$Header: /Users/vitor/Yap/yap-cvsbackup/library/mpi/mpe.c,v 1.4 2002-11-11 17:38:03 vsc Exp $"; static char *rcsid = "$Header: /Users/vitor/Yap/yap-cvsbackup/library/mpi/mpe.c,v 1.5 2002-11-18 18:16:43 vsc Exp $";
#endif #endif
#include "Yap.h" #include "Yap.h"
@ -204,14 +204,14 @@ p_log() /* mpe_log(+EventType, +EventNum, +EventStr) */
void void
_YAP_InitMPE(void) Yap_InitMPE(void)
{ {
_YAP_InitCPred( "mpe_open", 0, p_init, SafePredFlag ); Yap_InitCPred( "mpe_open", 0, p_init, SafePredFlag );
_YAP_InitCPred( "mpe_start", 0, p_start, SafePredFlag ); Yap_InitCPred( "mpe_start", 0, p_start, SafePredFlag );
_YAP_InitCPred( "mpe_close", 1, p_close, SafePredFlag ); Yap_InitCPred( "mpe_close", 1, p_close, SafePredFlag );
_YAP_InitCPred( "mpe_create_event", 1, p_create_event, SafePredFlag ); Yap_InitCPred( "mpe_create_event", 1, p_create_event, SafePredFlag );
_YAP_InitCPred( "mpe_create_state", 4, p_create_state, SafePredFlag ); Yap_InitCPred( "mpe_create_state", 4, p_create_state, SafePredFlag );
_YAP_InitCPred( "mpe_log", 3, p_log, SafePredFlag ); Yap_InitCPred( "mpe_log", 3, p_log, SafePredFlag );
} }
#endif /* HAVE_MPE */ #endif /* HAVE_MPE */

138
library/mpi/mpi.c
View File

@ -9,14 +9,14 @@
************************************************************************** **************************************************************************
* * * *
* File: mpi.c * * File: mpi.c *
* Last rev: $Date: 2002-11-12 10:25:11 $ * * Last rev: $Date: 2002-11-18 18:16:51 $ *
* mods: * * mods: *
* comments: Interface to an MPI library * * comments: Interface to an MPI library *
* * * *
*************************************************************************/ *************************************************************************/
#ifndef lint #ifndef lint
static char *rcsid = "$Header: /Users/vitor/Yap/yap-cvsbackup/library/mpi/mpi.c,v 1.15 2002-11-12 10:25:11 stasinos Exp $"; static char *rcsid = "$Header: /Users/vitor/Yap/yap-cvsbackup/library/mpi/mpi.c,v 1.16 2002-11-18 18:16:51 vsc Exp $";
#endif #endif
#include "Yap.h" #include "Yap.h"
@ -82,8 +82,8 @@ expand_buffer( int space )
tmp = malloc( bufsize + space ); tmp = malloc( bufsize + space );
if( tmp == NULL ) { if( tmp == NULL ) {
_YAP_Error(SYSTEM_ERROR, TermNil, "out of memory" ); Yap_Error(SYSTEM_ERROR, TermNil, "out of memory" );
_YAP_exit( EXIT_FAILURE ); Yap_exit( EXIT_FAILURE );
} }
memcpy( tmp, buf, bufsize ); memcpy( tmp, buf, bufsize );
#if 0 #if 0
@ -100,8 +100,8 @@ expand_buffer( int space )
printf("realloc'ed space..."); printf("realloc'ed space...");
#endif #endif
if( buf == NULL ) { if( buf == NULL ) {
_YAP_Error(SYSTEM_ERROR, TermNil, "out of memory"); Yap_Error(SYSTEM_ERROR, TermNil, "out of memory");
_YAP_exit( EXIT_FAILURE ); Yap_exit( EXIT_FAILURE );
} }
#endif #endif
@ -158,43 +158,43 @@ mpi_parse(void)
CELL *old_H; CELL *old_H;
/* Scans the term using stack space */ /* Scans the term using stack space */
_YAP_eot_before_eof = FALSE; Yap_eot_before_eof = FALSE;
/* the first arg is the getc_for_read, diff only if CharConv is on */ /* the first arg is the getc_for_read, diff only if CharConv is on */
tokstart = _YAP_tokptr = _YAP_toktide = _YAP_tokenizer(mpi_getc, mpi_getc); tokstart = Yap_tokptr = Yap_toktide = Yap_tokenizer(mpi_getc, mpi_getc);
/* preserve value of H after scanning: otherwise we may lose strings /* preserve value of H after scanning: otherwise we may lose strings
and floats */ and floats */
old_H = H; old_H = H;
if ( mpi_eob() && !_YAP_eot_before_eof) { if ( mpi_eob() && !Yap_eot_before_eof) {
if (tokstart != NIL && tokstart->Tok != Ord (eot_tok)) { if (tokstart != NIL && tokstart->Tok != Ord (eot_tok)) {
/* we got the end of file from an abort */ /* we got the end of file from an abort */
if (_YAP_ErrorMessage == "Abort") { if (Yap_ErrorMessage == "Abort") {
TR = old_TR; TR = old_TR;
return TermNil; return TermNil;
} }
/* we need to force the next reading to also give end of file.*/ /* we need to force the next reading to also give end of file.*/
buf[bufptr] = EOF; buf[bufptr] = EOF;
_YAP_ErrorMessage = "[ Error: end of file found before end of term ]"; Yap_ErrorMessage = "[ Error: end of file found before end of term ]";
} else { } else {
/* restore TR */ /* restore TR */
TR = old_TR; TR = old_TR;
return (_YAP_unify_constant(t, MkAtomTerm(AtomEof))); return (Yap_unify_constant(t, MkAtomTerm(AtomEof)));
} }
} }
repeat_cycle: repeat_cycle:
TR_before_parse = TR; TR_before_parse = TR;
if( _YAP_ErrorMessage || (t = _YAP_Parse())==0 ) { if( Yap_ErrorMessage || (t = Yap_Parse())==0 ) {
if (_YAP_ErrorMessage && (strcmp(_YAP_ErrorMessage,"Stack Overflow") == 0)) { if (Yap_ErrorMessage && (strcmp(Yap_ErrorMessage,"Stack Overflow") == 0)) {
/* ignore term we just built */ /* ignore term we just built */
TR = TR_before_parse; TR = TR_before_parse;
H = old_H; H = old_H;
if (_YAP_growstack_in_parser(&old_TR, &tokstart, &_YAP_VarTable)) { if (Yap_growstack_in_parser(&old_TR, &tokstart, &Yap_VarTable)) {
old_H = H; old_H = H;
_YAP_tokptr = _YAP_toktide = tokstart; Yap_tokptr = Yap_toktide = tokstart;
_YAP_ErrorMessage = NULL; Yap_ErrorMessage = NULL;
goto repeat_cycle; goto repeat_cycle;
} }
} }
@ -206,8 +206,8 @@ mpi_parse(void)
failing the predicate: the parse cannot fail unless there failing the predicate: the parse cannot fail unless there
is a problem with MPI or the pretty printer. is a problem with MPI or the pretty printer.
*/ */
_YAP_Error(SYSTEM_ERROR, TermNil, "Failed to parse MPI_Recv()'ed term" ); Yap_Error(SYSTEM_ERROR, TermNil, "Failed to parse MPI_Recv()'ed term" );
_YAP_exit( EXIT_FAILURE ); Yap_exit( EXIT_FAILURE );
} else { } else {
/* parsing succeeded */ /* parsing succeeded */
@ -257,7 +257,7 @@ Yap exit(FAILURE), whereas in Yap/LAM mpi_open/3 simply fails.
Term t; Term t;
t = MkIntegerTerm(retv); t = MkIntegerTerm(retv);
_YAP_Error( SYSTEM_ERROR, t, "MPI_Init() returned non-zero" ); Yap_Error( SYSTEM_ERROR, t, "MPI_Init() returned non-zero" );
return FALSE; return FALSE;
} }
#endif #endif
@ -265,9 +265,9 @@ Yap exit(FAILURE), whereas in Yap/LAM mpi_open/3 simply fails.
MPI_Comm_rank( MPI_COMM_WORLD, &rank ); MPI_Comm_rank( MPI_COMM_WORLD, &rank );
MPI_Get_processor_name( processor_name, &namelen ); MPI_Get_processor_name( processor_name, &namelen );
retv = _YAP_unify(t_rank, MkIntTerm(rank)); retv = Yap_unify(t_rank, MkIntTerm(rank));
retv = retv && _YAP_unify(t_numprocs, MkIntTerm(numprocs)); retv = retv && Yap_unify(t_numprocs, MkIntTerm(numprocs));
retv = retv && _YAP_unify(t_procname, MkAtomTerm(_YAP_LookupAtom(processor_name))); retv = retv && Yap_unify(t_procname, MkAtomTerm(Yap_LookupAtom(processor_name)));
return retv; return retv;
} }
@ -289,25 +289,25 @@ p_mpi_send() /* mpi_send(+data, +destination, +tag) */
/* The first argument (data) must be bound */ /* The first argument (data) must be bound */
if (IsVarTerm(t_data)) { if (IsVarTerm(t_data)) {
_YAP_Error(INSTANTIATION_ERROR, t_data, "mpi_send"); Yap_Error(INSTANTIATION_ERROR, t_data, "mpi_send");
return (FALSE); return (FALSE);
} }
/* The second and third args must be bount to integers */ /* The second and third args must be bount to integers */
if (IsVarTerm(t_dest)) { if (IsVarTerm(t_dest)) {
_YAP_Error(INSTANTIATION_ERROR, t_dest, "mpi_send"); Yap_Error(INSTANTIATION_ERROR, t_dest, "mpi_send");
return (FALSE); return (FALSE);
} else if( !IsIntegerTerm(t_dest) ) { } else if( !IsIntegerTerm(t_dest) ) {
_YAP_Error(TYPE_ERROR_INTEGER, t_dest, "mpi_send"); Yap_Error(TYPE_ERROR_INTEGER, t_dest, "mpi_send");
return (FALSE); return (FALSE);
} else { } else {
dest = IntOfTerm( t_dest ); dest = IntOfTerm( t_dest );
} }
if (IsVarTerm(t_tag)) { if (IsVarTerm(t_tag)) {
_YAP_Error(INSTANTIATION_ERROR, t_tag, "mpi_send"); Yap_Error(INSTANTIATION_ERROR, t_tag, "mpi_send");
return (FALSE); return (FALSE);
} else if( !IsIntegerTerm(t_tag) ) { } else if( !IsIntegerTerm(t_tag) ) {
_YAP_Error(TYPE_ERROR_INTEGER, t_tag, "mpi_send"); Yap_Error(TYPE_ERROR_INTEGER, t_tag, "mpi_send");
return (FALSE); return (FALSE);
} else { } else {
tag = IntOfTerm( t_tag ); tag = IntOfTerm( t_tag );
@ -315,7 +315,7 @@ p_mpi_send() /* mpi_send(+data, +destination, +tag) */
bufptr = 0; bufptr = 0;
/* Turn the term into its ASCII representation */ /* Turn the term into its ASCII representation */
_YAP_plwrite( t_data, mpi_putc, 5 ); Yap_plwrite( t_data, mpi_putc, 5 );
bufstrlen = (size_t)bufptr; bufstrlen = (size_t)bufptr;
/* The buf is not NULL-terminated and does not have the /* The buf is not NULL-terminated and does not have the
@ -363,7 +363,7 @@ p_mpi_receive() /* mpi_receive(-data, ?orig, ?tag) */
/* The first argument (data) must be unbound */ /* The first argument (data) must be unbound */
if(!IsVarTerm(t_data)) { if(!IsVarTerm(t_data)) {
_YAP_Error(INSTANTIATION_ERROR, t_data, "mpi_receive"); Yap_Error(INSTANTIATION_ERROR, t_data, "mpi_receive");
return FALSE; return FALSE;
} }
@ -373,7 +373,7 @@ p_mpi_receive() /* mpi_receive(-data, ?orig, ?tag) */
if (IsVarTerm(t_orig)) { if (IsVarTerm(t_orig)) {
orig = MPI_ANY_SOURCE; orig = MPI_ANY_SOURCE;
} else if( !IsIntegerTerm(t_orig) ) { } else if( !IsIntegerTerm(t_orig) ) {
_YAP_Error(TYPE_ERROR_INTEGER, t_orig, "mpi_receive"); Yap_Error(TYPE_ERROR_INTEGER, t_orig, "mpi_receive");
return (FALSE); return (FALSE);
} else { } else {
orig = IntOfTerm( t_orig ); orig = IntOfTerm( t_orig );
@ -384,7 +384,7 @@ p_mpi_receive() /* mpi_receive(-data, ?orig, ?tag) */
if (IsVarTerm(t_tag)) { if (IsVarTerm(t_tag)) {
tag = MPI_ANY_TAG; tag = MPI_ANY_TAG;
} else if( !IsIntegerTerm(t_tag) ) { } else if( !IsIntegerTerm(t_tag) ) {
_YAP_Error(TYPE_ERROR_INTEGER, t_tag, "mpi_receive"); Yap_Error(TYPE_ERROR_INTEGER, t_tag, "mpi_receive");
return (FALSE); return (FALSE);
} else } else
tag = IntOfTerm( t_tag ); tag = IntOfTerm( t_tag );
@ -412,7 +412,7 @@ p_mpi_receive() /* mpi_receive(-data, ?orig, ?tag) */
/* Already know the source from MPI_Probe() */ /* Already know the source from MPI_Probe() */
if( orig == MPI_ANY_SOURCE ) { if( orig == MPI_ANY_SOURCE ) {
orig = status.MPI_SOURCE; orig = status.MPI_SOURCE;
retv = _YAP_unify(t_orig, MkIntTerm(orig)); retv = Yap_unify(t_orig, MkIntTerm(orig));
if( retv == FALSE ) { if( retv == FALSE ) {
printf("PROBLEM: file %s, line %d\n", __FILE__, __LINE__); printf("PROBLEM: file %s, line %d\n", __FILE__, __LINE__);
} }
@ -421,7 +421,7 @@ p_mpi_receive() /* mpi_receive(-data, ?orig, ?tag) */
/* Already know the tag from MPI_Probe() */ /* Already know the tag from MPI_Probe() */
if( tag == MPI_ANY_TAG ) { if( tag == MPI_ANY_TAG ) {
tag = status.MPI_TAG; tag = status.MPI_TAG;
retv = _YAP_unify(t_tag, MkIntTerm(status.MPI_TAG)); retv = Yap_unify(t_tag, MkIntTerm(status.MPI_TAG));
if( retv == FALSE ) { if( retv == FALSE ) {
printf("PROBLEM: file %s, line %d\n", __FILE__, __LINE__); printf("PROBLEM: file %s, line %d\n", __FILE__, __LINE__);
} }
@ -451,13 +451,13 @@ p_mpi_receive() /* mpi_receive(-data, ?orig, ?tag) */
/* parse received string into a Prolog term */ /* parse received string into a Prolog term */
bufptr = 0; bufptr = 0;
retv = _YAP_unify(ARG1, mpi_parse()); retv = Yap_unify(ARG1, mpi_parse());
#if 0 #if 0
/* check up on mpi_parse(): /* check up on mpi_parse():
convert the newly-parsed term back to text and print */ convert the newly-parsed term back to text and print */
bufptr = 0; bufptr = 0;
_YAP_plwrite( t_data, mpi_putc, 5 ); Yap_plwrite( t_data, mpi_putc, 5 );
mpi_putc( 0, '.' ); mpi_putc( 0, '.' );
mpi_putc( 0, ' ' ); mpi_putc( 0, ' ' );
buf[bufptr] = 0; buf[bufptr] = 0;
@ -484,7 +484,7 @@ p_mpi_bcast3() /* mpi_bcast( ?data, +root, +max_size ) */
/* The second argument must be bound to an integer (the rank of /* The second argument must be bound to an integer (the rank of
root processor */ root processor */
if (IsVarTerm(t_root)) { if (IsVarTerm(t_root)) {
_YAP_Error(INSTANTIATION_ERROR, t_root, "mpi_bcast"); Yap_Error(INSTANTIATION_ERROR, t_root, "mpi_bcast");
return FALSE; return FALSE;
} }
root = IntOfTerm( t_root ); root = IntOfTerm( t_root );
@ -493,12 +493,12 @@ p_mpi_bcast3() /* mpi_bcast( ?data, +root, +max_size ) */
be bound to the term to be sent. */ be bound to the term to be sent. */
if( root == rank ) { if( root == rank ) {
if( IsVarTerm(t_data) ) { if( IsVarTerm(t_data) ) {
_YAP_Error(INSTANTIATION_ERROR, t_data, "mpi_bcast"); Yap_Error(INSTANTIATION_ERROR, t_data, "mpi_bcast");
return FALSE; return FALSE;
} }
bufptr = 0; bufptr = 0;
/* Turn the term into its ASCII representation */ /* Turn the term into its ASCII representation */
_YAP_plwrite( t_data, mpi_putc, 5 ); Yap_plwrite( t_data, mpi_putc, 5 );
/* NULL-terminate the string and add the ". " termination /* NULL-terminate the string and add the ". " termination
required by the parser. */ required by the parser. */
buf[bufptr] = 0; buf[bufptr] = 0;
@ -509,7 +509,7 @@ p_mpi_bcast3() /* mpi_bcast( ?data, +root, +max_size ) */
/* The third argument must be bound to an integer (the maximum length /* The third argument must be bound to an integer (the maximum length
of the broadcast term's ASCII representation */ of the broadcast term's ASCII representation */
if (IsVarTerm(t_max_size)) { if (IsVarTerm(t_max_size)) {
_YAP_Error(INSTANTIATION_ERROR, t_max_size, "mpi_bcast"); Yap_Error(INSTANTIATION_ERROR, t_max_size, "mpi_bcast");
return FALSE; return FALSE;
} }
/* allow for the ". " bit and the NULL at the end */ /* allow for the ". " bit and the NULL at the end */
@ -543,7 +543,7 @@ p_mpi_bcast3() /* mpi_bcast( ?data, +root, +max_size ) */
else { else {
/* ARG1 must be unbound so that it can receive data */ /* ARG1 must be unbound so that it can receive data */
if( !IsVarTerm(t_data) ) { if( !IsVarTerm(t_data) ) {
_YAP_Error(INSTANTIATION_ERROR, t_data, "mpi_bcast"); Yap_Error(INSTANTIATION_ERROR, t_data, "mpi_bcast");
return FALSE; return FALSE;
} }
@ -551,7 +551,7 @@ p_mpi_bcast3() /* mpi_bcast( ?data, +root, +max_size ) */
bufptr = 0; bufptr = 0;
/* parse received string into a Prolog term */ /* parse received string into a Prolog term */
return _YAP_unify(mpi_parse(), ARG1); return Yap_unify(mpi_parse(), ARG1);
} }
} }
@ -570,7 +570,7 @@ p_mpi_bcast2() /* mpi_bcast( ?data, +root ) */
/* The second argument must be bound to an integer (the rank of /* The second argument must be bound to an integer (the rank of
root processor */ root processor */
if (IsVarTerm(t_root)) { if (IsVarTerm(t_root)) {
_YAP_Error(INSTANTIATION_ERROR, t_root, "mpi_bcast"); Yap_Error(INSTANTIATION_ERROR, t_root, "mpi_bcast");
return FALSE; return FALSE;
} }
root = IntOfTerm( t_root ); root = IntOfTerm( t_root );
@ -580,12 +580,12 @@ p_mpi_bcast2() /* mpi_bcast( ?data, +root ) */
be bound to the term to be sent. */ be bound to the term to be sent. */
if( root == rank ) { if( root == rank ) {
if( IsVarTerm(t_data) ) { if( IsVarTerm(t_data) ) {
_YAP_Error(INSTANTIATION_ERROR, t_data, "mpi_bcast"); Yap_Error(INSTANTIATION_ERROR, t_data, "mpi_bcast");
return FALSE; return FALSE;
} }
bufptr = 0; bufptr = 0;
/* Turn the term into its ASCII representation */ /* Turn the term into its ASCII representation */
_YAP_plwrite( t_data, mpi_putc, 5 ); Yap_plwrite( t_data, mpi_putc, 5 );
/* NULL-terminate the string and add the ". " termination /* NULL-terminate the string and add the ". " termination
required by the parser. */ required by the parser. */
buf[bufptr] = 0; buf[bufptr] = 0;
@ -595,7 +595,7 @@ p_mpi_bcast2() /* mpi_bcast( ?data, +root ) */
/* Otherwise, it must a variable */ /* Otherwise, it must a variable */
else { else {
if( !IsVarTerm(t_data) ) { if( !IsVarTerm(t_data) ) {
_YAP_Error(INSTANTIATION_ERROR, t_data, "mpi_bcast"); Yap_Error(INSTANTIATION_ERROR, t_data, "mpi_bcast");
return FALSE; return FALSE;
} }
} }
@ -631,7 +631,7 @@ p_mpi_bcast2() /* mpi_bcast( ?data, +root ) */
else { else {
/* ARG1 must be unbound so that it can receive data */ /* ARG1 must be unbound so that it can receive data */
if( !IsVarTerm(t_data) ) { if( !IsVarTerm(t_data) ) {
_YAP_Error(INSTANTIATION_ERROR, t_data, "mpi_bcast"); Yap_Error(INSTANTIATION_ERROR, t_data, "mpi_bcast");
return FALSE; return FALSE;
} }
@ -639,7 +639,7 @@ p_mpi_bcast2() /* mpi_bcast( ?data, +root ) */
bufptr = 0; bufptr = 0;
/* parse received string into a Prolog term */ /* parse received string into a Prolog term */
return _YAP_unify(ARG1, mpi_parse()); return Yap_unify(ARG1, mpi_parse());
} }
} }
@ -662,31 +662,31 @@ p_mpi_barrier() /* mpi_barrier/0 */
void void
_YAP_InitMPI(void) Yap_InitMPI(void)
{ {
int i,j; int i,j;
mpi_argv = malloc( _YAP_argc * sizeof(char *) ); mpi_argv = malloc( Yap_argc * sizeof(char *) );
mpi_argv[0] = strdup( _YAP_argv[0] ); mpi_argv[0] = strdup( Yap_argv[0] );
bufsize = RECV_BUF_SIZE; bufsize = RECV_BUF_SIZE;
buf = malloc(bufsize * sizeof(char)); buf = malloc(bufsize * sizeof(char));
for( i=1; i<_YAP_argc; ++i ) { for( i=1; i<Yap_argc; ++i ) {
if( !strcmp(_YAP_argv[i], "--") ) { ++i; break; } if( !strcmp(Yap_argv[i], "--") ) { ++i; break; }
} }
for( j=1; i<_YAP_argc; ++i, ++j ) { for( j=1; i<Yap_argc; ++i, ++j ) {
mpi_argv[j] = strdup( _YAP_argv[i] ); mpi_argv[j] = strdup( Yap_argv[i] );
} }
mpi_argc = j; mpi_argc = j;
mpi_argv[0] = strdup( _YAP_argv[0] ); mpi_argv[0] = strdup( Yap_argv[0] );
#if 0 #if 0
/* DEBUG */ /* DEBUG */
printf( "_YAP_argc = %d\n", _YAP_argc ); printf( "Yap_argc = %d\n", Yap_argc );
for( i=0; i<_YAP_argc; ++i ) { for( i=0; i<Yap_argc; ++i ) {
printf( "%d %s\n", i, _YAP_argv[i] ); printf( "%d %s\n", i, Yap_argv[i] );
} }
#endif #endif
@ -698,7 +698,7 @@ _YAP_InitMPI(void)
} }
#endif #endif
/* With MPICH MPI__YAP_Init() must be called during initialisation, /* With MPICH MPI_Yap_Init() must be called during initialisation,
but with LAM it can be called from Prolog (mpi_open/3). but with LAM it can be called from Prolog (mpi_open/3).
See also the comment at "if ! HAVE_LIBMPICH" above! See also the comment at "if ! HAVE_LIBMPICH" above!
*/ */
@ -711,8 +711,8 @@ _YAP_InitMPI(void)
Term t; Term t;
t = MkIntegerTerm(retv); t = MkIntegerTerm(retv);
_YAP_Error(SYSTEM_ERROR, t, "MPI_Init() returned non-zero"); Yap_Error(SYSTEM_ERROR, t, "MPI_Init() returned non-zero");
_YAP_exit( EXIT_FAILURE ); Yap_exit( EXIT_FAILURE );
} }
#if 0 #if 0
/* DEBUG */ /* DEBUG */
@ -723,13 +723,13 @@ _YAP_InitMPI(void)
} }
#endif #endif
_YAP_InitCPred( "mpi_open", 3, p_mpi_open, SyncPredFlag ); Yap_InitCPred( "mpi_open", 3, p_mpi_open, SyncPredFlag );
_YAP_InitCPred( "mpi_close", 0, p_mpi_close, SafePredFlag|SyncPredFlag ); Yap_InitCPred( "mpi_close", 0, p_mpi_close, SafePredFlag|SyncPredFlag );
_YAP_InitCPred( "mpi_send", 3, p_mpi_send, SafePredFlag|SyncPredFlag ); Yap_InitCPred( "mpi_send", 3, p_mpi_send, SafePredFlag|SyncPredFlag );
_YAP_InitCPred( "mpi_receive", 3, p_mpi_receive, SyncPredFlag ); Yap_InitCPred( "mpi_receive", 3, p_mpi_receive, SyncPredFlag );
_YAP_InitCPred( "mpi_bcast", 3, p_mpi_bcast3, SyncPredFlag ); Yap_InitCPred( "mpi_bcast", 3, p_mpi_bcast3, SyncPredFlag );
_YAP_InitCPred( "mpi_bcast", 2, p_mpi_bcast2, SyncPredFlag ); Yap_InitCPred( "mpi_bcast", 2, p_mpi_bcast2, SyncPredFlag );
_YAP_InitCPred( "mpi_barrier", 0, p_mpi_barrier, SyncPredFlag ); Yap_InitCPred( "mpi_barrier", 0, p_mpi_barrier, SyncPredFlag );
} }
#endif /* HAVE_MPI */ #endif /* HAVE_MPI */

14
m4/TermExt.h.m4
View File

@ -10,7 +10,7 @@
* File: TermExt.h * * File: TermExt.h *
* mods: * * mods: *
* comments: Extensions to standard terms for YAP * * comments: Extensions to standard terms for YAP *
* version: $Id: TermExt.h.m4,v 1.7 2002-11-11 17:38:07 vsc Exp $ * * version: $Id: TermExt.h.m4,v 1.8 2002-11-18 18:17:04 vsc Exp $ *
*************************************************************************/ *************************************************************************/
#if USE_OFFSETS #if USE_OFFSETS
@ -162,11 +162,11 @@ Inline(IsLongIntTerm, int, Term, t, IsApplTerm(t) && FunctorOfTerm(t) == Functor
#include <gmp.h> #include <gmp.h>
MP_INT *STD_PROTO(_YAP_PreAllocBigNum,(void)); MP_INT *STD_PROTO(Yap_PreAllocBigNum,(void));
MP_INT *STD_PROTO(_YAP_InitBigNum,(Int)); MP_INT *STD_PROTO(Yap_InitBigNum,(Int));
Term STD_PROTO(_YAP_MkBigIntTerm, (MP_INT *)); Term STD_PROTO(Yap_MkBigIntTerm, (MP_INT *));
MP_INT *STD_PROTO(_YAP_BigIntOfTerm, (Term)); MP_INT *STD_PROTO(Yap_BigIntOfTerm, (Term));
void STD_PROTO(_YAP_CleanBigNum,(void)); void STD_PROTO(Yap_CleanBigNum,(void));
Inline(IsBigIntTerm, int, Term, t, IsApplTerm(t) && FunctorOfTerm(t) == FunctorBigInt) Inline(IsBigIntTerm, int, Term, t, IsApplTerm(t) && FunctorOfTerm(t) == FunctorBigInt)
@ -222,7 +222,7 @@ unify_extension(Functor f, CELL d0, CELL *pt0, CELL d1)
return(pt0[1] == RepAppl(d1)[1]); return(pt0[1] == RepAppl(d1)[1]);
#ifdef USE_GMP #ifdef USE_GMP
case big_int_e: case big_int_e:
return (mpz_cmp(_YAP_BigIntOfTerm(d0),_YAP_BigIntOfTerm(d1)) == 0); return (mpz_cmp(Yap_BigIntOfTerm(d0),Yap_BigIntOfTerm(d1)) == 0);
#endif /* USE_GMP */ #endif /* USE_GMP */
case double_e: case double_e:
{ {

86
m4/Yap.h.m4
View File

@ -10,7 +10,7 @@
* File: Yap.h.m4 * * File: Yap.h.m4 *
* mods: * * mods: *
* comments: main header file for YAP * * comments: main header file for YAP *
* version: $Id: Yap.h.m4,v 1.36 2002-11-11 17:38:08 vsc Exp $ * * version: $Id: Yap.h.m4,v 1.37 2002-11-18 18:17:13 vsc Exp $ *
*************************************************************************/ *************************************************************************/
#include "config.h" #include "config.h"
@ -222,19 +222,19 @@
#ifdef USE_GMP #ifdef USE_GMP
#ifdef __GNUC__ #ifdef __GNUC__
typedef long long int SIGNED_YAP_LONG_LONG; typedef long long int SIGNEDYap_LONG_LONG;
typedef unsigned long long int YAP_LONG_LONG; typedef unsigned long long int YAP_LONG_LONG;
#else #else
typedef long int SIGNED_YAP_LONG_LONG; typedef long int SIGNEDYap_LONG_LONG;
typedef unsigned long int YAP_LONG_LONG; typedef unsigned long int YAP_LONG_LONG;
#endif #endif
#else #else
typedef long int SIGNED_YAP_LONG_LONG; typedef long int SIGNEDYap_LONG_LONG;
typedef unsigned long int YAP_LONG_LONG; typedef unsigned long int YAP_LONG_LONG;
#endif #endif
#if DEBUG #if DEBUG
extern char _YAP_Option[20]; extern char Yap_Option[20];
#endif #endif
/* #define FORCE_SECOND_QUADRANT 1 */ /* #define FORCE_SECOND_QUADRANT 1 */
@ -268,8 +268,8 @@ extern char _YAP_Option[20];
#define HEAP_INIT_BASE (MMAP_ADDR) #define HEAP_INIT_BASE (MMAP_ADDR)
#define AtomBase ((char *)MMAP_ADDR) #define AtomBase ((char *)MMAP_ADDR)
#else #else
#define HEAP_INIT_BASE ((CELL)_YAP_HeapBase) #define HEAP_INIT_BASE ((CELL)Yap_HeapBase)
#define AtomBase (_YAP_HeapBase) #define AtomBase (Yap_HeapBase)
#endif #endif
@ -393,7 +393,7 @@ typedef volatile int lockvar;
#define siglongjmp(Env, Arg) longjmp(Env, Arg) #define siglongjmp(Env, Arg) longjmp(Env, Arg)
#endif #endif
extern sigjmp_buf _YAP_RestartEnv; /* used to restart after an abort */ extern sigjmp_buf Yap_RestartEnv; /* used to restart after an abort */
/* Support for arrays */ /* Support for arrays */
#include "arrays.h" #include "arrays.h"
@ -485,9 +485,9 @@ typedef enum {
UNKNOWN_ERROR UNKNOWN_ERROR
} yap_error_number; } yap_error_number;
extern char *_YAP_ErrorMessage; /* used to pass error messages */ extern char *Yap_ErrorMessage; /* used to pass error messages */
extern Term _YAP_Error_Term; /* used to pass error terms */ extern Term Yap_Error_Term; /* used to pass error terms */
extern yap_error_number _YAP_Error_TYPE; /* used to pass the error */ extern yap_error_number Yap_Error_TYPE; /* used to pass the error */
typedef enum { typedef enum {
YAP_INT_BOUNDED_FLAG = 0, YAP_INT_BOUNDED_FLAG = 0,
@ -641,11 +641,11 @@ and RefOfTerm(t) : Term -> DBRef = ...
/************* variables related to memory allocation *******************/ /************* variables related to memory allocation *******************/
/* must be before TermExt.h */ /* must be before TermExt.h */
extern ADDR _YAP_HeapBase, extern ADDR Yap_HeapBase,
_YAP_LocalBase, Yap_LocalBase,
_YAP_GlobalBase, Yap_GlobalBase,
_YAP_TrailBase, Yap_TrailBase,
_YAP_TrailTop; Yap_TrailTop;
/* applies to unbound variables */ /* applies to unbound variables */
@ -776,7 +776,7 @@ typedef struct opcode_tab_entry {
/******************* storing error messages ****************************/ /******************* storing error messages ****************************/
#define MAX_ERROR_MSG_SIZE 256 #define MAX_ERROR_MSG_SIZE 256
extern char _YAP_ErrorSay[MAX_ERROR_MSG_SIZE]; extern char Yap_ErrorSay[MAX_ERROR_MSG_SIZE];
/********************* how to write a Prolog term ***********************/ /********************* how to write a Prolog term ***********************/
@ -793,13 +793,13 @@ typedef enum {
ExtendStackMode = 128 /* trying to extend stack */ ExtendStackMode = 128 /* trying to extend stack */
} prolog_exec_mode; } prolog_exec_mode;
extern prolog_exec_mode _YAP_PrologMode; extern prolog_exec_mode Yap_PrologMode;
extern int _YAP_CritLocks; extern int Yap_CritLocks;
/************** Access to yap initial arguments ***************************/ /************** Access to yap initial arguments ***************************/
extern char **_YAP_argv; extern char **Yap_argv;
extern int _YAP_argc; extern int Yap_argc;
/******************* number of modules ****************************/ /******************* number of modules ****************************/
@ -812,21 +812,21 @@ extern int _YAP_argc;
LOCK(GLOBAL_LOCKS_heap_access); \ LOCK(GLOBAL_LOCKS_heap_access); \
GLOBAL_LOCKS_who_locked_heap = worker_id; \ GLOBAL_LOCKS_who_locked_heap = worker_id; \
} \ } \
_YAP_PrologMode |= CritMode; \ Yap_PrologMode |= CritMode; \
_YAP_CritLocks++; \ Yap_CritLocks++; \
} }
#define YAPLeaveCriticalSection() \ #define YAPLeaveCriticalSection() \
{ \ { \
_YAP_CritLocks--; \ Yap_CritLocks--; \
if (!_YAP_CritLocks) { \ if (!Yap_CritLocks) { \
_YAP_PrologMode &= ~CritMode; \ Yap_PrologMode &= ~CritMode; \
if (_YAP_PrologMode & InterruptMode) { \ if (Yap_PrologMode & InterruptMode) { \
_YAP_PrologMode &= ~InterruptMode; \ Yap_PrologMode &= ~InterruptMode; \
_YAP_ProcessSIGINT(); \ Yap_ProcessSIGINT(); \
} \ } \
if (_YAP_PrologMode & AbortMode) { \ if (Yap_PrologMode & AbortMode) { \
_YAP_PrologMode &= ~AbortMode; \ Yap_PrologMode &= ~AbortMode; \
_YAP_Error(PURE_ABORT, 0, ""); \ Yap_Error(PURE_ABORT, 0, ""); \
} \ } \
GLOBAL_LOCKS_who_locked_heap = MAX_WORKERS; \ GLOBAL_LOCKS_who_locked_heap = MAX_WORKERS; \
UNLOCK(GLOBAL_LOCKS_heap_access); \ UNLOCK(GLOBAL_LOCKS_heap_access); \
@ -835,21 +835,21 @@ extern int _YAP_argc;
#else #else
#define YAPEnterCriticalSection() \ #define YAPEnterCriticalSection() \
{ \ { \
_YAP_PrologMode |= CritMode; \ Yap_PrologMode |= CritMode; \
_YAP_CritLocks++; \ Yap_CritLocks++; \
} }
#define YAPLeaveCriticalSection() \ #define YAPLeaveCriticalSection() \
{ \ { \
_YAP_CritLocks--; \ Yap_CritLocks--; \
if (!_YAP_CritLocks) { \ if (!Yap_CritLocks) { \
_YAP_PrologMode &= ~CritMode; \ Yap_PrologMode &= ~CritMode; \
if (_YAP_PrologMode & InterruptMode) { \ if (Yap_PrologMode & InterruptMode) { \
_YAP_PrologMode &= ~InterruptMode; \ Yap_PrologMode &= ~InterruptMode; \
_YAP_ProcessSIGINT(); \ Yap_ProcessSIGINT(); \
} \ } \
if (_YAP_PrologMode & AbortMode) { \ if (Yap_PrologMode & AbortMode) { \
_YAP_PrologMode &= ~AbortMode; \ Yap_PrologMode &= ~AbortMode; \
_YAP_Error(PURE_ABORT, 0, ""); \ Yap_Error(PURE_ABORT, 0, ""); \
} \ } \
} \ } \
} }

32
m4/Yatom.h.m4
View File

@ -248,8 +248,8 @@ typedef struct {
CmpPredicate f; CmpPredicate f;
} cmp_entry; } cmp_entry;
extern CPredicate _YAP_c_predicates[MAX_C_PREDS]; extern CPredicate Yap_c_predicates[MAX_C_PREDS];
extern cmp_entry _YAP_cmp_funcs[MAX_CMP_FUNCS]; extern cmp_entry Yap_cmp_funcs[MAX_CMP_FUNCS];
/* Flags for code or dbase entry */ /* Flags for code or dbase entry */
@ -487,23 +487,23 @@ Inline(IsArrayProperty, PropFlags, int, flags, (flags == ArrayProperty) )
/* Proto types */ /* Proto types */
/* cdmgr.c */ /* cdmgr.c */
int STD_PROTO(_YAP_RemoveIndexation,(PredEntry *)); int STD_PROTO(Yap_RemoveIndexation,(PredEntry *));
/* dbase.c */ /* dbase.c */
void STD_PROTO(_YAP_ErDBE,(DBRef)); void STD_PROTO(Yap_ErDBE,(DBRef));
DBRef STD_PROTO(_YAP_StoreTermInDB,(int,int)); DBRef STD_PROTO(Yap_StoreTermInDB,(int,int));
Term STD_PROTO(_YAP_FetchTermFromDB,(DBRef,int)); Term STD_PROTO(Yap_FetchTermFromDB,(DBRef,int));
void STD_PROTO(_YAP_ReleaseTermFromDB,(DBRef)); void STD_PROTO(Yap_ReleaseTermFromDB,(DBRef));
/* .c */ /* .c */
CODEADDR STD_PROTO(_YAP_PredIsIndexable,(PredEntry *)); CODEADDR STD_PROTO(Yap_PredIsIndexable,(PredEntry *));
/* init.c */ /* init.c */
Atom STD_PROTO(_YAP_GetOp,(OpEntry *,int *,int)); Atom STD_PROTO(Yap_GetOp,(OpEntry *,int *,int));
/* vsc: redefined to GetAProp to avoid conflicts with Windows header files */ /* vsc: redefined to GetAProp to avoid conflicts with Windows header files */
Prop STD_PROTO(_YAP_GetAProp,(Atom,PropFlags)); Prop STD_PROTO(Yap_GetAProp,(Atom,PropFlags));
Prop STD_PROTO(_YAP_GetAPropHavingLock,(AtomEntry *,PropFlags)); Prop STD_PROTO(Yap_GetAPropHavingLock,(AtomEntry *,PropFlags));
EXTERN inline Prop EXTERN inline Prop
PredPropByFunc(Functor f, SMALLUNSGN cur_mod) PredPropByFunc(Functor f, SMALLUNSGN cur_mod)
@ -523,7 +523,7 @@ PredPropByFunc(Functor f, SMALLUNSGN cur_mod)
} }
p0 = p->NextOfPE; p0 = p->NextOfPE;
} }
return(_YAP_NewPredPropByFunctor(fe,cur_mod)); return(Yap_NewPredPropByFunctor(fe,cur_mod));
} }
EXTERN inline Prop EXTERN inline Prop
@ -544,12 +544,12 @@ PredPropByAtom(Atom at, SMALLUNSGN cur_mod)
} }
p0 = pe->NextOfPE; p0 = pe->NextOfPE;
} }
return(_YAP_NewPredPropByAtom(ae,cur_mod)); return(Yap_NewPredPropByAtom(ae,cur_mod));
} }
ADDR STD_PROTO(_YAP_PreAllocCodeSpace, (void)); ADDR STD_PROTO(Yap_PreAllocCodeSpace, (void));
#if defined(YAPOR) || defined(THREADS) #if defined(YAPOR) || defined(THREADS)
void STD_PROTO(_YAP_ReleasePreAllocCodeSpace, (ADDR)); void STD_PROTO(Yap_ReleasePreAllocCodeSpace, (ADDR));
#else #else
#define _YAP_ReleasePreAllocCodeSpace(x) #define Yap_ReleasePreAllocCodeSpace(x)
#endif #endif

8
m4/sshift.h.m4
View File

@ -33,7 +33,7 @@ extern ADDR OldHeapBase, OldHeapTop;
#define CharP(ptr) ((char *) (ptr)) #define CharP(ptr) ((char *) (ptr))
Inline(IsHeapP, int, CELL *, ptr, (ptr >= (CELL *)_YAP_HeapBase && ptr <= (CELL *)HeapTop) ) Inline(IsHeapP, int, CELL *, ptr, (ptr >= (CELL *)Yap_HeapBase && ptr <= (CELL *)HeapTop) )
/* Adjusting cells and pointers to cells */ /* Adjusting cells and pointers to cells */
Inline(PtoGloAdjust, CELL *, CELL *, ptr, ((CELL *)(CharP(ptr) + GDiff)) ) Inline(PtoGloAdjust, CELL *, CELL *, ptr, ((CELL *)(CharP(ptr) + GDiff)) )
@ -108,7 +108,7 @@ Inline(IsOldTrail, int, CELL, reg, IN_BETWEEN(OldTrailBase, reg, OldTR) )
Inline(IsOldTrailPtr, int, CELL *, ptr, IN_BETWEEN(OldTrailBase, ptr, OldTR) ) Inline(IsOldTrailPtr, int, CELL *, ptr, IN_BETWEEN(OldTrailBase, ptr, OldTR) )
Inline(IsOldCode, int, CELL, reg, IN_BETWEEN(OldHeapBase, reg, OldHeapTop) ) Inline(IsOldCode, int, CELL, reg, IN_BETWEEN(OldHeapBase, reg, OldHeapTop) )
Inline(IsOldCodeCellPtr, int, CELL *, ptr, IN_BETWEEN(OldHeapBase, ptr, OldHeapTop) ) Inline(IsOldCodeCellPtr, int, CELL *, ptr, IN_BETWEEN(OldHeapBase, ptr, OldHeapTop) )
Inline(IsGlobal, int, CELL, reg, IN_BETWEEN(_YAP_GlobalBase, reg, H) ) Inline(IsGlobal, int, CELL, reg, IN_BETWEEN(Yap_GlobalBase, reg, H) )
void STD_PROTO(_YAP_AdjustStacksAndTrail, (void)); void STD_PROTO(Yap_AdjustStacksAndTrail, (void));
void STD_PROTO(_YAP_AdjustRegs, (int)); void STD_PROTO(Yap_AdjustRegs, (int));