diff --git a/C/init.c b/C/init.c
index ce1e1277c..efec16f27 100644
--- a/C/init.c
+++ b/C/init.c
@@ -886,6 +886,7 @@ InitCodes(void)
   Yap_heap_regs->readutil_module = MkAtomTerm(Yap_LookupAtom("readutil"));
   Yap_heap_regs->hacks_module = MkAtomTerm(Yap_LookupAtom("yap_hacks"));
   Yap_heap_regs->globals_module = MkAtomTerm(Yap_LookupAtom("nb"));
+  Yap_heap_regs->swi_module = MkAtomTerm(Yap_LookupAtom("swi"));
   Yap_InitModules();
 #ifdef BEAM
   Yap_heap_regs->beam_retry_code.opc = Yap_opcode(_retry_eam);
diff --git a/C/mavar.c b/C/mavar.c
index 82fbd0d17..7acf54ab2 100644
--- a/C/mavar.c
+++ b/C/mavar.c
@@ -32,11 +32,19 @@ STD_PROTO(static Int p_is_mutable, (void));
 static Int
 p_setarg(void)
 {
-  CELL ti = Deref(ARG1), ts = Deref(ARG2);
+  CELL ti = Deref(ARG1), ts = Deref(ARG2), t3 = Deref(ARG3);
   Int i;
+
+  if (IsVarTerm(t3) &&
+      VarOfTerm(t3) > H &&VarOfTerm(t3) < ASP) {
+    /* local variable */
+    Term tn = MkVarTerm();
+    Bind_Local(VarOfTerm(t3), tn);
+    t3 = tn;
+  }
   if (IsVarTerm(ti)) {
     Yap_Error(INSTANTIATION_ERROR,ti,"setarg/3");
-    return(FALSE);
+    return FALSE;
   } else {
     if (IsIntTerm(ti))
       i = IntOfTerm(ti);
@@ -46,7 +54,7 @@ p_setarg(void)
 	i = v.Int;
       } else {
 	Yap_Error(TYPE_ERROR_INTEGER,ti,"setarg/3");
-	return(FALSE);
+	return FALSE;
       }
     }
   }
@@ -56,34 +64,34 @@ p_setarg(void)
     CELL *pt;
     if (IsExtensionFunctor(FunctorOfTerm(ts))) {
       Yap_Error(TYPE_ERROR_COMPOUND,ts,"setarg/3");
-      return(FALSE);
+      return FALSE;
     }
     if (i < 1 || i > (Int)ArityOfFunctor(FunctorOfTerm(ts))) {
       if (i<0)
 	Yap_Error(DOMAIN_ERROR_NOT_LESS_THAN_ZERO,ts,"setarg/3");
-      return(FALSE);
+      return FALSE;
       if (i==0)
 	Yap_Error(DOMAIN_ERROR_NOT_ZERO,ts,"setarg/3");
-      return(FALSE);
+      return FALSE;
     }
     pt = RepAppl(ts)+i;
     /* the evil deed is to be done now */
-    MaBind(pt, Deref(ARG3));
+    MaBind(pt, t3);
   } else if(IsPairTerm(ts)) {
     CELL *pt;
     if (i < 1 || i > 2) {
       if (i<0)
 	Yap_Error(DOMAIN_ERROR_NOT_LESS_THAN_ZERO,ts,"setarg/3");
-      return(FALSE);
+      return FALSE;
     }
     pt = RepPair(ts)+i-1;
     /* the evil deed is to be done now */
-    MaBind(pt, Deref(ARG3));    
+    MaBind(pt, t3);    
   } else {
     Yap_Error(TYPE_ERROR_COMPOUND,ts,"setarg/3");
-    return(FALSE);
+    return FALSE;
   }
-  return(TRUE);
+  return TRUE;
 }
 
 
diff --git a/C/stdpreds.c b/C/stdpreds.c
index 8a027152d..7ceb96d15 100644
--- a/C/stdpreds.c
+++ b/C/stdpreds.c
@@ -11,8 +11,11 @@
 * File:		stdpreds.c						 *
 * comments:	General-purpose C implemented system predicates		 *
 *									 *
-* Last rev:     $Date: 2007-10-08 23:02:15 $,$Author: vsc $						 *
+* Last rev:     $Date: 2007-10-10 09:44:24 $,$Author: vsc $						 *
 * $Log: not supported by cvs2svn $
+* Revision 1.120  2007/10/08 23:02:15  vsc
+* minor fixes
+*
 * Revision 1.119  2007/04/18 23:01:16  vsc
 * fix deadlock when trying to create a module with the same name as a
 * predicate (for now, just don't lock modules). obs Paulo Moura.
@@ -3944,9 +3947,14 @@ Yap_InitCPreds(void)
   init_sys();
   init_random();
   //  init_tries();
-  swi_install();
   init_regexp();
 #endif
+  {
+    Term cm = CurrentModule;
+    CurrentModule = SWI_MODULE;
+    swi_install();
+    CurrentModule = cm;
+  }
 }
 
 
diff --git a/H/Heap.h b/H/Heap.h
index 9a40e066f..d7b0ef29d 100644
--- a/H/Heap.h
+++ b/H/Heap.h
@@ -10,7 +10,7 @@
 * File:		Heap.h         						 *
 * mods:									 *
 * comments:	Heap Init Structure					 *
-* version:      $Id: Heap.h,v 1.117 2007-09-28 23:18:17 vsc Exp $	 *
+* version:      $Id: Heap.h,v 1.118 2007-10-10 09:44:24 vsc Exp $	 *
 *************************************************************************/
 
 /* information that can be stored in Code Space */
