new module system. BEWARE! BEWARE! BEWARE!

git-svn-id: https://yap.svn.sf.net/svnroot/yap/trunk@177 b08c6af1-5177-4d33-ba66-4b1c6b8b522a
2001-11-15 00:01:43 +00:00
parent a628251951
commit b289d9ac9c
57 changed files with 1859 additions and 2163 deletions
--- a/C/absmi.c
+++ b/C/absmi.c
@@ -1789,7 +1789,7 @@ absmi(int inp)
    NoStackComitY:
      /* find something to fool S */
      if (CFREG == Unsigned(LCL0) && ReadTimedVar(WokenGoals) != TermNil) {
-	SREG = (CELL *)RepPredProp(GetPredProp(AtomRestoreRegs,2));
+	SREG = (CELL *)RepPredProp(GetPredPropByFunc(MkFunctor(AtomRestoreRegs,2),0));
 	PREG = NEXTOP(PREG,x);
 	XREGS[0] = XREG(PREG->u.y.y);
 	goto creep_either;
@@ -1801,7 +1801,7 @@ absmi(int inp)
    NoStackComitX:
      /* find something to fool S */
      if (CFREG == Unsigned(LCL0) && ReadTimedVar(WokenGoals) != TermNil) {
-	SREG = (CELL *)RepPredProp(GetPredProp(AtomRestoreRegs,2));
+	SREG = (CELL *)RepPredProp(GetPredPropByFunc(MkFunctor(AtomRestoreRegs,2),0));
 	PREG = NEXTOP(PREG,x);
 #if USE_THREADED_CODE
 	if (PREG->opc == (OPCODE)OpAddress[_fcall])
@@ -1827,7 +1827,7 @@ absmi(int inp)
      /* don't forget I cannot creep at ; */
    NoStackEither:
      /* find something to fool S */
-      SREG = (CELL *)RepPredProp(GetPredProp(AtomRestoreRegs,1));
+      SREG = (CELL *)RepPredProp(GetPredPropByFunc(MkFunctor(AtomRestoreRegs,1),0));
 #ifdef YAPOR
      /* abort_optyap("NoStackCall in function absmi"); */
      if (HeapTop > GlobalBase - MinHeapGap)
@@ -5948,7 +5948,7 @@ absmi(int inp)

 	at = FullLookupAtom("$undefp");
 	{
-	  Prop p = GetPredProp (at, 1);
+	  Prop p = GetPredPropByFunc(MkFunctor(at, 1),0);
 	  if (p == NIL) {
 	    CFREG = CalculateStackGap();
 	    FAIL();
@@ -9557,7 +9557,7 @@ absmi(int inp)
      Op(p_dif, e);
 #ifdef LOW_LEVEL_TRACER
      if (do_low_level_trace)
-	low_level_trace(enter_pred,RepPredProp(GetPredProp(LookupAtom("\\="),2)),XREGS+1);
+	low_level_trace(enter_pred,RepPredProp(GetPredPropByFunc(MkFunctor(LookupAtom("\\="),2),0)),XREGS+1);
 #endif	/* LOW_LEVEL_TRACE */
      BEGD(d0);
      BEGD(d1);
@@ -9651,7 +9651,7 @@ absmi(int inp)
      Op(p_eq, e);
 #ifdef LOW_LEVEL_TRACER
      if (do_low_level_trace)
-	low_level_trace(enter_pred,RepPredProp(GetPredProp(LookupAtom("=="),2)),XREGS+1);
+	low_level_trace(enter_pred,RepPredProp(GetPredPropByFunc(MkFunctor(LookupAtom("=="),2),0)),XREGS+1);
 #endif	/* LOW_LEVEL_TRACE */
      BEGD(d0);
      BEGD(d1);
@@ -9775,7 +9775,7 @@ absmi(int inp)
 	H[0] = XREG(PREG->u.xxx.x1);
 	H[1] = XREG(PREG->u.xxx.x2);
 	RESET_VARIABLE(H+2);
-	low_level_trace(enter_pred,RepPredProp(GetPredProp(LookupAtom("arg"),3)),H);
+	low_level_trace(enter_pred,RepPredProp(GetPredPropByFunc(MkFunctor(LookupAtom("arg"),3),0)),H);
      }
 #endif	/* LOW_LEVEL_TRACE */
      BEGD(d0);
@@ -9864,7 +9864,7 @@ absmi(int inp)
 	H[0] =  t;
 	H[1] = XREG(PREG->u.xxc.xi);
 	RESET_VARIABLE(H+2);
-	low_level_trace(enter_pred,RepPredProp(GetPredProp(LookupAtom("arg"),3)),H);
+	low_level_trace(enter_pred,RepPredProp(GetPredPropByFunc(MkFunctor(LookupAtom("arg"),3),0)),H);
 	H = Ho;
      }
 #endif	/* LOW_LEVEL_TRACE */
@@ -9935,7 +9935,7 @@ absmi(int inp)
 	H[0] = XREG(PREG->u.yxx.x1);
 	H[1] = XREG(PREG->u.yxx.x2);
 	RESET_VARIABLE(H+2);
-	low_level_trace(enter_pred,RepPredProp(GetPredProp(LookupAtom("arg"),3)),H);
+	low_level_trace(enter_pred,RepPredProp(GetPredPropByFunc(MkFunctor(LookupAtom("arg"),3),0)),H);
      }
 #endif	/* LOW_LEVEL_TRACE */
      BEGD(d0);
@@ -10038,7 +10038,7 @@ absmi(int inp)
 	H[0] =  t;
 	H[1] = XREG(PREG->u.yxc.xi);
 	RESET_VARIABLE(H+2);
-	low_level_trace(enter_pred,RepPredProp(GetPredProp(LookupAtom("arg"),3)),H);
+	low_level_trace(enter_pred,RepPredProp(GetPredPropByFunc(MkFunctor(LookupAtom("arg"),3),0)),H);
 	H = Ho;
      }
 #endif	/* LOW_LEVEL_TRACE */
@@ -10125,7 +10125,7 @@ absmi(int inp)
 	RESET_VARIABLE(H);
 	H[1] = XREG(PREG->u.xxx.x1);
 	H[2] = XREG(PREG->u.xxx.x2);
-	low_level_trace(enter_pred,RepPredProp(GetPredProp(LookupAtom("functor"),3)),H);
+	low_level_trace(enter_pred,RepPredProp(GetPredPropByFunc(MkFunctor(LookupAtom("functor"),3),0)),H);
      }
 #endif	/* LOW_LEVEL_TRACE */
      /* We have to build the structure */
@@ -10230,7 +10230,7 @@ absmi(int inp)
 	RESET_VARIABLE(H);
 	H[1] = XREG(PREG->u.xcx.c);
 	H[2] = XREG(PREG->u.xcx.xi);
-	low_level_trace(enter_pred,RepPredProp(GetPredProp(LookupAtom("functor"),3)),H);
+	low_level_trace(enter_pred,RepPredProp(GetPredPropByFunc(MkFunctor(LookupAtom("functor"),3),0)),H);
      }
 #endif	/* LOW_LEVEL_TRACE */
      BEGD(d0);
@@ -10325,7 +10325,7 @@ absmi(int inp)
 	RESET_VARIABLE(H);
 	H[1] = XREG(PREG->u.xxc.xi);
 	H[2] = ti;
-	low_level_trace(enter_pred,RepPredProp(GetPredProp(LookupAtom("functor"),3)),H);
+	low_level_trace(enter_pred,RepPredProp(GetPredPropByFunc(MkFunctor(LookupAtom("functor"),3),0)),H);
 	H = hi;
      }
 #endif	/* LOW_LEVEL_TRACE */
@@ -10410,7 +10410,7 @@ absmi(int inp)
 	RESET_VARIABLE(H);
 	H[1] = XREG(PREG->u.yxx.x1);
 	H[2] = XREG(PREG->u.yxx.x2);
-	low_level_trace(enter_pred,RepPredProp(GetPredProp(LookupAtom("functor"),3)),H);
+	low_level_trace(enter_pred,RepPredProp(GetPredPropByFunc(MkFunctor(LookupAtom("functor"),3),0)),H);
      }
 #endif	/* LOW_LEVEL_TRACE */
      /* We have to build the structure */
@@ -10533,7 +10533,7 @@ absmi(int inp)
 	RESET_VARIABLE(H);
 	H[1] = XREG(PREG->u.ycx.c);
 	H[2] = XREG(PREG->u.ycx.xi);
-	low_level_trace(enter_pred,RepPredProp(GetPredProp(LookupAtom("functor"),3)),H);
+	low_level_trace(enter_pred,RepPredProp(GetPredPropByFunc(MkFunctor(LookupAtom("functor"),3),0)),H);
      }
 #endif	/* LOW_LEVEL_TRACE */
      /* We have to build the structure */
@@ -10650,7 +10650,7 @@ absmi(int inp)
 	RESET_VARIABLE(H);
 	H[1] = XREG(PREG->u.yxc.xi);
 	H[2] = ti;
-	low_level_trace(enter_pred,RepPredProp(GetPredProp(LookupAtom("functor"),3)),H);
+	low_level_trace(enter_pred,RepPredProp(GetPredPropByFunc(MkFunctor(LookupAtom("functor"),3),0)),H);
 	H = hi;
      }
 #endif	/* LOW_LEVEL_TRACE */
@@ -10758,7 +10758,7 @@ absmi(int inp)
 	H[0] = XREG(PREG->u.xxx.x);
 	RESET_VARIABLE(H+1);
 	RESET_VARIABLE(H+2);
-	low_level_trace(enter_pred,RepPredProp(GetPredProp(LookupAtom("functor"),3)),H);
+	low_level_trace(enter_pred,RepPredProp(GetPredPropByFunc(MkFunctor(LookupAtom("functor"),3),0)),H);
      }
 #endif	/* LOW_LEVEL_TRACE */
      BEGD(d0);
@@ -10804,7 +10804,7 @@ absmi(int inp)
 	H[0] = XREG(PREG->u.xyx.x);
 	RESET_VARIABLE(H+1);
 	RESET_VARIABLE(H+2);
-	low_level_trace(enter_pred,RepPredProp(GetPredProp(LookupAtom("functor"),3)),H);
+	low_level_trace(enter_pred,RepPredProp(GetPredPropByFunc(MkFunctor(LookupAtom("functor"),3),0)),H);
      }
 #endif	/* LOW_LEVEL_TRACE */
      BEGD(d0);
@@ -10853,7 +10853,7 @@ absmi(int inp)
 	H[0] = XREG(PREG->u.yxx.x2);
 	RESET_VARIABLE(H+1);
 	RESET_VARIABLE(H+2);
-	low_level_trace(enter_pred,RepPredProp(GetPredProp(LookupAtom("functor"),3)),H);
+	low_level_trace(enter_pred,RepPredProp(GetPredPropByFunc(MkFunctor(LookupAtom("functor"),3),0)),H);
      }
 #endif	/* LOW_LEVEL_TRACE */
      BEGD(d0);
@@ -10902,7 +10902,7 @@ absmi(int inp)
 	H[0] = XREG(PREG->u.yyx.x);
 	RESET_VARIABLE(H+1);
 	RESET_VARIABLE(H+2);
-	low_level_trace(enter_pred,RepPredProp(GetPredProp(LookupAtom("functor"),3)),H);
+	low_level_trace(enter_pred,RepPredProp(GetPredPropByFunc(MkFunctor(LookupAtom("functor"),3),0)),H);
      }
 #endif	/* LOW_LEVEL_TRACE */
      BEGD(d0);
@@ -10951,7 +10951,7 @@ absmi(int inp)
      Op(p_functor, e);
 #ifdef LOW_LEVEL_TRACER
      if (do_low_level_trace)
-	low_level_trace(enter_pred,RepPredProp(GetPredProp(LookupAtom("functor"),3)),XREGS+1);
+	low_level_trace(enter_pred,RepPredProp(GetPredPropByFunc(MkFunctor(LookupAtom("functor"),3),0)),XREGS+1);
 #endif	/* LOW_LEVEL_TRACE */
      restart_functor:
      BEGD(d0);
@@ -11135,24 +11135,33 @@ absmi(int inp)
      BOp(p_execute, sla);
      { 
 	PredEntry *pen;
+	int mod = IntOfTerm(ARG2);

 	CACHE_Y_AS_ENV(Y);
 	BEGD(d0);
 	d0 = ARG1;
 	if (PredGoalExpansion->OpcodeOfPred != UNDEF_OPCODE) {
-	  d0 = ExecuteCallMetaCall();
+	  d0 = ExecuteCallMetaCall(mod);
 	}
 	deref_head(d0, execute_unk);
      execute_nvar:
 	if (IsApplTerm(d0)) {
 	  Functor f = FunctorOfTerm(d0);
 	  if (IsExtensionFunctor(f)) {
-	    d0 = ExecuteCallMetaCall();
+	    d0 = ExecuteCallMetaCall(mod);
 	    goto execute_nvar;
 	  }
-	  pen = RepPredProp(PredPropByFunc(f, ARG2));
+	  pen = RepPredProp(PredPropByFunc(f, mod));
 	  if (pen->PredFlags & MetaPredFlag) {
-	    d0 = ExecuteCallMetaCall();
+	    if (f == FunctorModule) {
+	      Term tmod = LookupModule(ArgOfTerm(1,d0));
+	      if (!IsVarTerm(tmod) && IsAtomTerm(tmod)) {
+		mod = LookupModule(tmod);
+		d0 = ArgOfTerm(2,d0);
+		goto execute_nvar;
+	      }
+	    }
+	    d0 = ExecuteCallMetaCall(mod);
 	    goto execute_nvar;
 	  }
 	  BEGP(pt1);
@@ -11174,9 +11183,9 @@ absmi(int inp)
 	  ENDP(pt1);
 	  CACHE_A1();
 	} else if (IsAtomTerm(d0)) {
-	  pen = RepPredProp(PredPropByAtom(AtomOfTerm(d0), ARG2));
+	  pen = RepPredProp(PredPropByAtom(AtomOfTerm(d0), mod));
 	} else {
-	  d0 = ExecuteCallMetaCall();
+	  d0 = ExecuteCallMetaCall(mod);
 	  goto execute_nvar;
 	}

@@ -11230,7 +11239,7 @@ absmi(int inp)

 	BEGP(pt1);
 	deref_body(d0, pt1, execute_unk, execute_nvar);
-	d0 = ExecuteCallMetaCall();
+	d0 = ExecuteCallMetaCall(mod);
 	goto execute_nvar;
 	ENDP(pt1);
 	ENDD(d0);
@@ -11248,24 +11257,34 @@ absmi(int inp)
      BOp(p_execute_within, sla);
      { 
 	PredEntry *pen;
+	int mod = CurrentModule;

 	CACHE_Y_AS_ENV(Y);
 	BEGD(d0);
 	d0 = ARG1;
 	if (PredGoalExpansion->OpcodeOfPred != UNDEF_OPCODE) {
-	  d0 = ExecuteCallMetaCall();
+	  d0 = ExecuteCallMetaCall(mod);
 	}
 	deref_head(d0, execute_within_unk);
      execute_within_nvar:
 	if (IsApplTerm(d0)) {
 	  Functor f = FunctorOfTerm(d0);
 	  if (IsExtensionFunctor(f)) {
-	    d0 = ExecuteCallMetaCall();
+	    d0 = ExecuteCallMetaCall(mod);
 	    goto execute_within_nvar;
 	  }
-	  pen = RepPredProp(PredPropByFunc(f, *CurrentModulePtr));
+	  pen = RepPredProp(PredPropByFunc(f, mod));
 	  if (pen->PredFlags & MetaPredFlag) {
-	    d0 = ExecuteCallMetaCall();
+	    if (f == FunctorModule) {
+	      Term tmod;
+	      tmod = ArgOfTerm(1,d0);
+	      if (!IsVarTerm(tmod) && IsAtomTerm(tmod)) {
+		mod = LookupModule(tmod);
+		d0 = ArgOfTerm(2,d0);
+		goto execute_within_nvar;
+	      }
+	    }
+	    d0 = ExecuteCallMetaCall(mod);
 	    goto execute_within_nvar;
 	  }
 	  BEGP(pt1);
@@ -11310,9 +11329,9 @@ absmi(int inp)
 	    PREG = NEXTOP(PREG, sla);
 	    JMPNext();
 	  }else
-	    pen = RepPredProp(PredPropByAtom(AtomOfTerm(d0), *CurrentModulePtr));
+	    pen = RepPredProp(PredPropByAtom(AtomOfTerm(d0), mod));
 	} else {
-	  d0 = ExecuteCallMetaCall();
+	  d0 = ExecuteCallMetaCall(mod);
 	  goto execute_within_nvar;
 	}

@@ -11366,7 +11385,7 @@ absmi(int inp)

 	BEGP(pt1);
 	deref_body(d0, pt1, execute_within_unk, execute_within_nvar);
-	d0 = ExecuteCallMetaCall();
+	d0 = ExecuteCallMetaCall(mod);
 	goto execute_within_nvar;
 	ENDP(pt1);
 	ENDD(d0);
@@ -11383,24 +11402,33 @@ absmi(int inp)
      BOp(p_last_execute_within, sla);
      { 
 	PredEntry *pen;
+	int mod = CurrentModule;

 	CACHE_Y_AS_ENV(Y);
 	BEGD(d0);
 	d0 = ARG1;
 	if (PredGoalExpansion->OpcodeOfPred != UNDEF_OPCODE) {
-	  d0 = ExecuteCallMetaCall();
+	  d0 = ExecuteCallMetaCall(mod);
 	}
 	deref_head(d0, last_execute_within_unk);
      last_execute_within_nvar:
 	if (IsApplTerm(d0)) {
 	  Functor f = FunctorOfTerm(d0);
 	  if (IsExtensionFunctor(f)) {
-	    d0 = ExecuteCallMetaCall();
+	    d0 = ExecuteCallMetaCall(mod);
 	    goto last_execute_within_nvar;
 	  }
-	  pen = RepPredProp(PredPropByFunc(f, *CurrentModulePtr));
+	  pen = RepPredProp(PredPropByFunc(f, mod));
 	  if (pen->PredFlags & MetaPredFlag) {
-	    d0 = ExecuteCallMetaCall();
+	    if (f == FunctorModule) {
+	      Term tmod = ArgOfTerm(1,d0);
+	      if (!IsVarTerm(tmod) && IsAtomTerm(tmod)) {
+		mod = LookupModule(tmod);
+		d0 = ArgOfTerm(2,d0);
+		goto last_execute_within_nvar;
+	      }
+	    }
+	    d0 = ExecuteCallMetaCall(mod);
 	    goto last_execute_within_nvar;
 	  }
 	  BEGP(pt1);
@@ -11445,9 +11473,9 @@ absmi(int inp)
 	    PREG = NEXTOP(PREG, sla);
 	    JMPNext();
 	  }else
-	    pen = RepPredProp(PredPropByAtom(AtomOfTerm(d0), *CurrentModulePtr));
+	    pen = RepPredProp(PredPropByAtom(AtomOfTerm(d0), mod));
 	} else {
-	  d0 = ExecuteCallMetaCall();
+	  d0 = ExecuteCallMetaCall(mod);
 	  goto last_execute_within_nvar;
 	}

@@ -11489,7 +11517,7 @@ absmi(int inp)

 	BEGP(pt1);
 	deref_body(d0, pt1, last_execute_within_unk, last_execute_within_nvar);
-	d0 = ExecuteCallMetaCall();
+	d0 = ExecuteCallMetaCall(mod);
 	goto last_execute_within_nvar;
 	ENDP(pt1);
 	ENDD(d0);
--- a/C/adtdefs.c
+++ b/C/adtdefs.c
@@ -22,8 +22,8 @@ static char SccsId[] = "%W% %G%";
 #define ADTDEFS_C

 #include "Yap.h"
-Prop	STD_PROTO(PredPropByFunc,(Functor, Term));
-Prop	STD_PROTO(PredPropByAtom,(Atom, Term));
+Prop	STD_PROTO(PredPropByFunc,(Functor, SMALLUNSGN));
+Prop	STD_PROTO(PredPropByAtom,(Atom, SMALLUNSGN));
 #include "Yatom.h"
 #include "Heap.h"
 #include "yapio.h"
@@ -263,22 +263,7 @@ GetAProp(Atom a, PropFlags kind)
 }

 inline static Prop
-UnlockedFunctorGetPredProp(Functor f, Term cur_mod)
-     /* get predicate entry for ap/arity;               */
-{
-  Prop p0;
-  FunctorEntry *fe = (FunctorEntry *)f;
-  PredEntry *p;
-
-  p = RepPredProp(p0 = fe->PropsOfFE);
-  while (p0 && (/* p->KindOfPE != PEProp || only preds in here */
-		(p->ModuleOfPred != cur_mod  && p->ModuleOfPred)))
-    p = RepPredProp(p0 = p->NextOfPE);
-  return (p0);
-}
-
-inline static Prop
-GetPredPropByAtomHavingLock(AtomEntry* ae, Term cur_mod)
+GetPredPropByAtomHavingLock(AtomEntry* ae, int cur_mod)
 /* get predicate entry for ap/arity; create it if neccessary.              */
 {
  Prop p0;
@@ -296,7 +281,7 @@ GetPredPropByAtomHavingLock(AtomEntry* ae, Term cur_mod)
 }

 Prop
