make atom locking compatible with SWI-Prolog.

C/adtdefs.c

@@ -1391,8 +1391,8 @@ Yap_PutInSlot(long slot, Term t)
   LCL0[slot] = t;
 }
 
-HoldEntry *
+static HoldEntry *
-Yap_InitAtomHold(void)
+InitAtomHold(void)
 {
   HoldEntry *x = (HoldEntry *)Yap_AllocAtomSpace(sizeof(struct hold_entry));
   if (x == NULL) {
@@ -1400,54 +1400,62 @@ Yap_InitAtomHold(void)
   }
   x->KindOfPE = HoldProperty;
   x->NextOfPE = NIL;
+  x->RefsOfPE = 1;
   return x;
 }
 
 int
-Yap_AtomGetHold(Atom at)
+Yap_AtomIncreaseHold(Atom at)
 {
   AtomEntry *ae = RepAtom(at);
-  PropEntry *pp, *opp = NULL;
+  HoldEntry *pp;
+  Prop *opp = &(ae->PropsOfAE);
 
   WRITE_LOCK(ae->ARWLock);
-  pp = RepProp(ae->PropsOfAE);
+  pp = RepHoldProp(ae->PropsOfAE);
-  while (!EndOfPAEntr(pp)) {
+  while (!EndOfPAEntr(pp)
-    pp = RepProp(pp->NextOfPE);
+	 && pp->KindOfPE != HoldProperty) {
-    opp = pp;
+    opp = &(pp->NextOfPE);
+    pp = RepHoldProp(pp->NextOfPE);
   }
   if (!pp) {
-    ae->PropsOfAE = AbsHoldProp(GlobalHoldEntry);
+    HoldEntry *new = InitAtomHold();
-  } else if (opp->KindOfPE != HoldProperty) {
+    if (!new) {
-    opp->NextOfPE = AbsHoldProp(GlobalHoldEntry);
+      WRITE_UNLOCK(ae->ARWLock);
+      return FALSE;
+    }
+    *opp = AbsHoldProp(new);
   } else {
-    WRITE_UNLOCK(ae->ARWLock);
+    pp->RefsOfPE++;
-    return FALSE;
   }
   WRITE_UNLOCK(ae->ARWLock);
   return TRUE;
 }
 
 int
-Yap_AtomReleaseHold(Atom at)
+Yap_AtomDecreaseHold(Atom at)
 {
   AtomEntry *ae = RepAtom(at);
-  PropEntry *pp, *opp = NULL;
+  HoldEntry *pp;
+  Prop *opp = &(ae->PropsOfAE);
 
   WRITE_LOCK(ae->ARWLock);
-  pp = RepProp(ae->PropsOfAE);
+  pp = RepHoldProp(ae->PropsOfAE);
-  while (!EndOfPAEntr(pp)) {
+  while (!EndOfPAEntr(pp)
-    if (pp->KindOfPE == HoldProperty) {
+	 && pp->KindOfPE != HoldProperty) {
-      if (!opp) {
+    opp = &(pp->NextOfPE);
-	ae->PropsOfAE = NIL;
+    pp = RepHoldProp(pp->NextOfPE);
-      } else {
+  }
-	opp->NextOfPE = NIL;
+  if (!pp) {
-      }
+    WRITE_UNLOCK(ae->ARWLock);
-      WRITE_UNLOCK(ae->ARWLock);
+    return FALSE;
-      return TRUE;
+  }
-    }
+  pp->RefsOfPE--;
-    pp = RepProp(pp->NextOfPE);
+  if (!pp->RefsOfPE) {
-    opp = pp;
+    *opp = pp->NextOfPE;
+    Yap_FreeCodeSpace((ADDR)pp);
   }
   WRITE_UNLOCK(ae->ARWLock);
-  return FALSE;
+  return TRUE;
 }
+

C/c_interface.c

@@ -1304,7 +1304,7 @@ X_API void *
 YAP_ReallocSpaceFromYap(void *ptr,unsigned int size) {
   void *new_ptr;
   BACKUP_MACHINE_REGS();
-  while ((new_ptr = Yap_ReallocCodeSpace(size,ptr)) == NULL) {
+  while ((new_ptr = Yap_ReallocCodeSpace(ptr,size)) == NULL) {
     if (!Yap_growheap(FALSE, size, NULL)) {
       Yap_Error(OUT_OF_HEAP_ERROR, TermNil, Yap_ErrorMessage);
       return NULL;
@@ -2596,13 +2596,13 @@ YAP_TermNil(void)
 X_API int
 YAP_AtomGetHold(Atom at)
 {
-  return Yap_AtomGetHold(at);
+  return Yap_AtomIncreaseHold(at);
 } 
 
 X_API int
 YAP_AtomReleaseHold(Atom at)
 {
-  return Yap_AtomReleaseHold(at);
+  return Yap_AtomDecreaseHold(at);
 } 
 
 X_API Agc_hook

H/Yapproto.h

@@ -55,9 +55,8 @@ Term	STD_PROTO(Yap_NStringToListOfAtoms,(char *, size_t));
 Term	STD_PROTO(Yap_WideStringToListOfAtoms,(wchar_t *));
 Term	STD_PROTO(Yap_NWideStringToListOfAtoms,(wchar_t *, size_t));
 Term	STD_PROTO(Yap_NWideStringToDiffListOfAtoms,(wchar_t *, Term, size_t));
-struct hold_entry *STD_PROTO(Yap_InitAtomHold,(void));
+int     STD_PROTO(Yap_AtomIncreaseHold,(Atom));
-int     STD_PROTO(Yap_AtomGetHold,(Atom));
+int     STD_PROTO(Yap_AtomDecreaseHold,(Atom));
-int     STD_PROTO(Yap_AtomReleaseHold,(Atom));
 
 #define Yap_StartSlots() (*--ASP = MkIntTerm(0))
 #define Yap_CurrentSlot() IntOfTerm(ASP[0])

H/Yatom.h

@@ -1127,6 +1127,7 @@ typedef struct hold_entry
 {
   Prop NextOfPE;		/* used to chain properties             */
   PropFlags KindOfPE;		/* kind of property                     */
+  UInt  RefsOfPE;		/* used to count the number of holds    */
 } HoldEntry;
 
 #if USE_OFFSETS_IN_PROPS

H/dhstruct.h

@@ -273,7 +273,6 @@
 #define Yap_AllowGlobalExpansion Yap_heap_regs->allow_global_expansion
 #define Yap_AllowTrailExpansion Yap_heap_regs->allow_trail_expansion
 #define SizeOfOverflow Yap_heap_regs->size_of_overflow
-#define GlobalHoldEntry Yap_heap_regs->global_hold_entry
 
 #define AGcLastCall Yap_heap_regs->agc_last_call
 

H/hstruct.h

@@ -273,7 +273,6 @@
   int  allow_global_expansion;
   int  allow_trail_expansion;
   UInt  size_of_overflow;
-  struct hold_entry  *global_hold_entry;
 
   UInt  agc_last_call;
 

H/ihstruct.h

@@ -273,7 +273,6 @@
   Yap_heap_regs->allow_global_expansion = TRUE;
   Yap_heap_regs->allow_trail_expansion = TRUE;
   Yap_heap_regs->size_of_overflow = 0;
-  Yap_heap_regs->global_hold_entry = Yap_InitAtomHold();
 
   Yap_heap_regs->agc_last_call = 0;
 

H/rhstruct.h

@@ -273,7 +273,6 @@
 
 
 
-  Yap_heap_regs->global_hold_entry = HoldEntryAdjust(Yap_heap_regs->global_hold_entry);
 
 
 

library/yap2swi/yap2swi.c

@@ -698,7 +698,9 @@ X_API int PL_get_tail(term_t ts, term_t tl)
       */
 X_API atom_t PL_new_atom(const char *c)
 {
-  return AtomToSWIAtom(Yap_LookupAtom((char *)c));
+  Atom at = Yap_LookupAtom((char *)c);
+  Yap_AtomIncreaseHold(at);
+  return AtomToSWIAtom(at);
 }
 
 X_API atom_t PL_new_atom_wchars(int len, const wchar_t *c)
@@ -1637,17 +1639,15 @@ X_API int PL_unify_term(term_t l,...)
 /* end PL_unify_* functions =============================*/
 
 /* SWI: void PL_register_atom(atom_t atom) */
-/* SAM TO DO */
 X_API void PL_register_atom(atom_t atom)
 {
-  Yap_AtomGetHold(SWIAtomToAtom(atom));
+  Yap_AtomIncreaseHold(SWIAtomToAtom(atom));
 }
 
 /* SWI: void PL_unregister_atom(atom_t atom) */
-/* SAM TO DO */
 X_API void PL_unregister_atom(atom_t atom)
 {
-  Yap_AtomReleaseHold(SWIAtomToAtom(atom));
+  Yap_AtomDecreaseHold(SWIAtomToAtom(atom));
 }
 
 X_API int PL_get_string_chars(term_t t, char **s, int *len)

misc/HEAPFIELDS

@@ -307,7 +307,6 @@ int		allow_local_expansion	Yap_AllowLocalExpansion =TRUE void
 int		allow_global_expansion	Yap_AllowGlobalExpansion =TRUE void 
 int		allow_trail_expansion	Yap_AllowTrailExpansion =TRUE void 
 UInt		size_of_overflow	SizeOfOverflow		=0 void
-struct hold_entry *global_hold_entry	GlobalHoldEntry		=Yap_InitAtomHold() HoldEntryAdjust
 /* amount of space recovered in all garbage collections */
 UInt		agc_last_call		AGcLastCall		=0 void
 /* amount of space recovered in all garbage collections */