@@ -491,7 +491,8 @@ typedef struct various_codes {
     system_module,
     readutil_module,
     hacks_module,
-    globals_module;
+    globals_module,
+    swi_module;
   void *last_wtime;
   struct pred_entry *pred_goal_expansion;
   struct pred_entry *pred_meta_call;
@@ -795,6 +796,7 @@ struct various_codes *Yap_heap_regs;
 #define  READUTIL_MODULE          Yap_heap_regs->readutil_module
 #define  HACKS_MODULE             Yap_heap_regs->hacks_module
 #define  GLOBALS_MODULE           Yap_heap_regs->globals_module
+#define  SWI_MODULE               Yap_heap_regs->swi_module
 #define  PredGoalExpansion        Yap_heap_regs->pred_goal_expansion
 #define  PredMetaCall             Yap_heap_regs->pred_meta_call
 #define  PredDollarCatch          Yap_heap_regs->pred_dollar_catch
diff --git a/H/rheap.h b/H/rheap.h
index d2d3001e6..dda0d023e 100644
--- a/H/rheap.h
+++ b/H/rheap.h
@@ -11,8 +11,11 @@
 * File:		rheap.h							 *
 * comments:	walk through heap code					 *
 *									 *
-* Last rev:     $Date: 2007-09-28 23:18:17 $,$Author: vsc $						 *
+* Last rev:     $Date: 2007-10-10 09:44:24 $,$Author: vsc $						 *
 * $Log: not supported by cvs2svn $
+* Revision 1.76  2007/09/28 23:18:17  vsc
+* handle learning from interpretations.
+*
 * Revision 1.75  2007/04/10 22:13:21  vsc
 * fix max modules limitation
 *
@@ -690,6 +693,7 @@ restore_codes(void)
   Yap_heap_regs->system_module = AtomTermAdjust(Yap_heap_regs->system_module);
   Yap_heap_regs->readutil_module = AtomTermAdjust(Yap_heap_regs->readutil_module);
   Yap_heap_regs->globals_module = AtomTermAdjust(Yap_heap_regs->globals_module);
+  Yap_heap_regs->swi_module = AtomTermAdjust(Yap_heap_regs->swi_module);
   if (Yap_heap_regs->file_aliases != NULL) {
     Yap_heap_regs->yap_streams =
       (struct stream_desc *)AddrAdjust((ADDR)Yap_heap_regs->yap_streams);
diff --git a/LGPL/chr/chr_compiler_errors.pl b/LGPL/chr/chr_compiler_errors.pl
new file mode 100644
index 000000000..e69de29bb
diff --git a/LGPL/chr/chr_integertable_store.pl b/LGPL/chr/chr_integertable_store.pl
new file mode 100644
index 000000000..e69de29bb
diff --git a/changes-5.1.html b/changes-5.1.html
index 4be591f37..253f1442f 100644
--- a/changes-5.1.html
+++ b/changes-5.1.html
@@ -17,6 +17,7 @@
 
 <h2>Yap-5.1.3:</h2>
 <ul>
+<li> FIXED: setarg/3 should always set a global variable.</li>
 <li> NEW: define dialect and version_data flags.</li>
 <li> NEW: define __YAP_PROLOG__.</li>
 <li> FIXED: LAM compilation was broken (obs from Bernd Gutmann).</li>
diff --git a/library/Makefile.in b/library/Makefile.in
index ab50f0548..c3c2fe45c 100644
--- a/library/Makefile.in
+++ b/library/Makefile.in
@@ -30,6 +30,7 @@ PROGRAMS= $(srcdir)/apply_macros.yap \
 	$(srcdir)/avl.yap \
 	$(srcdir)/charsio.yap \
 	$(srcdir)/cleanup.yap \
+	$(srcdir)/clpfd.pl \
 	$(srcdir)/dbqueues.yap \
 	$(srcdir)/dgraphs.yap \
 	$(srcdir)/gensym.yap \
diff --git a/library/swi.yap b/library/swi.yap
index 0d0a59428..f1075d28a 100644
--- a/library/swi.yap
+++ b/library/swi.yap
@@ -42,6 +42,50 @@ user:file_search_path(foreign, swi(ArchLib)) :-
         atom_concat('lib/', Arch, ArchLib).
 user:file_search_path(foreign, swi(lib)).
 
+:- meta_predicate prolog:predsort(:,+,-).
+
+%%	predsort(:Compare, +List, -Sorted) is det.
+%
+%	 Sorts similar to sort/2, but determines  the order of two terms
+%	 by calling Compare(-Delta, +E1,  +E2).   This  call  must unify
+%	 Delta with one of <, > or =. If built-in predicate compare/3 is
+%	 used, the result is the same as sort/2. See also keysort/2.
+
+prolog:predsort(P, L, R) :-
+	length(L, N), 
+	predsort(P, N, L, _, R1), !, 
+	R = R1.
+
+predsort(P, 2, [X1, X2|L], L, R) :- !, 
+	call(P, Delta, X1, X2),
+	sort2(Delta, X1, X2, R).
+predsort(_, 1, [X|L], L, [X]) :- !.
+predsort(_, 0, L, L, []) :- !.
+predsort(P, N, L1, L3, R) :-
+	N1 is N // 2, 
+	plus(N1, N2, N), 
+	predsort(P, N1, L1, L2, R1), 
+	predsort(P, N2, L2, L3, R2), 
+	predmerge(P, R1, R2, R).
+
+sort2(<, X1, X2, [X1, X2]).
+sort2(=, X1, _,  [X1]).
+sort2(>, X1, X2, [X2, X1]).
+
+predmerge(_, [], R, R) :- !.
+predmerge(_, R, [], R) :- !.
+predmerge(P, [H1|T1], [H2|T2], Result) :-
+	call(P, Delta, H1, H2),
+	predmerge(Delta, P, H1, H2, T1, T2, Result).
+
+predmerge(>, P, H1, H2, T1, T2, [H2|R]) :-
+	predmerge(P, [H1|T1], T2, R).
+predmerge(=, P, H1, _, T1, T2, [H1|R]) :-
+	predmerge(P, T1, T2, R).
+predmerge(<, P, H1, H2, T1, T2, [H1|R]) :-
+	predmerge(P, T1, [H2|T2], R).
+
+
 %
 % maybe a good idea to eventually support this in YAP.
 % but for now just ignore it.
@@ -69,9 +113,7 @@ prolog:load_foreign_library(P) :-
 
 do_volatile(_,_).
 
-:- meta_predicate prolog:forall(+,:).
-
-:- load_foreign_files([yap2swi], [], swi_install).
+:- meta_predicate prolog:forall(:,:).
 
 :- use_module(library(lists)).
 
@@ -94,6 +136,7 @@ prolog:concat_atom(List, Separator, New) :-
 prolog:concat_atom(List, New) :-
 	atomic_concat(List, New).
 
+
 split_atom_by_chars([],_,[],L,A,[]):-
 	atom_codes(A,L).
 split_atom_by_chars([C|NewChars],C,[],L,A,[NA|Atoms]) :- !,
@@ -256,3 +299,27 @@ prolog:intersection([_|T], L, R) :-
 
 prolog:(Term1 =@= Term2) :-
 	variant(Term1, Term2), !.
+
+%%	flatten(+List1, ?List2) is det.
+%
+%	Is true it List2 is a non nested version of List1.
+%	
+%	@deprecated	Ending up needing flatten/3 often indicates,
+%			like append/3 for appending two lists, a bad
+%			design.  Efficient code that generates lists
+%			from generated small lists must use difference
+%			lists, often possible through grammar rules for
+%			optimal readability.
+
+prolog:flatten(List, FlatList) :-
+	flatten(List, [], FlatList0), !,
+	FlatList = FlatList0.
+
+flatten(Var, Tl, [Var|Tl]) :-
+	var(Var), !.
+flatten([], Tl, Tl) :- !.
+flatten([Hd|Tl], Tail, List) :- !,
+	flatten(Hd, FlatHeadTail, List), 
+	flatten(Tl, Tail, FlatHeadTail).
+flatten(NonList, Tl, [NonList|Tl]).
+
diff --git a/library/yap2swi/yap2swi.c b/library/yap2swi/yap2swi.c
index 06387b814..b5cb7a2bc 100644
--- a/library/yap2swi/yap2swi.c
+++ b/library/yap2swi/yap2swi.c
@@ -1,514 +1,514 @@
-/* yap2swi.c  */
-/*
- * Project: jpl for Yap Prolog
- * Author: Steve Moyle and Vitor Santos Costa
- * Email:  steve.moyle@comlab.ox.ac.uk
- * Date:   21 January 2002
-
- * Copyright (c) 2002 Steve Moyle.  All rights reserved.
-
-*/
-
-//=== includes ===============================================================
-#include	<stdlib.h>
-#include	<string.h>
-#include	<stdio.h>
-
-#include	<yap2swi.h>
-
-#define BUF_SIZE 256
-#define TMP_BUF_SIZE 2*BUF_SIZE
-#define BUF_RINGS 16
-
-char buffers[TMP_BUF_SIZE+BUF_SIZE*BUF_RINGS];
-static int buf_index = 0;
-
-static char *
-alloc_ring_buf(void)
-{
-  int ret = buf_index;
-  buf_index++;
-  if (buf_index == BUF_RINGS)
-    buf_index = 0;
-  return buffers+(TMP_BUF_SIZE+ret*BUF_SIZE);
-}
-
-/* SWI: void PL_agc_hook(void)
-   YAP: NO EQUIVALENT */
-
-/* dummy function for now (until Vitor comes through!)*/
-X_API PL_agc_hook_t
-PL_agc_hook(PL_agc_hook_t entry)
-{
-  return entry;
-}
-
-/* SWI: char* PL_atom_chars(atom_t atom)
-   YAP: char* AtomName(Atom) */
-X_API char* PL_atom_chars(atom_t a)	 /* SAM check type */
-{
-  return (char *)YAP_AtomName((YAP_Atom)a);
-}
-
-
-/* SWI: term_t PL_copy_term_ref(term_t from)
-   YAP: NO EQUIVALENT */
-/* SAM TO DO */
-X_API term_t PL_copy_term_ref(term_t from)
-{
-  return YAP_InitSlot(YAP_GetFromSlot(from));
-}
-
-X_API term_t PL_new_term_ref(void)
-{
-  
-  term_t to = YAP_NewSlots(1);
-  return to;
-}
-
-X_API term_t PL_new_term_refs(int n)
-{
-  
-  term_t to = YAP_NewSlots(n);
-  return to;
-}
-
-X_API void PL_reset_term_refs(term_t after)
-{
-  term_t new = YAP_NewSlots(1);
-  YAP_RecoverSlots(after-new);
-}
-
-/* begin PL_get_* functions =============================*/
-
-/* SWI: int PL_get_arg(int index, term_t t, term_t a)
-   YAP: YAP_Term YAP_ArgOfTerm(int argno, YAP_Term t)*/
-X_API int PL_get_arg(int index, term_t ts, term_t a)
-{
-  YAP_Term t = YAP_GetFromSlot(ts);
-  if ( !YAP_IsApplTerm(t) ) {
-    if (YAP_IsPairTerm(t)) {
-      if (index == 1){
-	YAP_PutInSlot(a,YAP_HeadOfTerm(t));
-	return 1;
-      } else if (index == 2) {
-	YAP_PutInSlot(a,YAP_TailOfTerm(t));
-	return 1;
-      }
-    }
-    return 0;
-  }
-  YAP_PutInSlot(a,YAP_ArgOfTerm(index, t));
-  return 1;
-}
-   
-/* SWI: int PL_get_atom(term_t t, YAP_Atom *a)
-   YAP: YAP_Atom YAP_AtomOfTerm(Term) */
-X_API int PL_get_atom(term_t ts, atom_t *a)
-{
-  YAP_Term t = YAP_GetFromSlot(ts);
-  if ( !YAP_IsAtomTerm(t))
-    return 0;
-  *a = (atom_t)YAP_AtomOfTerm(t);
-  return 1;
-}
-
-/* SWI: int PL_get_atom_chars(term_t t, char **s)
-   YAP: char* AtomName(Atom) */
-X_API int PL_get_atom_chars(term_t ts, char **a)  /* SAM check type */
-{
-  YAP_Term t = YAP_GetFromSlot(ts);
-  if (!YAP_IsAtomTerm(t))
-    return 0;
-  *a = (char *)YAP_AtomName(YAP_AtomOfTerm(t));
-  return 1;
-}
-
-/*
-  int PL_get_chars(term_t +t, char **s, unsigned flags) Convert the
-  argument term t to a 0-terminated C-string. flags is a bitwise
-  disjunction from two groups of constants. The first specifies which
-  term-types should converted and the second how the argument is
-  stored. Below is a specification of these constants. BUF_RING
-  implies, if the data is not static (as from an atom), the data is
-  copied to the next buffer from a ring of sixteen (16) buffers. This is a
-  convenient way of converting multiple arguments passed to a foreign
-  predicate to C-strings. If BUF_MALLOC is used, the data must be
-  freed using free() when not needed any longer.
-
-    CVT_ATOM Convert if term is an atom
-    CVT_STRING Convert if term is a string
-    CVT_LIST Convert if term is a list of integers between 1 and 255
-    CVT_INTEGER Convert if term is an integer (using %d)
-    CVT_FLOAT Convert if term is a float (using %f)
-    CVT_NUMBER Convert if term is a integer or float
-    CVT_ATOMIC Convert if term is atomic
-    CVT_VARIABLE Convert variable to print-name
-    CVT_ALL Convert if term is any of the above, except for variables
-    BUF_DISCARDABLE Data must copied immediately
-    BUF_RING Data is stored in a ring of buffers
-    BUF_MALLOC Data is copied to a new buffer returned by malloc(3)
-*/
-
-static int CvtToStringTerm(YAP_Term t, char *buf, char *buf_max)
-{
-  *buf++ = '\"';
-  while (YAP_IsPairTerm(t)) {
-    YAP_Term hd = YAP_HeadOfTerm(t);
-    long int  i;
-    if (!YAP_IsIntTerm(hd))
-      return 0;
-    i = YAP_IntOfTerm(hd);
-    if (i <= 0 || i >= 255)
-      return 0;
-    if (!YAP_IsIntTerm(hd))
-      return 0;
-    *buf++ = i;
-    if (buf == buf_max)
-      return 0;
-    t = YAP_TailOfTerm(t);
-  }
-  if (t != YAP_MkAtomTerm(YAP_LookupAtom("[]")))
-    return 0;
-  if (buf+1 == buf_max)
-    return 0;
-  buf[0] = '\"';
-  buf[1] = '\0';
-  return 1;
-}
-
-char *bf, *bf_lim;
-
-static void
-buf_writer(int c)
-{
-  if (bf == bf_lim) {
-    return;
-  }
-  *bf++ = c;
-}
-
-#if !HAVE_SNPRINTF
-#define snprintf(X,Y,Z,A) sprintf(X,Z,A)
-#endif
-
-
-X_API int PL_get_chars(term_t l, char **sp, unsigned flags)
-{
-  YAP_Term t = YAP_GetFromSlot(l);
-  char *tmp;
-
-  if (!(flags & BUF_RING)) {
-    tmp = alloc_ring_buf();
-  } else {
-    tmp = buffers;
-  }
-  *sp = tmp;
-  if (YAP_IsAtomTerm(t)) {
-    YAP_Atom at = YAP_AtomOfTerm(t);
-    if (!(flags & (CVT_ATOM|CVT_ATOMIC|CVT_ALL)))
-      return 0;
-    if (YAP_IsWideAtom(at))
-      /* will this always work? */
-      snprintf(*sp,BUF_SIZE,"%ls",YAP_WideAtomName(at));
-    else
-      *sp = (char *)YAP_AtomName(YAP_AtomOfTerm(t));
-    return 1;
-  } else if (YAP_IsIntTerm(t)) {
-    if (!(flags & (CVT_INTEGER|CVT_NUMBER|CVT_ATOMIC|CVT_ALL)))
-      return 0;
-    snprintf(tmp,BUF_SIZE,"%ld",YAP_IntOfTerm(t));
-  } else if (YAP_IsFloatTerm(t)) {
-    if (!(flags & (CVT_FLOAT|CVT_ATOMIC|CVT_NUMBER|CVT_ALL)))
-      return 0;
-    snprintf(tmp,BUF_SIZE,"%f",YAP_FloatOfTerm(t));
-  } else if (flags & CVT_STRING) {
-    if (CvtToStringTerm(t,tmp,tmp+BUF_SIZE) == 0)
-      return 0;
-  } else {
-    bf = tmp;
-    bf_lim = tmp+(BUF_SIZE-1);
-    YAP_Write(t,buf_writer,0);
-    if (bf == bf_lim)
-      return 0;
-    *bf = '\0';
-  }
-  if (flags & BUF_MALLOC) {
-    char *nbf = YAP_AllocSpaceFromYap(strlen(tmp)+1);
-    if (nbf == NULL)
-      return 0;
-    strncpy(nbf,tmp,BUF_SIZE);
-    *sp = nbf;
-  }
-  return 1;
-}
-
-X_API int PL_get_nchars(term_t l, size_t *len, char **sp, unsigned flags)
-{
-  int out = PL_get_chars(l, sp, flags);
-  if (!out) return out;
-  *len = strlen(*sp);
-  return out;
-}
-
-
-/* same as get_chars, but works on buffers of wide chars */
-X_API int PL_get_wchars(term_t l, size_t *len, wchar_t **wsp, unsigned flags)
-{
-  if (YAP_IsAtomTerm(l)) {
-    YAP_Atom at = YAP_AtomOfTerm(l);
-
-    if (!(flags & (CVT_ATOM|CVT_ATOMIC|CVT_ALL)))
-      return 0;
-    if (YAP_IsWideAtom(at))
-      /* will this always work? */
-      *wsp = (wchar_t *)YAP_WideAtomName(at);
-  } else {
-    char *sp;
-    int res = PL_get_chars(l, &sp, ((flags & ~(BUF_MALLOC|BUF_DISCARDABLE))|BUF_RING));
-    size_t sz;
-
-    if (!res)
-      return FALSE;
-    sz = wcstombs(sp,NULL,BUF_SIZE);
-    if (flags & BUF_MALLOC) {
-      wchar_t *nbf = (wchar_t *)YAP_AllocSpaceFromYap(sz+1);
-      if (nbf == NULL)
-	return 0;
-      *wsp = nbf;
-    } else if (flags & BUF_DISCARDABLE) {
-      wchar_t *buf = (wchar_t *)buffers;
-
-      if (wcstombs(sp,buf,BUF_SIZE) == -1)
-	return 0;
-      *wsp = buf;
-    } else {
-      wchar_t *tmp = (wchar_t *)alloc_ring_buf();
-      if (wcstombs(sp, tmp, BUF_SIZE) == -1)
-	return 0;
-      *wsp = tmp;
-    }
-    return res;
-  }
-  return 0;
-}
-
-
-/* SWI: int PL_get_functor(term_t t, functor_t *f)
-   YAP: YAP_Functor YAP_FunctorOfTerm(Term) */
-X_API int PL_get_functor(term_t ts, functor_t *f)
-{
-  YAP_Term t = YAP_GetFromSlot(ts);
-  if ( YAP_IsAtomTerm(t)) {
-    *f = t;
-  } else {
-    *f = (functor_t)YAP_FunctorOfTerm(t);
-  }
-  return 1;
-}
-
-/* SWI: int PL_get_float(term_t t, double *f)
-   YAP: double YAP_FloatOfTerm(Term) */
-X_API int PL_get_float(term_t ts, double *f) /* SAM type check*/
-{	
-  YAP_Term t = YAP_GetFromSlot(ts);
-  if ( !YAP_IsFloatTerm(t))
-    return 0;
-  *f = YAP_FloatOfTerm(t);
-  return 1;
-}
-
-X_API int PL_get_head(term_t ts, term_t h)
-{
-  YAP_Term t = YAP_GetFromSlot(ts);
-  if (!YAP_IsPairTerm(t) ) {
-    return 0;
-  }
-  YAP_PutInSlot(h,YAP_HeadOfTerm(t));
-  return 1;
-}
-
-/* SWI: int PL_get_integer(term_t t, int *i)
-   YAP: long int  YAP_IntOfTerm(Term) */
-X_API int PL_get_integer(term_t ts, int *i)
-{
-  YAP_Term t = YAP_GetFromSlot(ts);
-  if (!YAP_IsIntTerm(t) )
-    return 0;
-  *i = YAP_IntOfTerm(t);
-  return 1;
-}
-
-X_API int PL_get_long(term_t ts, long *i)
-{
-  YAP_Term t = YAP_GetFromSlot(ts);
-  if (!YAP_IsIntTerm(t) ) {
-    if (YAP_IsFloatTerm(t)) {
-      double dbl = YAP_FloatOfTerm(t);
-      if (dbl - (long)dbl == 0.0) {
-	*i = (long)dbl;
-	return 1;
-      }
-    }
-    return 0;
-  }
-  *i = YAP_IntOfTerm(t);
-  return 1;
-}
-
+/* yap2swi.c  */
+/*
+ * Project: jpl for Yap Prolog
+ * Author: Steve Moyle and Vitor Santos Costa
+ * Email:  steve.moyle@comlab.ox.ac.uk
+ * Date:   21 January 2002
 
-X_API int PL_get_int64(term_t ts, int64_t *i)
-{
-  YAP_Term t = YAP_GetFromSlot(ts);
-  if (!YAP_IsIntTerm(t) ) {
-    if (YAP_IsFloatTerm(t)) {
-      double dbl = YAP_FloatOfTerm(t);
-      if (dbl - (int64_t)dbl == 0.0) {
-	*i = (int64_t)dbl;
-	return 1;
-      }
-#if USE_GMP
-    } else if (YAP_IsBigNumTerm(t)) {
-      MP_INT g;
-      char s[64];
-      YAP_BigNumOfTerm(t, (void *)&g);
-      if (mpz_sizeinbase(&g,2) > 64) {
-	return 0;
-      }
-      mpz_get_str (s, 10, &g);
-      sscanf(s, "%lld", (long long int *)i);
-      return 1;
-#endif
-    }
-    return 0;
-  }
-  *i = YAP_IntOfTerm(t);
-  return 1;
-}
-
+ * Copyright (c) 2002 Steve Moyle.  All rights reserved.
 
-X_API int PL_get_list(term_t ts, term_t h, term_t tl)
-{
-  YAP_Term t = YAP_GetFromSlot(ts);
-  if (!YAP_IsPairTerm(t) ) {
-    return 0;
-  }
-  YAP_PutInSlot(h,YAP_HeadOfTerm(t));
-  YAP_PutInSlot(tl,YAP_TailOfTerm(t));
-  return 1;
-}
-
-X_API int PL_get_list_chars(term_t l, char **sp, unsigned flags)
-{
-  if (flags & (CVT_ATOM|CVT_STRING|CVT_INTEGER|CVT_FLOAT|CVT_NUMBER|CVT_ATOMIC|CVT_VARIABLE|CVT_ALL))
-    return 0;
-  return PL_get_chars(l, sp, CVT_LIST|flags);
-}
-
-/* SWI: int PL_get_module(term_t t, module_t *m) */
-X_API int PL_get_module(term_t ts, module_t *m)
-{
-  YAP_Term t = YAP_GetFromSlot(ts);
-  if (!YAP_IsAtomTerm(t) )
-    return 0;
-  *m = (module_t)YAP_LookupModule(t);
-  return 1;
-}
-
-/* SWI: int PL_new_module(term_t t, module_t *m) */
-X_API module_t PL_new_module(atom_t at)
-{
-  return (module_t)YAP_CreateModule((YAP_Atom)at);
-}
-
-/* SWI: int PL_get_atom(term_t t, YAP_Atom *a)
-   YAP: YAP_Atom YAP_AtomOfTerm(Term) */
-X_API int PL_get_name_arity(term_t ts, atom_t *name, int *arity)
-{
-  YAP_Term t = YAP_GetFromSlot(ts);
-  if (YAP_IsAtomTerm(t)) {
-    *name = (atom_t)YAP_AtomOfTerm(t);
-    *arity = 0;
-    return 1;
-  }
-  if (YAP_IsApplTerm(t)) {
-    YAP_Functor f = YAP_FunctorOfTerm(t);
-    *name = (atom_t)YAP_NameOfFunctor(f);
-    *arity = YAP_ArityOfFunctor(f);
-    return 1;
-  }
-  if (YAP_IsPairTerm(t)) {
-    *name = (atom_t)YAP_LookupAtom(".");
-    *arity = 2;
-    return 1;
-  }
-  return 0;
-}
-
-/* SWI: int PL_get_atom(term_t t, YAP_Atom *a)
-   YAP: YAP_Atom YAP_AtomOfTerm(Term) */
-X_API int PL_get_nil(term_t ts)
-{
-  YAP_Term t = YAP_GetFromSlot(ts);
-  return ( t == YAP_MkAtomTerm(YAP_LookupAtom("[]")));
-}
-
-/* SWI: int PL_get_pointer(term_t t, int *i)
-   YAP: NO EQUIVALENT */
-/* SAM TO DO */
-X_API int PL_get_pointer(term_t ts, void **i)
-{
-  YAP_Term t = YAP_GetFromSlot(ts);
-  if (!YAP_IsIntTerm(t) )
-    return 0;
-  *i = (void *)YAP_IntOfTerm(t);
-  return 1;
-}
-
-/* SWI: int PL_get_atom_chars(term_t t, char **s)
-   YAP: char* AtomName(Atom) */
-X_API int PL_get_string(term_t ts, char **sp, int *lenp)  /* SAM check type */
-{
-  YAP_Term t = YAP_GetFromSlot(ts);
-  char *to;
-  int len;
-  if (!YAP_IsPairTerm(t))
-    return 0;
-  if (!YAP_StringToBuffer(t, buffers, TMP_BUF_SIZE))
-      return(FALSE);
-  len = strlen(buffers);
-  to = (char *)YAP_NewSlots((len/sizeof(YAP_Term))+1);
-  strncpy(to, buffers, TMP_BUF_SIZE);
-  *sp = to;
-  return 1;
-}
-
-X_API int PL_get_tail(term_t ts, term_t tl)
-{
-  YAP_Term t = YAP_GetFromSlot(ts);
-  if (!YAP_IsPairTerm(t) ) {
-    return 0;
-  }
-  YAP_PutInSlot(tl,YAP_TailOfTerm(t));
-  return 1;
-}
-
-/* end PL_get_* functions  =============================*/
-
-/* begin PL_new_* functions =============================*/
-
-/* SWI: atom_t PL_new_atom(const char *)
-   YAP: YAP_Atom LookupAtom(char *) */
-/*  SAM should the following be used instead?
-      YAP_Atom  FullLookupAtom(char *)
-      */
-X_API atom_t PL_new_atom(const char *c)
-{
-  return (atom_t)YAP_LookupAtom((char *)c);
-}
-
-X_API atom_t PL_new_atom_wchars(int len, const wchar_t *c)
-{
+*/
+
+//=== includes ===============================================================
+#include	<stdlib.h>
+#include	<string.h>
+#include	<stdio.h>
+
+#include	<yap2swi.h>
+
+#define BUF_SIZE 256
+#define TMP_BUF_SIZE 2*BUF_SIZE
+#define BUF_RINGS 16
+
+char buffers[TMP_BUF_SIZE+BUF_SIZE*BUF_RINGS];
+static int buf_index = 0;
+
+static char *
+alloc_ring_buf(void)
+{
+  int ret = buf_index;
+  buf_index++;
+  if (buf_index == BUF_RINGS)
+    buf_index = 0;
+  return buffers+(TMP_BUF_SIZE+ret*BUF_SIZE);
+}
+
+/* SWI: void PL_agc_hook(void)
+   YAP: NO EQUIVALENT */
+
+/* dummy function for now (until Vitor comes through!)*/
+X_API PL_agc_hook_t
+PL_agc_hook(PL_agc_hook_t entry)
+{
+  return entry;
+}
+
+/* SWI: char* PL_atom_chars(atom_t atom)
+   YAP: char* AtomName(Atom) */
+X_API char* PL_atom_chars(atom_t a)	 /* SAM check type */
+{
+  return (char *)YAP_AtomName((YAP_Atom)a);
+}
+
+
+/* SWI: term_t PL_copy_term_ref(term_t from)
+   YAP: NO EQUIVALENT */
+/* SAM TO DO */
+X_API term_t PL_copy_term_ref(term_t from)
+{
+  return YAP_InitSlot(YAP_GetFromSlot(from));
+}
+
+X_API term_t PL_new_term_ref(void)
+{
+  
+  term_t to = YAP_NewSlots(1);
+  return to;
+}
+
+X_API term_t PL_new_term_refs(int n)
+{
+  
+  term_t to = YAP_NewSlots(n);
+  return to;
+}
+
+X_API void PL_reset_term_refs(term_t after)
+{
+  term_t new = YAP_NewSlots(1);
+  YAP_RecoverSlots(after-new);
+}
+
+/* begin PL_get_* functions =============================*/
+
+/* SWI: int PL_get_arg(int index, term_t t, term_t a)
+   YAP: YAP_Term YAP_ArgOfTerm(int argno, YAP_Term t)*/
+X_API int PL_get_arg(int index, term_t ts, term_t a)
+{
+  YAP_Term t = YAP_GetFromSlot(ts);
+  if ( !YAP_IsApplTerm(t) ) {
+    if (YAP_IsPairTerm(t)) {
+      if (index == 1){
+	YAP_PutInSlot(a,YAP_HeadOfTerm(t));
+	return 1;
+      } else if (index == 2) {
+	YAP_PutInSlot(a,YAP_TailOfTerm(t));
+	return 1;
+      }
+    }
+    return 0;
+  }
+  YAP_PutInSlot(a,YAP_ArgOfTerm(index, t));
+  return 1;
+}
+   
+/* SWI: int PL_get_atom(term_t t, YAP_Atom *a)
+   YAP: YAP_Atom YAP_AtomOfTerm(Term) */
+X_API int PL_get_atom(term_t ts, atom_t *a)
+{
+  YAP_Term t = YAP_GetFromSlot(ts);
+  if ( !YAP_IsAtomTerm(t))
+    return 0;
+  *a = (atom_t)YAP_AtomOfTerm(t);
+  return 1;
+}
+
+/* SWI: int PL_get_atom_chars(term_t t, char **s)
+   YAP: char* AtomName(Atom) */
+X_API int PL_get_atom_chars(term_t ts, char **a)  /* SAM check type */
+{
+  YAP_Term t = YAP_GetFromSlot(ts);
+  if (!YAP_IsAtomTerm(t))
+    return 0;
+  *a = (char *)YAP_AtomName(YAP_AtomOfTerm(t));
+  return 1;
+}
+
+/*
+  int PL_get_chars(term_t +t, char **s, unsigned flags) Convert the
+  argument term t to a 0-terminated C-string. flags is a bitwise
+  disjunction from two groups of constants. The first specifies which
+  term-types should converted and the second how the argument is
+  stored. Below is a specification of these constants. BUF_RING
+  implies, if the data is not static (as from an atom), the data is
+  copied to the next buffer from a ring of sixteen (16) buffers. This is a
+  convenient way of converting multiple arguments passed to a foreign
+  predicate to C-strings. If BUF_MALLOC is used, the data must be
+  freed using free() when not needed any longer.
+
+    CVT_ATOM Convert if term is an atom
+    CVT_STRING Convert if term is a string
+    CVT_LIST Convert if term is a list of integers between 1 and 255
+    CVT_INTEGER Convert if term is an integer (using %d)
+    CVT_FLOAT Convert if term is a float (using %f)
+    CVT_NUMBER Convert if term is a integer or float
+    CVT_ATOMIC Convert if term is atomic
+    CVT_VARIABLE Convert variable to print-name
+    CVT_ALL Convert if term is any of the above, except for variables
+    BUF_DISCARDABLE Data must copied immediately
+    BUF_RING Data is stored in a ring of buffers
+    BUF_MALLOC Data is copied to a new buffer returned by malloc(3)
+*/
+
+static int CvtToStringTerm(YAP_Term t, char *buf, char *buf_max)
+{
+  *buf++ = '\"';
+  while (YAP_IsPairTerm(t)) {
+    YAP_Term hd = YAP_HeadOfTerm(t);
+    long int  i;
+    if (!YAP_IsIntTerm(hd))
+      return 0;
+    i = YAP_IntOfTerm(hd);
+    if (i <= 0 || i >= 255)
+      return 0;
+    if (!YAP_IsIntTerm(hd))
+      return 0;
+    *buf++ = i;
+    if (buf == buf_max)
+      return 0;
+    t = YAP_TailOfTerm(t);
+  }
+  if (t != YAP_MkAtomTerm(YAP_LookupAtom("[]")))
+    return 0;
+  if (buf+1 == buf_max)
+    return 0;
+  buf[0] = '\"';
+  buf[1] = '\0';
+  return 1;
+}
+
+char *bf, *bf_lim;
+
+static void
+buf_writer(int c)
+{
+  if (bf == bf_lim) {
+    return;
+  }
+  *bf++ = c;
+}
+
+#if !HAVE_SNPRINTF
+#define snprintf(X,Y,Z,A) sprintf(X,Z,A)
+#endif
+
+
+X_API int PL_get_chars(term_t l, char **sp, unsigned flags)
+{
+  YAP_Term t = YAP_GetFromSlot(l);
+  char *tmp;
+
+  if (!(flags & BUF_RING)) {
+    tmp = alloc_ring_buf();
+  } else {
+    tmp = buffers;
+  }
+  *sp = tmp;
+  if (YAP_IsAtomTerm(t)) {
+    YAP_Atom at = YAP_AtomOfTerm(t);
+    if (!(flags & (CVT_ATOM|CVT_ATOMIC|CVT_ALL)))
+      return 0;
+    if (YAP_IsWideAtom(at))
+      /* will this always work? */
+      snprintf(*sp,BUF_SIZE,"%ls",YAP_WideAtomName(at));
+    else
+      *sp = (char *)YAP_AtomName(YAP_AtomOfTerm(t));
+    return 1;
+  } else if (YAP_IsIntTerm(t)) {
+    if (!(flags & (CVT_INTEGER|CVT_NUMBER|CVT_ATOMIC|CVT_ALL)))
+      return 0;
+    snprintf(tmp,BUF_SIZE,"%ld",YAP_IntOfTerm(t));
+  } else if (YAP_IsFloatTerm(t)) {
+    if (!(flags & (CVT_FLOAT|CVT_ATOMIC|CVT_NUMBER|CVT_ALL)))
+      return 0;
+    snprintf(tmp,BUF_SIZE,"%f",YAP_FloatOfTerm(t));
+  } else if (flags & CVT_STRING) {
+    if (CvtToStringTerm(t,tmp,tmp+BUF_SIZE) == 0)
+      return 0;
+  } else {
+    bf = tmp;
+    bf_lim = tmp+(BUF_SIZE-1);
+    YAP_Write(t,buf_writer,0);
+    if (bf == bf_lim)
+      return 0;
+    *bf = '\0';
+  }
+  if (flags & BUF_MALLOC) {
+    char *nbf = YAP_AllocSpaceFromYap(strlen(tmp)+1);
+    if (nbf == NULL)
+      return 0;
+    strncpy(nbf,tmp,BUF_SIZE);
+    *sp = nbf;
+  }
+  return 1;
+}
+
+X_API int PL_get_nchars(term_t l, size_t *len, char **sp, unsigned flags)
+{
+  int out = PL_get_chars(l, sp, flags);
+  if (!out) return out;
+  *len = strlen(*sp);
+  return out;
+}
+
+
+/* same as get_chars, but works on buffers of wide chars */
+X_API int PL_get_wchars(term_t l, size_t *len, wchar_t **wsp, unsigned flags)
+{
+  if (YAP_IsAtomTerm(l)) {
+    YAP_Atom at = YAP_AtomOfTerm(l);
+
+    if (!(flags & (CVT_ATOM|CVT_ATOMIC|CVT_ALL)))
+      return 0;
+    if (YAP_IsWideAtom(at))
+      /* will this always work? */
+      *wsp = (wchar_t *)YAP_WideAtomName(at);
+  } else {
+    char *sp;
+    int res = PL_get_chars(l, &sp, ((flags & ~(BUF_MALLOC|BUF_DISCARDABLE))|BUF_RING));
+    size_t sz;
+
+    if (!res)
+      return FALSE;
+    sz = wcstombs(sp,NULL,BUF_SIZE);
+    if (flags & BUF_MALLOC) {
+      wchar_t *nbf = (wchar_t *)YAP_AllocSpaceFromYap(sz+1);
+      if (nbf == NULL)
+	return 0;
+      *wsp = nbf;
+    } else if (flags & BUF_DISCARDABLE) {
+      wchar_t *buf = (wchar_t *)buffers;
+
+      if (wcstombs(sp,buf,BUF_SIZE) == -1)
+	return 0;
+      *wsp = buf;
+    } else {
+      wchar_t *tmp = (wchar_t *)alloc_ring_buf();
+      if (wcstombs(sp, tmp, BUF_SIZE) == -1)
+	return 0;
+      *wsp = tmp;
+    }
+    return res;
+  }
+  return 0;
+}
+
+
+/* SWI: int PL_get_functor(term_t t, functor_t *f)
+   YAP: YAP_Functor YAP_FunctorOfTerm(Term) */
+X_API int PL_get_functor(term_t ts, functor_t *f)
+{
+  YAP_Term t = YAP_GetFromSlot(ts);
+  if ( YAP_IsAtomTerm(t)) {
+    *f = t;
+  } else {
+    *f = (functor_t)YAP_FunctorOfTerm(t);
+  }
+  return 1;
+}
+
+/* SWI: int PL_get_float(term_t t, double *f)
+   YAP: double YAP_FloatOfTerm(Term) */
+X_API int PL_get_float(term_t ts, double *f) /* SAM type check*/
+{	
+  YAP_Term t = YAP_GetFromSlot(ts);
+  if ( !YAP_IsFloatTerm(t))
+    return 0;
+  *f = YAP_FloatOfTerm(t);
+  return 1;
+}
+
+X_API int PL_get_head(term_t ts, term_t h)
+{
+  YAP_Term t = YAP_GetFromSlot(ts);
+  if (!YAP_IsPairTerm(t) ) {
+    return 0;
+  }
+  YAP_PutInSlot(h,YAP_HeadOfTerm(t));
+  return 1;
+}
+
+/* SWI: int PL_get_integer(term_t t, int *i)
+   YAP: long int  YAP_IntOfTerm(Term) */
+X_API int PL_get_integer(term_t ts, int *i)
+{
+  YAP_Term t = YAP_GetFromSlot(ts);
+  if (!YAP_IsIntTerm(t) )
+    return 0;
+  *i = YAP_IntOfTerm(t);
+  return 1;
+}
+
+X_API int PL_get_long(term_t ts, long *i)
+{
+  YAP_Term t = YAP_GetFromSlot(ts);
+  if (!YAP_IsIntTerm(t) ) {
+    if (YAP_IsFloatTerm(t)) {
+      double dbl = YAP_FloatOfTerm(t);
+      if (dbl - (long)dbl == 0.0) {
+	*i = (long)dbl;
+	return 1;
+      }
+    }
+    return 0;
+  }
+  *i = YAP_IntOfTerm(t);
+  return 1;
+}
+
+
+X_API int PL_get_int64(term_t ts, int64_t *i)
+{
+  YAP_Term t = YAP_GetFromSlot(ts);
+  if (!YAP_IsIntTerm(t) ) {
+    if (YAP_IsFloatTerm(t)) {
+      double dbl = YAP_FloatOfTerm(t);
+      if (dbl - (int64_t)dbl == 0.0) {
+	*i = (int64_t)dbl;
+	return 1;
+      }
+#if USE_GMP
+    } else if (YAP_IsBigNumTerm(t)) {
+      MP_INT g;
+      char s[64];
+      YAP_BigNumOfTerm(t, (void *)&g);
+      if (mpz_sizeinbase(&g,2) > 64) {
+	return 0;
+      }
+      mpz_get_str (s, 10, &g);
+      sscanf(s, "%lld", (long long int *)i);
+      return 1;
+#endif
+    }
+    return 0;
+  }
+  *i = YAP_IntOfTerm(t);
+  return 1;
+}
+
+
+X_API int PL_get_list(term_t ts, term_t h, term_t tl)
+{
+  YAP_Term t = YAP_GetFromSlot(ts);
+  if (!YAP_IsPairTerm(t) ) {
+    return 0;
+  }
+  YAP_PutInSlot(h,YAP_HeadOfTerm(t));
+  YAP_PutInSlot(tl,YAP_TailOfTerm(t));
+  return 1;
+}
+
+X_API int PL_get_list_chars(term_t l, char **sp, unsigned flags)
+{
+  if (flags & (CVT_ATOM|CVT_STRING|CVT_INTEGER|CVT_FLOAT|CVT_NUMBER|CVT_ATOMIC|CVT_VARIABLE|CVT_ALL))
+    return 0;
+  return PL_get_chars(l, sp, CVT_LIST|flags);
+}
+
+/* SWI: int PL_get_module(term_t t, module_t *m) */
+X_API int PL_get_module(term_t ts, module_t *m)
+{
+  YAP_Term t = YAP_GetFromSlot(ts);
+  if (!YAP_IsAtomTerm(t) )
+    return 0;
+  *m = (module_t)YAP_LookupModule(t);
+  return 1;
+}
+
+/* SWI: int PL_new_module(term_t t, module_t *m) */
+X_API module_t PL_new_module(atom_t at)
+{
+  return (module_t)YAP_CreateModule((YAP_Atom)at);
+}
+
+/* SWI: int PL_get_atom(term_t t, YAP_Atom *a)
+   YAP: YAP_Atom YAP_AtomOfTerm(Term) */
+X_API int PL_get_name_arity(term_t ts, atom_t *name, int *arity)
+{
+  YAP_Term t = YAP_GetFromSlot(ts);
+  if (YAP_IsAtomTerm(t)) {
+    *name = (atom_t)YAP_AtomOfTerm(t);
+    *arity = 0;
+    return 1;
+  }
+  if (YAP_IsApplTerm(t)) {
+    YAP_Functor f = YAP_FunctorOfTerm(t);
+    *name = (atom_t)YAP_NameOfFunctor(f);
+    *arity = YAP_ArityOfFunctor(f);
+    return 1;
+  }
+  if (YAP_IsPairTerm(t)) {
+    *name = (atom_t)YAP_LookupAtom(".");
+    *arity = 2;
+    return 1;
+  }
+  return 0;
+}
+
+/* SWI: int PL_get_atom(term_t t, YAP_Atom *a)
+   YAP: YAP_Atom YAP_AtomOfTerm(Term) */
+X_API int PL_get_nil(term_t ts)
+{
+  YAP_Term t = YAP_GetFromSlot(ts);
+  return ( t == YAP_MkAtomTerm(YAP_LookupAtom("[]")));
+}
+
+/* SWI: int PL_get_pointer(term_t t, int *i)
+   YAP: NO EQUIVALENT */
+/* SAM TO DO */
+X_API int PL_get_pointer(term_t ts, void **i)
+{
+  YAP_Term t = YAP_GetFromSlot(ts);
+  if (!YAP_IsIntTerm(t) )
+    return 0;
+  *i = (void *)YAP_IntOfTerm(t);
+  return 1;
+}
+
+/* SWI: int PL_get_atom_chars(term_t t, char **s)
+   YAP: char* AtomName(Atom) */
+X_API int PL_get_string(term_t ts, char **sp, int *lenp)  /* SAM check type */
+{
+  YAP_Term t = YAP_GetFromSlot(ts);
+  char *to;
+  int len;
+  if (!YAP_IsPairTerm(t))
+    return 0;
+  if (!YAP_StringToBuffer(t, buffers, TMP_BUF_SIZE))
+      return(FALSE);
+  len = strlen(buffers);
+  to = (char *)YAP_NewSlots((len/sizeof(YAP_Term))+1);
+  strncpy(to, buffers, TMP_BUF_SIZE);
+  *sp = to;
+  return 1;
+}
+
+X_API int PL_get_tail(term_t ts, term_t tl)
+{
+  YAP_Term t = YAP_GetFromSlot(ts);
+  if (!YAP_IsPairTerm(t) ) {
+    return 0;
+  }
+  YAP_PutInSlot(tl,YAP_TailOfTerm(t));
+  return 1;
+}
+
+/* end PL_get_* functions  =============================*/
+
+/* begin PL_new_* functions =============================*/
+
+/* SWI: atom_t PL_new_atom(const char *)
+   YAP: YAP_Atom LookupAtom(char *) */
+/*  SAM should the following be used instead?
+      YAP_Atom  FullLookupAtom(char *)
+      */
+X_API atom_t PL_new_atom(const char *c)
+{
+  return (atom_t)YAP_LookupAtom((char *)c);
+}
+
+X_API atom_t PL_new_atom_wchars(int len, const wchar_t *c)
+{
   atom_t at;
   int i;
 
@@ -531,1008 +531,1008 @@ X_API atom_t PL_new_atom_wchars(int len, const wchar_t *c)
     YAP_FreeSpaceFromYap(nbf);
   }
   return at;
-}
-
-X_API char *PL_atom_nchars(atom_t name, size_t *sp)
-{
-  *sp = YAP_AtomNameLength((YAP_Atom)name);
-  return (char *)YAP_AtomName((YAP_Atom)name);
-}
-
-X_API wchar_t *PL_atom_wchars(atom_t name, size_t *sp)
-{
-  if (!YAP_IsWideAtom((YAP_Atom)name))
-    return NULL;
-  *sp = YAP_AtomNameLength((YAP_Atom)name);
-  return (wchar_t *)YAP_WideAtomName((YAP_Atom)name);
-}
-
-X_API functor_t PL_new_functor(atom_t name, int arity)
-{
-  functor_t f;
-  if (arity == 0) {
-    f = (functor_t)YAP_MkAtomTerm((YAP_Atom)name);
-  } else {
-    f = (functor_t)YAP_MkFunctor((YAP_Atom)name,arity);
-  }
-  return f;
-}
-
-X_API atom_t PL_functor_name(functor_t f)
-{
-  if (YAP_IsAtomTerm(f)) {
-    return (atom_t)YAP_AtomOfTerm(f);
-  } else {
-    return (atom_t)YAP_NameOfFunctor((YAP_Functor)f);
-  }
-}
-
-X_API int PL_functor_arity(functor_t f)
-{
-  if (YAP_IsAtomTerm(f)) {
-    return 0;
-  } else {
-    return YAP_ArityOfFunctor((YAP_Functor)f);
-  }
-}
-
-/* end PL_new_* functions =============================*/
-
-/* begin PL_put_* functions =============================*/
-
-X_API void PL_cons_functor(term_t d, functor_t f,...)
-{
-  va_list ap;
-  int arity, i;
-  YAP_Term *tmp = (YAP_CELL *)buffers;
-
-  if (YAP_IsAtomTerm((YAP_Term)f)) {
-    YAP_PutInSlot(d, (YAP_Term)f);
-    return;
-  }
-  arity = YAP_ArityOfFunctor((YAP_Functor)f);
-  if (arity > TMP_BUF_SIZE/sizeof(YAP_CELL)) {
-    fprintf(stderr,"PL_cons_functor: arity too large (%d)\n", arity); 
-    return;
-  }
-  va_start (ap, f);
-  for (i = 0; i < arity; i++) {
-    tmp[i] =  YAP_GetFromSlot(va_arg(ap, term_t));
-  }
-  va_end (ap);
-  if (arity == 2 && (YAP_Functor)f == YAP_MkFunctor(YAP_LookupAtom("."),2))
-    YAP_PutInSlot(d,YAP_MkPairTerm(tmp[0],tmp[1]));
-  else
-    YAP_PutInSlot(d,YAP_MkApplTerm((YAP_Functor)f,arity,tmp));
-}
-
-X_API void PL_cons_functor_v(term_t d, functor_t f,term_t a0)
-{
-  int arity;
-
-  if (YAP_IsAtomTerm(f)) {
-    YAP_PutInSlot(d,(YAP_Term)f);
-    return;
-  }
-  arity = YAP_ArityOfFunctor((YAP_Functor)f);
-  if (arity == 2 && (YAP_Functor)f == YAP_MkFunctor(YAP_LookupAtom("."),2))
-    YAP_PutInSlot(d,YAP_MkPairTerm(YAP_GetFromSlot(a0),YAP_GetFromSlot(a0+1)));    
-  else
-    YAP_PutInSlot(d,YAP_MkApplTerm((YAP_Functor)f,arity,YAP_AddressFromSlot(a0)));
-}
-
-X_API void PL_cons_list(term_t d, term_t h, term_t t)
-{
-  YAP_PutInSlot(d,YAP_MkPairTerm(YAP_GetFromSlot(h),YAP_GetFromSlot(t)));
-}
-
-X_API void PL_put_atom(term_t t, atom_t a)
-{
-  YAP_PutInSlot(t,YAP_MkAtomTerm((YAP_Atom)a));
-}
-
-X_API void PL_put_atom_chars(term_t t, const char *s)
-{
-  YAP_PutInSlot(t,YAP_MkAtomTerm(YAP_LookupAtom((char *)s)));
-}
-
-X_API void PL_put_float(term_t t, double fl)
-{
-  YAP_PutInSlot(t,YAP_MkFloatTerm(fl));
-}
-
-X_API void PL_put_functor(term_t t, functor_t f)
-{
-  long int  arity;
-  if (YAP_IsAtomTerm(f)) {
-    YAP_PutInSlot(t,f);
-  } else {
-    arity = YAP_ArityOfFunctor((YAP_Functor)f);
-    if (arity == 2 && (YAP_Functor)f == YAP_MkFunctor(YAP_LookupAtom("."),2))
-      YAP_PutInSlot(t,YAP_MkNewPairTerm());    
-    else
-      YAP_PutInSlot(t,YAP_MkNewApplTerm((YAP_Functor)f,arity));
-  }
-}
-
-X_API void PL_put_integer(term_t t, long n)
-{
-  YAP_PutInSlot(t,YAP_MkIntTerm(n));
-}
-
-X_API void PL_put_int64(term_t t, int64_t n)
-{
-#if USE_GMP
-  char s[64];
-  MP_INT rop;
-
-  sprintf(s, "%lld", (long long int)n);
-  mpz_init_set_str (&rop, s, 10);
-  YAP_PutInSlot(t,YAP_MkBigNumTerm((void *)&rop));
-#endif
-}
-
-X_API void PL_put_list(term_t t)
-{
-  YAP_PutInSlot(t,YAP_MkNewPairTerm());
-}
-
-X_API void PL_put_list_chars(term_t t, const char *s)
-{
-  YAP_PutInSlot(t,YAP_BufferToString((char *)s));
-}
-
-X_API void PL_put_nil(term_t t)
-{
-  YAP_PutInSlot(t,YAP_MkAtomTerm(YAP_LookupAtom("[]")));
-}
-
-/* SWI: void PL_put_pointer(term_t -t, void *ptr)
-   YAP: NO EQUIVALENT */
-/* SAM TO DO */
-X_API void PL_put_pointer(term_t t, void *ptr)
-{
-  YAP_Term tptr = YAP_MkIntTerm((long int)ptr);
-  YAP_PutInSlot(t,tptr);
-}
-
-X_API void PL_put_string_chars(term_t t, const char *s)
-{
-  YAP_PutInSlot(t,YAP_BufferToString((char *)s));
-}
-
-X_API void PL_put_term(term_t d, term_t s)
-{
-  YAP_PutInSlot(d,YAP_GetFromSlot(s));
-}
-
-X_API void PL_put_variable(term_t t)
-{
-  YAP_PutInSlot(t,YAP_MkVarTerm());
-}
-
-/* end PL_put_* functions =============================*/
-
-/* SWI: int PL_raise_exception(term_t exception)
-   YAP: NO EQUIVALENT */
-/* SAM TO DO */
-
-X_API int PL_raise_exception(term_t exception)
-{
-  YAP_Throw(YAP_GetFromSlot(exception));
-  return 0;
-}
-
-/* begin PL_unify_* functions =============================*/
-
-X_API int PL_unify(term_t t1, term_t t2)
-{
-  return YAP_Unify(YAP_GetFromSlot(t1),YAP_GetFromSlot(t2));
-}
-
-/* SWI: int PL_unify_atom(term_t ?t, atom  *at)
-   YAP long int  unify(YAP_Term* a, Term* b) */
-X_API int PL_unify_atom(term_t t, atom_t at)
-{
-  YAP_Term cterm = YAP_MkAtomTerm((YAP_Atom)at);
-  return YAP_Unify(YAP_GetFromSlot(t),cterm);
-}
-
-/* SWI: int PL_unify_atom_chars(term_t ?t, const char *chars)
-   YAP long int  unify(YAP_Term* a, Term* b) */
-X_API int PL_unify_atom_chars(term_t t, const char *s)
-{
-  YAP_Atom catom = YAP_LookupAtom((char *)s);
-  YAP_Term cterm = YAP_MkAtomTerm(catom);
-  return YAP_Unify(YAP_GetFromSlot(t),cterm);
-}
-
-/* SWI: int PL_unify_float(term_t ?t, double f)
-   YAP long int  unify(YAP_Term* a, Term* b) */
-X_API int PL_unify_float(term_t t, double f)
-{
-  YAP_Term fterm = YAP_MkFloatTerm(f);
-  return YAP_Unify(YAP_GetFromSlot(t),fterm);
-}
-
-/* SWI: int PL_unify_integer(term_t ?t, long n)
-   YAP long int  unify(YAP_Term* a, Term* b) */
-X_API int PL_unify_integer(term_t t, long n)
-{	
-  YAP_Term iterm = YAP_MkIntTerm(n);
-  return YAP_Unify(YAP_GetFromSlot(t),iterm);
-}
-
-/* SWI: int PL_unify_integer(term_t ?t, long n)
-   YAP long int  unify(YAP_Term* a, Term* b) */
-X_API int PL_unify_int64(term_t t, int64_t n)
-{	
-#if USE_GMP
-  YAP_Term iterm;
-  char s[64];
-  MP_INT rop;
-
-  sprintf(s, "%lld", (long long int)n);
-  mpz_init_set_str (&rop, s, 10);
-  iterm = YAP_MkBigNumTerm((void *)&rop);
-  return YAP_Unify(YAP_GetFromSlot(t),iterm);
-#else
-  return FALSE;
-#endif
-}
-
-/* SWI: int PL_unify_list(term_t ?t, term_t +h, term_t -t)
-   YAP long int  unify(YAP_Term* a, Term* b) */
-X_API int PL_unify_list(term_t t, term_t h, term_t tail)
-{
-  YAP_Term pairterm = YAP_MkPairTerm(YAP_GetFromSlot(h),YAP_GetFromSlot(tail));
-  return YAP_Unify(YAP_GetFromSlot(t), pairterm);
-}
-
-/* SWI: int PL_unify_list(term_t ?t, term_t +h, term_t -t)
-   YAP long int  unify(YAP_Term* a, Term* b) */
-X_API int PL_unify_list_chars(term_t t, const char *chars)
-{
-  YAP_Term chterm = YAP_BufferToString((char *)chars);
-  return YAP_Unify(YAP_GetFromSlot(t), chterm);
-}
-
-/* SWI: int PL_unify_nil(term_t ?l)
-   YAP long int  unify(YAP_Term* a, Term* b) */
-X_API int PL_unify_nil(term_t l)
-{
-  YAP_Term nilterm = YAP_MkAtomTerm(YAP_LookupAtom("[]"));
-  return YAP_Unify(YAP_GetFromSlot(l), nilterm);
-}
-
-/* SWI: int PL_unify_pointer(term_t ?t, void *ptr)
-   YAP: NO EQUIVALENT */
-/* SAM TO DO */
-X_API int PL_unify_pointer(term_t t, void *ptr)
-{
-  YAP_Term ptrterm = YAP_MkIntTerm((long int)ptr);
-  return YAP_Unify(YAP_GetFromSlot(t), ptrterm);
-}
-
-/* SWI: int PL_unify_list(term_t ?t, term_t +h, term_t -t)
-   YAP long int  unify(YAP_Term* a, Term* b) */
-X_API int PL_unify_string_chars(term_t t, const char *chars)
-{
-  YAP_Term chterm = YAP_BufferToString((char *)chars);
-  return YAP_Unify(YAP_GetFromSlot(t), chterm);
-}
-
-typedef struct {
-  int type;
-  union {
-    functor_t f;
-    term_t t;
-    atom_t a;
-    long l;
-    double dbl;
-    char *s;
-    void *p;
-  } arg;
-} arg_types;
-
-static YAP_Term
-get_term(arg_types **buf)
-{
-  arg_types *ptr = *buf;
-  int type = ptr->type;
-  YAP_Term t;
-
-  switch (type) {
-  /* now build the error string */
-  case PL_VARIABLE:
-    t = YAP_MkVarTerm();
-    ptr++;
-    break;
-  case PL_ATOM:
-    t = YAP_MkAtomTerm((YAP_Atom)ptr->arg.a);
-    ptr++;
-    break;
-  case PL_INTEGER:
-    t = YAP_MkIntTerm(ptr->arg.l);
-    ptr++;
-    break;
-  case PL_FLOAT:
-    t = YAP_MkFloatTerm(ptr->arg.dbl);
-    ptr++;
-    break;
-  case PL_POINTER:
-    t = YAP_MkIntTerm((long int)(ptr->arg.p));
-    ptr++;
-    break;
-  case PL_STRING:
-    t = YAP_BufferToString(ptr->arg.s);
-    ptr++;
-    break;
-  case PL_TERM:
-    t = YAP_GetFromSlot(ptr->arg.t);
-    ptr++;
-    break;
-  case PL_CHARS:
-    t = YAP_MkAtomTerm(YAP_LookupAtom(ptr->arg.s));
-    break;
-  case PL_FUNCTOR:
-    {
-      functor_t f = ptr->arg.f;
-      long int  arity, i;
-      term_t loc;
-
-      if (YAP_IsAtomTerm((YAP_Term)f)) {
-	t = (YAP_Term)f;
-	break;
-      }
-      arity = YAP_ArityOfFunctor((YAP_Functor)f);
-      loc = YAP_NewSlots(arity);
-      ptr++;
-      for (i= 0; i < arity; i++) {
-	YAP_PutInSlot(loc+i,get_term(&ptr));
-      }
-      t = YAP_MkApplTerm((YAP_Functor)f,arity,YAP_AddressFromSlot(loc));
-    }
-    break;
-  case PL_LIST:
-    {
-      term_t loc;
-
-      loc = YAP_NewSlots(2);
-      ptr++;
-      YAP_PutInSlot(loc,get_term(&ptr));
-      YAP_PutInSlot(loc+1,get_term(&ptr));
-      t = YAP_MkPairTerm(YAP_GetFromSlot(loc),YAP_GetFromSlot(loc+1));
-    }
-    break;
-  default:
-    fprintf(stderr, "type %d not implemented yet\n", type);
-    exit(1);
-  }
-  *buf = ptr;
-  return t;
-}
-
-/* SWI: int PL_unify_term(term_t ?t1, term_t ?t2)
-   YAP long int  YAP_Unify(YAP_Term* a, Term* b) */
-X_API int PL_unify_term(term_t l,...)
-{
-  va_list ap;
-  int type;
-  int nels = 1;
-  arg_types *ptr = (arg_types *)buffers;
-
-  va_start (ap, l);
-  while (nels > 0) {
-    type = va_arg(ap, int);
-    nels --;
-    
-    ptr->type = type;
-    switch(type) {
-    case PL_VARIABLE:
-      break;
-    case PL_ATOM:
-      ptr->arg.a = va_arg(ap, atom_t);
-      break;
-    case PL_INTEGER:
-      ptr->arg.l = va_arg(ap, long);
-      break;
-    case PL_FLOAT:
-      ptr->arg.dbl = va_arg(ap, double);
-      break;
-    case PL_STRING:
-      ptr->arg.s = va_arg(ap, char *);
-      break;
-    case PL_TERM:
-      ptr->arg.t = va_arg(ap, term_t);
-      break;
-    case PL_POINTER:
-      ptr->arg.p = va_arg(ap, void *);
-      break;
-    case PL_CHARS:
-      ptr->arg.s = va_arg(ap, char *);
-      break;
-    case PL_FUNCTOR:
-      {
-	functor_t f = va_arg(ap, functor_t);
-	ptr->arg.f = f;
-	if (!YAP_IsAtomTerm((YAP_Term)f)) {
-	  nels += YAP_ArityOfFunctor((YAP_Functor)f);
-	}
-      }
-      break;
-    case PL_LIST:
-      nels += 2;
-      break;
-    default:
-      fprintf(stderr, "%d not supported\n", type);
-      exit(1);
-    }
-    ptr++;
-  }
-  va_end (ap);
-  ptr = (arg_types *)buffers;
-    return YAP_Unify(YAP_GetFromSlot(l),get_term(&ptr));
-}
-
-/* end PL_unify_* functions =============================*/
-
-/* SWI: void PL_register_atom(atom_t atom)
-   YAP: NO EQUIVALENT */
-/* SAM TO DO */
-X_API void PL_register_atom(atom_t atom)
-{
-}
-
-/* SWI: void PL_unregister_atom(atom_t atom)
-   YAP: NO EQUIVALENT */
-/* SAM TO DO */
-X_API void PL_unregister_atom(atom_t atom)
-{
-}
-
-X_API int PL_get_string_chars(term_t t, char **s, int *len)
-{
-  /* there are no such objects in Prolog */
-  return FALSE;
-}
-
-X_API int PL_term_type(term_t t)
-{
-  /* YAP_ does not support strings as different objects */
-  YAP_Term v = YAP_GetFromSlot(t);
-  if (YAP_IsVarTerm(v)) {
-    return PL_VARIABLE;
-  } else if (YAP_IsAtomTerm(v)) {
-    return PL_ATOM;
-  } else if (YAP_IsIntTerm(v)) {
-    return PL_INTEGER;
-  } else if (YAP_IsFloatTerm(v)) {
-    return PL_FLOAT;
-  } else {
-    return PL_TERM;
-  }
-}
-
-X_API int PL_is_atom(term_t t)
-{
-  return YAP_IsAtomTerm(YAP_GetFromSlot(t));
-}
-
-X_API int PL_is_atomic(term_t ts)
-{
-  YAP_Term t = YAP_GetFromSlot(ts);
-  return !YAP_IsVarTerm(t) || !YAP_IsApplTerm(t) || !YAP_IsPairTerm(t);
-}
-
-X_API int PL_is_compound(term_t ts)
-{
-  YAP_Term t = YAP_GetFromSlot(ts);
-  return (YAP_IsApplTerm(t) || YAP_IsPairTerm(t));
-}
-
-X_API int PL_is_functor(term_t ts, functor_t f)
-{
-  YAP_Term t = YAP_GetFromSlot(ts);
-  if (YAP_IsApplTerm(t)) {
-    return YAP_FunctorOfTerm(t) == (YAP_Functor)f;
-  } else if (YAP_IsPairTerm(t)) {
-    return YAP_FunctorOfTerm(t) == YAP_MkFunctor(YAP_LookupAtom("."),2);
-  } else
-    return 0;
-}
-
-X_API int PL_is_float(term_t ts)
-{
-  YAP_Term t = YAP_GetFromSlot(ts);
-  return YAP_IsFloatTerm(t);
-}
-
-X_API int PL_is_integer(term_t ts)
-{
-  YAP_Term t = YAP_GetFromSlot(ts);
-  return YAP_IsIntTerm(t);
-}
-
-X_API int PL_is_list(term_t ts)
-{
-  YAP_Term t = YAP_GetFromSlot(ts);
-  if (YAP_IsPairTerm(t)) {
-    return 1;
-  } else if (YAP_IsAtomTerm(t)) {
-    return t == YAP_MkAtomTerm(YAP_LookupAtom("[]"));
-  } else
-    return 0;
-}
-
-X_API int PL_is_number(term_t ts)
-{
-  YAP_Term t = YAP_GetFromSlot(ts);
-  return YAP_IsIntTerm(t) || YAP_IsFloatTerm(t);
-}
-
-X_API int PL_is_string(term_t ts)
-{
-  YAP_Term t = YAP_GetFromSlot(ts);
-  while (YAP_IsPairTerm(t)) {
-    YAP_Term hd = YAP_HeadOfTerm(t);
-    long int  i;
-    if (!YAP_IsIntTerm(hd))
-      return 0;
-    i = YAP_IntOfTerm(hd);
-    if (i <= 0 || i >= 255)
-      return 0;
-    if (!YAP_IsIntTerm(hd))
-      return 0;
-    t = YAP_TailOfTerm(t);
-  }
-  if (t != YAP_MkAtomTerm(YAP_LookupAtom("[]")))
-    return 0;
-  return FALSE;
-}
-
-X_API int PL_is_variable(term_t ts)
-{
-  YAP_Term t = YAP_GetFromSlot(ts);
-  return YAP_IsVarTerm(t);
-}
-
-X_API int PL_compare(term_t ts1, term_t ts2)
-{
-  YAP_Term t1 = YAP_GetFromSlot(ts1);
-  YAP_Term t2 = YAP_GetFromSlot(ts2);
-  return YAP_CompareTerms(t1, t2);
-}
-
-X_API void PL_halt(int e)
-{
-   YAP_Halt(e);
-}
-
-X_API int PL_action(int action,...)
-{
-  va_list ap;
-
-  va_start (ap, action);
-  switch (action) {
-  case PL_ACTION_TRACE:
-    fprintf(stderr, "PL_ACTION_TRACE not supported\n");
-    break;
-  case PL_ACTION_DEBUG:
-    fprintf(stderr, "PL_ACTION_DEBUG not supported\n");
-    break;
-  case PL_ACTION_BACKTRACE:
-    fprintf(stderr, "PL_ACTION_BACKTRACE not supported\n");
-    break;
-  case PL_ACTION_HALT:
-    {
-      int halt_arg = va_arg(ap, int);
-      YAP_Halt(halt_arg);
-    }
-    break;
-  case PL_ACTION_ABORT:
-    {
-      YAP_Throw(YAP_MkAtomTerm(YAP_LookupAtom("abort")));
-    }
-    break;
-  case PL_ACTION_BREAK:
-    fprintf(stderr, "PL_ACTION_BREAK not supported\n");
-    break;
-  case PL_ACTION_GUIAPP:
-    fprintf(stderr, "PL_ACTION_GUIAPP not supported\n");
-    break;
-  case PL_ACTION_WRITE:
-    fprintf(stderr, "PL_ACTION_WRITE not supported\n");
-    break;
-  case PL_ACTION_FLUSH:
-    fprintf(stderr, "PL_ACTION_WRITE not supported\n");
-    break;
-  case PL_ACTION_ATTACH_CONSOLE:
-    fprintf(stderr, "PL_ACTION_WRITE not supported\n");
-    break;
-  }
-  va_end (ap);
-  return 0;
-}
-
-X_API fid_t
-PL_open_foreign_frame(void)
-{
-  return 0;
-}
-
-X_API void
-PL_close_foreign_frame(fid_t f)
-{
-}
-
-X_API void
-PL_discard_foreign_frame(fid_t f)
-{
-  fprintf(stderr,"WARNING: PL_discard_foreign_frame not fully implemented!!");
-  /* Missing: undo Trail!! */
-}
-
-X_API term_t
-PL_exception(qid_t q)
-{
-  YAP_Term t;
-  if (YAP_GoalHasException(&t)) {
-    term_t to = YAP_NewSlots(1);
-    YAP_PutInSlot(to,t);
-    return to;
-  } else {
-    return 0L;
-  }
-}
-
-X_API int
-PL_initialise(int myargc, char **myargv)
-{
-  YAP_init_args init_args;
-
-  init_args.Argv = myargv;
-  init_args.Argc = myargc;
-  init_args.SavedState = "startup";
-  init_args.HeapSize = 0;
-  init_args.StackSize = 0;
-  init_args.TrailSize = 0;
-  init_args.YapLibDir = NULL;
-  init_args.YapPrologBootFile = NULL;
-  init_args.HaltAfterConsult = FALSE;
-  init_args.FastBoot = FALSE;
-  init_args.NumberWorkers = 1;
-  init_args.SchedulerLoop = 10;
-  init_args.DelayedReleaseLoad = 3;
-  return YAP_Init(&init_args);
-}
-
-X_API int
-PL_is_initialised(int *argc, char ***argv)
-{
-  return TRUE;
-}
-
-X_API atom_t PL_module_name(module_t m)
-{
-  YAP_Atom at = YAP_AtomOfTerm((YAP_Term)m);
-  YAP_CreateModule(at);
-  return (atom_t)at;
-}
-
-X_API predicate_t PL_pred(functor_t f, module_t m)
-{
-  if (YAP_IsAtomTerm(f)) {
-    return YAP_Predicate(YAP_AtomOfTerm(f),0,(YAP_Module)m);
-  } else {
-    YAP_Functor tf = (YAP_Functor)f;
-    return YAP_Predicate(YAP_NameOfFunctor(tf),YAP_ArityOfFunctor(tf),(YAP_Module)m);
-  }
-}
-
-X_API predicate_t PL_predicate(const char *name, int arity, const char *m)
-{
-  int mod;
-  if (m == NULL)
-    mod = YAP_CurrentModule();
-  else
-    mod = YAP_LookupModule(YAP_MkAtomTerm(YAP_LookupAtom((char *)m)));
-  return YAP_Predicate(YAP_LookupAtom((char *)name),
-		      arity,
-		      mod);
-}
-
-X_API void PL_predicate_info(predicate_t p,atom_t *name, int *arity, module_t *m)
-{
-  YAP_PredicateInfo(p, (YAP_Atom *)name, (unsigned long int  *)arity, (YAP_Module *)m);
-}
-
-typedef struct open_query_struct {
-  int open;
-  int state;
-  YAP_Term g;
-} open_query;
-
-open_query execution;
-
-X_API qid_t PL_open_query(module_t ctx, int flags, predicate_t p, term_t t0)
-{
-  YAP_Atom yname;
-  atom_t name;
-  unsigned long int  arity;
-  YAP_Module  m;
-  YAP_Term t[2];
-
-  /* ignore flags  and module for now */
-  if (execution.open != 0) {
-    YAP_Error(0, 0L, "only one query at a time allowed\n");
-  }
-  execution.open=1;
-  execution.state=0;
-  YAP_PredicateInfo(p, &yname, &arity, &m);
-  name = (atom_t)yname;
-  t[0] = YAP_ModuleName(m);
-  if (arity == 0) {
-    t[1] = YAP_MkAtomTerm((YAP_Atom)name);
-  } else {
-    YAP_Functor f = YAP_MkFunctor((YAP_Atom)name, arity);
-    t[1] = YAP_MkApplTerm(f,arity,YAP_AddressFromSlot(t0));
-  }
-  execution.g = YAP_MkApplTerm(YAP_MkFunctor(YAP_LookupAtom(":"),2),2,t);
-  return &execution;
-}
-
-X_API int PL_next_solution(qid_t qi)
-{
-  int result;
-
-  if (qi->open != 1) return 0;
-  if (qi->state == 0) {
-    result = YAP_RunGoal(qi->g);
-  } else {
-    result = YAP_RestartGoal();
-  }
-  qi->state = 1;
-  if (result == 0) {
-    qi->open = 0;
-  }
-  return result;
-}
-
-X_API void PL_cut_query(qid_t qi)
-{
-  YAP_PruneGoal();
-  qi->open = 0;
-}
-
-X_API void PL_close_query(qid_t qi)
-{
-  /* need to implement backtracking here */
-  if (qi->open != 1)
-    return;
-  YAP_PruneGoal();
-  YAP_RestartGoal();
-  qi->open = 0;
-}
-
-X_API int PL_call_predicate(module_t ctx, int flags, predicate_t p, term_t t0)
-{
-  qid_t qi = PL_open_query(ctx, flags, p, t0);
-  int ret = PL_next_solution(qi);
-  PL_cut_query(qi);
-  return ret;
-}
-
-X_API int PL_call(term_t tp, module_t m)
-{
-  YAP_Term t[2], g;
-  t[0] = YAP_ModuleName((YAP_Module)m);
-  t[1] = YAP_GetFromSlot(tp);
-  g = YAP_MkApplTerm(YAP_MkFunctor(YAP_LookupAtom(":"),2),2,t);
-  return YAP_RunGoal(g);
-}
-
-X_API void PL_register_extensions(PL_extension *ptr)
-{
-  /* ignore flags for now */
-  while(ptr->predicate_name != NULL) {
-    YAP_UserCPredicateWithArgs(ptr->predicate_name,(YAP_Bool (*)(void))ptr->function,ptr->arity,YAP_CurrentModule());
-    ptr++;
-  }
-}
-
-X_API void PL_load_extensions(PL_extension *ptr)
-{
-  /* ignore flags for now */
-  while(ptr->predicate_name != NULL) {
-    YAP_UserCPredicateWithArgs(ptr->predicate_name,(YAP_Bool (*)(void))ptr->function,ptr->arity,YAP_CurrentModule());
-    ptr++;
-  }
-}
-
-X_API int PL_thread_self(void)
-{
-  return YAP_ThreadSelf();
-}
-
-X_API int PL_thread_attach_engine(const PL_thread_attr_t *attr)
-{
-  int wid = YAP_ThreadSelf();
-  
-  if (wid < 0) {
-    /* we do not have an engine */
-    if (attr) {
-      YAP_thread_attr yapt;
-      int wid; 
-
-      yapt.ssize = attr->local_size;
-      yapt.tsize = attr->global_size;
-      yapt.alias = (YAP_Term)attr->alias;
-      yapt.cancel =  attr->cancel;
-      wid = YAP_ThreadCreateEngine(&yapt);
-    } else {
-      wid = YAP_ThreadCreateEngine(NULL);
-    }
-    if (wid < 0)
-      return -1;
-    if (YAP_ThreadAttachEngine(wid)) {
-      return wid;
-    }
-    return -1;
-  } else {
-    /* attach myself again */
-    YAP_ThreadAttachEngine(wid);
-    return wid;
-  }
-}
-
-X_API int PL_thread_destroy_engine(void)
-{
-  int wid = YAP_ThreadSelf();
-
-  if (wid < 0) {
-    /* we do not have an engine */
-    return FALSE;
-  }
-  YAP_ThreadDetachEngine(wid);
-  return YAP_ThreadDestroyEngine(wid);
-}
-
-X_API int
-PL_thread_at_exit(void (*function)(void *), void *closure, int global)
-{
-  /* don't do nothing for now */
-  fprintf(stderr,"%% YAP ERROR: PL_thread_at_exit not implemented yet\n");
-  return TRUE;
-}
-
-
-X_API PL_engine_t
-PL_create_engine(const PL_thread_attr_t *attr)
-{
-  if (attr) {
-    YAP_thread_attr yapt;
-
-    yapt.ssize = attr->local_size;
-    yapt.tsize = attr->global_size;
-    yapt.alias = (YAP_Term)attr->alias;
-    yapt.cancel =  attr->cancel;
-    return (PL_engine_t)YAP_ThreadCreateEngine(&yapt);
-  } else {
-    return (PL_engine_t)YAP_ThreadCreateEngine(NULL);
-  }
-}
-
-
-X_API int
-PL_destroy_engine(PL_engine_t e)
-{
-  return YAP_ThreadDestroyEngine((YAP_Int)e);
-}
-
-X_API int
-PL_set_engine(PL_engine_t engine, PL_engine_t *old)
-{
-  int cwid = YAP_ThreadSelf();
-  if (*old) *old = (PL_engine_t)cwid;
-  if (engine == PL_ENGINE_CURRENT)
-    return PL_ENGINE_SET;
-  if (engine < 0) /* should really check if engine does not exist */
-    return PL_ENGINE_INVAL;
-  if (!(YAP_ThreadAttachEngine((int)engine))) {
-    return PL_ENGINE_INUSE;
-  }
-  return PL_ENGINE_SET;
-}
-
-
-/* note: fprintf may be called from anywhere, so please don't try
-   to be smart and allocate stack from somewhere else */
-X_API int Sprintf(char *format,...)
-{
-  va_list ap;
-  char buf[512];
-
-  va_start(ap,format);
-#ifdef HAVE_VSNPRINTF
-  vsnprintf(buf,512,format,ap);
-#else
-  vsprintf(buf,format,ap);
-#endif
-  va_end(ap);
-
-  fputs(buf, stderr);
-  return 1;
-}
-
-
-/* note: fprintf may be called from anywhere, so please don't try
-   to be smart and allocate stack from somewhere else */
-X_API int Sdprintf(char *format,...)
-{
-  va_list ap;
-  char buf[512];
-
-  va_start(ap,format);
-#ifdef HAVE_VSNPRINTF
-  vsnprintf(buf,512,format,ap);
-#else
-  vsprintf(buf,format,ap);
-#endif
-  va_end(ap);
-
-#if DEBUG
-  fputs(buf, stderr);
-#endif
-  return 1;
-}
-
-static int
-SWI_ctime(void)
-{
-#if HAVE_CTIME
-  time_t tim;
-#endif
-  YAP_Term t1 = YAP_ARG1;
-
-  if (YAP_IsVarTerm(t1)) {
-    YAP_Error(0,t1,"bad argumento to ctime");
-    return FALSE;
-  }
-#if HAVE_CTIME
-  tim = (time_t)YAP_IntOfTerm(t1);
-  return YAP_Unify(YAP_BufferToString(ctime(&tim)), YAP_ARG2);
-#else
-  YAP_Error(0,0L,"convert_time requires ctime");
-  return FALSE;
-#endif
-}
-
-void
-swi_install(void)
-{
-  YAP_UserCPredicate("ctime", SWI_ctime, 2);
-}
-
-#ifdef _WIN32
-
-#include <windows.h>
-
-int WINAPI PROTO(win_yap2swi, (HANDLE, DWORD, LPVOID));
-
-int WINAPI win_yap2swi(HANDLE hinst, DWORD reason, LPVOID reserved)
-{
-  switch (reason) 
-    {
-    case DLL_PROCESS_ATTACH:
-      break;
-    case DLL_PROCESS_DETACH:
-      break;
-    case DLL_THREAD_ATTACH:
-      break;
-    case DLL_THREAD_DETACH:
-      break;
-    }
-  return 1;
-}
-#endif
+}
+
+X_API char *PL_atom_nchars(atom_t name, size_t *sp)
+{
+  *sp = YAP_AtomNameLength((YAP_Atom)name);
+  return (char *)YAP_AtomName((YAP_Atom)name);
+}
+
+X_API wchar_t *PL_atom_wchars(atom_t name, size_t *sp)
+{
+  if (!YAP_IsWideAtom((YAP_Atom)name))
+    return NULL;
+  *sp = YAP_AtomNameLength((YAP_Atom)name);
+  return (wchar_t *)YAP_WideAtomName((YAP_Atom)name);
+}
+
+X_API functor_t PL_new_functor(atom_t name, int arity)
+{
+  functor_t f;
+  if (arity == 0) {
+    f = (functor_t)YAP_MkAtomTerm((YAP_Atom)name);
+  } else {
+    f = (functor_t)YAP_MkFunctor((YAP_Atom)name,arity);
+  }
+  return f;
+}
+
+X_API atom_t PL_functor_name(functor_t f)
+{
+  if (YAP_IsAtomTerm(f)) {
+    return (atom_t)YAP_AtomOfTerm(f);
+  } else {
+    return (atom_t)YAP_NameOfFunctor((YAP_Functor)f);
+  }
+}
+
+X_API int PL_functor_arity(functor_t f)
+{
+  if (YAP_IsAtomTerm(f)) {
+    return 0;
+  } else {
+    return YAP_ArityOfFunctor((YAP_Functor)f);
+  }
+}
+
+/* end PL_new_* functions =============================*/
+
+/* begin PL_put_* functions =============================*/
+
+X_API void PL_cons_functor(term_t d, functor_t f,...)
+{
+  va_list ap;
+  int arity, i;
+  YAP_Term *tmp = (YAP_CELL *)buffers;
+
+  if (YAP_IsAtomTerm((YAP_Term)f)) {
+    YAP_PutInSlot(d, (YAP_Term)f);
+    return;
+  }
+  arity = YAP_ArityOfFunctor((YAP_Functor)f);
+  if (arity > TMP_BUF_SIZE/sizeof(YAP_CELL)) {
+    fprintf(stderr,"PL_cons_functor: arity too large (%d)\n", arity); 
+    return;
+  }
+  va_start (ap, f);
+  for (i = 0; i < arity; i++) {
+    tmp[i] =  YAP_GetFromSlot(va_arg(ap, term_t));
+  }
+  va_end (ap);
+  if (arity == 2 && (YAP_Functor)f == YAP_MkFunctor(YAP_LookupAtom("."),2))
+    YAP_PutInSlot(d,YAP_MkPairTerm(tmp[0],tmp[1]));
+  else
+    YAP_PutInSlot(d,YAP_MkApplTerm((YAP_Functor)f,arity,tmp));
+}
+
+X_API void PL_cons_functor_v(term_t d, functor_t f,term_t a0)
+{
+  int arity;
+
+  if (YAP_IsAtomTerm(f)) {
+    YAP_PutInSlot(d,(YAP_Term)f);
+    return;
+  }
+  arity = YAP_ArityOfFunctor((YAP_Functor)f);
+  if (arity == 2 && (YAP_Functor)f == YAP_MkFunctor(YAP_LookupAtom("."),2))
+    YAP_PutInSlot(d,YAP_MkPairTerm(YAP_GetFromSlot(a0),YAP_GetFromSlot(a0+1)));    
+  else
+    YAP_PutInSlot(d,YAP_MkApplTerm((YAP_Functor)f,arity,YAP_AddressFromSlot(a0)));
+}
+
+X_API void PL_cons_list(term_t d, term_t h, term_t t)
+{
+  YAP_PutInSlot(d,YAP_MkPairTerm(YAP_GetFromSlot(h),YAP_GetFromSlot(t)));
+}
+
+X_API void PL_put_atom(term_t t, atom_t a)
+{
+  YAP_PutInSlot(t,YAP_MkAtomTerm((YAP_Atom)a));
+}
+
+X_API void PL_put_atom_chars(term_t t, const char *s)
+{
+  YAP_PutInSlot(t,YAP_MkAtomTerm(YAP_LookupAtom((char *)s)));
+}
+
+X_API void PL_put_float(term_t t, double fl)
+{
+  YAP_PutInSlot(t,YAP_MkFloatTerm(fl));
+}
+
+X_API void PL_put_functor(term_t t, functor_t f)
+{
+  long int  arity;
+  if (YAP_IsAtomTerm(f)) {
+    YAP_PutInSlot(t,f);
+  } else {
+    arity = YAP_ArityOfFunctor((YAP_Functor)f);
+    if (arity == 2 && (YAP_Functor)f == YAP_MkFunctor(YAP_LookupAtom("."),2))
+      YAP_PutInSlot(t,YAP_MkNewPairTerm());    
+    else
+      YAP_PutInSlot(t,YAP_MkNewApplTerm((YAP_Functor)f,arity));
+  }
+}
+
+X_API void PL_put_integer(term_t t, long n)
+{
+  YAP_PutInSlot(t,YAP_MkIntTerm(n));
+}
+
+X_API void PL_put_int64(term_t t, int64_t n)
+{
+#if USE_GMP
+  char s[64];
+  MP_INT rop;
+
+  sprintf(s, "%lld", (long long int)n);
+  mpz_init_set_str (&rop, s, 10);
+  YAP_PutInSlot(t,YAP_MkBigNumTerm((void *)&rop));
+#endif
+}
+
+X_API void PL_put_list(term_t t)
+{
+  YAP_PutInSlot(t,YAP_MkNewPairTerm());
+}
+
+X_API void PL_put_list_chars(term_t t, const char *s)
+{
+  YAP_PutInSlot(t,YAP_BufferToString((char *)s));
+}
+
+X_API void PL_put_nil(term_t t)
+{
+  YAP_PutInSlot(t,YAP_MkAtomTerm(YAP_LookupAtom("[]")));
+}
+
+/* SWI: void PL_put_pointer(term_t -t, void *ptr)
+   YAP: NO EQUIVALENT */
+/* SAM TO DO */
+X_API void PL_put_pointer(term_t t, void *ptr)
+{
+  YAP_Term tptr = YAP_MkIntTerm((long int)ptr);
+  YAP_PutInSlot(t,tptr);
+}
+
+X_API void PL_put_string_chars(term_t t, const char *s)
+{
+  YAP_PutInSlot(t,YAP_BufferToString((char *)s));
+}
+
+X_API void PL_put_term(term_t d, term_t s)
+{
+  YAP_PutInSlot(d,YAP_GetFromSlot(s));
+}
+
+X_API void PL_put_variable(term_t t)
+{
+  YAP_PutInSlot(t,YAP_MkVarTerm());
+}
+
+/* end PL_put_* functions =============================*/
+
+/* SWI: int PL_raise_exception(term_t exception)
+   YAP: NO EQUIVALENT */
+/* SAM TO DO */
+
+X_API int PL_raise_exception(term_t exception)
+{
+  YAP_Throw(YAP_GetFromSlot(exception));
+  return 0;
+}
+
+/* begin PL_unify_* functions =============================*/
+
+X_API int PL_unify(term_t t1, term_t t2)
+{
+  return YAP_Unify(YAP_GetFromSlot(t1),YAP_GetFromSlot(t2));
+}
+
+/* SWI: int PL_unify_atom(term_t ?t, atom  *at)
+   YAP long int  unify(YAP_Term* a, Term* b) */
+X_API int PL_unify_atom(term_t t, atom_t at)
+{
+  YAP_Term cterm = YAP_MkAtomTerm((YAP_Atom)at);
+  return YAP_Unify(YAP_GetFromSlot(t),cterm);
+}
+
+/* SWI: int PL_unify_atom_chars(term_t ?t, const char *chars)
+   YAP long int  unify(YAP_Term* a, Term* b) */
+X_API int PL_unify_atom_chars(term_t t, const char *s)
+{
+  YAP_Atom catom = YAP_LookupAtom((char *)s);
+  YAP_Term cterm = YAP_MkAtomTerm(catom);
+  return YAP_Unify(YAP_GetFromSlot(t),cterm);
+}
+
+/* SWI: int PL_unify_float(term_t ?t, double f)
+   YAP long int  unify(YAP_Term* a, Term* b) */
+X_API int PL_unify_float(term_t t, double f)
+{
+  YAP_Term fterm = YAP_MkFloatTerm(f);
+  return YAP_Unify(YAP_GetFromSlot(t),fterm);
+}
+
+/* SWI: int PL_unify_integer(term_t ?t, long n)
+   YAP long int  unify(YAP_Term* a, Term* b) */
+X_API int PL_unify_integer(term_t t, long n)
+{	
+  YAP_Term iterm = YAP_MkIntTerm(n);
+  return YAP_Unify(YAP_GetFromSlot(t),iterm);
+}
+
+/* SWI: int PL_unify_integer(term_t ?t, long n)
+   YAP long int  unify(YAP_Term* a, Term* b) */
+X_API int PL_unify_int64(term_t t, int64_t n)
+{	
+#if USE_GMP
+  YAP_Term iterm;
+  char s[64];
+  MP_INT rop;
+
+  sprintf(s, "%lld", (long long int)n);
+  mpz_init_set_str (&rop, s, 10);
+  iterm = YAP_MkBigNumTerm((void *)&rop);
+  return YAP_Unify(YAP_GetFromSlot(t),iterm);
+#else
+  return FALSE;
+#endif
+}
+
+/* SWI: int PL_unify_list(term_t ?t, term_t +h, term_t -t)
+   YAP long int  unify(YAP_Term* a, Term* b) */
+X_API int PL_unify_list(term_t t, term_t h, term_t tail)
+{
+  YAP_Term pairterm = YAP_MkPairTerm(YAP_GetFromSlot(h),YAP_GetFromSlot(tail));
+  return YAP_Unify(YAP_GetFromSlot(t), pairterm);
+}
+
+/* SWI: int PL_unify_list(term_t ?t, term_t +h, term_t -t)
+   YAP long int  unify(YAP_Term* a, Term* b) */
+X_API int PL_unify_list_chars(term_t t, const char *chars)
+{
+  YAP_Term chterm = YAP_BufferToString((char *)chars);
+  return YAP_Unify(YAP_GetFromSlot(t), chterm);
+}
+
+/* SWI: int PL_unify_nil(term_t ?l)
+   YAP long int  unify(YAP_Term* a, Term* b) */
+X_API int PL_unify_nil(term_t l)
+{
+  YAP_Term nilterm = YAP_MkAtomTerm(YAP_LookupAtom("[]"));
+  return YAP_Unify(YAP_GetFromSlot(l), nilterm);
+}
+
+/* SWI: int PL_unify_pointer(term_t ?t, void *ptr)
+   YAP: NO EQUIVALENT */
+/* SAM TO DO */
+X_API int PL_unify_pointer(term_t t, void *ptr)
+{
+  YAP_Term ptrterm = YAP_MkIntTerm((long int)ptr);
+  return YAP_Unify(YAP_GetFromSlot(t), ptrterm);
+}
+
+/* SWI: int PL_unify_list(term_t ?t, term_t +h, term_t -t)
+   YAP long int  unify(YAP_Term* a, Term* b) */
+X_API int PL_unify_string_chars(term_t t, const char *chars)
+{
+  YAP_Term chterm = YAP_BufferToString((char *)chars);
+  return YAP_Unify(YAP_GetFromSlot(t), chterm);
+}
+
+typedef struct {
+  int type;
+  union {
+    functor_t f;
+    term_t t;
+    atom_t a;
+    long l;
+    double dbl;
+    char *s;
+    void *p;
+  } arg;
+} arg_types;
+
+static YAP_Term
+get_term(arg_types **buf)
+{
+  arg_types *ptr = *buf;
+  int type = ptr->type;
+  YAP_Term t;
+
+  switch (type) {
+  /* now build the error string */
+  case PL_VARIABLE:
+    t = YAP_MkVarTerm();
+    ptr++;
+    break;
+  case PL_ATOM:
+    t = YAP_MkAtomTerm((YAP_Atom)ptr->arg.a);
+    ptr++;
+    break;
+  case PL_INTEGER:
+    t = YAP_MkIntTerm(ptr->arg.l);
+    ptr++;
+    break;
+  case PL_FLOAT:
+    t = YAP_MkFloatTerm(ptr->arg.dbl);
+    ptr++;
+    break;
+  case PL_POINTER:
+    t = YAP_MkIntTerm((long int)(ptr->arg.p));
+    ptr++;
+    break;
+  case PL_STRING:
+    t = YAP_BufferToString(ptr->arg.s);
+    ptr++;
+    break;
+  case PL_TERM:
+    t = YAP_GetFromSlot(ptr->arg.t);
+    ptr++;
+    break;
+  case PL_CHARS:
+    t = YAP_MkAtomTerm(YAP_LookupAtom(ptr->arg.s));
+    break;
+  case PL_FUNCTOR:
+    {
+      functor_t f = ptr->arg.f;
+      long int  arity, i;
+      term_t loc;
+
+      if (YAP_IsAtomTerm((YAP_Term)f)) {
+	t = (YAP_Term)f;
+	break;
+      }
+      arity = YAP_ArityOfFunctor((YAP_Functor)f);
+      loc = YAP_NewSlots(arity);
+      ptr++;
+      for (i= 0; i < arity; i++) {
+	YAP_PutInSlot(loc+i,get_term(&ptr));
+      }
+      t = YAP_MkApplTerm((YAP_Functor)f,arity,YAP_AddressFromSlot(loc));
+    }
+    break;
+  case PL_LIST:
+    {
+      term_t loc;
+
+      loc = YAP_NewSlots(2);
+      ptr++;
+      YAP_PutInSlot(loc,get_term(&ptr));
+      YAP_PutInSlot(loc+1,get_term(&ptr));
+      t = YAP_MkPairTerm(YAP_GetFromSlot(loc),YAP_GetFromSlot(loc+1));
+    }
+    break;
+  default:
+    fprintf(stderr, "type %d not implemented yet\n", type);
+    exit(1);
+  }
+  *buf = ptr;
+  return t;
+}
+
+/* SWI: int PL_unify_term(term_t ?t1, term_t ?t2)
+   YAP long int  YAP_Unify(YAP_Term* a, Term* b) */
+X_API int PL_unify_term(term_t l,...)
+{
+  va_list ap;
+  int type;
+  int nels = 1;
+  arg_types *ptr = (arg_types *)buffers;
+
+  va_start (ap, l);
+  while (nels > 0) {
+    type = va_arg(ap, int);
+    nels --;
+    
+    ptr->type = type;
+    switch(type) {
+    case PL_VARIABLE:
+      break;
+    case PL_ATOM:
+      ptr->arg.a = va_arg(ap, atom_t);
+      break;
+    case PL_INTEGER:
+      ptr->arg.l = va_arg(ap, long);
+      break;
+    case PL_FLOAT:
+      ptr->arg.dbl = va_arg(ap, double);
+      break;
+    case PL_STRING:
+      ptr->arg.s = va_arg(ap, char *);
+      break;
+    case PL_TERM:
+      ptr->arg.t = va_arg(ap, term_t);
+      break;
+    case PL_POINTER:
+      ptr->arg.p = va_arg(ap, void *);
+      break;
+    case PL_CHARS:
+      ptr->arg.s = va_arg(ap, char *);
+      break;
+    case PL_FUNCTOR:
+      {
+	functor_t f = va_arg(ap, functor_t);
+	ptr->arg.f = f;
+	if (!YAP_IsAtomTerm((YAP_Term)f)) {
+	  nels += YAP_ArityOfFunctor((YAP_Functor)f);
+	}
+      }
+      break;
+    case PL_LIST:
+      nels += 2;
+      break;
+    default:
+      fprintf(stderr, "%d not supported\n", type);
+      exit(1);
+    }
+    ptr++;
+  }
+  va_end (ap);
+  ptr = (arg_types *)buffers;
+    return YAP_Unify(YAP_GetFromSlot(l),get_term(&ptr));
+}
+
+/* end PL_unify_* functions =============================*/
+
+/* SWI: void PL_register_atom(atom_t atom)
+   YAP: NO EQUIVALENT */
+/* SAM TO DO */
+X_API void PL_register_atom(atom_t atom)
+{
+}
+
+/* SWI: void PL_unregister_atom(atom_t atom)
+   YAP: NO EQUIVALENT */
+/* SAM TO DO */
+X_API void PL_unregister_atom(atom_t atom)
+{
+}
+
+X_API int PL_get_string_chars(term_t t, char **s, int *len)
+{
+  /* there are no such objects in Prolog */
+  return FALSE;
+}
+
+X_API int PL_term_type(term_t t)
+{
+  /* YAP_ does not support strings as different objects */
+  YAP_Term v = YAP_GetFromSlot(t);
+  if (YAP_IsVarTerm(v)) {
+    return PL_VARIABLE;
+  } else if (YAP_IsAtomTerm(v)) {
+    return PL_ATOM;
+  } else if (YAP_IsIntTerm(v)) {
+    return PL_INTEGER;
+  } else if (YAP_IsFloatTerm(v)) {
+    return PL_FLOAT;
+  } else {
+    return PL_TERM;
+  }
+}
+
+X_API int PL_is_atom(term_t t)
+{
+  return YAP_IsAtomTerm(YAP_GetFromSlot(t));
+}
+
+X_API int PL_is_atomic(term_t ts)
+{
+  YAP_Term t = YAP_GetFromSlot(ts);
+  return !YAP_IsVarTerm(t) || !YAP_IsApplTerm(t) || !YAP_IsPairTerm(t);
+}
+
+X_API int PL_is_compound(term_t ts)
+{
+  YAP_Term t = YAP_GetFromSlot(ts);
+  return (YAP_IsApplTerm(t) || YAP_IsPairTerm(t));
+}
+
+X_API int PL_is_functor(term_t ts, functor_t f)
+{
+  YAP_Term t = YAP_GetFromSlot(ts);
+  if (YAP_IsApplTerm(t)) {
+    return YAP_FunctorOfTerm(t) == (YAP_Functor)f;
+  } else if (YAP_IsPairTerm(t)) {
+    return YAP_FunctorOfTerm(t) == YAP_MkFunctor(YAP_LookupAtom("."),2);
+  } else
+    return 0;
+}
+
+X_API int PL_is_float(term_t ts)
+{
+  YAP_Term t = YAP_GetFromSlot(ts);
+  return YAP_IsFloatTerm(t);
+}
+
+X_API int PL_is_integer(term_t ts)
+{
+  YAP_Term t = YAP_GetFromSlot(ts);
+  return YAP_IsIntTerm(t);
+}
+
+X_API int PL_is_list(term_t ts)
+{
+  YAP_Term t = YAP_GetFromSlot(ts);
+  if (YAP_IsPairTerm(t)) {
+    return 1;
+  } else if (YAP_IsAtomTerm(t)) {
+    return t == YAP_MkAtomTerm(YAP_LookupAtom("[]"));
+  } else
+    return 0;
+}
+
+X_API int PL_is_number(term_t ts)
+{
+  YAP_Term t = YAP_GetFromSlot(ts);
+  return YAP_IsIntTerm(t) || YAP_IsFloatTerm(t);
+}
+
+X_API int PL_is_string(term_t ts)
+{
+  YAP_Term t = YAP_GetFromSlot(ts);
+  while (YAP_IsPairTerm(t)) {
+    YAP_Term hd = YAP_HeadOfTerm(t);
+    long int  i;
+    if (!YAP_IsIntTerm(hd))
+      return 0;
+    i = YAP_IntOfTerm(hd);
+    if (i <= 0 || i >= 255)
+      return 0;
+    if (!YAP_IsIntTerm(hd))
+      return 0;
+    t = YAP_TailOfTerm(t);
+  }
+  if (t != YAP_MkAtomTerm(YAP_LookupAtom("[]")))
+    return 0;
+  return FALSE;
+}
+
+X_API int PL_is_variable(term_t ts)
+{
+  YAP_Term t = YAP_GetFromSlot(ts);
+  return YAP_IsVarTerm(t);
+}
+
+X_API int PL_compare(term_t ts1, term_t ts2)
+{
+  YAP_Term t1 = YAP_GetFromSlot(ts1);
+  YAP_Term t2 = YAP_GetFromSlot(ts2);
+  return YAP_CompareTerms(t1, t2);
+}
+
+X_API void PL_halt(int e)
+{
+   YAP_Halt(e);
+}
+
+X_API int PL_action(int action,...)
+{
+  va_list ap;
+
+  va_start (ap, action);
+  switch (action) {
+  case PL_ACTION_TRACE:
+    fprintf(stderr, "PL_ACTION_TRACE not supported\n");
+    break;
+  case PL_ACTION_DEBUG:
+    fprintf(stderr, "PL_ACTION_DEBUG not supported\n");
+    break;
+  case PL_ACTION_BACKTRACE:
+    fprintf(stderr, "PL_ACTION_BACKTRACE not supported\n");
+    break;
+  case PL_ACTION_HALT:
+    {
+      int halt_arg = va_arg(ap, int);
+      YAP_Halt(halt_arg);
+    }
+    break;
+  case PL_ACTION_ABORT:
+    {
+      YAP_Throw(YAP_MkAtomTerm(YAP_LookupAtom("abort")));
+    }
+    break;
+  case PL_ACTION_BREAK:
+    fprintf(stderr, "PL_ACTION_BREAK not supported\n");
+    break;
+  case PL_ACTION_GUIAPP:
+    fprintf(stderr, "PL_ACTION_GUIAPP not supported\n");
+    break;
+  case PL_ACTION_WRITE:
+    fprintf(stderr, "PL_ACTION_WRITE not supported\n");
+    break;
+  case PL_ACTION_FLUSH:
+    fprintf(stderr, "PL_ACTION_WRITE not supported\n");
+    break;
+  case PL_ACTION_ATTACH_CONSOLE:
+    fprintf(stderr, "PL_ACTION_WRITE not supported\n");
+    break;
+  }
+  va_end (ap);
+  return 0;
+}
+
+X_API fid_t
+PL_open_foreign_frame(void)
+{
+  return 0;
+}
+
+X_API void
+PL_close_foreign_frame(fid_t f)
+{
+}
+
+X_API void
+PL_discard_foreign_frame(fid_t f)
+{
+  fprintf(stderr,"WARNING: PL_discard_foreign_frame not fully implemented!!");
+  /* Missing: undo Trail!! */
+}
+
+X_API term_t
+PL_exception(qid_t q)
+{
+  YAP_Term t;
+  if (YAP_GoalHasException(&t)) {
+    term_t to = YAP_NewSlots(1);
+    YAP_PutInSlot(to,t);
+    return to;
+  } else {
+    return 0L;
+  }
+}
+
+X_API int
+PL_initialise(int myargc, char **myargv)
+{
+  YAP_init_args init_args;
+
+  init_args.Argv = myargv;
+  init_args.Argc = myargc;
+  init_args.SavedState = "startup";
+  init_args.HeapSize = 0;
+  init_args.StackSize = 0;
+  init_args.TrailSize = 0;
+  init_args.YapLibDir = NULL;
+  init_args.YapPrologBootFile = NULL;
+  init_args.HaltAfterConsult = FALSE;
+  init_args.FastBoot = FALSE;
+  init_args.NumberWorkers = 1;
+  init_args.SchedulerLoop = 10;
+  init_args.DelayedReleaseLoad = 3;
+  return YAP_Init(&init_args);
+}
+
+X_API int
+PL_is_initialised(int *argc, char ***argv)
+{
+  return TRUE;
+}
+
+X_API atom_t PL_module_name(module_t m)
+{
+  YAP_Atom at = YAP_AtomOfTerm((YAP_Term)m);
+  YAP_CreateModule(at);
+  return (atom_t)at;
+}
+
+X_API predicate_t PL_pred(functor_t f, module_t m)
+{
+  if (YAP_IsAtomTerm(f)) {
+    return YAP_Predicate(YAP_AtomOfTerm(f),0,(YAP_Module)m);
+  } else {
+    YAP_Functor tf = (YAP_Functor)f;
+    return YAP_Predicate(YAP_NameOfFunctor(tf),YAP_ArityOfFunctor(tf),(YAP_Module)m);
+  }
+}
+
+X_API predicate_t PL_predicate(const char *name, int arity, const char *m)
+{
+  int mod;
+  if (m == NULL)
+    mod = YAP_CurrentModule();
+  else
+    mod = YAP_LookupModule(YAP_MkAtomTerm(YAP_LookupAtom((char *)m)));
+  return YAP_Predicate(YAP_LookupAtom((char *)name),
+		      arity,
+		      mod);
+}
+
+X_API void PL_predicate_info(predicate_t p,atom_t *name, int *arity, module_t *m)
+{
+  YAP_PredicateInfo(p, (YAP_Atom *)name, (unsigned long int  *)arity, (YAP_Module *)m);
+}
+
+typedef struct open_query_struct {
+  int open;
+  int state;
+  YAP_Term g;
+} open_query;
+
+open_query execution;
+
+X_API qid_t PL_open_query(module_t ctx, int flags, predicate_t p, term_t t0)
+{
+  YAP_Atom yname;
+  atom_t name;
+  unsigned long int  arity;
+  YAP_Module  m;
+  YAP_Term t[2];
+
+  /* ignore flags  and module for now */
+  if (execution.open != 0) {
+    YAP_Error(0, 0L, "only one query at a time allowed\n");
+  }
+  execution.open=1;
+  execution.state=0;
+  YAP_PredicateInfo(p, &yname, &arity, &m);
+  name = (atom_t)yname;
+  t[0] = YAP_ModuleName(m);
+  if (arity == 0) {
+    t[1] = YAP_MkAtomTerm((YAP_Atom)name);
+  } else {
+    YAP_Functor f = YAP_MkFunctor((YAP_Atom)name, arity);
+    t[1] = YAP_MkApplTerm(f,arity,YAP_AddressFromSlot(t0));
+  }
+  execution.g = YAP_MkApplTerm(YAP_MkFunctor(YAP_LookupAtom(":"),2),2,t);
+  return &execution;
+}
+
+X_API int PL_next_solution(qid_t qi)
+{
+  int result;
+
+  if (qi->open != 1) return 0;
+  if (qi->state == 0) {
+    result = YAP_RunGoal(qi->g);
+  } else {
+    result = YAP_RestartGoal();
+  }
+  qi->state = 1;
+  if (result == 0) {
+    qi->open = 0;
+  }
+  return result;
+}
+
+X_API void PL_cut_query(qid_t qi)
+{
+  YAP_PruneGoal();
+  qi->open = 0;
+}
+
+X_API void PL_close_query(qid_t qi)
+{
+  /* need to implement backtracking here */
+  if (qi->open != 1)
+    return;
+  YAP_PruneGoal();
+  YAP_RestartGoal();
+  qi->open = 0;
+}
+
+X_API int PL_call_predicate(module_t ctx, int flags, predicate_t p, term_t t0)
+{
+  qid_t qi = PL_open_query(ctx, flags, p, t0);
+  int ret = PL_next_solution(qi);
+  PL_cut_query(qi);
+  return ret;
+}
+
+X_API int PL_call(term_t tp, module_t m)
+{
+  YAP_Term t[2], g;
+  t[0] = YAP_ModuleName((YAP_Module)m);
+  t[1] = YAP_GetFromSlot(tp);
+  g = YAP_MkApplTerm(YAP_MkFunctor(YAP_LookupAtom(":"),2),2,t);
+  return YAP_RunGoal(g);
+}
+
+X_API void PL_register_extensions(PL_extension *ptr)
+{
+  /* ignore flags for now */
+  while(ptr->predicate_name != NULL) {
+    YAP_UserCPredicateWithArgs(ptr->predicate_name,(YAP_Bool (*)(void))ptr->function,ptr->arity,YAP_CurrentModule());
+    ptr++;
+  }
+}
+
+X_API void PL_load_extensions(PL_extension *ptr)
+{
+  /* ignore flags for now */
+  while(ptr->predicate_name != NULL) {
+    YAP_UserCPredicateWithArgs(ptr->predicate_name,(YAP_Bool (*)(void))ptr->function,ptr->arity,YAP_CurrentModule());
+    ptr++;
+  }
+}
+
+X_API int PL_thread_self(void)
+{
+  return YAP_ThreadSelf();
+}
+
+X_API int PL_thread_attach_engine(const PL_thread_attr_t *attr)
+{
+  int wid = YAP_ThreadSelf();
+  
+  if (wid < 0) {
+    /* we do not have an engine */
+    if (attr) {
+      YAP_thread_attr yapt;
+      int wid; 
+
+      yapt.ssize = attr->local_size;
+      yapt.tsize = attr->global_size;
+      yapt.alias = (YAP_Term)attr->alias;
+      yapt.cancel =  attr->cancel;
+      wid = YAP_ThreadCreateEngine(&yapt);
+    } else {
+      wid = YAP_ThreadCreateEngine(NULL);
+    }
+    if (wid < 0)
+      return -1;
+    if (YAP_ThreadAttachEngine(wid)) {
+      return wid;
+    }
+    return -1;
+  } else {
+    /* attach myself again */
+    YAP_ThreadAttachEngine(wid);
+    return wid;
+  }
+}
+
+X_API int PL_thread_destroy_engine(void)
+{
+  int wid = YAP_ThreadSelf();
+
+  if (wid < 0) {
+    /* we do not have an engine */
+    return FALSE;
+  }
+  YAP_ThreadDetachEngine(wid);
+  return YAP_ThreadDestroyEngine(wid);
+}
+
+X_API int
+PL_thread_at_exit(void (*function)(void *), void *closure, int global)
+{
+  /* don't do nothing for now */
+  fprintf(stderr,"%% YAP ERROR: PL_thread_at_exit not implemented yet\n");
+  return TRUE;
+}
+
+
+X_API PL_engine_t
+PL_create_engine(const PL_thread_attr_t *attr)
+{
+  if (attr) {
+    YAP_thread_attr yapt;
+
+    yapt.ssize = attr->local_size;
+    yapt.tsize = attr->global_size;
+    yapt.alias = (YAP_Term)attr->alias;
+    yapt.cancel =  attr->cancel;
+    return (PL_engine_t)YAP_ThreadCreateEngine(&yapt);
+  } else {
+    return (PL_engine_t)YAP_ThreadCreateEngine(NULL);
+  }
+}
+
+
+X_API int
+PL_destroy_engine(PL_engine_t e)
+{
+  return YAP_ThreadDestroyEngine((YAP_Int)e);
+}
+
+X_API int
+PL_set_engine(PL_engine_t engine, PL_engine_t *old)
+{
+  int cwid = YAP_ThreadSelf();
+  if (*old) *old = (PL_engine_t)cwid;
+  if (engine == PL_ENGINE_CURRENT)
+    return PL_ENGINE_SET;
+  if (engine < 0) /* should really check if engine does not exist */
+    return PL_ENGINE_INVAL;
+  if (!(YAP_ThreadAttachEngine((int)engine))) {
+    return PL_ENGINE_INUSE;
+  }
+  return PL_ENGINE_SET;
+}
+
+
+/* note: fprintf may be called from anywhere, so please don't try
+   to be smart and allocate stack from somewhere else */
+X_API int Sprintf(char *format,...)
+{
+  va_list ap;
+  char buf[512];
+
+  va_start(ap,format);
+#ifdef HAVE_VSNPRINTF
+  vsnprintf(buf,512,format,ap);
+#else
+  vsprintf(buf,format,ap);
+#endif
+  va_end(ap);
+
+  fputs(buf, stderr);
+  return 1;
+}
+
+
+/* note: fprintf may be called from anywhere, so please don't try
+   to be smart and allocate stack from somewhere else */
+X_API int Sdprintf(char *format,...)
+{
+  va_list ap;
+  char buf[512];
+
+  va_start(ap,format);
+#ifdef HAVE_VSNPRINTF
+  vsnprintf(buf,512,format,ap);
+#else
+  vsprintf(buf,format,ap);
+#endif
+  va_end(ap);
+
+#if DEBUG
+  fputs(buf, stderr);
+#endif
+  return 1;
+}
+
+static int
+SWI_ctime(void)
+{
+#if HAVE_CTIME
+  time_t tim;
+#endif
+  YAP_Term t1 = YAP_ARG1;
+
+  if (YAP_IsVarTerm(t1)) {
+    YAP_Error(0,t1,"bad argumento to ctime");
+    return FALSE;
+  }
+#if HAVE_CTIME
+  tim = (time_t)YAP_IntOfTerm(t1);
+  return YAP_Unify(YAP_BufferToString(ctime(&tim)), YAP_ARG2);
+#else
+  YAP_Error(0,0L,"convert_time requires ctime");
+  return FALSE;
+#endif
+}
+
+void
+swi_install(void)
+{
+  YAP_UserCPredicate("ctime", SWI_ctime, 2);
+}
+
+#ifdef _WIN32
+
+#include <windows.h>
+
+int WINAPI PROTO(win_yap2swi, (HANDLE, DWORD, LPVOID));
+
+int WINAPI win_yap2swi(HANDLE hinst, DWORD reason, LPVOID reserved)
+{
+  switch (reason) 
+    {
+    case DLL_PROCESS_ATTACH:
+      break;
+    case DLL_PROCESS_DETACH:
+      break;
+    case DLL_THREAD_ATTACH:
+      break;
+    case DLL_THREAD_DETACH:
+      break;
+    }
+  return 1;
+}
+#endif
diff --git a/pl/boot.yap b/pl/boot.yap
index 3eb380225..ecb15705d 100644
--- a/pl/boot.yap
+++ b/pl/boot.yap
@@ -291,7 +291,9 @@ true :- true.
  '$execute_command'(end_of_file,_,_,_) :- !.
  '$execute_command'((:-G),_,Option,_) :- !,
 	 '$current_module'(M),
-	 '$process_directive'(G, Option, M),
+	 % allow user expansion
+	 '$precompile_term'((:- G), _, (:- G1), M),
+	 '$process_directive'(G1, Option, M),
 	 fail.
  '$execute_command'((?-G),V,_,Source) :- !,
 	 '$execute_command'(G,V,top,Source).
diff --git a/pl/consult.yap b/pl/consult.yap
index a615dadd5..7c12d37f3 100644
--- a/pl/consult.yap
+++ b/pl/consult.yap
@@ -747,10 +747,10 @@ absolute_file_name(File,Opts,TrueFileName) :-
 	'$extend_pathd'(Dir, D, File, Opts, NewFile, Call).
 
 
-'$extend_pathd'(Dir, A, File, Opts, NFile, Call) :-
+'$extend_pathd'(Dir, A, File, Opts, NewFile, Call) :-
 	atom(Dir), !,
 	atom_concat([Dir,A,File],NFile),
-	'$search_in_path'(NFile, Opts, NewFile), !.
+	'$find_in_path'(NFile, Opts, NewFile, Goal), !.
 '$extend_pathd'(Name, A, File, Opts, OFile, Goal) :-
 	nonvar(Name),
 	Name =.. [N,P0],