-GetPredPropByAtom(Atom at, Term cur_mod)
+GetPredPropByAtom(Atom at, int cur_mod)
 /* get predicate entry for ap/arity; create it if neccessary.              */
 {
  Prop p0;
@@ -309,39 +294,39 @@ GetPredPropByAtom(Atom at, Term cur_mod)
 }


-Prop
-GetPredProp(Atom ap, unsigned int arity)
-     /* get predicate entry for ap/arity;               */
+static inline Prop
+GetPredPropByFuncHavingLock(Functor f, SMALLUNSGN cur_mod)
+/* get predicate entry for ap/arity; create it if neccessary.              */
 {
  Prop p0;
-  AtomEntry *ae = RepAtom(ap);
-  Functor f;
+  FunctorEntry *fe = (FunctorEntry *)f;

-  if (arity == 0)
-    return(GetPredPropByAtom(ap, *CurrentModulePtr));
-  WRITE_LOCK(ae->ARWLock);
-  f = InlinedUnlockedMkFunctor(ae, arity);
-  WRITE_UNLOCK(ae->ARWLock);
-  READ_LOCK(f->FRWLock);
-  p0 = UnlockedFunctorGetPredProp(f, *CurrentModulePtr);
-  READ_UNLOCK(f->FRWLock);
-  return (p0);
+  p0 = fe->PropsOfFE;
+  while (p0) {
+    PredEntry *p = RepPredProp(p0);
+    if (/* p->KindOfPE != 0 || only props */
+	(p->ModuleOfPred == cur_mod || !(p->ModuleOfPred))) {
+      return (p0);
+    }
+    p0 = p->NextOfPE;
+  }
+  return(NIL);
 }

 Prop
-GetPredPropByFunc(Functor f, Term t)
+GetPredPropByFunc(Functor f, int cur_mod)
     /* get predicate entry for ap/arity;               */
 {
  Prop p0;

  READ_LOCK(f->FRWLock);
-  p0 = UnlockedFunctorGetPredProp(f, t);
+  p0 = GetPredPropByFuncHavingLock(f, cur_mod);
  READ_UNLOCK(f->FRWLock);
  return (p0);
 }

 Prop
-GetPredPropHavingLock(Atom ap, unsigned int arity)
+GetPredPropHavingLock(Atom ap, unsigned int arity, SMALLUNSGN mod)
     /* get predicate entry for ap/arity;               */
 {
  Prop p0;
@@ -349,11 +334,11 @@ GetPredPropHavingLock(Atom ap, unsigned int arity)
  Functor f;

  if (arity == 0) {
-    GetPredPropByAtomHavingLock(ae, *CurrentModulePtr);
+    GetPredPropByAtomHavingLock(ae, mod);
  }
  f = InlinedUnlockedMkFunctor(ae, arity);
  READ_LOCK(f->FRWLock);
-  p0 = UnlockedFunctorGetPredProp(f, *CurrentModulePtr);
+  p0 = GetPredPropByFuncHavingLock(f, mod);
  READ_UNLOCK(f->FRWLock);
  return (p0);
 }
@@ -388,11 +373,12 @@ GetExpPropHavingLock(AtomEntry *ae, unsigned int arity)
 }

 Prop
-NewPredPropByFunctor(FunctorEntry *fe, Term cur_mod)
+NewPredPropByFunctor(FunctorEntry *fe, SMALLUNSGN cur_mod)
 {
  Prop p0;
  PredEntry *p = (PredEntry *) AllocAtomSpace(sizeof(*p));
-  Int m = IntOfTerm(cur_mod);
+
+  /*  printf("entering %s:%s/%d\n", RepAtom(AtomOfTerm(ModuleName[cur_mod]))->StrOfAE, RepAtom(fe->NameOfFE)->StrOfAE, fe->ArityOfFE); */

  INIT_RWLOCK(p->PRWLock);
  p->KindOfPE = PEProp;
@@ -403,12 +389,9 @@ NewPredPropByFunctor(FunctorEntry *fe, Term cur_mod)
  p->OwnerFile = AtomNil;
  p->OpcodeOfPred = UNDEF_OPCODE;
  p->TrueCodeOfPred = p->CodeOfPred = (CODEADDR)(&(p->OpcodeOfPred)); 
-  if (m == 0)
-    p->ModuleOfPred = 0;
-  else
-    p->ModuleOfPred = cur_mod;
-  p->NextPredOfModule = ModulePred[m];
-  ModulePred[m] = p;
+  p->ModuleOfPred = cur_mod;
+  p->NextPredOfModule = ModulePred[cur_mod];
+  ModulePred[cur_mod] = p;
  INIT_LOCK(p->StatisticsForPred.lock);
  p->StatisticsForPred.NOfEntries = 0;
  p->StatisticsForPred.NOfHeadSuccesses = 0;
@@ -425,11 +408,12 @@ NewPredPropByFunctor(FunctorEntry *fe, Term cur_mod)
 }

 Prop
-NewPredPropByAtom(AtomEntry *ae, Term cur_mod)
+NewPredPropByAtom(AtomEntry *ae, SMALLUNSGN cur_mod)
 {
  Prop p0;
  PredEntry *p = (PredEntry *) AllocAtomSpace(sizeof(*p));
-  int m = IntOfTerm(cur_mod);
+
+/* Printf("entering %s:%s/0\n", RepAtom(AtomOfTerm(ModuleName[cur_mod]))->StrOfAE, ae->StrOfAE); */

  INIT_RWLOCK(p->PRWLock);
  p->KindOfPE = PEProp;
@@ -440,12 +424,9 @@ NewPredPropByAtom(AtomEntry *ae, Term cur_mod)
  p->OwnerFile = AtomNil;
  p->OpcodeOfPred = UNDEF_OPCODE;
  p->TrueCodeOfPred = p->CodeOfPred = (CODEADDR)(&(p->OpcodeOfPred)); 
-  if (!m)
-    p->ModuleOfPred = 0;
-  else
-    p->ModuleOfPred = cur_mod;
-  p->NextPredOfModule = ModulePred[m];
-  ModulePred[m] = p;
+  p->ModuleOfPred = cur_mod;
+  p->NextPredOfModule = ModulePred[cur_mod];
+  ModulePred[cur_mod] = p;
  INIT_LOCK(p->StatisticsForPred.lock);
  p->StatisticsForPred.NOfEntries = 0;
  p->StatisticsForPred.NOfHeadSuccesses = 0;
@@ -461,25 +442,6 @@ NewPredPropByAtom(AtomEntry *ae, Term cur_mod)
  return (p0);
 }

-Prop
-PredProp(Atom ap, unsigned int arity)
-     /* get predicate entry for ap/arity; create it if neccessary.              */
-{
-  Prop p0;
-  AtomEntry *ae;
-  Functor f;
-
-  if (arity == 0) {
-    return(PredPropByAtom(ap, *CurrentModulePtr));
-  }
-  ae = RepAtom(ap);
-  WRITE_LOCK(ae->ARWLock);
-  f = InlinedUnlockedMkFunctor(ae, arity);
-  p0 = PredPropByFunc(f, *CurrentModulePtr);
-  WRITE_UNLOCK(ae->ARWLock);
-  return(p0);
-}
-
 Term
 GetValue(Atom a)
 {
--- a/C/amasm.c
+++ b/C/amasm.c
@@ -858,7 +858,7 @@ a_empty_call(void)
      code_p->opc = emit_op(_fcall);
  }
  if (pass_no) {
-    PredEntry *pe = RepPredProp(GetPredProp(AtomTrue,0));
+    PredEntry *pe = RepPredProp(GetPredPropByAtom(AtomTrue,0));
    code_p->u.sla.s = emit_count(-Signed(RealEnvSize) - CELLSIZE *
 				   cpc->rnd2);
    code_p->u.sla.l = emit_a((CELL)&(pe->StateOfPred));
@@ -1184,7 +1184,7 @@ a_either(op_numbers opcode, CELL opr, CELL lab)
 #endif /* YAPOR */
 {
  if (pass_no) {
-    Prop fe = GetPredProp(AtomTrue,0);
+    Prop fe = GetPredPropByAtom(AtomTrue,0);
    code_p->opc = emit_op(opcode);
    code_p->u.sla.s = emit_count(opr);
    code_p->u.sla.l = emit_a(lab);
--- a/C/bb.c
+++ b/C/bb.c
@@ -26,7 +26,7 @@ static char     SccsId[] = "%W% %G%";
 #endif

 static BBProp 
-PutBBProp(AtomEntry *ae)		/* get BBentry for at; */
+PutBBProp(AtomEntry *ae, SMALLUNSGN mod)		/* get BBentry for at; */
 {
  Prop          p0;
  BBProp        p;
@@ -34,7 +34,7 @@ PutBBProp(AtomEntry *ae)		/* get BBentry for at; */
  WRITE_LOCK(ae->ARWLock);
  p = RepBBProp(p0 = ae->PropsOfAE);
  while (p0 != NIL && (!IsBBProperty(p->KindOfPE) ||
-		(p->ModuleOfBB != CurrentModule))) {
+		(p->ModuleOfBB != mod))) {
    p = RepBBProp(p0 = p->NextOfPE);
  }
  if (p0 == NIL) {
@@ -46,7 +46,7 @@ PutBBProp(AtomEntry *ae)		/* get BBentry for at; */
    }
    p->NextOfPE = ae->PropsOfAE;
    ae->PropsOfAE = AbsBBProp(p);
-    p->ModuleOfBB = CurrentModule;
+    p->ModuleOfBB = mod;
    p->Element = NULL;
    p->KeyOfBB = AbsAtom(ae);
    p->KindOfPE = BBProperty;
@@ -57,7 +57,7 @@ PutBBProp(AtomEntry *ae)		/* get BBentry for at; */
 }

 static BBProp 
-PutIntBBProp(Int key)			/* get BBentry for at; */
+PutIntBBProp(Int key, SMALLUNSGN mod)	/* get BBentry for at; */
 {
  Prop          p0;
  BBProp        p;
@@ -82,7 +82,7 @@ PutIntBBProp(Int key)			/* get BBentry for at; */
  p = RepBBProp(p0);
  while (p0 != NIL && (!IsBBProperty(p->KindOfPE) ||
 		       key != (Int)(p->KeyOfBB) ||
-		(p->ModuleOfBB != CurrentModule))) {
+		(p->ModuleOfBB != mod))) {
    p = RepBBProp(p0 = p->NextOfPE);
  }
  if (p0 == NIL) {
@@ -93,7 +93,7 @@ PutIntBBProp(Int key)			/* get BBentry for at; */
      Error(SYSTEM_ERROR,ARG1,"could not allocate space in bb_put/2");
      return(NULL);
    }
-    p->ModuleOfBB = CurrentModule;
+    p->ModuleOfBB = mod;
    p->Element = NULL;
    p->KeyOfBB = (Atom)key;
    p->KindOfPE = BBProperty;
@@ -105,7 +105,7 @@ PutIntBBProp(Int key)			/* get BBentry for at; */
 }

 static BBProp 
-GetBBProp(AtomEntry *ae)		/* get BBentry for at; */
+GetBBProp(AtomEntry *ae, SMALLUNSGN mod)		/* get BBentry for at; */
 {
  Prop          p0;
  BBProp        p;
@@ -113,7 +113,7 @@ GetBBProp(AtomEntry *ae)		/* get BBentry for at; */
  READ_LOCK(ae->ARWLock);
  p = RepBBProp(p0 = ae->PropsOfAE);
  while (p0 != NIL && (!IsBBProperty(p->KindOfPE) ||
-		(p->ModuleOfBB != CurrentModule))) {
+		(p->ModuleOfBB != mod))) {
    p = RepBBProp(p0 = p->NextOfPE);
  }
  READ_UNLOCK(ae->ARWLock);
@@ -124,7 +124,7 @@ GetBBProp(AtomEntry *ae)		/* get BBentry for at; */
 }

 static BBProp 
-GetIntBBProp(Int key)			/* get BBentry for at; */
+GetIntBBProp(Int key, SMALLUNSGN mod)		/* get BBentry for at; */
 {
  Prop          p0;
  BBProp        p;
@@ -137,7 +137,7 @@ GetIntBBProp(Int key)			/* get BBentry for at; */
  p = RepBBProp(p0);
  while (p0 != NIL && (!IsBBProperty(p->KindOfPE) ||
 		       key != (Int)(p->KeyOfBB) ||
-		(p->ModuleOfBB != CurrentModule))) {
+		(p->ModuleOfBB != mod))) {
    p = RepBBProp(p0 = p->NextOfPE);
  }
  if (p0 == NIL) {
@@ -187,70 +187,62 @@ resize_bb_int_keys(UInt new_size) {
 }

 static BBProp
-AddBBProp(Term t1, char *msg)
+AddBBProp(Term t1, char *msg, SMALLUNSGN mod)
 {
-  SMALLUNSGN old_module = CurrentModule;
  BBProp p;

+ restart:
  if (IsVarTerm(t1)) {
    Error(INSTANTIATION_ERROR, t1, msg);
-    *CurrentModulePtr = MkIntTerm(old_module);
    return(NULL);
  } if (IsAtomTerm(t1)) {
-    p = PutBBProp(RepAtom(AtomOfTerm(t1)));
+    p = PutBBProp(RepAtom(AtomOfTerm(t1)), mod);
  } else if (IsIntegerTerm(t1)) {
-    p = PutIntBBProp(IntegerOfTerm(t1));
+    p = PutIntBBProp(IntegerOfTerm(t1), mod);
  } else if (IsApplTerm(t1) && FunctorOfTerm(t1) == FunctorModule) {
-    Term mod = ArgOfTerm(1, t1);
-    if (!IsVarTerm(mod) ) {
-      *CurrentModulePtr = MkIntTerm(LookupModule(mod));
+    Term tmod = ArgOfTerm(1, t1);
+    if (!IsVarTerm(tmod) ) {
      t1 = ArgOfTerm(2, t1);
-      p = AddBBProp(t1, msg);
+      mod = LookupModule(tmod);
+      goto restart;
    } else {
      Error(INSTANTIATION_ERROR, t1, msg);
-      *CurrentModulePtr = MkIntTerm(old_module);
      return(NULL);
    }
  } else {
    Error(TYPE_ERROR_ATOM, t1, msg);
-    *CurrentModulePtr = MkIntTerm(old_module);
    return(NULL);
  }
-  *CurrentModulePtr = MkIntTerm(old_module);
  return(p);
 }

 static BBProp
-FetchBBProp(Term t1, char *msg)
+FetchBBProp(Term t1, char *msg, SMALLUNSGN mod)
 {
-  SMALLUNSGN old_module = CurrentModule;
  BBProp p;

+ restart:
  if (IsVarTerm(t1)) {
    Error(INSTANTIATION_ERROR, t1, msg);
-    *CurrentModulePtr = MkIntTerm(old_module);
    return(NULL);
  } if (IsAtomTerm(t1)) {
-    p = GetBBProp(RepAtom(AtomOfTerm(t1)));
+    p = GetBBProp(RepAtom(AtomOfTerm(t1)), mod);
  } else if (IsIntegerTerm(t1)) {
-    p = GetIntBBProp(IntegerOfTerm(t1));
+    p = GetIntBBProp(IntegerOfTerm(t1), mod);
  } else if (IsApplTerm(t1) && FunctorOfTerm(t1) == FunctorModule) {
-    Term mod = ArgOfTerm(1, t1);
-    if (!IsVarTerm(mod) ) {
-      *CurrentModulePtr = MkIntTerm(LookupModule(mod));
+    Term tmod = ArgOfTerm(1, t1);
+    if (!IsVarTerm(tmod) ) {
+      mod = LookupModule(tmod);
      t1 = ArgOfTerm(2, t1);
-      p = FetchBBProp(t1, msg);
+      goto restart;
    } else {
      Error(INSTANTIATION_ERROR, t1, msg);
-      *CurrentModulePtr = MkIntTerm(old_module);
      return(NULL);
    }
  } else {
    Error(TYPE_ERROR_ATOM, t1, msg);
-    *CurrentModulePtr = MkIntTerm(old_module);
    return(NULL);
  }
-  *CurrentModulePtr = MkIntTerm(old_module);
  return(p);
 }

@@ -258,7 +250,7 @@ static Int
 p_bb_put(void)
 {
  Term t1 = Deref(ARG1);
-  BBProp p = AddBBProp(t1, "bb_put/2");
+  BBProp p = AddBBProp(t1, "bb_put/2", CurrentModule);
  if (p == NULL)
    return(FALSE);
  WRITE_LOCK(p->BBRWLock);    
@@ -274,7 +266,7 @@ static Int
 p_bb_get(void)
 {
  Term t1 = Deref(ARG1);
-  BBProp p = FetchBBProp(t1, "bb_get/2");
+  BBProp p = FetchBBProp(t1, "bb_get/2", CurrentModule);
  Term out;
  if (p == NULL || p->Element == NULL)
    return(FALSE);
@@ -291,7 +283,7 @@ p_bb_delete(void)
  BBProp p;
  Term out;

-  p = FetchBBProp(t1, "bb_delete/2");
+  p = FetchBBProp(t1, "bb_delete/2", CurrentModule);
  if (p == NULL || p->Element == NULL)
    return(FALSE);
  out = FetchTermFromDB(p->Element,3);
@@ -309,7 +301,7 @@ p_bb_update(void)
  BBProp p;
  Term out;

-  p = FetchBBProp(t1, "bb_update/3");
+  p = FetchBBProp(t1, "bb_update/3", CurrentModule);
  if (p == NULL || p->Element == NULL)
    return(FALSE);
  WRITE_LOCK(p->BBRWLock);  
--- a/C/c_interface.c
+++ b/C/c_interface.c
@@ -376,7 +376,7 @@ YapCallProlog(Term t)
  Int out;
  BACKUP_MACHINE_REGS();

-  out = execute_goal(t,0);
+  out = execute_goal(t, 0, CurrentModule);

  RECOVER_MACHINE_REGS();
  return(out);
@@ -594,14 +594,16 @@ YapCompileClause(Term t)
 {
  char *ErrorMessage;
  CODEADDR codeaddr;
+  int mod = CurrentModule;
+
  BACKUP_MACHINE_REGS();

  ErrorMessage = NULL;
  ARG1 = t;
-  codeaddr = cclause (t,0);
+  codeaddr = cclause (t,0, mod);
  if (codeaddr != NULL) {
    t = Deref(ARG1); /* just in case there was an heap overflow */
-    addclause (t, codeaddr, TRUE);
+    addclause (t, codeaddr, TRUE, mod);
  }

  RECOVER_MACHINE_REGS();
@@ -677,7 +679,7 @@ YapInit(yap_init_args *yap_init)
    InitYaamRegs();
 #endif
    /* slaves, waiting for work */
-    *CurrentModulePtr = MkIntTerm(1);
+    CurrentModule = 1;
    P = GETWORK_FIRST_TIME;
    exec_absmi(FALSE);
    abort_optyap("abstract machine unexpected exit");
--- a/C/cdmgr.c
+++ b/C/cdmgr.c
@@ -52,8 +52,6 @@ STATIC_PROTO(void do_toggle_static_predicates_in_use, (int));
 STATIC_PROTO(void recover_log_upd_clause, (Clause *));
 STATIC_PROTO(PredEntry *NextPred, (PredEntry *,AtomEntry *));
 STATIC_PROTO(Int  p_number_of_clauses, (void));
-STATIC_PROTO(Int  p_find_dynamic, (void));
-STATIC_PROTO(Int  p_next_dynamic, (void));
 STATIC_PROTO(Int  p_compile, (void));
 STATIC_PROTO(Int  p_compile_dynamic, (void));
 STATIC_PROTO(Int  p_purge_clauses, (void));
@@ -66,7 +64,6 @@ STATIC_PROTO(Int  p_undefined, (void));
 STATIC_PROTO(Int  p_in_use, (void));
 STATIC_PROTO(Int  p_new_multifile, (void));
 STATIC_PROTO(Int  p_is_multifile, (void));
-STATIC_PROTO(Int  p_is_logical_updatable, (void));
 STATIC_PROTO(Int  p_optimizer_on, (void));
 STATIC_PROTO(Int  p_optimizer_off, (void));
 STATIC_PROTO(Int  p_in_this_f_before, (void));
@@ -79,7 +76,6 @@ STATIC_PROTO(Int  p_is_profiled, (void));
 STATIC_PROTO(Int  p_profile_info, (void));
 STATIC_PROTO(Int  p_profile_reset, (void));
 STATIC_PROTO(Int  p_toggle_static_predicates_in_use, (void));
-STATIC_PROTO(Int  p_search_for_static_predicate_in_use, (void));

 #define PredArity(p) (p->ArityOfPE)
 #define TRYCODE(G,F,N) ( (N)<5 ? (op_numbers)((int)F+(N)*3) : G)
@@ -787,34 +783,35 @@ addcl_permission_error(AtomEntry *ap, Int Arity)


 void
-addclause(Term t, CODEADDR cp, int mode)
+addclause(Term t, CODEADDR cp, int mode, int mod)
 /*
 * mode		0  assertz 1  consult 2  asserta				 
 */
 {
-  AtomEntry      *ap;
-  Int             Arity;
  PredEntry      *p;
  int             spy_flag = FALSE;
-  SMALLUNSGN      mod = CurrentModule;
+  Atom           at;
+  UInt           Arity;


  if (IsApplTerm(t) && FunctorOfTerm(t) == FunctorAssert)
    t = ArgOfTerm(1, t);
  if (IsAtomTerm(t)) {
+    at = AtomOfTerm(t);
+    p = RepPredProp(PredPropByAtom(at, mod));
    Arity = 0;
-    ap = RepAtom(AtomOfTerm(t));
  } else {
    Functor f = FunctorOfTerm(t);
-    ap = RepAtom(NameOfFunctor(f));
    Arity = ArityOfFunctor(f);
+    at = NameOfFunctor(f);
+    p = RepPredProp(PredPropByFunc(f, mod));
  }
-  p = RepPredProp(PredProp(AbsAtom(ap), Arity));
  PutValue(AtomAbol, TermNil);
  WRITE_LOCK(p->PRWLock);
  /* we are redefining a prolog module predicate */
  if (mod != 0 && p->ModuleOfPred == 0) {
-    addcl_permission_error(ap, Arity);
+    WRITE_UNLOCK(p->PRWLock);
+    addcl_permission_error(RepAtom(at), Arity);
    return;
  }
  /* The only problem we have now is when we need to throw away
@@ -824,7 +821,7 @@ addclause(Term t, CODEADDR cp, int mode)
    if (!RemoveIndexation(p)) {
      /* should never happen */
      WRITE_UNLOCK(p->PRWLock);
-      addcl_permission_error(ap,Arity);
+      addcl_permission_error(RepAtom(at),Arity);
      return;
    }
  }
@@ -877,12 +874,13 @@ addclause(Term t, CODEADDR cp, int mode)

 static Int 
 p_in_this_f_before(void)
-{				/* '$in_this_file_before'(N,A) */
+{				/* '$in_this_file_before'(N,A,M) */
  unsigned int    arity;
  Atom            at;
  Term            t;
  register consult_obj  *fp;
  Prop            p0;
+  SMALLUNSGN      mod;

  if (IsVarTerm(t = Deref(ARG1)) && !IsAtomTerm(t))
    return (FALSE);
@@ -892,7 +890,14 @@ p_in_this_f_before(void)
    return (FALSE);
  else
    arity = IntOfTerm(t);
-  p0 = PredProp(at, arity);
+  if (IsVarTerm(t = Deref(ARG3)) && !IsAtomTerm(t))
+    return (FALSE);
+  else
+    mod = LookupModule(t);
+  if (arity)
+    p0 = PredPropByFunc(MkFunctor(at, arity),CurrentModule);
+  else
+    p0 = PredPropByAtom(at, CurrentModule);
  if (ConsultSp == ConsultBase || (fp = ConsultSp)->p == p0)
    return (FALSE);
  else
@@ -908,12 +913,14 @@ p_in_this_f_before(void)

 static Int 
 p_first_cl_in_f(void)
-{				/* '$first_cl_in_file'(+N,+Ar) */
+{				/* '$first_cl_in_file'(+N,+Ar,+Mod) */
  unsigned int    arity;
  Atom            at;
  Term            t;
  register consult_obj  *fp;
  Prop            p0;
+  SMALLUNSGN      mod;
+  

  if (IsVarTerm(t = Deref(ARG1)) && !IsAtomTerm(t))
    return (FALSE);
@@ -923,7 +930,14 @@ p_first_cl_in_f(void)
    return (FALSE);
  else
    arity = IntOfTerm(t);
-  p0 = PredProp(at, arity);
+  if (IsVarTerm(t = Deref(ARG3)) && !IsAtomTerm(t))
+    return (FALSE);
+  else
+    mod = LookupModule(t);
+  if (arity)
+    p0 = PredPropByFunc(MkFunctor(at, arity),mod);
+  else
+    p0 = PredPropByAtom(at, mod);
  for (fp = ConsultSp; fp < ConsultBase; ++fp)
    if (fp->p == p0)
      break;
@@ -948,7 +962,10 @@ p_mk_cl_not_first(void)
    return (FALSE);
  else
    arity = IntOfTerm(t);
-  p0 = PredProp(at, arity);
+  if (arity)
+    p0 = PredPropByFunc(MkFunctor(at, arity),CurrentModule);
+  else
+    p0 = PredPropByAtom(at, CurrentModule);
  --ConsultSp;
  ConsultSp->p = p0;
  return (TRUE);
@@ -991,18 +1008,23 @@ where_new_clause(pred_prop, mode)

 static Int 
 p_compile(void)
-{				/* '$compile'(+C,+Flags) */
+{				/* '$compile'(+C,+Flags, Mod) */
  Term            t = Deref(ARG1);
  Term            t1 = Deref(ARG2);
+  Term            t3 = Deref(ARG3);
  CODEADDR        codeadr;
+  Int mod;

  if (IsVarTerm(t1) || !IsIntTerm(t1))
    return (FALSE);
-  codeadr = cclause(t, 2); /* vsc: give the number of arguments
+  if (IsVarTerm(t3) || !IsAtomTerm(t3))
+    return (FALSE);
+  mod = LookupModule(t3);
+  codeadr = cclause(t, 2, mod); /* vsc: give the number of arguments
 			      to cclause in case there is overflow */
  t = Deref(ARG1);        /* just in case there was an heap overflow */
  if (!ErrorMessage)
-    addclause(t, codeadr, (int) (IntOfTerm(t1) & 3));
+    addclause(t, codeadr, (int) (IntOfTerm(t1) & 3), mod);
  if (ErrorMessage) {
    if (IntOfTerm(t1) & 4) {
      Error(Error_TYPE, Error_Term,
@@ -1016,25 +1038,30 @@ p_compile(void)

 static Int 
 p_compile_dynamic(void)
-{				/* '$compile_dynamic'(+C,+Flags,-Ref) */
+{				/* '$compile_dynamic'(+C,+Flags,Mod,-Ref) */
  Term            t = Deref(ARG1);
  Term            t1 = Deref(ARG2);
+  Term            t3 = Deref(ARG3);
  Clause         *cl;
  CODEADDR        code_adr;
  int             old_optimize;
+  Int mod;

  if (IsVarTerm(t1) || !IsIntTerm(t1))
    return (FALSE);
+  if (IsVarTerm(t3) || !IsAtomTerm(t3))
+    return (FALSE);
  old_optimize = optimizer_on;
  optimizer_on = FALSE;
-  code_adr = cclause(t, 3); /* vsc: give the number of arguments to
+  mod = LookupModule(t3);
+  code_adr = cclause(t, 3, mod); /* vsc: give the number of arguments to
 			       cclause() in case there is a overflow */
  t = Deref(ARG1);        /* just in case there was an heap overflow */
  if (!ErrorMessage) {
    
    optimizer_on = old_optimize;
    cl = ClauseCodeToClause(code_adr);
-    addclause(t, code_adr, (int) (IntOfTerm(t1) & 3));
+    addclause(t, code_adr, (int) (IntOfTerm(t1) & 3), mod);
  }
  if (ErrorMessage) {
    if (IntOfTerm(t1) & 4) {
@@ -1047,7 +1074,7 @@ p_compile_dynamic(void)
  if (!(cl->ClFlags & LogUpdMask))
    cl->ClFlags = DynamicMask;
  t = MkIntegerTerm((Int)code_adr);
-  return(unify(ARG3, t));
+  return(unify(ARG4, t));
 }


@@ -1145,17 +1172,23 @@ p_purge_clauses(void)
 {				/* '$purge_clauses'(+Func) */
  PredEntry      *pred;
  Term            t = Deref(ARG1);
+  Term            t2 = Deref(ARG2);
  CODEADDR        q, q1;
+  int             mod;

  PutValue(AtomAbol, MkAtomTerm(AtomNil));
  if (IsVarTerm(t))
    return (FALSE);
+  if (IsVarTerm(t2) || !IsAtomTerm(t2)) {
+    return (FALSE);
+  }
+  mod = LookupModule(t2);
  if (IsAtomTerm(t)) {
    Atom at = AtomOfTerm(t);
-    pred = RepPredProp(PredProp(at, 0));
+    pred = RepPredProp(PredPropByAtom(at, mod));
  } else if (IsApplTerm(t)) {
    Functor         fun = FunctorOfTerm(t);
-    pred = RepPredProp(PredPropByFunc(fun, *CurrentModulePtr));
+    pred = RepPredProp(PredPropByFunc(fun, mod));
  } else
    return (FALSE);
  WRITE_LOCK(pred->PRWLock);
@@ -1197,24 +1230,30 @@ p_purge_clauses(void)

 static Int 
 p_setspy(void)
-{				/* '$set_spy'(+Fun)	 */
+{				/* '$set_spy'(+Fun,+M)	 */
  Atom            at;
  PredEntry      *pred;
  CELL            fg;
  Term            t;
+  Term            t2;
+  SMALLUNSGN	  mod;

  at = FullLookupAtom("$spy");
-  pred = RepPredProp(PredProp(at, 1));
+  pred = RepPredProp(PredPropByFunc(MkFunctor(at, 1),0));
  SpyCode = pred;
  t = Deref(ARG1);
+  t2 = Deref(ARG2);
  if (IsVarTerm(t))
    return (FALSE);
+  if (IsVarTerm(t2) || !IsAtomTerm(t2))
+    return (FALSE);
+  mod = LookupModule(t2);
  if (IsAtomTerm(t)) {
    Atom at = AtomOfTerm(t);
-    pred = RepPredProp(PredProp(at, 0));
+    pred = RepPredProp(PredPropByAtom(at, mod));
  } else if (IsApplTerm(t)) {
    Functor fun = FunctorOfTerm(t);
-    pred = RepPredProp(PredPropByFunc(fun, *CurrentModulePtr));
+    pred = RepPredProp(PredPropByFunc(fun, mod));
  } else {
    return (FALSE);
  }
@@ -1249,20 +1288,26 @@ p_setspy(void)

 static Int 
 p_rmspy(void)
-{				/* '$rm_spy'(+T)	 */
+{				/* '$rm_spy'(+T,+Mod)	 */
  Atom            at;
  PredEntry      *pred;
  Term            t;
+  Term            t2;
+  SMALLUNSGN	  mod;

  t = Deref(ARG1);
+  t2 = Deref(ARG2);
+  if (IsVarTerm(t2) || !IsAtomTerm(t2))
+    return (FALSE);
+  mod = LookupModule(t2);
  if (IsVarTerm(t))
    return (FALSE);
  if (IsAtomTerm(t)) {
    at = AtomOfTerm(t);
-    pred = RepPredProp(PredProp(at, 0));
+    pred = RepPredProp(PredPropByAtom(at, mod));
  } else if (IsApplTerm(t)) {
    Functor fun = FunctorOfTerm(t);
-    pred = RepPredProp(PredPropByFunc(fun, *CurrentModulePtr));
+    pred = RepPredProp(PredPropByFunc(fun, mod));
  } else
    return (FALSE);
  WRITE_LOCK(pred->PRWLock);
@@ -1294,19 +1339,25 @@ p_rmspy(void)

 static Int 
 p_number_of_clauses(void)
-{				/* '$number_of_clauses'(Predicate,N) */
+{				/* '$number_of_clauses'(Predicate,M,N) */
  Term            t = Deref(ARG1);
+  Term            t2 = Deref(ARG2);
  int ncl = 0;
  Prop            pe;
  CODEADDR        q;
  int             testing;
+  int             mod;

+  if (IsVarTerm(t2)  || !IsAtomTerm(t2)) {
+    return(FALSE);
+  }
+  mod = LookupModule(t2);
  if (IsAtomTerm(t)) {
    Atom a = AtomOfTerm(t);
-    pe = PredProp(a, 0);
+    pe = PredPropByAtom(a, mod);
  } else if (IsApplTerm(t)) {
    register Functor f = FunctorOfTerm(t);
-    pe = PredPropByFunc(f, *CurrentModulePtr);
+    pe = PredPropByFunc(f, mod);
  } else
    return (FALSE);
  q = RepPredProp(pe)->FirstClause;
@@ -1328,113 +1379,29 @@ p_number_of_clauses(void)
  }
  READ_UNLOCK(RepPredProp(pe)->PRWLock);
  t = MkIntTerm(ncl);
-  return (unify_constant(ARG2, t));
-}
-
-static Int 
-p_find_dynamic(void)
-{				/* '$find_dynamic'(+G,+N,-C) */
-  Term            t = Deref(ARG1);
-  Prop            pe;
-  CODEADDR        q;
-  int             position;
-
-  if (IsAtomTerm(t)) {
-    Atom a = AtomOfTerm(t);
-    pe = PredProp(a, 0);
-  } else if (IsApplTerm(t)) {
-    register Functor f = FunctorOfTerm(t);
-    pe = PredPropByFunc(f, *CurrentModulePtr);
-  } else
-    return (FALSE);
-  q = RepPredProp(pe)->FirstClause;
-  t = Deref(ARG2);
-  if (IsVarTerm(t) || !IsIntTerm(t))
-    return (FALSE);
-  position = IntOfTerm(t);
-  READ_LOCK(RepPredProp(pe)->PRWLock);
-  if (!(RepPredProp(pe)->PredFlags & DynamicPredFlag))
-    return (FALSE);
-  while (position > 1) {
-    while (ClauseCodeToClause(q)->ClFlags & ErasedMask)
-      q = NextClause(q);
-    position--;
-    q = NextClause(q);
-  }
-  while (ClauseCodeToClause(q)->ClFlags & ErasedMask)
-    q = NextClause(q);
-#if defined(YAPOR) || defined(THREADS)
-  {
-    Clause *cl = ClauseCodeToClause(q);
-    LOCK(cl->ClLock);
-    TRAIL_CLREF(cl);
-    INC_CLREF_COUNT(cl);
-    UNLOCK(cl->ClLock);
-  }
-#else
-  if (!(ClauseCodeToClause(q)->ClFlags & InUseMask)) {
-    OPREG     *opp = &(ClauseCodeToClause(q)->ClFlags);
-    TRAIL_CLREF(ClauseCodeToClause(q));
-    *opp |= InUseMask;
-  }
-#endif
-  READ_UNLOCK(RepPredProp(pe)->PRWLock);
-  t = MkIntegerTerm((Int)q);
-  return (unify(ARG3, t));
-}
-
-static Int 
-p_next_dynamic(void)
-{				/* '$next_dynamic'(+G,+C,-N) */
-  Term            t = Deref(ARG1);
-  Prop            pe;
-  CODEADDR        q, oldq;
-  int             position;
-
-  t = Deref(ARG2);
-  if (IsVarTerm(t) || !IsIntegerTerm(t))
-    return (FALSE);
-  if (IsAtomTerm(t)) {
-    Atom a = AtomOfTerm(t);
-    pe = PredProp(a, 0);
-  } else if (IsApplTerm(t)) {
-    register Functor f = FunctorOfTerm(t);
-    pe = PredPropByFunc(f, *CurrentModulePtr);
-  } else
-    return (FALSE);
-  q = RepPredProp(pe)->FirstClause;
-  READ_LOCK(RepPredProp(pe)->PRWLock);
-  if (!(RepPredProp(pe)->PredFlags & DynamicPredFlag))
-    return (FALSE);
-  oldq = (CODEADDR)IntegerOfTerm(t);
-  position = 1;
-  while (q != oldq) {
-    if (!(ClauseCodeToClause(q)->ClFlags & ErasedMask))
-      position++;
-    q = NextClause(q);
-  }
-  if (!(ClauseCodeToClause(q)->ClFlags & ErasedMask))
-    position++;
-  READ_UNLOCK(RepPredProp(pe)->PRWLock);
-  t = MkIntTerm(position);
  return (unify_constant(ARG3, t));
 }

 static Int 
 p_in_use(void)
-{				/* '$in_use'(+P)	 */
+{				/* '$in_use'(+P,+Mod)	 */
  Term            t = Deref(ARG1);
+  Term            t2 = Deref(ARG2);
  PredEntry      *pe;
  Int            out;
+  int            mod;

  if (IsVarTerm(t))
    return (FALSE);
+  if (IsVarTerm(t2) || !IsAtomTerm(t2))
+    return (FALSE);
+  mod = LookupModule(t2);
  if (IsAtomTerm(t)) {
    Atom at = AtomOfTerm(t);
-    pe = RepPredProp(PredProp(at, 0));
+    pe = RepPredProp(PredPropByAtom(at, mod));
  } else if (IsApplTerm(t)) {
    Functor         fun = FunctorOfTerm(t);
-    pe = RepPredProp(PredPropByFunc(fun, *CurrentModulePtr));
+    pe = RepPredProp(PredPropByFunc(fun, mod));
  } else
    return (FALSE);
  READ_LOCK(pe->PRWLock);
@@ -1445,11 +1412,12 @@ p_in_use(void)

 static Int 
 p_new_multifile(void)
-{				/* '$new_multifile'(+N,+Ar)	 */
+{				/* '$new_multifile'(+N,+Ar,+Mod)  */
  Atom            at;
  int             arity;
  PredEntry      *pe;
  Term            t = Deref(ARG1);
+  SMALLUNSGN      mod = LookupModule(Deref(ARG3));

  if (IsVarTerm(t))
    return (FALSE);
@@ -1464,7 +1432,10 @@ p_new_multifile(void)
    arity = IntOfTerm(t);
  else
    return (FALSE);
-  pe = RepPredProp(PredProp(at, arity));
+  if (arity == 0) 
+    pe = RepPredProp(PredPropByAtom(at, mod));
+  else 
+    pe = RepPredProp(PredPropByFunc(MkFunctor(at, arity),mod));
  WRITE_LOCK(pe->PRWLock);
  pe->PredFlags |= MultiFileFlag;
  WRITE_UNLOCK(pe->PRWLock);
@@ -1474,28 +1445,27 @@ p_new_multifile(void)

 static Int 
 p_is_multifile(void)
-{				/* '$is_multifile'(+N,+Ar)	 */
-  Atom            at;
-  int             arity;
+{				/* '$is_multifile'(+S,+Mod)	 */
  PredEntry      *pe;
  Term            t = Deref(ARG1);
+  Term            t2 = Deref(ARG2);
  Int		  out;
+  int		  mod;

  if (IsVarTerm(t))
    return (FALSE);
-  if (IsAtomTerm(t))
-    at = AtomOfTerm(t);
-  else
+  if (IsVarTerm(t2))
    return (FALSE);
-  t = Deref(ARG2);
-  if (IsVarTerm(t))
+  if (!IsAtomTerm(t2))
    return (FALSE);
-  if (IsIntTerm(t))
-    arity = IntOfTerm(t);
-  else
-    return (FALSE);
-  pe = RepPredProp(PredProp(at, arity));
-  if (pe == NIL)
+  mod = LookupModule(t2);
+  if (IsAtomTerm(t)) {
+    pe = RepPredProp(PredPropByAtom(AtomOfTerm(t), mod));
+  } else if (IsApplTerm(t)) {
+    pe = RepPredProp(PredPropByFunc(FunctorOfTerm(t), mod));
+  } else
+    return(FALSE);
+  if (EndOfPAEntr(pe))
    return (FALSE);
  READ_LOCK(pe->PRWLock);
  out = (pe->PredFlags & MultiFileFlag);
@@ -1503,52 +1473,23 @@ p_is_multifile(void)
  return(out);
 }

-static Int 
-p_is_logical_updatable(void)
-{				/* '$is_logical_updatable'(+N,+Ar)	 */
-  Atom            at;
-  int             arity;
-  PredEntry      *pe;
-  Term            t = Deref(ARG1);
-  Int             out;
-
-  if (IsVarTerm(t))
-    return (FALSE);
-  if (IsAtomTerm(t))
-    at = AtomOfTerm(t);
-  else
-    return (FALSE);
-  t = Deref(ARG2);
-  if (IsVarTerm(t))
-    return (FALSE);
-  if (IsIntTerm(t))
-    arity = IntOfTerm(t);
-  else
-    return (FALSE);
-  pe = RepPredProp(PredProp(at, arity));
-  if (pe == NIL)
-    return (FALSE);
-  READ_LOCK(pe->PRWLock);
-  out = (pe->PredFlags & LogUpdatePredFlag);
-  READ_UNLOCK(pe->PRWLock);
-  return(out);
-}
-
 static Int 
 p_is_dynamic(void)
 {				/* '$is_dynamic'(+P)	 */
  PredEntry      *pe;
  Term            t = Deref(ARG1);
+  Term            t2 = Deref(ARG2);
  Int             out;
-  
+  SMALLUNSGN      mod = LookupModule(t2);
+
  if (IsVarTerm(t)) {
    return (FALSE);
  } else if (IsAtomTerm(t)) {
    Atom at = AtomOfTerm(t);
-    pe = RepPredProp(PredProp(at, 0));
+    pe = RepPredProp(PredPropByAtom(at, mod));
  } else if (IsApplTerm(t)) {
    Functor         fun = FunctorOfTerm(t);
-    pe = RepPredProp(PredPropByFunc(fun, *CurrentModulePtr));
+    pe = RepPredProp(PredPropByFunc(fun, mod));
  } else
    return (FALSE);
  if (pe == NIL)
@@ -1562,31 +1503,40 @@ p_is_dynamic(void)
 static Int 
 p_set_pred_module(void)
 {				/* '$set_pred_module'(+P,+Mod)	 */
-  Atom            at;
-  int             arity;
  PredEntry      *pe;
  Term            t = Deref(ARG1);
+  SMALLUNSGN      mod = CurrentModule;
+
+ restart_set_pred:
  if (IsVarTerm(t)) {
    return (FALSE);
  } else if (IsAtomTerm(t)) {
-    at = AtomOfTerm(t);
-    arity = 0;
+    pe = RepPredProp(PredPropByAtom(AtomOfTerm(t), mod));
  } else if (IsApplTerm(t)) {
    Functor         fun = FunctorOfTerm(t);
-    at = NameOfFunctor(fun);
-    arity = ArityOfFunctor(fun);
+    if (fun == FunctorModule) {
+      Term tmod = ArgOfTerm(1, t);
+      if (IsVarTerm(tmod) ) {
+	Error(INSTANTIATION_ERROR,ARG1,"set_pred_module/1");
+	return(FALSE);
+      }
+      if (!IsAtomTerm(tmod) ) {
+	Error(TYPE_ERROR_ATOM,ARG1,"set_pred_module/1");
+	return(FALSE);
+      }
+      mod = LookupModule(tmod);
+      t = ArgOfTerm(2, t);
+      goto restart_set_pred;
+    }
+    pe = RepPredProp(PredPropByFunc(fun, mod));
  } else
    return (FALSE);
-  pe = RepPredProp(PredProp(at, arity));
-  if (pe == NIL)
+  if (EndOfPAEntr(pe))
    return (FALSE);
  WRITE_LOCK(pe->PRWLock);
  {
    SMALLUNSGN mod = LookupModule(Deref(ARG2));
-    if (mod)
-      pe->ModuleOfPred = MkIntTerm(mod);
-    else
-      pe->ModuleOfPred = 0;
+    pe->ModuleOfPred = mod;
  }
  WRITE_UNLOCK(pe->PRWLock);
  return(TRUE);
@@ -1594,12 +1544,23 @@ p_set_pred_module(void)

 static Int 
 p_undefined(void)
-{				/* '$undefined'(P)	 */
+{				/* '$undefined'(P,Mod)	 */
  PredEntry      *pe;
  Term            t;
-  Term tmod = *CurrentModulePtr;
+  Term            t2;
+  SMALLUNSGN      mod;

  t = Deref(ARG1);
+  t2 = Deref(ARG2);
+  if (IsVarTerm(t2)) {
+    Error(INSTANTIATION_ERROR,ARG2,"undefined/1");
+    return(FALSE);
+  }
+  if (!IsAtomTerm(t2)) {
+    Error(TYPE_ERROR_ATOM,ARG2,"undefined/1");
+    return(FALSE);
+  }
+  mod = LookupModule(t2);
 restart_undefined:
  if (IsVarTerm(t)) {
    Error(INSTANTIATION_ERROR,ARG1,"undefined/1");
@@ -1607,24 +1568,24 @@ p_undefined(void)
  }
  if (IsAtomTerm(t)) {
    Atom at = AtomOfTerm(t);
-    pe = RepPredProp(GetPredPropByAtom(at,tmod));
+    pe = RepPredProp(GetPredPropByAtom(at,mod));
  } else if (IsApplTerm(t)) {
    Functor         funt = FunctorOfTerm(t);
    if (funt == FunctorModule) {
-      Term mod = ArgOfTerm(1, t);
-      if (IsVarTerm(mod) ) {
+      Term tmod = ArgOfTerm(1, t);
+      if (IsVarTerm(tmod) ) {
 	Error(INSTANTIATION_ERROR,ARG1,"undefined/1");
 	return(FALSE);
      }
-      if (!IsAtomTerm(mod) ) {
+      if (!IsAtomTerm(tmod) ) {
 	Error(TYPE_ERROR_ATOM,ARG1,"undefined/1");
 	return(FALSE);
      }
-      tmod = MkIntTerm(LookupModule(mod));
+      mod = LookupModule(tmod);
      t = ArgOfTerm(2, t);
      goto restart_undefined;
    }
-    pe = RepPredProp(GetPredPropByFunc(funt, tmod));
+    pe = RepPredProp(GetPredPropByFunc(funt, mod));
  } else {
    return (FALSE);
  }
@@ -1650,20 +1611,32 @@ p_undefined(void)

 static Int 
 p_kill_dynamic(void)
-{				/* '$kill_dynamic'(P)       */
+{				/* '$kill_dynamic'(P,M)       */
  PredEntry      *pe;
  Term            t;
-  
+  Term            t2;
+  SMALLUNSGN      mod;
+
+  t2 = Deref(ARG2);
+  if (IsVarTerm(t2)) {
+    Error(INSTANTIATION_ERROR,ARG2,"undefined/1");
+    return(FALSE);
+  }
+  if (!IsAtomTerm(t2)) {
+    Error(TYPE_ERROR_ATOM,ARG2,"undefined/1");
+    return(FALSE);
+  }
+  mod = LookupModule(t2);
  t = Deref(ARG1);
  if (IsAtomTerm(t)) {
    Atom at = AtomOfTerm(t);
-    pe = RepPredProp(PredProp(at, 0));
+    pe = RepPredProp(PredPropByAtom(at, mod));
  } else if (IsApplTerm(t)) {
    Functor         funt = FunctorOfTerm(t);
-    pe = RepPredProp(PredPropByFunc(funt, *CurrentModulePtr));
+    pe = RepPredProp(PredPropByFunc(funt, mod));
  } else
    return (FALSE);
-  if (pe == NIL)
+  if (EndOfPAEntr(pe))
    return (TRUE);
  WRITE_LOCK(pe->PRWLock);
  if (!(pe->PredFlags & DynamicPredFlag)) {
@@ -1845,43 +1818,6 @@ do_toggle_static_predicates_in_use(int mask)

 #endif

-static Int
-p_search_for_static_predicate_in_use(void)
-{
-#if defined(YAPOR) || defined(THREADS)
-  return(FALSE);
-#else
-  PredEntry      *pe;
-  Term		  t;
-  Int             out;
-  
-  t = Deref(ARG1);
-  if (IsAtomTerm(t)) {
-    Atom at = AtomOfTerm(t);
-    pe = RepPredProp(PredProp(at, 0));
-  }  else if (IsApplTerm(t)) {
-    Functor         funt = FunctorOfTerm(ARG1);
-    pe = RepPredProp(PredPropByFunc(funt, *CurrentModulePtr));
-  } else
-    return(FALSE);
-  /* do nothing if we are in consult */
-  if (STATIC_PREDICATES_MARKED)
-    return (pe->StateOfPred & InUseMask);
-  /* if it was not defined, surely it was not in use */
-  if (pe == NIL)
-    return (TRUE);
-  READ_LOCK(pe->PRWLock);
-  if (pe->PredFlags & (BasicPredFlag|StandardPredFlag|DynamicPredFlag|CPredFlag)) {
-    READ_UNLOCK(pe->PRWLock);
-    return(FALSE);
-  }
-  out = search_for_static_predicate_in_use(pe, TRUE);
-  READ_UNLOCK(pe->PRWLock);  
-  return(out);
-#endif
-}
-
-
 /* This predicate is to be used by reconsult to mark all predicates
   currently in use as being executed.

@@ -2039,22 +1975,30 @@ p_is_profiled(void)
 static Int
 p_profile_info(void)
 {
-  Term tname = Deref(ARG1);
-  Term tarity = Deref(ARG2);
+  Term tmod = Deref(ARG1);
+  Term tfun = Deref(ARG2);
+  int mod;
  Term out;
  PredEntry *pe;
-  Int arity;
-  Atom name;
  Term p[3];

-  if (IsVarTerm(tname) || !IsAtomTerm(tname))
+  if (IsVarTerm(tmod) || !IsAtomTerm(tmod))
    return(FALSE);
-  if (IsVarTerm(tarity) || !IsIntTerm(tarity))
+  mod = LookupModule(tmod);
+  if (IsVarTerm(tfun)) {
    return(FALSE);
-  name = AtomOfTerm(tname);
-  arity = IntOfTerm(tarity);
-  pe = RepPredProp(GetPredProp(name, arity));
-  if (pe == NULL)
+  } else if (IsApplTerm(tfun)) {
+    Functor f = FunctorOfTerm(tfun);
+    if (IsExtensionFunctor(f)) {
+      return(FALSE);
+    }
+    pe = RepPredProp(GetPredPropByFunc(f, mod));
+  } else if (IsAtomTerm(tfun)) {
+    pe = RepPredProp(GetPredPropByAtom(AtomOfTerm(tfun), mod));
+  } else {
+    return(FALSE);
+  }
+  if (EndOfPAEntr(pe))
    return(FALSE);
  LOCK(pe->StatisticsForPred.lock);
  if (!(pe->StatisticsForPred.NOfEntries)) {
@@ -2072,20 +2016,28 @@ p_profile_info(void)
 static Int
 p_profile_reset(void)
 {
-  Term tname = Deref(ARG1);
-  Term tarity = Deref(ARG2);
+  Term tmod = Deref(ARG1);
+  Term tfun = Deref(ARG2);
+  int mod;
  PredEntry *pe;
-  Int arity;
-  Atom name;

-  if (IsVarTerm(tname) || !IsAtomTerm(tname))
+  if (IsVarTerm(tmod) || !IsAtomTerm(tmod))
    return(FALSE);
-  if (IsVarTerm(tarity) || !IsIntTerm(tarity))
+  mod = LookupModule(tmod);
+  if (IsVarTerm(tfun)) {
    return(FALSE);
-  name = AtomOfTerm(tname);
-  arity = IntOfTerm(tarity);
-  pe = RepPredProp(GetPredProp(name, arity));
-  if (pe == NULL)
+  } else if (IsApplTerm(tfun)) {
+    Functor f = FunctorOfTerm(tfun);
+    if (IsExtensionFunctor(f)) {
+      return(FALSE);
+    }
+    pe = RepPredProp(GetPredPropByFunc(f, mod));
+  } else if (IsAtomTerm(tfun)) {
+    pe = RepPredProp(GetPredPropByAtom(AtomOfTerm(tfun), mod));
+  } else {
+    return(FALSE);
+  }
+  if (EndOfPAEntr(pe))
    return(FALSE);
  LOCK(pe->StatisticsForPred.lock);
  pe->StatisticsForPred.NOfEntries = 0;
@@ -2124,21 +2076,23 @@ p_parent_pred(void)
 	 unify(ARG3, MkIntTerm(arity)));
 }

-static Int			/* $parent_pred(Module, Name, Arity) */
+static Int			/* $system_predicate(P) */
 p_system_pred(void)
 {
  PredEntry      *pe;
-  Term mod       = *CurrentModulePtr;

  Term t1 = Deref(ARG1);
- restart:
+ restart_system_pred:
  if (IsVarTerm(t1))
    return (FALSE);
  if (IsAtomTerm(t1)) {
-    pe = RepPredProp(PredPropByAtom(AtomOfTerm(t1), mod));
+    pe = RepPredProp(GetPredPropByAtom(AtomOfTerm(t1), 0));
  } else if (IsApplTerm(t1)) {
    Functor         funt = FunctorOfTerm(t1);
-    if (funt == FunctorModule) {
+    if (IsExtensionFunctor(funt)) {
+      return(FALSE);
+    } 
+    while (funt == FunctorModule) {
      Term nmod = ArgOfTerm(1, t1);
      if (IsVarTerm(nmod)) {
 	Error(INSTANTIATION_ERROR,ARG1,"system_predicate/1");
@@ -2148,13 +2102,14 @@ p_system_pred(void)
 	Error(TYPE_ERROR_ATOM,ARG1,"system_predicate/1");
 	return(FALSE);
      }
-      mod = MkIntTerm(LookupModule(nmod));
      t1 = ArgOfTerm(2, t1);
-      goto restart;
+      goto restart_system_pred;
    }
-    pe = RepPredProp(PredPropByFunc(funt, mod));
+    pe = RepPredProp(GetPredPropByFunc(funt, 0));
  } else
    return (FALSE);
+  if (EndOfPAEntr(pe))
+    return(FALSE);
  return(pe->ModuleOfPred == 0);
 }

@@ -2165,33 +2120,29 @@ InitCdMgr(void)
  InitCPred("$start_consult", 3, p_startconsult, SafePredFlag|SyncPredFlag);
  InitCPred("$show_consult_level", 1, p_showconslultlev, SafePredFlag);
  InitCPred("$end_consult", 0, p_endconsult, SafePredFlag|SyncPredFlag);
-  InitCPred("$set_spy", 1, p_setspy, SafePredFlag|SyncPredFlag);
-  InitCPred("$rm_spy", 1, p_rmspy, SafePredFlag|SyncPredFlag);
+  InitCPred("$set_spy", 2, p_setspy, SafePredFlag|SyncPredFlag);
+  InitCPred("$rm_spy", 2, p_rmspy, SafePredFlag|SyncPredFlag);
  /* gc() may happen during compilation, hence these predicates are
 	now unsafe */
-  InitCPred("$compile", 2, p_compile, SyncPredFlag);
-  InitCPred("$compile_dynamic", 3, p_compile_dynamic, SyncPredFlag);
-  InitCPred("$purge_clauses", 1, p_purge_clauses, SafePredFlag|SyncPredFlag);
-  InitCPred("$in_use", 1, p_in_use, TestPredFlag | SafePredFlag|SyncPredFlag);
-  InitCPred("$is_logical_updatable", 1, p_is_logical_updatable, TestPredFlag | SafePredFlag);
-  InitCPred("$is_dynamic", 1, p_is_dynamic, TestPredFlag | SafePredFlag);
-  InitCPred("$number_of_clauses", 2, p_number_of_clauses, SafePredFlag|SyncPredFlag);
-  InitCPred("$find_dynamic", 3, p_find_dynamic, SafePredFlag|SyncPredFlag);
-  InitCPred("$next_dynamic", 3, p_next_dynamic, SafePredFlag|SyncPredFlag);
-  InitCPred("$undefined", 1, p_undefined, SafePredFlag|TestPredFlag);
+  InitCPred("$compile", 3, p_compile, SyncPredFlag);
+  InitCPred("$compile_dynamic", 4, p_compile_dynamic, SyncPredFlag);
+  InitCPred("$purge_clauses", 2, p_purge_clauses, SafePredFlag|SyncPredFlag);
+  InitCPred("$in_use", 2, p_in_use, TestPredFlag | SafePredFlag|SyncPredFlag);
+  InitCPred("$is_dynamic", 2, p_is_dynamic, TestPredFlag | SafePredFlag);
+  InitCPred("$number_of_clauses", 3, p_number_of_clauses, SafePredFlag|SyncPredFlag);
+  InitCPred("$undefined", 2, p_undefined, SafePredFlag|TestPredFlag);
  InitCPred("$optimizer_on", 0, p_optimizer_on, SafePredFlag|SyncPredFlag);
  InitCPred("$clean_up_dead_clauses", 0, p_clean_up_dead_clauses, SyncPredFlag);
  InitCPred("$optimizer_off", 0, p_optimizer_off, SafePredFlag|SyncPredFlag);
  InitCPred("$kill_dynamic", 1, p_kill_dynamic, SafePredFlag|SyncPredFlag);
-  InitCPred("$in_this_file_before", 2, p_in_this_f_before, SafePredFlag);
-  InitCPred("$first_clause_in_file", 2, p_first_cl_in_f, SafePredFlag);
+  InitCPred("$in_this_file_before", 3, p_in_this_f_before, SafePredFlag);
+  InitCPred("$first_clause_in_file", 3, p_first_cl_in_f, SafePredFlag);
  InitCPred("$mk_cl_not_first", 2, p_mk_cl_not_first, SafePredFlag);
-  InitCPred("$new_multifile", 2, p_new_multifile, SafePredFlag|SyncPredFlag);
+  InitCPred("$new_multifile", 3, p_new_multifile, SafePredFlag|SyncPredFlag);
  InitCPred("$is_multifile", 2, p_is_multifile, TestPredFlag | SafePredFlag);
  InitCPred("$is_profiled", 1, p_is_profiled, SafePredFlag|SyncPredFlag);
  InitCPred("$profile_info", 3, p_profile_info, SafePredFlag|SyncPredFlag);
  InitCPred("$profile_reset", 2, p_profile_reset, SafePredFlag|SyncPredFlag);
-  InitCPred("$search_for_static_predicates_in_use", 1, p_search_for_static_predicate_in_use, TestPredFlag|SafePredFlag|SyncPredFlag);
  InitCPred("$toggle_static_predicates_in_use", 0, p_toggle_static_predicates_in_use, SafePredFlag|SyncPredFlag);
  InitCPred("$set_pred_module", 2, p_set_pred_module, SafePredFlag);
  InitCPred("$parent_pred", 3, p_parent_pred, SafePredFlag);
--- a/C/compiler.c
+++ b/C/compiler.c
@@ -34,10 +34,10 @@ STATIC_PROTO(void c_arg, (Int, Term, unsigned int));
 STATIC_PROTO(void c_args, (Term));
 STATIC_PROTO(void c_eq, (Term, Term));
 STATIC_PROTO(void c_test, (Int, Term));
-STATIC_PROTO(void c_bifun, (Int, Term, Term, Term));
-STATIC_PROTO(void c_goal, (Term));
+STATIC_PROTO(void c_bifun, (Int, Term, Term, Term, int));
+STATIC_PROTO(void c_goal, (Term, int));
 STATIC_PROTO(void get_type_info, (Term));
-STATIC_PROTO(void c_body, (Term));
+STATIC_PROTO(void c_body, (Term, int));
 STATIC_PROTO(void get_cl_info, (Term));
 STATIC_PROTO(void c_head, (Term));
 STATIC_PROTO(int usesvar, (int));
@@ -702,7 +702,7 @@ bip_cons	   Op,Xk,Ri,C

 */
 static void
-c_bifun(Int Op, Term t1, Term t2, Term t3)
+c_bifun(Int Op, Term t1, Term t2, Term t3, int mod)
 {
  /* compile Z = X Op Y  arithmetic function */
  /* first we fetch the arguments */
@@ -821,7 +821,7 @@ c_bifun(Int Op, Term t1, Term t2, Term t3)
 	if (IsNumTerm(t1)) {
 	  /* we will always fail */
 	  if (i2)
-	    c_goal(MkAtomTerm(AtomFalse));
+	    c_goal(MkAtomTerm(AtomFalse), mod);
 	} else if (!IsAtomTerm(t1)) {
 	  char s[32];

@@ -892,7 +892,7 @@ c_bifun(Int Op, Term t1, Term t2, Term t3)
 	} else if (IsApplTerm(t2)) {
 	  Functor f = FunctorOfTerm(t2);
 	  if (i1 < 1 || i1 > ArityOfFunctor(f)) {
-	    c_goal(MkAtomTerm(AtomFalse));
+	    c_goal(MkAtomTerm(AtomFalse), mod);
 	  } else {
 	    c_eq(ArgOfTerm(i1, t2), t3);
 	  }
@@ -906,7 +906,7 @@ c_bifun(Int Op, Term t1, Term t2, Term t3)
 	    c_eq(TailOfTerm(t2), t3);
 	    return;
 	  default:
-	    c_goal(MkAtomTerm(AtomFalse));
+	    c_goal(MkAtomTerm(AtomFalse), mod);
 	    return;
 	  }
 	}
@@ -1066,13 +1066,13 @@ c_bifun(Int Op, Term t1, Term t2, Term t3)
 }

 static void
-c_functor(Term Goal)
+c_functor(Term Goal, int mod)
 {
  Term t1 = ArgOfTerm(1, Goal);
  Term t2 = ArgOfTerm(2, Goal);
  Term t3 = ArgOfTerm(3, Goal);
  if (IsVarTerm(t1) && IsNewVar(t1)) {
-    c_bifun(_functor, t2, t3, t1);
+    c_bifun(_functor, t2, t3, t1, mod);
  } else if (IsNonVarTerm(t1)) {
    /* just split the structure */
    if (IsAtomicTerm(t1)) {
@@ -1095,7 +1095,7 @@ c_functor(Term Goal)
    c_var(t3,f_flag,(unsigned int)_functor);
  } else {
    Functor f = FunctorOfTerm(Goal);
-    Prop p0 = PredPropByFunc(f, *CurrentModulePtr);
+    Prop p0 = PredPropByFunc(f, mod);
    if (profiling)
      emit(enter_profiling_op, (CELL)RepPredProp(p0), Zero);
    c_args(Goal);
@@ -1122,16 +1122,14 @@ IsTrueGoal(Term t) {
 }

 static void
-c_goal(Term Goal)
+c_goal(Term Goal, int mod)
 {
  Functor f;
  PredEntry *p;
  Prop p0;
-  int save_CurrentModule = CurrentModule;

  if (IsVarTerm(Goal)) {
    Goal = MkApplTerm(FunctorCall, 1, &Goal);
-    *CurrentModulePtr = MkIntTerm(PrimitivesModule);
  }
  if (IsNumTerm(Goal)) {
    FAIL("goal can not be a number", TYPE_ERROR_CALLABLE, Goal);
@@ -1142,7 +1140,6 @@ c_goal(Term Goal)
    FAIL("goal argument in static procedure can not be a data base reference", TYPE_ERROR_CALLABLE, Goal);
  } else if (IsPairTerm(Goal)) {
    Goal = MkApplTerm(FunctorCall, 1, &Goal);
-    *CurrentModulePtr = MkIntTerm(PrimitivesModule);
  } else if (IsApplTerm(Goal) && FunctorOfTerm(Goal) == FunctorModule) {
    Term M = ArgOfTerm(1, Goal);

@@ -1153,19 +1150,17 @@ c_goal(Term Goal)
      save_machine_regs();
      longjmp(CompilerBotch, 1);
    }
-    *CurrentModulePtr = MkIntTerm(LookupModule(M));
    Goal = ArgOfTerm(2, Goal);
+    mod = LookupModule(M);
  }
  if (IsVarTerm(Goal)) {
    Goal = MkApplTerm(FunctorCall, 1, &Goal);
-    *CurrentModulePtr = MkIntTerm(PrimitivesModule);
  }
  if (IsAtomTerm(Goal)) {
    Atom atom = AtomOfTerm(Goal);

    if (atom == AtomFail || atom == AtomFalse) {
      emit(fail_op, Zero, Zero);
-      *CurrentModulePtr = MkIntTerm(save_CurrentModule);
      return;
    }
    else if (atom == AtomTrue || atom == AtomOtherwise) {
@@ -1178,13 +1173,12 @@ c_goal(Term Goal)
 #endif /* TABLING */
 	  emit(procceed_op, Zero, Zero);
      }
-      *CurrentModulePtr = MkIntTerm(save_CurrentModule);
      return;
    }
    else if (atom == AtomCut) {

      if (profiling)
-	emit(enter_profiling_op, (CELL)RepPredProp(PredProp(AtomCut,0)), Zero);
+	emit(enter_profiling_op, (CELL)RepPredProp(PredPropByAtom(AtomCut,0)), Zero);
      if (onlast) {
 	/* never a problem here with a -> b, !, c ; d */
 	emit(deallocate_op, Zero, Zero);
@@ -1207,7 +1201,6 @@ c_goal(Term Goal)
 	/* needs to adjust previous commits */
 	adjust_current_commits();
      }
-      *CurrentModulePtr = MkIntTerm(save_CurrentModule);
      return;
    }
 #ifndef YAPOR
@@ -1216,7 +1209,7 @@ c_goal(Term Goal)
      CELL l2 = ++labelno;

      if (profiling)
-	emit(enter_profiling_op, (CELL)RepPredProp(PredProp(AtomRepeat,0)), Zero);
+	emit(enter_profiling_op, (CELL)RepPredProp(PredPropByAtom(AtomRepeat,0)), Zero);
      or_found = 1;
      push_branch(onbranch, TermNil);
      cur_branch++;
@@ -1247,20 +1240,17 @@ c_goal(Term Goal)
      onbranch = pop_branch();
      emit(pop_or_op, Zero, Zero);
 /*                      --onbranch; */
-      *CurrentModulePtr = MkIntTerm(save_CurrentModule);
      return;
    }
 #endif /* YAPOR */
-    else
-      f = MkFunctor(atom, 0);
-    p = RepPredProp(p0 = PredProp(atom, 0));
+    p = RepPredProp(p0 = PredPropByAtom(atom, mod));
    /* if we are profiling, make sure we register we entered this predicate */
    if (profiling)
      emit(enter_profiling_op, (CELL)p, Zero);
  }
  else {
    f = FunctorOfTerm(Goal);
-    p = RepPredProp(p0 = PredPropByFunc(f, *CurrentModulePtr));
+    p = RepPredProp(p0 = PredPropByFunc(f, mod));
    if (f == FunctorOr) {
      CELL l = ++labelno;
      CELL m = ++labelno;
@@ -1289,7 +1279,7 @@ c_goal(Term Goal)
 	  }
 	  emit_3ops(push_or_op, l, Zero, Zero);
 	  if (looking_at_comit &&
-	      is_a_test_pred(ArgOfTerm(1, arg))) {
+	      is_a_test_pred(ArgOfTerm(1, arg), mod)) {
 	    /*
 	     * let them think they are still the
 	     * first 
@@ -1346,16 +1336,16 @@ c_goal(Term Goal)
 	  }
 	  save = onlast;
 	  onlast = FALSE;
-	  c_goal(ArgOfTerm(1, arg));
+	  c_goal(ArgOfTerm(1, arg), mod);
 	  if (!optimizing_comit) {
 	    c_var((Term) comitvar, comit_b_flag,
 		  1);
 	  }
 	  onlast = save;
-	  c_goal(ArgOfTerm(2, arg));
+	  c_goal(ArgOfTerm(2, arg), mod);
 	}
 	else
-	  c_goal(ArgOfTerm(1, Goal));
+	  c_goal(ArgOfTerm(1, Goal), mod);
 	if (!onlast) {
 	  emit(jump_op, m, Zero);
 	}
@@ -1372,16 +1362,15 @@ c_goal(Term Goal)
      else {
 	optimizing_comit = FALSE;	/* not really necessary */
      }
-      c_goal(Goal);
+      c_goal(Goal, mod);
      /*              --onbranch; */
      onbranch = pop_branch();
      if (!onlast) {
 	emit(label_op, m, Zero);
 	if ((onlast = save))
-	  c_goal(MkAtomTerm(AtomTrue));
+	  c_goal(MkAtomTerm(AtomTrue), mod);
      }
      emit(pop_or_op, Zero, Zero);
-      *CurrentModulePtr = MkIntTerm(save_CurrentModule);
      return;
    }
    else if (f == FunctorComma) {
@@ -1389,10 +1378,9 @@ c_goal(Term Goal)
      int t2 = ArgOfTerm(2, Goal);

      onlast = FALSE;
-      c_goal(ArgOfTerm(1, Goal));
+      c_goal(ArgOfTerm(1, Goal), mod);
      onlast = save;
-      c_goal(t2);
-      *CurrentModulePtr = MkIntTerm(save_CurrentModule);
+      c_goal(t2, mod);
      return;
    }
    else if (f == FunctorNot || f == FunctorAltNot) {
@@ -1416,7 +1404,7 @@ c_goal(Term Goal)
      emit_3ops(push_or_op, label, Zero, Zero);
      emit_3ops(either_op, label,  Zero, Zero);
      emit(restore_tmps_op, Zero, Zero);
-      c_goal(ArgOfTerm(1, Goal));
+      c_goal(ArgOfTerm(1, Goal), mod);
      c_var(comitvar, comit_b_flag, 1);
      onlast = save;
      emit(fail_op, end_label, Zero);
@@ -1427,10 +1415,9 @@ c_goal(Term Goal)
      onlast = save;
      /*              --onbranch; */
      onbranch = pop_branch();
-      c_goal(MkAtomTerm(AtomTrue));
+      c_goal(MkAtomTerm(AtomTrue), mod);
      ++goalno;
      emit(pop_or_op, Zero, Zero);
-      *CurrentModulePtr = MkIntTerm(save_CurrentModule);
      return;
    }
    else if (f == FunctorArrow) {
@@ -1445,11 +1432,10 @@ c_goal(Term Goal)
      }
      onlast = FALSE;
      c_var(comitvar, save_b_flag, 1);
-      c_goal(ArgOfTerm(1, Goal));
+      c_goal(ArgOfTerm(1, Goal), mod);
      c_var(comitvar, comit_b_flag, 1);
      onlast = save;
-      c_goal(ArgOfTerm(2, Goal));
-      *CurrentModulePtr = MkIntTerm(save_CurrentModule);
+      c_goal(ArgOfTerm(2, Goal), mod);
      return;
    } else if (f == FunctorEq) {
      if (profiling)
@@ -1468,23 +1454,6 @@ c_goal(Term Goal)
 	READ_UNLOCK(CurrentPred->PRWLock);
 #endif
      }
-      *CurrentModulePtr = MkIntTerm(save_CurrentModule);
-      return;
-    } else if (f == FunctorModSwitch) {
-      Term omod = MkVarTerm();
-      Term mod = ArgOfTerm(1, Goal);
-      Term goal = ArgOfTerm(2, Goal);
-      Term a[1];
-      int cp_onlast = onlast;
-      onlast = FALSE;
-      a[0] = omod;
-      c_goal(MkApplTerm(FunctorCurrentModule, 1, a));
-      a[0] = mod;
-      c_goal(MkApplTerm(FunctorChangeModule, 1, a));
-      c_goal(goal);
-      a[0] = omod;
-      onlast = cp_onlast;
-      c_goal(MkApplTerm(FunctorChangeModule, 1, a));
      return;
    } else if (p->PredFlags & BasicPredFlag) {
      int op = p->PredFlags & 0x7f;
@@ -1505,16 +1474,16 @@ c_goal(Term Goal)
 	  READ_UNLOCK(CurrentPred->PRWLock);
 #endif
 	}
-	*CurrentModulePtr = MkIntTerm(save_CurrentModule);
 	return;
      } else if (op >= _plus && op <= _functor) {
 	if (op == _functor) {
-	  c_functor(Goal);
+	  c_functor(Goal, mod);
 	} else {
 	  c_bifun(op,
 		  ArgOfTerm(1, Goal),
 		  ArgOfTerm(2, Goal),
-		  ArgOfTerm(3, Goal));
+		  ArgOfTerm(3, Goal),
+		  mod);
 	}
 	if (onlast) {
 	  emit(deallocate_op, Zero, Zero);
@@ -1529,7 +1498,6 @@ c_goal(Term Goal)
 	  READ_UNLOCK(CurrentPred->PRWLock);
 #endif
 	}
-	*CurrentModulePtr = MkIntTerm(save_CurrentModule);
 	return;
      } else {
 	c_args(Goal);
@@ -1604,7 +1572,6 @@ c_goal(Term Goal)
 	  READ_UNLOCK(CurrentPred->PRWLock);
 #endif
      }
-      *CurrentModulePtr = MkIntTerm(save_CurrentModule);
      return;
    } else {
      if (profiling)
@@ -1678,7 +1645,6 @@ c_goal(Term Goal)
    if (!onlast)
      ++goalno;
  }
-  *CurrentModulePtr = MkIntTerm(save_CurrentModule);
 }

 static void
@@ -1707,7 +1673,7 @@ get_type_info(Term Goal)
 }

 static void
-c_body(Term Body)
+c_body(Term Body, int mod)
 {
  onhead = FALSE;
  BodyStart = cpc;
@@ -1728,11 +1694,11 @@ c_body(Term Body)
      Body = ArgOfTerm(1, Body);
      break;
    }
-    c_goal(ArgOfTerm(1, Body));
+    c_goal(ArgOfTerm(1, Body), mod);
    Body = t2;
  }
  onlast = TRUE;
-  c_goal(Body);
+  c_goal(Body, mod);
 }

 static void
@@ -2739,7 +2705,7 @@ c_optimize(PInstr *pc)
 }

 CODEADDR
-cclause(Term inp_clause, int NOfArgs)
+cclause(Term inp_clause, int NOfArgs, int mod)
 {				/* compile a prolog clause, copy of clause myst be in ARG1 */
  /* returns address of code for clause */
  Term head, body;
@@ -2750,7 +2716,6 @@ cclause(Term inp_clause, int NOfArgs)
  int botch_why;
  volatile Term my_clause = inp_clause;
  /* may botch while doing a different module */
-  volatile int save_CurrentModule = CurrentModule;

  /* first, initialise CompilerBotch to handle all cases of interruptions */
  ErrorMessage = NIL;
@@ -2760,7 +2725,6 @@ cclause(Term inp_clause, int NOfArgs)
    reset_vars();
    {
      Int osize = 2*sizeof(CELL)*(ASP-H);
-      *CurrentModulePtr = MkIntTerm(save_CurrentModule);
      ARG1 = my_clause;
      if (!gc(2, ENV, P)) {
 	Error_TYPE = SYSTEM_ERROR;
@@ -2780,7 +2744,6 @@ cclause(Term inp_clause, int NOfArgs)
    /* out of temporary cells */
    restore_machine_regs();
    reset_vars();
-    *CurrentModulePtr = MkIntTerm(save_CurrentModule);
    if (maxvnum < 16*1024) {
      maxvnum *= 2;
    } else {
@@ -2790,7 +2753,6 @@ cclause(Term inp_clause, int NOfArgs)
    /* not enough heap */
    restore_machine_regs();
    reset_vars();
-    *CurrentModulePtr = MkIntTerm(save_CurrentModule);
    Error_TYPE = SYSTEM_ERROR;
    Error_Term = TermNil;
    ErrorMessage = "not enough heap space to compile clause";
@@ -2798,7 +2760,6 @@ cclause(Term inp_clause, int NOfArgs)
  }
 restart_compilation:
  if (ErrorMessage != NIL) {
-    *CurrentModulePtr = MkIntTerm(save_CurrentModule);
    reset_vars();
    return (0);
  }
@@ -2852,9 +2813,9 @@ cclause(Term inp_clause, int NOfArgs)
    /* find out which predicate we are compiling for */
    if (IsAtomTerm(head)) {
      Atom ap = AtomOfTerm(head);
-      CurrentPred = RepPredProp(PredProp(ap, 0));
+      CurrentPred = RepPredProp(PredPropByAtom(ap, mod));
    } else {
-      CurrentPred = RepPredProp(PredPropByFunc(FunctorOfTerm(head),*CurrentModulePtr));
+      CurrentPred = RepPredProp(PredPropByFunc(FunctorOfTerm(head),mod));
    }
    /* insert extra instructions to count calls */
    READ_LOCK(CurrentPred->PRWLock);
@@ -2868,7 +2829,7 @@ cclause(Term inp_clause, int NOfArgs)
  /* phase 1 : produce skeleton code and variable information              */
  c_head(head);
  emit(allocate_op, Zero, Zero);
-  c_body(body);
+  c_body(body, mod);
  /* Insert blobs at the very end */ 
  if (BlobsStart != NULL) {
    cpc->nextInst = BlobsStart;
--- a/C/computils.c
+++ b/C/computils.c
@@ -68,23 +68,25 @@ AllocCMem (int size)
 }

 int
-is_a_test_pred (Term arg)
+is_a_test_pred (Term arg, SMALLUNSGN mod)
 {
  if (IsVarTerm (arg))
    return (FALSE);
  else if (IsAtomTerm (arg))
    {
      Atom At = AtomOfTerm (arg);
-      if (RepPredProp (PredProp (At, 0)) == NULL)
+      PredEntry *pe = RepPredProp(PredPropByAtom(At, mod));
+      if (EndOfPAEntr(pe))
 	return (FALSE);
-      return (RepPredProp (PredProp (At, 0))->PredFlags & TestPredFlag);
+      return (pe->PredFlags & TestPredFlag);
    }
  else if (IsApplTerm (arg))
    {
      Functor f = FunctorOfTerm (arg);
-      if (RepPredProp (PredPropByFunc (f, *CurrentModulePtr)) == NULL)
+      PredEntry *pe = RepPredProp(PredPropByFunc(f, mod));
+      if (EndOfPAEntr(pe))
 	return (FALSE);
-      return (RepPredProp (PredPropByFunc (f, *CurrentModulePtr))->PredFlags & TestPredFlag);
+      return (pe->PredFlags & TestPredFlag);
    }
  else
    return (FALSE);
--- a/C/corout.c
+++ b/C/corout.c
@@ -1158,8 +1158,8 @@ void InitCoroutPreds(void)
  attas[susp_ext].mark_op = mark_suspended_goal;
 #endif /* FIXED_STACKS */
  at = LookupAtom("$wake_up_goal");
-  pred = RepPredProp(PredProp(at, 2));
-  WakeUpCode = (CELL *) pred;
+  pred = RepPredProp(PredPropByFunc(MkFunctor(at, 2),0));
+  WakeUpCode = pred;
  InitAttVarPreds();
 #endif /* COROUTINING */
  InitCPred("$read_svar_list", 2, p_read_svar_list, SafePredFlag);
--- a/C/dbase.c
+++ b/C/dbase.c
@@ -164,8 +164,6 @@ static Term      DBErrorTerm; /* error term */
 static char     *DBErrorMsg;       /* Error Message */
 static DBRef    *tofref;	/* place the refs also up	 */

-static SMALLUNSGN      DBModule;
-
 CELL *next_float = NULL;

 #ifdef SFUNC
@@ -197,7 +195,7 @@ STATIC_PROTO(void linkblk,(link_entry *,CELL *));
 STATIC_PROTO(CELL *linkcells,(CELL *,Int));
 #endif
 STATIC_PROTO(Int cmpclls,(CELL *,CELL *,Int));
-STATIC_PROTO(Prop FindDBProp,(AtomEntry *, int, unsigned int));
+STATIC_PROTO(Prop FindDBProp,(AtomEntry *, int, unsigned int, SMALLUNSGN));
 STATIC_PROTO(CELL  CalcKey, (Term));
 STATIC_PROTO(CELL  *MkDBTerm, (CELL *, CELL *, CELL *, CELL *, CELL *, int *));
 STATIC_PROTO(DBRef  CreateDBStruct, (Term, DBProp, int));
@@ -392,7 +390,7 @@ int DBTrailOverflow(void)

 /* get DB entry for ap/arity; */
 static Prop 
-FindDBPropHavingLock(AtomEntry *ae, int CodeDB, unsigned int arity)
+FindDBPropHavingLock(AtomEntry *ae, int CodeDB, unsigned int arity, SMALLUNSGN dbmod)
 {
  Prop          p0;
  DBProp        p;
@@ -400,7 +398,7 @@ FindDBPropHavingLock(AtomEntry *ae, int CodeDB, unsigned int arity)
  p = RepDBProp(p0 = ae->PropsOfAE);
  while (p0 && (((p->KindOfPE & ~0x1) != (CodeDB|DBProperty)) ||
 		(p->ArityOfDB != arity) ||
-		((CodeDB & MkCode) && p->ModuleOfDB && p->ModuleOfDB != DBModule ))) {
+		((CodeDB & MkCode) && p->ModuleOfDB && p->ModuleOfDB != dbmod))) {
    p = RepDBProp(p0 = p->NextOfPE);
  }
  return (p0);
@@ -409,12 +407,12 @@ FindDBPropHavingLock(AtomEntry *ae, int CodeDB, unsigned int arity)

 /* get DB entry for ap/arity; */
 static Prop 
-FindDBProp(AtomEntry *ae, int CodeDB, unsigned int arity)
+FindDBProp(AtomEntry *ae, int CodeDB, unsigned int arity, SMALLUNSGN dbmod)
 {
  Prop out;

  READ_LOCK(ae->ARWLock);
-  out = FindDBPropHavingLock(ae, CodeDB, arity);
+  out = FindDBPropHavingLock(ae, CodeDB, arity, dbmod);
  READ_UNLOCK(ae->ARWLock);
  return(out);
 }
@@ -1551,7 +1549,6 @@ p_rcda(void)
  /* Idiotic xlc's cpp does not work with ARG1 within MkDBRefTerm */
  Term            TRef, t1 = Deref(ARG1), t2 = Deref(ARG2);

-  DBModule = 0;
  if (!IsVarTerm(Deref(ARG3)))
    return (FALSE);
 restart_record:
@@ -1591,7 +1588,6 @@ p_rcdap(void)
 {
  Term            TRef, t1 = Deref(ARG1), t2 = Deref(ARG2);

-  DBModule = CurrentModule;
  if (!IsVarTerm(Deref(ARG3)))
    return (FALSE);
 restart_record:
@@ -1631,7 +1627,6 @@ p_rcdz(void)
 {
  Term            TRef, t1 = Deref(ARG1), t2 = Deref(ARG2);

-  DBModule = 0;
  if (!IsVarTerm(Deref(ARG3)))
    return (FALSE);
 restart_record:
@@ -1671,7 +1666,6 @@ p_rcdzp(void)
 {
  Term            TRef, t1 = Deref(ARG1), t2 = Deref(ARG2);

-  DBModule = CurrentModule;
  if (!IsVarTerm(Deref(ARG3)))
    return (FALSE);
 restart_record:
@@ -1713,7 +1707,6 @@ p_rcdstatp(void)
  int mk_first;
  Term TRef;

-  DBModule = CurrentModule;
  if (IsVarTerm(t3) || !IsIntTerm(t3))
    return (FALSE);
  if (IsVarTerm(t3) || !IsIntTerm(t3))
@@ -1759,7 +1752,6 @@ p_drcdap(void)
 {
  Term            TRef, t1 = Deref(ARG1), t2 = Deref(ARG2), t4 = Deref(ARG4);

-  DBModule = CurrentModule;
  if (!IsVarTerm(Deref(ARG3)))
    return (FALSE);
  if (IsVarTerm(t4) || !IsIntegerTerm(t4))
@@ -1803,7 +1795,6 @@ p_drcdzp(void)
 {
  Term            TRef, t1 = Deref(ARG1), t2 = Deref(ARG2), t4 =  Deref(ARG4);

-  DBModule = CurrentModule;
  if (!IsVarTerm(Deref(ARG3)))
    return (FALSE);
  if (IsVarTerm(t4) || !IsIntegerTerm(t4))
@@ -1849,7 +1840,6 @@ p_rcdaifnot(void)
  DBRef           db_ref;

 restart_record:
-  DBModule = 0;
  if (!IsVarTerm(Deref(ARG3)))
    return (FALSE);
  found_one = NIL;
@@ -1892,7 +1882,6 @@ p_rcdzifnot(void)
  DBRef           db_ref;

 restart_record:
-  DBModule = 0;
  if (!IsVarTerm(Deref(ARG3)))
    return (FALSE);
  found_one = NIL;
@@ -2062,7 +2051,7 @@ FetchIntDBPropFromKey(Int key, int flag, int new, char *error_mssg)
    }
    p->ArityOfDB = 0;
    p->First = p->Last = NIL;
-    p->ModuleOfDB = DBModule;
+    p->ModuleOfDB = 0;
    p->FunctorOfDB = fun;
    p->NextOfPE = INT_KEYS[hash_key];
    INIT_RWLOCK(p->DBRWLock);
@@ -2078,7 +2067,37 @@ FetchDBPropFromKey(Term twork, int flag, int new, char *error_mssg)
 {
  Atom At;
  Int arity;
+  SMALLUNSGN dbmod;

+  if (flag & MkCode) {
+    if (IsVarTerm(twork)) {
+      Error(INSTANTIATION_ERROR, twork, error_mssg);
+      return(RepDBProp(NIL));
+    }
+    if (!IsApplTerm(twork)) {
+      Error(SYSTEM_ERROR, twork, "missing module");
+      return(RepDBProp(NIL));
+    } else {
+      Functor f = FunctorOfTerm(twork);
+      Term tmod;
+      if (f != FunctorModule) {
+	Error(SYSTEM_ERROR, twork, "missing module");
+	return(RepDBProp(NIL));
+      }
+      tmod = ArgOfTerm(1, twork);
+      if (IsVarTerm(tmod)) {
+	Error(INSTANTIATION_ERROR, twork, "var in module");
+	return(RepDBProp(NIL));
+      }
+      if (!IsAtomTerm(tmod)) {
+	Error(TYPE_ERROR_ATOM, twork, "not atom in module");
+	return(RepDBProp(NIL));
+      }
+      dbmod = LookupModule(tmod);
+      twork = ArgOfTerm(2, twork);
+    }
+  } else
+    dbmod = 0;
  if (IsVarTerm(twork)) {
    Error(INSTANTIATION_ERROR, twork, error_mssg);
    return(RepDBProp(NIL));
@@ -2106,11 +2125,13 @@ FetchDBPropFromKey(Term twork, int flag, int new, char *error_mssg)
    AtomEntry *ae = RepAtom(At);

    WRITE_LOCK(ae->ARWLock);
-    if (EndOfPAEntr(p = RepDBProp(FindDBPropHavingLock(ae, flag, arity)))) {
+    if (EndOfPAEntr(p = RepDBProp(FindDBPropHavingLock(ae, flag, arity, dbmod)))) {
     /* create a new DBProp				 */
      int OLD_UPDATE_MODE = UPDATE_MODE;
      if (flag & MkCode) {
-	PredEntry *pp = RepPredProp(GetPredPropHavingLock(At, arity));
+	PredEntry *pp;
+	pp = RepPredProp(GetPredPropHavingLock(At, arity, dbmod));
+
 	if (!EndOfPAEntr(pp)) {
 	  READ_LOCK(pp->PRWLock);
 	  if(pp->PredFlags & LogUpdatePredFlag)
@@ -2139,7 +2160,7 @@ FetchDBPropFromKey(Term twork, int flag, int new, char *error_mssg)
      UPDATE_MODE = OLD_UPDATE_MODE;
      p->ArityOfDB = arity;
      p->First = p->Last = NIL;
-      p->ModuleOfDB = DBModule;
+      p->ModuleOfDB = dbmod;
      /* This is NOT standard but is QUITE convenient */
      INIT_RWLOCK(p->DBRWLock);
      if (arity == 0)
@@ -2152,7 +2173,7 @@ FetchDBPropFromKey(Term twork, int flag, int new, char *error_mssg)
    WRITE_UNLOCK(ae->ARWLock);
    return(p);
  } else
-    return(RepDBProp(FindDBProp(RepAtom(At), flag, arity)));
+    return(RepDBProp(FindDBProp(RepAtom(At), flag, arity, dbmod)));
 }

 /* Finds a term recorded under the key ARG1			 */
@@ -2335,7 +2356,6 @@ p_db_key(void)
  Register Term   twork = Deref(ARG1);	/* fetch the key */
  DBProp          AtProp;

-  DBModule = 0;
  if (EndOfPAEntr(AtProp = FetchDBPropFromKey(twork, 0, TRUE, "db_key/3"))) {
    /* should never happen */
    return(FALSE);
@@ -2733,7 +2753,6 @@ in_rded(void)
 					 * ARG1 */


-  DBModule = 0;
  if (EndOfPAEntr(AtProp = FetchDBPropFromKey(twork, 0, FALSE, "recorded/3"))) {
    if (b0 == B)
      cut_fail();
@@ -2754,7 +2773,6 @@ in_rded_with_key(void)
 static Int 
 co_rded(void)
 {
-  DBModule = 0;
  return (c_recorded(0));
 }

@@ -2767,7 +2785,6 @@ in_rdedp(void)
  Register Term   twork = Deref(ARG1);	/* initially working with
 					 * ARG1 */

-  DBModule = CurrentModule;
  if (EndOfPAEntr(AtProp = FetchDBPropFromKey(twork, MkCode, FALSE, "recorded/3"))) {
    if (b0 == B)
      cut_fail();
@@ -2781,7 +2798,6 @@ in_rdedp(void)
 static Int 
 co_rdedp(void)
 {
-  DBModule = CurrentModule;
  return (c_recorded(MkCode));
 }

@@ -2793,7 +2809,6 @@ p_somercdedp(void)
  DBProp            AtProp;
  Register Term   twork = Deref(ARG1);	/* initially working with
 						 * ARG1 */
-  DBModule = CurrentModule;
  if (EndOfPAEntr(AtProp = FetchDBPropFromKey(twork, MkCode, FALSE, "some_recorded/3"))) {
    return(FALSE);
  }
@@ -2823,7 +2838,6 @@ p_first_instance(void)
  if (!IsVarTerm(ARG3)) {
    cut_fail();
  }
-  DBModule = CurrentModule;
  if (EndOfPAEntr(AtProp = FetchDBPropFromKey(twork, 0, FALSE, "first_instance/3"))) {
    return(FALSE);
  }
@@ -3121,11 +3135,10 @@ MyEraseClause(Clause *clau)
    father = ref->Parent;
    if ((arity = father->ArityOfDB) == 0) {
      Atom name = (Atom) father->FunctorOfDB;
-      pred = RepPredProp(PredProp(name, 0));
+      pred = RepPredProp(PredPropByAtom(name, father->ModuleOfDB));
    } else {
-      pred = RepPredProp(PredPropByFunc(father->FunctorOfDB, *CurrentModulePtr));
+      pred = RepPredProp(PredPropByFunc(father->FunctorOfDB, father->ModuleOfDB));
    }
-    DBModule = father->ModuleOfDB;
    WRITE_LOCK(pred->PRWLock);
    if (StillInChain((CODEADDR)(clau->ClCode), pred)) {
      if (previous == NIL && next != NIL) {
@@ -3315,11 +3328,10 @@ PrepareToEraseClause(Clause *clau, DBRef dbr)
    /* inefficient, but that will do for the moment, sir. */
    if (father->ArityOfDB == 0) {
      Atom name = (Atom) father->FunctorOfDB;
-      pred = RepPredProp(PredProp(name, 0));
+      pred = RepPredProp(PredPropByAtom(name, father->ModuleOfDB));
    } else {
-      pred = RepPredProp(PredPropByFunc(father->FunctorOfDB, *CurrentModulePtr));
+      pred = RepPredProp(PredPropByFunc(father->FunctorOfDB, father->ModuleOfDB));
    }
-    DBModule = father->ModuleOfDB;
    WRITE_LOCK(pred->PRWLock);
    /* got my pred entry, let's have some fun! */
    clau_code = (CODEADDR)(clau->ClCode);
@@ -3465,7 +3477,6 @@ p_eraseall(void)
  Register DBRef  entryref;
  DBProp          p;

-  DBModule = 0;
  if (EndOfPAEntr(p = FetchDBPropFromKey(twork, 0, FALSE, "eraseall/3"))) {
    return(TRUE);
  }
@@ -3947,7 +3958,6 @@ p_first_age(void)
  Term to;
  DBProp AtProp;

-  DBModule = CurrentModule;
  if (EndOfPAEntr(AtProp = FetchDBPropFromKey(t1, MkCode, FALSE, "first_age/3"))) {
    return(FALSE);
  }
@@ -3984,7 +3994,6 @@ p_db_nb_to_ref(void)
  else if (IsLongIntTerm(t1))
    age = LongIntOfTerm(t1);
  else return(FALSE);
-  DBModule = CurrentModule;
  if (EndOfPAEntr(AtProp = FetchDBPropFromKey(t2, MkCode, FALSE, "recorded/3"))) {
    return(FALSE);
  }
@@ -4024,7 +4033,6 @@ p_last_age(void)
  DBProp AtProp;
  Term last_age;

-  DBModule = CurrentModule;
  if ((AtProp = FetchDBPropFromKey(t1, MkCode, FALSE, "$last_age/2")) == NIL) {
    return(FALSE);
  }
@@ -4065,7 +4073,6 @@ p_hold_index(void)
  DBRef index;


-  DBModule = CurrentModule;
  if (EndOfPAEntr(AtProp = (LogUpdDBProp)FetchDBPropFromKey(Deref(ARG1), MkCode, FALSE, "recorded/3"))) {
    return(FALSE);
  }
@@ -4173,16 +4180,16 @@ InitBackDB(void)
  InitCPredBack("recorded", 3, 3, in_rded, co_rded, SyncPredFlag);
  /* internal version, just to prevent the debugger from nosying around */
  RETRY_C_RECORDED_CODE = NEXTOP((yamop *)
-    (RepPredProp(PredProp(LookupAtom("recorded"), 3))->FirstClause),lds);
+    (RepPredProp(PredPropByFunc(MkFunctor(LookupAtom("recorded"), 3),0))->FirstClause),lds);
  InitCPredBack("$recorded_with_key", 3, 3, in_rded_with_key, co_rded, SyncPredFlag);
  RETRY_C_RECORDED_K_CODE = NEXTOP((yamop *)
-    (RepPredProp(PredProp(LookupAtom("$recorded_with_key"), 3))->FirstClause),lds);
+    (RepPredProp(PredPropByFunc(MkFunctor(LookupAtom("$recorded_with_key"), 3),0))->FirstClause),lds);
  InitCPredBack("$recorded", 3, 3, in_rded, co_rded, SyncPredFlag);
  RETRY_C_DRECORDED_CODE = NEXTOP((yamop *)
-    (RepPredProp(PredProp(LookupAtom("$recorded"), 3))->FirstClause),lds);
+    (RepPredProp(PredPropByFunc(MkFunctor(LookupAtom("$recorded"), 3),0))->FirstClause),lds);
  InitCPredBack("$recordedp", 3, 3, in_rdedp, co_rdedp, SyncPredFlag);
  RETRY_C_RECORDEDP_CODE = NEXTOP((yamop *)
-    (RepPredProp(PredProp(LookupAtom("$recordedp"), 3))->FirstClause),lds);
+    (RepPredProp(PredPropByFunc(MkFunctor(LookupAtom("$recordedp"), 3),0))->FirstClause),lds);
  InitCPredBack("current_key", 2, 4, init_current_key, cont_current_key,
 		SyncPredFlag);
 }
--- a/C/exec.c
+++ b/C/exec.c
@@ -61,26 +61,28 @@ CallPredicate(PredEntry *pen, choiceptr cut_pt) {
 }

 inline static Int
-CallMetaCall(void) {
+CallMetaCall(SMALLUNSGN mod) {
  ARG2 = current_cp_as_integer(); /* p_save_cp */
  ARG3 = ARG1;
+  ARG4 = ModuleName[mod];
  return (CallPredicate(PredMetaCall, B));
 }

 Term
-ExecuteCallMetaCall(void) {
-  Term ts[3];
+ExecuteCallMetaCall(SMALLUNSGN mod) {
+  Term ts[4];
  ts[0] = ARG1;
  ts[1] = current_cp_as_integer(); /* p_save_cp */
  ts[2] = ARG1;
-  return(MkApplTerm(PredMetaCall->FunctorOfPred,3,ts));
+  ts[3] = ModuleName[mod];
+  return(MkApplTerm(PredMetaCall->FunctorOfPred,4,ts));
 }

 static Int
-CallError(yap_error_number err)
+CallError(yap_error_number err, SMALLUNSGN mod)
 {
  if (yap_flags[LANGUAGE_MODE_FLAG] == 1) {
-    return(CallMetaCall());
+    return(CallMetaCall(mod));
  } else {
    Error(err, ARG1, "call/1");
    return(FALSE);
@@ -189,42 +191,51 @@ p_save_cp(void)
 }

 inline static Int
-EnterCreepMode(PredEntry *pen) {
-  PredEntry *PredSpy = RepPredProp(PredPropByFunc(FunctorSpy,*CurrentModulePtr));
-  ARG1 = MkPairTerm(Module_Name((CODEADDR)(pen)),ARG1);
+EnterCreepMode(PredEntry *pen, Term t) {
+  PredEntry *PredSpy = RepPredProp(PredPropByFunc(FunctorSpy,0));
+  ARG1 = MkPairTerm(Module_Name((CODEADDR)(pen)),t);
  CreepFlag = CalculateStackGap();
  P_before_spy = P;
  return (CallPredicate(PredSpy, B));
 }

 inline static Int
-do_execute(Term t)
+do_execute(Term t, int mod)
 {
-
  if (PredGoalExpansion->OpcodeOfPred != UNDEF_OPCODE) {
-    return(CallMetaCall());
+    return(CallMetaCall(mod));
  }
+ restart_exec:
  if (IsVarTerm(t)) {
-    return CallError(INSTANTIATION_ERROR);
+    return CallError(INSTANTIATION_ERROR, mod);
  } else if (IsApplTerm(t)) {
    register Functor f = FunctorOfTerm(t);
    register CELL *pt;
    PredEntry *pen;
    unsigned int i, arity;

+    f = FunctorOfTerm(t);
    if (IsExtensionFunctor(f)) {
-      return CallError(TYPE_ERROR_CALLABLE);
+      return CallError(TYPE_ERROR_CALLABLE, mod);
    }
    arity = ArityOfFunctor(f);
    
-    pen = RepPredProp(PredPropByFunc(f, *CurrentModulePtr));
+    pen = RepPredProp(PredPropByFunc(f, mod));
    /* You thought we would be over by now */
    /* but no meta calls require special preprocessing */
    if (pen->PredFlags & MetaPredFlag) {
-      return(CallMetaCall());
+      if (f == FunctorModule) {
+	Term tmod = ArgOfTerm(1,t);
+	if (!IsVarTerm(tmod) && IsAtomTerm(tmod)) {
+	  mod = LookupModule(tmod);
+	  t = ArgOfTerm(2,t);
+	  goto restart_exec;
+	}
+      }
+      return(CallMetaCall(mod));
    }
    if (yap_flags[SPY_CREEP_FLAG]) {
-      return(EnterCreepMode(pen));
+      return(EnterCreepMode(pen, t));
    }
    /* now let us do what we wanted to do from the beginning !! */
    /* I cannot use the standard macro here because
@@ -252,16 +263,16 @@ do_execute(Term t)
    else if (a == AtomFail || a == AtomFalse)
      return(FALSE);
    /* call may not define new system predicates!! */
-    pe = RepPredProp(PredPropByAtom(a, *CurrentModulePtr));
+    pe = RepPredProp(PredPropByAtom(a, mod));
    if (yap_flags[SPY_CREEP_FLAG]) {
-      return(EnterCreepMode(pe));
+      return(EnterCreepMode(pe, t));
    }
    return (CallPredicate(pe, B));
  } else if (IsIntTerm(t)) {
-    return CallError(TYPE_ERROR_CALLABLE);
+    return CallError(TYPE_ERROR_CALLABLE, mod);
  } else {
    /* Is Pair Term */
-    return(CallMetaCall());
+    return(CallMetaCall(mod));
  }
 }

@@ -269,21 +280,13 @@ static Int
 p_execute(void)
 {				/* '$execute'(Goal)	 */
  Term            t = Deref(ARG1);
-  return(do_execute(t));
+  return(do_execute(t, CurrentModule));
 }

 static Int
 p_execute_in_mod(void)
 {				/* '$execute'(Goal)	 */
-  if (ARG2 != ModuleName[CurrentModule]) {
-    /* switch modules, but do it in Prolog */
-    Term ts[2];
-
-    ts[0] = ARG2;
-    ts[1] = ARG1;
-    ARG1 = MkApplTerm(FunctorModule, 2, ts);
-  }
-  return(do_execute(Deref(ARG1)));
+  return(do_execute(Deref(ARG1), IntOfTerm(ARG2)));
 }

 inline static Int
@@ -292,62 +295,54 @@ CallMetaCallWithin(void)
  return (CallPredicate(PredMetaCall, B));
 }

-/* '$execute_within'(Goal,CutPt,OrigGoal)	 */
+/* '$execute_within'(Goal,CutPt,OrigGoal,Mod)	 */
 static Int
 p_execute_within(void)
 { 
  Term            t = Deref(ARG1);
+  Term            tmod = Deref(ARG4);
  unsigned int    arity;
  Prop            pe;
  Atom            a;
+  SMALLUNSGN      mod = LookupModule(tmod);

 restart_exec:
  if (PredGoalExpansion->OpcodeOfPred != UNDEF_OPCODE) {
    return(CallMetaCallWithin());
  } else  if (IsVarTerm(t)) {
-    return CallError(INSTANTIATION_ERROR);
+    return CallError(INSTANTIATION_ERROR, mod);
  } else if (IsApplTerm(t)) {
    register Functor f = FunctorOfTerm(t);
    register unsigned int    i;
    register CELL *pt;

    if (IsExtensionFunctor(f)) {
-      return CallError(TYPE_ERROR_CALLABLE);
+      return CallError(TYPE_ERROR_CALLABLE, mod);
    }
    
-    if (f == FunctorModule) {
-      Term mod = ArgOfTerm(1, t);
-      if (mod == ModuleName[CurrentModule]) {
-	/* we can skip this operation */
-	/* should catch most cases */
-	t = ArgOfTerm(2, t);
-	goto restart_exec;
-      } else {
-	/* I can't do better because I don't have a way of restoring the module */
-	return(CallMetaCallWithin());
-      }
-    } else {
+    {
      PredEntry *pen;
      arity = ArityOfFunctor(f);
      a = NameOfFunctor(f);

-      if (CurrentModule)
-	pe = PredPropByFunc(f, *CurrentModulePtr);
-      else {
-	pe = GetPredPropByFunc(f, *CurrentModulePtr);
-	if (pe == NIL) {
-	  return(CallMetaCallWithin());
-	}
-      }
+      pe = PredPropByFunc(f, mod);
      pen = RepPredProp(pe);
      /* You thought we would be over by now */
      /* but no meta calls require special preprocessing */
      if (pen->PredFlags & MetaPredFlag) {
+	if (f == FunctorModule) {
+	  Term tmod = ArgOfTerm(1,t);
+	  if (!IsVarTerm(tmod) && IsAtomTerm(tmod)) {
+	    mod = LookupModule(tmod);
+	    t = ArgOfTerm(2,t);
+	    goto restart_exec;
+	  }
+	}
 	return(CallMetaCallWithin());
      }
      /* at this point check if we should enter creep mode */ 
      if (yap_flags[SPY_CREEP_FLAG]) {
-	return(EnterCreepMode(pen));
+	return(EnterCreepMode(pen,t));
      }
      /* now let us do what we wanted to do from the beginning !! */
      /* I cannot use the standard macro here because
@@ -369,7 +364,7 @@ p_execute_within(void)
    }
  } else if (IsAtomOrIntTerm(t)) {
    if (IsIntTerm(t)) {
-      return CallError(TYPE_ERROR_CALLABLE);
+      return CallError(TYPE_ERROR_CALLABLE, mod);
    }    
    a = AtomOfTerm(t);
    if (a == AtomTrue || a == AtomOtherwise)
@@ -401,9 +396,9 @@ p_execute_within(void)
      return(FALSE);
    } else {
      /* call may not define new system predicates!! */
-      pe = PredPropByAtom(a, *CurrentModulePtr);
+      pe = PredPropByAtom(a, mod);
      if (yap_flags[SPY_CREEP_FLAG]) {
-	return(EnterCreepMode(RepPredProp(pe)));
+	return(EnterCreepMode(RepPredProp(pe),t));
      }
      return (CallPredicate(RepPredProp(pe), B));
    }
@@ -423,12 +418,12 @@ p_execute_within2(void)
  if (PredGoalExpansion->OpcodeOfPred != UNDEF_OPCODE) {
    return(CallMetaCallWithin());
  } else  if (IsVarTerm(t)) {
-    return CallError(INSTANTIATION_ERROR);
+    return CallError(INSTANTIATION_ERROR, CurrentModule);
  } else if (IsApplTerm(t)) {
    register Functor f = FunctorOfTerm(t);

    if (IsExtensionFunctor(f)) {
-      return CallError(TYPE_ERROR_CALLABLE);
+      return CallError(TYPE_ERROR_CALLABLE, CurrentModule);
    }
    
    {
@@ -438,7 +433,7 @@ p_execute_within2(void)
      register unsigned int    i;
      unsigned int arity = ArityOfFunctor(f);

-      pe = PredPropByFunc(f, *CurrentModulePtr);
+      pe = PredPropByFunc(f, CurrentModule);
      pen = RepPredProp(pe);
      /* You thought we would be over by now */
      /* but no meta calls require special preprocessing */
@@ -447,7 +442,7 @@ p_execute_within2(void)
      }
      /* at this point check if we should enter creep mode */ 
      if (yap_flags[SPY_CREEP_FLAG]) {
-	return(EnterCreepMode(pen));
+	return(EnterCreepMode(pen,t));
      }
      /* now let us do what we wanted to do from the beginning !! */
      /* I cannot use the standard macro here because
@@ -498,13 +493,13 @@ p_execute_within2(void)
      return(FALSE);
    }
    /* call may not define new system predicates!! */
-    pe = PredPropByAtom(a, *CurrentModulePtr);
+    pe = PredPropByAtom(a, CurrentModule);
    if (yap_flags[SPY_CREEP_FLAG]) {
-      return(EnterCreepMode(RepPredProp(pe)));
+      return(EnterCreepMode(RepPredProp(pe),t));
    }
    return (CallPredicate(RepPredProp(pe), B));
  } else if (IsIntTerm(t)) {
-    return CallError(TYPE_ERROR_CALLABLE);
+    return CallError(TYPE_ERROR_CALLABLE, CurrentModule);
  } else {
    /* Is Pair Term */
    return(CallMetaCallWithin());
@@ -514,14 +509,16 @@ p_execute_within2(void)

 static Int
 p_execute0(void)
-{				/* '$execute'(Goal)	 */
+{				/* '$execute0'(Goal,Mod)	 */
  Term            t = Deref(ARG1);
+  Term            tmod = Deref(ARG2);
  unsigned int    arity;
  Prop            pe;
+  SMALLUNSGN      mod = LookupModule(tmod);

  if (IsAtomTerm(t)) {
    Atom a = AtomOfTerm(t);
-    pe = PredPropByAtom(a, *CurrentModulePtr);
+    pe = PredPropByAtom(a, mod);
  } else if (IsApplTerm(t)) {
    register Functor f = FunctorOfTerm(t);
    register unsigned int    i;
@@ -545,7 +542,7 @@ p_execute0(void)
      XREGS[i] = *pt++;
 #endif
    }
-    pe = GetPredPropByFunc(f, *CurrentModulePtr);
+    pe = PredPropByFunc(f, mod);
  } else
    return (FALSE);	/* for the moment */
  /*	N = arity; */
@@ -557,11 +554,12 @@ static Int
 p_execute_0(void)
 {				/* '$execute_0'(Goal)	 */
  Term            t = Deref(ARG1);
+  SMALLUNSGN      mod = LookupModule(Deref(ARG2));
  Prop            pe;
  Atom            a;

  a = AtomOfTerm(t);
-  pe = PredPropByAtom(a, *CurrentModulePtr);
+  pe = PredPropByAtom(a, mod);
  return (CallPredicate(RepPredProp(pe), B));
 }

@@ -569,18 +567,13 @@ static Int
 p_execute_1(void)
 {				/* '$execute_0'(Goal)	 */
  Term            t = Deref(ARG1);
+  SMALLUNSGN      mod = LookupModule(Deref(ARG3));
  Prop            pe;
  Atom            a;

  a = AtomOfTerm(t);
  ARG1 = ARG2;
-  if (CurrentModule)
-    pe = PredProp(a, 1);
-  else {
-    pe = GetPredProp(a, 1);
-    if (pe == NIL)
-      return(FALSE);
-  }
+  pe = PredPropByFunc(MkFunctor(a,1),mod);
  return (CallPredicate(RepPredProp(pe), B));
 }

@@ -588,19 +581,14 @@ static Int
 p_execute_2(void)
 {				/* '$execute_2'(Goal)	 */
  Term            t = Deref(ARG1);
+  SMALLUNSGN      mod = LookupModule(Deref(ARG4));
  Prop            pe;
  Atom            a;

  a = AtomOfTerm(t);
  ARG1 = ARG2;
  ARG2 = ARG3;
-  if (CurrentModule)
-    pe = PredProp(a, 2);
-  else {
-    pe = GetPredProp(a, 2);
-    if (pe == NIL)
-      return(FALSE);
-  }
+  pe = PredPropByFunc(MkFunctor(a, 2),mod);
  return (CallPredicate(RepPredProp(pe), B));
 }

@@ -608,6 +596,7 @@ static Int
 p_execute_3(void)
 {				/* '$execute_3'(Goal)	 */
  Term            t = Deref(ARG1);
+  SMALLUNSGN      mod = LookupModule(Deref(ARG5));
  Prop            pe;
  Atom            a;

@@ -615,13 +604,7 @@ p_execute_3(void)
  ARG1 = ARG2;
  ARG2 = ARG3;
  ARG3 = ARG4;
-  if (CurrentModule)
-    pe = PredProp(a, 3);
-  else {
-    pe = GetPredProp(a, 3);
-    if (pe == NIL)
-      return(FALSE);
-  }
+  pe = PredPropByFunc(MkFunctor(a, 3),mod);
  return (CallPredicate(RepPredProp(pe), B));
 }

@@ -629,6 +612,7 @@ static Int
 p_execute_4(void)
 {				/* '$execute_4'(Goal)	 */
  Term            t = Deref(ARG1);
+  SMALLUNSGN      mod = LookupModule(Deref(ARG6));
  Prop            pe;
  Atom            a;

@@ -637,13 +621,7 @@ p_execute_4(void)
  ARG2 = ARG3;
  ARG3 = ARG4;
  ARG4 = ARG5;
-  if (CurrentModule)
-    pe = PredProp(a, 4);
-  else {
-    pe = GetPredProp(a, 4);
-    if (pe == NIL)
-      return(FALSE);
-  }
+  pe = PredPropByFunc(MkFunctor(a, 4),mod);
  return (CallPredicate(RepPredProp(pe), B));
 }

@@ -651,6 +629,7 @@ static Int
 p_execute_5(void)
 {				/* '$execute_5'(Goal)	 */
  Term            t = Deref(ARG1);
+  SMALLUNSGN      mod = LookupModule(Deref(ARG7));
  Prop            pe;
  Atom            a;

@@ -660,13 +639,7 @@ p_execute_5(void)
  ARG3 = ARG4;
  ARG4 = ARG5;
  ARG5 = ARG6;
-  if (CurrentModule)
-    pe = PredProp(a, 5);
-  else {
-    pe = GetPredProp(a, 5);
-    if (pe == NIL)
-      return(FALSE);
-  }
+  pe = PredPropByFunc(MkFunctor(a, 5),mod);
  return (CallPredicate(RepPredProp(pe), B));
 }

@@ -674,6 +647,7 @@ static Int
 p_execute_6(void)
 {				/* '$execute_6'(Goal)	 */
  Term            t = Deref(ARG1);
+  SMALLUNSGN      mod = LookupModule(Deref(ARG8));
  Prop            pe;
  Atom            a;

@@ -684,13 +658,7 @@ p_execute_6(void)
  ARG4 = ARG5;
  ARG5 = ARG6;
  ARG6 = ARG7;
-  if (CurrentModule)
-    pe = PredProp(a, 6);
-  else {
-    pe = GetPredProp(a, 6);
-    if (pe == NIL)
-      return(FALSE);
-  }
+  pe = PredPropByFunc(MkFunctor(a, 6),mod);
  return (CallPredicate(RepPredProp(pe), B));
 }

@@ -698,6 +666,7 @@ static Int
 p_execute_7(void)
 {				/* '$execute_7'(Goal)	 */
  Term            t = Deref(ARG1);
+  SMALLUNSGN      mod = LookupModule(Deref(ARG9));
  Prop            pe;
  Atom            a;

@@ -709,13 +678,7 @@ p_execute_7(void)
  ARG5 = ARG6;
  ARG6 = ARG7;
  ARG7 = ARG8;
-  if (CurrentModule)
-    pe = PredProp(a, 7);
-  else {
-    pe = GetPredProp(a, 7);
-    if (pe == NIL)
-      return(FALSE);
-  }
+  pe = PredPropByFunc(MkFunctor(a, 6),mod);
  return (CallPredicate(RepPredProp(pe), B));
 }

@@ -723,6 +686,7 @@ static Int
 p_execute_8(void)
 {				/* '$execute_8'(Goal)	 */
  Term            t = Deref(ARG1);
+  SMALLUNSGN      mod = LookupModule(Deref(ARG10));
  Prop            pe;
  Atom            a;

@@ -735,13 +699,7 @@ p_execute_8(void)
  ARG6 = ARG7;
  ARG7 = ARG8;
  ARG8 = ARG9;
-  if (CurrentModule)
-    pe = PredProp(a, 8);
-  else {
-    pe = GetPredProp(a, 8);
-    if (pe == NIL)
-      return(FALSE);
-  }
+  pe = PredPropByFunc(MkFunctor(a, 8),mod);
  return (CallPredicate(RepPredProp(pe), B));
 }

@@ -749,6 +707,7 @@ static Int
 p_execute_9(void)
 {				/* '$execute_9'(Goal)	 */
  Term            t = Deref(ARG1);
+  SMALLUNSGN      mod = LookupModule(Deref(ARG11));
  Prop            pe;
  Atom            a;

@@ -762,13 +721,7 @@ p_execute_9(void)
  ARG7 = ARG8;
  ARG8 = ARG9;
  ARG9 = ARG10;
-  if (CurrentModule)
-    pe = PredProp(a, 9);
-  else {
-    pe = GetPredProp(a, 9);
-    if (pe == NIL)
-      return(FALSE);
-  }
+  pe = PredPropByFunc(MkFunctor(a, 9),mod);
  return (CallPredicate(RepPredProp(pe), B));
 }

@@ -776,6 +729,7 @@ static Int
 p_execute_10(void)
 {				/* '$execute_10'(Goal)	 */
  Term            t = Deref(ARG1);
+  SMALLUNSGN      mod = LookupModule(Deref(ARG12));
  Prop            pe;
  Atom            a;

@@ -790,13 +744,7 @@ p_execute_10(void)
  ARG8 = ARG9;
  ARG9 = ARG10;
  ARG10 = ARG11;
-  if (CurrentModule)
-    pe = PredProp(a, 10);
-  else {
-    pe = GetPredProp(a, 10);
-    if (pe == NIL)
-      return(FALSE);
-  }
+  pe = PredPropByFunc(MkFunctor(a, 10),mod);
  return (CallPredicate(RepPredProp(pe), B));
 }

@@ -825,20 +773,36 @@ p_pred_goal_expansion_on(void) {
 static Int 
 p_at_execute(void)
 {				/* '$execute'(Goal,ClauseNumber) */
-  Term            t = Deref(ARG1), t2 = Deref(ARG2);
-  unsigned int arity;
+  Term            t = Deref(ARG1), tmod = Deref(ARG2), t2 = Deref(ARG3);
+  unsigned	  int arity;
  Prop            pe;
  Atom            a;
+  SMALLUNSGN      mod = LookupModule(tmod);

-  if (IsAtomTerm(t))
-    arity = 0, a = AtomOfTerm(t);
-  else if (IsApplTerm(t)) {
+ restart_exec:
+  if (IsAtomTerm(t)) {
+    a = AtomOfTerm(t);
+    pe = PredPropByAtom(a, mod);
+    arity = 0;
+  } else if (IsApplTerm(t)) {
    register Functor f = FunctorOfTerm(t);
    register unsigned int    i;
    register CELL *pt;

    if (IsBlobFunctor(f))
      return(FALSE);
+    if (f == FunctorModule) {
+      Term tmod = ArgOfTerm(1,t);
+      if (!IsVarTerm(tmod) && IsAtomTerm(tmod)) {
+	mod = LookupModule(tmod);
+	t = ArgOfTerm(2,t);
+	goto restart_exec;
+      }
+      if (IsVarTerm(tmod)) {
+	Error(INSTANTIATION_ERROR, ARG1, "calling clause in debugger");
+      }
+      Error(TYPE_ERROR_ATOM, ARG1, "calling clause in debugger");
+    }
    arity = ArityOfFunctor(f);
    a = NameOfFunctor(f);
    /* I cannot use the standard macro here because
@@ -857,19 +821,13 @@ p_at_execute(void)
 #else
      XREGS[i] = *pt++;
 #endif
+      pe = PredPropByFunc(f,mod);
  } else
    return (FALSE);	/* for the moment */
  if (IsVarTerm(t2) || !IsIntTerm(t2))
    return (FALSE);
  /* N = arity; */
  /* call may not define new system predicates!! */
-  if (CurrentModule) {
-    pe = PredProp(a, arity);
-  } else {
-    pe = GetPredProp(a, arity);
-    if (pe == NIL)
-      return(FALSE);
-  }
  return (CallClause(RepPredProp(pe), arity, IntOfTerm(t2)));
 }

@@ -973,7 +931,6 @@ do_goal(CODEADDR CodeAdr, int arity, CELL *pt, int args_to_save, int top)
  B->cp_depth = DEPTH;
 #endif /* DEPTH_LIMIT */
  if (top) {
-    Term t;
 #if COROUTINING
    RESET_VARIABLE((CELL *)GlobalBase);
    DelayedVars = NewTimedVar((CELL)GlobalBase);
@@ -981,14 +938,12 @@ do_goal(CODEADDR CodeAdr, int arity, CELL *pt, int args_to_save, int top)
    MutableList = NewTimedVar(TermNil);
    AttsMutableList = NewTimedVar(TermNil);
 #endif
-    t = NewTimedVar(MkIntTerm(0));
-    CurrentModulePtr = RepAppl(t)+1;
  }
  YENV = ASP = (CELL *)B;
  HB = H;
  YENV[E_CB] = Unsigned (B);
  P = (yamop *) CodeAdr;
-  S = CellPtr (RepPredProp (PredProp (AtomCall, 1)));	/* A1 mishaps */
+  S = CellPtr (RepPredProp (PredPropByFunc (MkFunctor(AtomCall, 1),0)));	/* A1 mishaps */
  TopB = B;

  return(exec_absmi(top));
@@ -996,7 +951,7 @@ do_goal(CODEADDR CodeAdr, int arity, CELL *pt, int args_to_save, int top)


 Int
-execute_goal(Term t, int nargs)
+execute_goal(Term t, int nargs, SMALLUNSGN mod)
 {
  Int             out;
  CODEADDR        CodeAdr;
@@ -1021,7 +976,7 @@ execute_goal(Term t, int nargs)
  if (IsAtomTerm(t)) {
    Atom a = AtomOfTerm(t);
    pt = NULL;
-    pe = PredPropByAtom(a, *CurrentModulePtr);
+    pe = PredPropByAtom(a, mod);
  } else if (IsApplTerm(t)) {
    Functor f = FunctorOfTerm(t);

@@ -1033,31 +988,23 @@ execute_goal(Term t, int nargs)
       otherwise I would dereference the argument and
       might skip a svar */
    pt = RepAppl(t)+1;
-    pe = GetPredPropByFunc(f, *CurrentModulePtr);
+    pe = PredPropByFunc(f, mod);
  } else {
    Error(TYPE_ERROR_CALLABLE,t,"call/1");
    return(FALSE);
  }
  ppe = RepPredProp(pe);
-  if (pe != NIL) {
-    READ_LOCK(ppe->PRWLock);
-  }
-  if (pe == NIL ||
-      ppe->OpcodeOfPred == UNDEF_OPCODE ||
-      ppe->PredFlags & (UserCPredFlag|CPredFlag|BasicPredFlag) ) {
-    if (pe != NIL) {
-      READ_UNLOCK(ppe->PRWLock);
-    }
-    return(CallMetaCall());
+  if (pe == NIL) {
+    return(CallMetaCall(mod));
  }
+  READ_LOCK(ppe->PRWLock);
  if (IsAtomTerm(t)) {
-    Atom at = AtomOfTerm(t);
-    CodeAdr = RepPredProp (PredPropByAtom(at, *CurrentModulePtr))->CodeOfPred;
+    CodeAdr = RepPredProp (pe)->CodeOfPred;
    READ_UNLOCK(ppe->PRWLock);
    out = do_goal(CodeAdr, 0, pt, nargs, FALSE);
  } else {
    Functor f = FunctorOfTerm(t);
-    CodeAdr = RepPredProp (PredPropByFunc (f, *CurrentModulePtr))->CodeOfPred;
+    CodeAdr = RepPredProp (pe)->CodeOfPred;
    READ_UNLOCK(ppe->PRWLock);
    out = do_goal(CodeAdr, ArityOfFunctor(f), pt, nargs, FALSE);
  }
@@ -1181,7 +1128,7 @@ RunTopGoal(Term t)
  if (IsAtomTerm(t)) {
    Atom a = AtomOfTerm(t);
    pt = NULL;
-    pe = PredPropByAtom(a, *CurrentModulePtr);
+    pe = PredPropByAtom(a, CurrentModule);
    arity = 0;
  } else if (IsApplTerm(t)) {
    Functor f = FunctorOfTerm(t);
@@ -1193,7 +1140,7 @@ RunTopGoal(Term t)
    /* I cannot use the standard macro here because
       otherwise I would dereference the argument and
       might skip a svar */
-    pe = GetPredPropByFunc(f, *CurrentModulePtr);
+    pe = GetPredPropByFunc(f, CurrentModule);
    pt = RepAppl(t)+1;
    arity = ArityOfFunctor(f); 
  } else {
@@ -1325,10 +1272,10 @@ InitExecFs(void)
 {
  InitCPred("$execute", 1, p_execute, 0);
  InitCPred("$execute_in_mod", 2, p_execute_in_mod, 0);
-  InitCPred("$execute_within", 3, p_execute_within, 0);
+  InitCPred("$execute_within", 4, p_execute_within, 0);
  InitCPred("$execute_within", 1, p_execute_within2, 0);
  InitCPred("$last_execute_within", 1, p_execute_within2, 0);
-  InitCPred("$execute", 2, p_at_execute, 0);
+  InitCPred("$execute", 3, p_at_execute, 0);
  InitCPred("$call_with_args", 1, p_execute_0, 0);
  InitCPred("$call_with_args", 2, p_execute_1, 0);
  InitCPred("$call_with_args", 3, p_execute_2, 0);
@@ -1343,7 +1290,7 @@ InitExecFs(void)
 #ifdef DEPTH_LIMIT
  InitCPred("$execute_under_depth_limit", 2, p_execute_depth_limit, 0);
 #endif
-  InitCPred("$execute0", 1, p_execute0, 0);
+  InitCPred("$execute0", 2, p_execute0, 0);
  InitCPred("$save_current_choice_point", 1, p_save_cp, 0);
  InitCPred("$pred_goal_expansion_on", 0, p_pred_goal_expansion_on, SafePredFlag);
  InitCPred("$restore_regs", 1, p_restore_regs, SafePredFlag);
--- a/C/grow.c
+++ b/C/grow.c
@@ -142,8 +142,6 @@ SetHeapRegs(void)
  AttsMutableList = AbsAppl(PtoGloAdjust(RepAppl(AttsMutableList)));
  WokenGoals = AbsAppl(PtoGloAdjust(RepAppl(WokenGoals)));
 #endif
-  if (CurrentModulePtr)
-    CurrentModulePtr = PtoGloAdjust(CurrentModulePtr);
 }

 static void
@@ -182,8 +180,6 @@ SetStackRegs(void)
  YENV = PtoLocAdjust(YENV);
  if (MyTR)
    MyTR = PtoTRAdjust(MyTR);
-  if (CurrentModulePtr)
-    CurrentModulePtr = PtoGloAdjust(CurrentModulePtr);
 }

 static void
--- a/C/heapgc.c
+++ b/C/heapgc.c
@@ -359,7 +359,6 @@ push_registers(Int num_regs, yamop *nextop)
  TrailTerm(TR+3) = DelayedVars;
  TR += 4;
 #endif
-  TrailTerm(TR++) = AbsAppl(CurrentModulePtr-1);
  for (i = 1; i <= num_regs; i++)
    TrailTerm(TR++) = (CELL) XREGS[i];
  /* push any live registers we might have hanging around */
@@ -403,7 +402,6 @@ pop_registers(Int num_regs, yamop *nextop)
  DelayedVars = TrailTerm(ptr++);
 #endif
 #endif
-  CurrentModulePtr = RepAppl(TrailTerm(ptr++))+1;
  for (i = 1; i <= num_regs; i++)
    XREGS[i] = TrailTerm(ptr++);
  /* pop any live registers we might have hanging around */
--- a/C/init.c
+++ b/C/init.c
@@ -169,8 +169,6 @@ sigjmp_buf         RestartEnv;	/* used to restart after an abort execution */
 CPredicate    c_predicates[MAX_C_PREDS];
 cmp_entry     cmp_funcs[MAX_CMP_FUNCS];

-static CELL InitModuleAddress;
-
 /**************	declarations local to init.c ************************/
 static char    *optypes[] =
 {"", "xfx", "xfy", "yfx", "xf", "yf", "fx", "fy"};
@@ -511,9 +509,13 @@ void
 InitCPred(char *Name, int Arity, CPredicate code, int flags)
 {
  Atom            atom = LookupAtom(Name);
-  PredEntry      *pe = RepPredProp(PredProp(atom, Arity));
+  PredEntry      *pe;
  yamop          *p_code = (yamop *)AllocCodeSpace((CELL)NEXTOP(NEXTOP(((yamop *)NULL),sla),e));

+  if (Arity)
+    pe = RepPredProp(PredPropByFunc(MkFunctor(atom, Arity),CurrentModule));
+  else
+    pe = RepPredProp(PredPropByAtom(atom,CurrentModule));
  pe->PredFlags = flags | StandardPredFlag | CPredFlag;
  p_code->u.sla.l = pe->TrueCodeOfPred = (CODEADDR) code;
  pe->CodeOfPred = pe->FirstClause = pe->LastClause = (CODEADDR) p_code;
@@ -528,7 +530,6 @@ InitCPred(char *Name, int Arity, CPredicate code, int flags)
  p_code->opc = opcode(_procceed);
  { 
    Term mod = CurrentModule;
-    if (mod) mod = MkIntTerm(mod);
    pe->ModuleOfPred = mod;
  }
  if (!(flags & UserCPredFlag)) {
@@ -542,12 +543,17 @@ void
 InitCmpPred(char *Name, int Arity, CmpPredicate cmp_code, CPredicate code, int flags)
 {
  Atom            atom = LookupAtom(Name);
-  PredEntry      *pe = RepPredProp(PredProp(atom, Arity));
+  PredEntry      *pe;
  yamop          *p_code = (yamop *)AllocCodeSpace((CELL)NEXTOP(NEXTOP(((yamop *)NULL),sla),e));

+  if (Arity)
+    pe = RepPredProp(PredPropByFunc(MkFunctor(atom, Arity),CurrentModule));
+  else
+    pe = RepPredProp(PredPropByAtom(atom,CurrentModule));
  pe->PredFlags = flags | StandardPredFlag | CPredFlag;
  p_code->u.sla.l = pe->TrueCodeOfPred = (CODEADDR) code;
  pe->CodeOfPred = pe->FirstClause = pe->LastClause = (CODEADDR) p_code;
+  pe->ModuleOfPred = CurrentModule;
  p_code->opc = pe->OpcodeOfPred = opcode(_call_cpred);
  p_code->u.sla.l2 = (CELL)NIL;
  p_code->u.sla.s = -Signed(RealEnvSize);
@@ -567,14 +573,19 @@ void
 InitAsmPred(char *Name,  int Arity, int code, CPredicate def, int flags)
 {
  Atom            atom = LookupAtom(Name);
-  PredEntry      *pe = RepPredProp(PredProp(atom, Arity));
+  PredEntry      *pe;
 	
+  if (Arity)
+    pe = RepPredProp(PredPropByFunc(MkFunctor(atom, Arity),CurrentModule));
+  else
+    pe = RepPredProp(PredPropByAtom(atom,CurrentModule));
  pe->PredFlags = flags | StandardPredFlag | (code);
  if (def != NULL) {
    yamop          *p_code = (yamop *)AllocCodeSpace((CELL)NEXTOP(NEXTOP(((yamop *)NULL),sla),e));

    p_code->u.sla.l = pe->TrueCodeOfPred = (CODEADDR) def;
    pe->CodeOfPred = pe->FirstClause = pe->LastClause = (CODEADDR) p_code;
+    pe->ModuleOfPred = CurrentModule;
    p_code->opc = pe->OpcodeOfPred = opcode(_call_cpred);
    p_code->u.sla.l2 = (CELL)NIL;
    p_code->u.sla.s = -Signed(RealEnvSize);
@@ -634,7 +645,10 @@ InitCPredBack(char *Name, int Arity, int Extra, CPredicate Start, CPredicate Con
  PredEntry      *pe;
  Atom            atom = LookupAtom(Name);

-  pe = RepPredProp(PredProp(atom, Arity));
+  if (Arity)
+    pe = RepPredProp(PredPropByFunc(MkFunctor(atom, Arity),CurrentModule));
+  else
+    pe = RepPredProp(PredPropByAtom(atom,CurrentModule));
  if (pe->FirstClause != NIL)
    CleanBack(pe, Start, Cont);
  else {
@@ -753,11 +767,11 @@ InitCodes(void)
  heap_regs->seq_def = TRUE;
  heap_regs->getworkfirsttimecode.opc = opcode(_getwork_first_time);
  heap_regs->getworkcode.opc = opcode(_getwork);
-  heap_regs->getworkcode.u.ld.p = (CODEADDR)RepPredProp(PredProp(LookupAtom("$getwork"), 0));
+  heap_regs->getworkcode.u.ld.p = (CODEADDR)RepPredProp(PredPropByAtom(LookupAtom("$getwork"), 0));
  INIT_YAMOP_LTT(&(heap_regs->getworkcode), 0);
  heap_regs->getworkcode_seq.opc = opcode(_getwork_seq);
  INIT_YAMOP_LTT(&(heap_regs->getworkcode_seq), 0);
-  heap_regs->getworkcode_seq.u.ld.p = (CODEADDR)RepPredProp(PredProp(LookupAtom("$getwork_seq"), 0));
+  heap_regs->getworkcode_seq.u.ld.p = (CODEADDR)RepPredProp(PredPropByAtom(LookupAtom("$getwork_seq"), 0));
 #endif /* YAPOR */
 #ifdef TABLING
  heap_regs->tablecompletioncode.opc = opcode(_table_completion);
@@ -970,7 +984,6 @@ InitCodes(void)
  heap_regs->functor_stream_eOS = MkFunctor (LookupAtom("end_of_stream"), 1);
  heap_regs->functor_change_module = MkFunctor (LookupAtom("$change_module"), 1);
  heap_regs->functor_current_module = MkFunctor (LookupAtom("$current_module"), 1);
-  heap_regs->functor_mod_switch = MkFunctor (LookupAtom("$mod_switch"), 2);
  heap_regs->functor_u_minus = MkFunctor (heap_regs->atom_minus, 1);
  heap_regs->functor_u_plus = MkFunctor (heap_regs->atom_plus, 1);
  heap_regs->functor_v_bar = MkFunctor(LookupAtom("|"), 2);
@@ -986,12 +999,16 @@ InitCodes(void)
  heap_regs->yap_lib_dir = NULL;
  heap_regs->size_of_overflow  = 0;
  /* make sure no one else can use these two atoms */
-  *CurrentModulePtr = MkIntTerm(1);
-  heap_regs->pred_goal_expansion = RepPredProp(PredPropByFunc(MkFunctor(LookupAtom("goal_expansion"),3),MkIntTerm(1)));
-  *CurrentModulePtr = MkIntTerm(0);
+  heap_regs->pred_goal_expansion = RepPredProp(PredPropByFunc(MkFunctor(LookupAtom("goal_expansion"),3),1));
+  CurrentModule = 0;
  heap_regs->dead_clauses = NULL;
-  heap_regs->pred_meta_call = RepPredProp(PredPropByFunc(MkFunctor(heap_regs->atom_meta_call,3),MkIntTerm(0)));
+  heap_regs->pred_meta_call = RepPredProp(PredPropByFunc(MkFunctor(heap_regs->atom_meta_call,4),0));
  ReleaseAtom(AtomOfTerm(heap_regs->term_refound_var));
+  {
+    /* make sure we know about the module predicate */
+    PredEntry *modp = RepPredProp(PredPropByFunc(heap_regs->functor_module,0));
+    modp->PredFlags |= MetaPredFlag;
+  }
 }

 static void 
@@ -1032,7 +1049,7 @@ InitYaamRegs(void)
 #endif
  at = FullLookupAtom("$undefp");
  {
-    Prop p = GetPredProp (at, 1);
+    Prop p = GetPredPropByFunc(MkFunctor(at, 1),0);
    if (p == NIL) {
      UndefCode = NULL;
    } else {
@@ -1116,7 +1133,6 @@ InitStacks(int Heap,
  /* the emulator will eventually copy them to its own local
     register array, but for now they exist */
 #endif /* PUSH_REGS */
-  CurrentModulePtr = &InitModuleAddress;

  /* Init signal handling and time */
  /* also init memory page size, required by later functions */
--- a/C/load_foreign.c
+++ b/C/load_foreign.c
@@ -121,17 +121,17 @@ void
 ReOpenLoadForeign(void)
 {
  ForeignObj *f_code = ForeignCodeLoaded;
-  int OldModule = CurrentModule;
+  SMALLUNSGN OldModule = CurrentModule;
  YapInitProc InitProc = NULL;

  while (f_code != NULL) {
-    *CurrentModulePtr = MkIntTerm(f_code->module);
+    CurrentModule = f_code->module;
    if(ReLoadForeign(f_code->objs,f_code->libs,f_code->f,&InitProc)==LOAD_SUCCEEDED) {
      (*InitProc)();
    }
    f_code = f_code->next;
  }
-  *CurrentModulePtr = MkIntTerm(OldModule);
+  CurrentModule = OldModule;
 }


--- a/C/modules.c
+++ b/C/modules.c
@@ -42,8 +42,6 @@ Module_Name(CODEADDR cap)
    */
    return(ModuleName[CurrentModule]);
  else {
-    if (ap->ModuleOfPred)
-      return (ModuleName[IntOfTerm(ap->ModuleOfPred)]);
    return (ModuleName[ap->ModuleOfPred]);
  }
 }
@@ -73,10 +71,10 @@ p_current_module(void)
    return (0);
  for (i = 0; i < NoOfModules; ++i)
    if (ModuleName[i] == t) {
-       *CurrentModulePtr = MkIntTerm(i);
+       CurrentModule = i;
      return (TRUE);
    }
-    *CurrentModulePtr = MkIntTerm(NoOfModules);
+    CurrentModule = NoOfModules;
  ModuleName[NoOfModules++] = t;
  return (TRUE);
 }
@@ -92,8 +90,8 @@ p_current_module1(void)
 static Int
 p_change_module(void)
 {				/* $change_module(New)		 */
-  Term t = MkIntTerm(LookupModule(Deref(ARG1)));
-  UpdateTimedVar(AbsAppl(CurrentModulePtr-1), t);
+  SMALLUNSGN mod = LookupModule(Deref(ARG1));
+  CurrentModule = mod;
  return (TRUE);
 }

@@ -101,7 +99,9 @@ static Int
 p_module_number(void)
 {				/* $change_module(New)		 */
  Term t = MkIntTerm(LookupModule(Deref(ARG1)));
-  return (unify(ARG2,t));
+  unify(t,ARG2);
+  ARG2 = t;
+  return(TRUE);
 }

 void 
@@ -109,10 +109,10 @@ InitModules(void)
 {
  ModuleName[PrimitivesModule = 0] =
    MkAtomTerm(LookupAtom("prolog"));
-  *CurrentModulePtr = MkIntTerm(0);
+  CurrentModule = 0;
  ModuleName[1] = MkAtomTerm(LookupAtom("user"));
  InitCPred("$current_module", 2, p_current_module, SafePredFlag|SyncPredFlag);
  InitCPred("$current_module", 1, p_current_module1, SafePredFlag|SyncPredFlag);
  InitCPred("$change_module", 1, p_change_module, SafePredFlag|SyncPredFlag);
-  InitCPred("$module_number", 2, p_module_number, SafePredFlag|SyncPredFlag);
+  InitCPred("$module_number", 2, p_module_number, SafePredFlag);
 }
--- a/C/save.c
+++ b/C/save.c
@@ -377,7 +377,7 @@ save_regs(int mode)
    putcellptr((CELL *)TopB);
    putcellptr((CELL *)DelayedB);
    putout(FlipFlop);
-    putcellptr(CurrentModulePtr);
+    putout(CurrentModule);
 #ifdef COROUTINING
    putout(DelayedVars);
 #endif
@@ -672,7 +672,7 @@ get_regs(int flag)
    TopB = (choiceptr)get_cellptr();
    DelayedB = (choiceptr)get_cellptr();
    FlipFlop = get_cell();
-    CurrentModulePtr = get_cellptr();
+    CurrentModule = get_cell();
 #ifdef COROUTINING
    DelayedVars = get_cell();
 #endif
@@ -1097,7 +1097,6 @@ restore_codes(void)
  heap_regs->functor_stream_eOS = FuncAdjust(heap_regs->functor_stream_eOS);
  heap_regs->functor_change_module = FuncAdjust(heap_regs->functor_change_module);
  heap_regs->functor_current_module = FuncAdjust(heap_regs->functor_current_module);
-  heap_regs->functor_mod_switch = FuncAdjust(heap_regs->functor_mod_switch);
  heap_regs->functor_u_minus = FuncAdjust(heap_regs->functor_u_minus);
  heap_regs->functor_u_plus = FuncAdjust(heap_regs->functor_u_plus);
  heap_regs->functor_v_bar = FuncAdjust(heap_regs->functor_v_bar);
@@ -1164,8 +1163,6 @@ restore_regs(int flag)
    HeapPlus = AddrAdjust(HeapPlus);
    if (MyTR)
      MyTR = PtoTRAdjust(MyTR);
-    if (CurrentModulePtr)
-      CurrentModulePtr = PtoGloAdjust(CurrentModulePtr);
 #ifdef COROUTINING
    DelayedVars = AbsAppl(PtoGloAdjust(RepAppl(DelayedVars)));
 #ifdef MULTI_ASSIGNMENT_VARIABLES
--- a/C/stdpreds.c
+++ b/C/stdpreds.c
@@ -140,7 +140,7 @@ p_flipflop(void)
  PredEntry      *pred;

  at = FullLookupAtom("$spy");
-  pred = RepPredProp(PredProp(at, 1));
+  pred = RepPredProp(PredPropByFunc(MkFunctor(at, 1),0));
  SpyCode = pred;
  return ((int) (FlipFlop = (1 - FlipFlop)));
 }
@@ -164,7 +164,7 @@ p_creep(void)
  PredEntry      *pred;

  at = FullLookupAtom("$creep");
-  pred = RepPredProp(PredProp(at, 1));
+  pred = RepPredProp(PredPropByFunc(MkFunctor(at, 1),0));
  CreepCode = pred;
  CreepFlag = Unsigned(LCL0)-Unsigned(H0);
  return (TRUE);
@@ -1362,26 +1362,29 @@ init_current_atom(void)
 static Int 
 cont_current_predicate(void)
 {
-  PredEntry      *pp = (PredEntry *)IntegerOfTerm(EXTRA_CBACK_ARG(2,1));
+  PredEntry      *pp = (PredEntry *)IntegerOfTerm(EXTRA_CBACK_ARG(3,1));
  UInt Arity;
  Atom name;

  if (pp == NULL)
    cut_fail();
-  EXTRA_CBACK_ARG(2,1) = (CELL)MkIntegerTerm((Int)(pp->NextPredOfModule));
+  EXTRA_CBACK_ARG(3,1) = (CELL)MkIntegerTerm((Int)(pp->NextPredOfModule));
  Arity = pp->ArityOfPE;
  if (Arity)
    name = NameOfFunctor(pp->FunctorOfPred);
  else
    name = (Atom)pp->FunctorOfPred;
-  return (unify(ARG1,MkAtomTerm(name)) &&
-	  unify(ARG2, MkIntegerTerm(Arity)));
+  return (unify(ARG2,MkAtomTerm(name)) &&
+	  unify(ARG3, MkIntegerTerm(Arity)));
 }

 static Int 
 init_current_predicate(void)
 {
-  EXTRA_CBACK_ARG(2,1) = (CELL)MkIntegerTerm((Int)ModulePred[CurrentModule]);
+  Term t1 = Deref(ARG1);
+
+  if (IsVarTerm(t1) || !IsAtomTerm(t1)) cut_fail();
+  EXTRA_CBACK_ARG(3,1) = (CELL)MkIntegerTerm((Int)ModulePred[LookupModule(t1)]);
  return (cont_current_predicate());
 }

@@ -1555,43 +1558,51 @@ p_debug()

 static Int 
 p_flags(void)
-{				/* $flags(+Functor,?OldFlags,?NewFlags) */
+{				/* $flags(+Functor,+Mod,?OldFlags,?NewFlags) */
  PredEntry      *pe;
  Int             newFl;
-
  Term t1 = Deref(ARG1);
+  Term t2 = Deref(ARG2);
+  int mod;
+
+  if (IsVarTerm(t1))
+    return (FALSE);
+  if (!IsAtomTerm(t2)) {
+    return(FALSE);
+  }
+  mod = LookupModule(t2);
  if (IsVarTerm(t1))
    return (FALSE);
  if (IsAtomTerm(t1)) {
-    pe = RepPredProp(PredProp(AtomOfTerm(t1), 0));
+    pe = RepPredProp(PredPropByAtom(AtomOfTerm(t1), mod));
  } else if (IsApplTerm(t1)) {
    Functor         funt = FunctorOfTerm(t1);
-    pe = RepPredProp(PredPropByFunc(funt, *CurrentModulePtr));
+    pe = RepPredProp(PredPropByFunc(funt, mod));
  } else
    return (FALSE);
  if (EndOfPAEntr(pe))
    return (FALSE);
  WRITE_LOCK(pe->PRWLock);
-  if (!unify_constant(ARG2, MkIntTerm(pe->PredFlags))) {
+  if (!unify_constant(ARG3, MkIntTerm(pe->PredFlags))) {
    WRITE_UNLOCK(pe->PRWLock);
    return(FALSE);
  }
-  ARG3 = Deref(ARG3);
-  if (IsVarTerm(ARG3)) {
+  ARG4 = Deref(ARG4);
+  if (IsVarTerm(ARG4)) {
    WRITE_UNLOCK(pe->PRWLock);
    return (TRUE);
-  } else if (!IsIntTerm(ARG3)) {
+  } else if (!IsIntTerm(ARG4)) {
    union arith_ret v;

-    if (Eval(ARG3, &v) == long_int_e) {
+    if (Eval(ARG4, &v) == long_int_e) {
 	newFl = v.Int;
    } else {
      WRITE_UNLOCK(pe->PRWLock);
-      Error(TYPE_ERROR_INTEGER, ARG3, "flags");
+      Error(TYPE_ERROR_INTEGER, ARG4, "flags");
      return(FALSE);
    }
  } else
-    newFl = IntOfTerm(ARG3);
+    newFl = IntOfTerm(ARG4);
  pe->PredFlags = (SMALLUNSGN) newFl;
  WRITE_UNLOCK(pe->PRWLock);
  return (TRUE);
@@ -2005,10 +2016,10 @@ p_set_yap_flags(void)
    if (value < 0 || value > 2)
      return(FALSE);
    if (value == 1) {
-      heap_regs->pred_meta_call = RepPredProp(PredProp(heap_regs->atom_meta_call,4));
+      heap_regs->pred_meta_call = RepPredProp(PredPropByFunc(MkFunctor(AtomMetaCall,4),0));
      set_fpu_exceptions(TRUE);
    } else {
-      heap_regs->pred_meta_call = RepPredProp(PredProp(heap_regs->atom_meta_call,3));
+      heap_regs->pred_meta_call = RepPredProp(PredPropByFunc(MkFunctor(AtomMetaCall,4),0));
      set_fpu_exceptions(FALSE);
    }
    yap_flags[LANGUAGE_MODE_FLAG] = value;
@@ -2073,7 +2084,7 @@ InitBackCPreds(void)
 {
  InitCPredBack("$current_atom", 1, 2, init_current_atom, cont_current_atom,
 		SafePredFlag|SyncPredFlag);
-  InitCPredBack("$current_predicate", 2, 1, init_current_predicate, cont_current_predicate,
+  InitCPredBack("$current_predicate", 3, 1, init_current_predicate, cont_current_predicate,
 		SafePredFlag|SyncPredFlag);
  InitCPredBack("current_op", 3, 3, init_current_op, cont_current_op,
 		SafePredFlag|SyncPredFlag);
@@ -2134,7 +2145,7 @@ InitCPreds(void)
  InitCPred("$debug", 1, p_debug, SafePredFlag|SyncPredFlag);
 #endif
  /* Accessing and changing the flags for a predicate */
-  InitCPred("$flags", 3, p_flags, SafePredFlag|SyncPredFlag);
+  InitCPred("$flags", 4, p_flags, SafePredFlag|SyncPredFlag);
  /* hiding and unhiding some predicates */
  InitCPred("hide", 1, p_hide, SafePredFlag|SyncPredFlag);
  InitCPred("unhide", 1, p_unhide, SafePredFlag|SyncPredFlag);
--- a/C/tracer.c
+++ b/C/tracer.c
@@ -133,7 +133,7 @@ low_level_trace(yap_low_level_port port, PredEntry *pred, CELL *args)
  /*  if (vsc_count < 24) return; */
  /* if (vsc_count > 500000) exit(0); */
  /* if (gc_calls < 1) return;*/
-  YP_fprintf(YP_stderr,"%lu %p (%d)", vsc_count, B, CurrentModule);
+  YP_fprintf(YP_stderr,"%lu (%d)", vsc_count, CurrentModule);
  /* check_trail_consistency(); */
  if (pred == NULL) {
    return;
--- a/C/write.c
+++ b/C/write.c
@@ -379,7 +379,7 @@ writeTerm(Term t, int p, int depth, int rinfixarg)
      Term targs[1];
      targs[0] = t;
      PutValue(AtomPortray, MkAtomTerm(AtomNil));
-      execute_goal(MkApplTerm(FunctorPortray, 1, targs),0);
+      execute_goal(MkApplTerm(FunctorPortray, 1, targs), 0, 1);
      Use_portray = TRUE;
      if (GetValue(AtomPortray) == MkAtomTerm(AtomTrue))
 	return;
@@ -456,7 +456,7 @@ writeTerm(Term t, int p, int depth, int rinfixarg)
      Term targs[1];
      targs[0] = t;
      PutValue(AtomPortray, MkAtomTerm(AtomNil));
-      execute_goal(MkApplTerm(FunctorPortray, 1, targs),0);
+      execute_goal(MkApplTerm(FunctorPortray, 1, targs),0, 1);
      Use_portray = TRUE;
      if (GetValue(AtomPortray) == MkAtomTerm(AtomTrue))
 	return;