sync

Merge https://github.com/vscosta/yap-6.3
fix bad merge
2019-05-28 22:48:00 +01:00 · 2019-05-28 22:42:17 +01:00 · 2019-05-28 19:30:04 +01:00 · 2019-05-27 15:34:24 +01:00 · 2019-05-27 15:32:39 +01:00 · 2019-05-27 15:31:22 +01:00
3056 changed files with 1829505 additions and 242322 deletions
--- a/#.gitignore#
+++ b/#.gitignore#
@ -0,0 +1,203 @@
+*~
+*.itf
+*.po
+*.qlf
+*.xwam
+*.wam
+*.ma
+*.s
+*.o
+*.so
+*.dylib
+*.dll
+docs/yap.info*
+.build
+tags
+TGSautom4te.cache
+cscope.*
+GPATH
+m32
+GRTAGS
+GTAGS
+tmtags*
+.autotools
+.Rhistory
+.zedstate
+config.h
+Yap.h
+YapConfig.h
+YapTermConfig.h
+.graffiti
+.#*#
+*/#*#
+*bak
+*rej
+*.db
+groups
+*.ede
+.??*
+*ggtags*
+.atom-build.josn
+.autotools
+.cproject
+.dir-locals.el
+.DS_store
+.kateproject
+.project
+.pydevproject
+.Rhistory
+.zedstate
+.graffiti
+.kateproject
+autom4te.cache
+*rej
+#*
+#*#
+config.h
+*.html
+packages/gecode/dev
+JIT/HPP/bkp
+cmake_install.cmake
+cmake_clean.cmake
+*.build
+C/myabsmi.c
+*.ctags#
+*.hs
+CMakeFiles
+*.make
+C/new_iop.c
+*.pdf
+*.log
+*.orig
+JIT/HPP/#JIT_In#
+*.text
+yap
+*startup.yss
+*cmake_files
+C/pl-yap.c
+GitSHA1.c
+.vscode
+CMakeLists.txt.*
+FindPackageLog.txt
+GitSHA1.c
+clang
+cmake-build-debug
+os/YapIOConfig.h
+CodeBlocks
+
+os/readterm.c.cpp
+
+os/readterm.c.cpp
+
+packages/ProbLog/problog_examples/output/,_query_1_cluster_1.dot
+
+packages/ProbLog/#problog_lbdd.yap#
+
+packages/ProbLog/problog_examples/output/,_query_1_cluster_1.dot
+
+packages/ProbLog/problog_examples/output/out.dat
+
+packages/ProbLog/problog_examples/outputvalues.pl
+
+packages/ProbLog/problogbdd
+
+packages/raptor/raptor_config.h
+
+packages/real/rconfig.h
+
+packages/ProbLog/problog/#completion.yap#
+
+packages/ProbLog/problog_examples/output
+packages/ProbLog/problog_examples/queries
+packages/swig/java/*.java
+packages/swig/java/*.class
+packages/swig/java/*.jar
+packages/swig/java/*wrap*
+*jnilib
+*.jar
+*LOG
+packages/cplint/approx/simplecuddLPADs/LPADBDD
+
+packages/swi-minisat2/˜:ilp
+packages/swig/android/app
+packages/cplint/L
+
+packages/CLPBN/horus/hcli
+tmp
+Eclipse
+packages/bdd/simplecudd/problogbdd
+trace
+packages/bdd/cudd_config.h
+Makefile
+build
+Debug
+debug
+Release
+Build
+xcode
+Threads
+droid
+mxe
+mxe32
+msys2
+caret
+codelite
+configure
+Qt
+cmake/cmake-android
+sublime
+yap-6.3.workspace
+yap-6.3.geany
+YAP.project
+CBlocks
+yPQ	
+*.tmp
+YAP.sublime*
+yap32
+Eclipse
+codeblocks
+yap-6.3.tags
+android
+yap.prj
+
+yap.VITORs-MBP.vsc.pui
+vc
+packages/myddas/pl/myddas_odbc.yap
+
+packages/myddas/pl/myddas_postgres.yap
+
+packages/myddas/pl/myddas_sqlite3.ypp
+
+packages/myddas/pl/#myddas_postgres.ypp#
+
+packages/myddas/hh
+
+packages/myddas/DaysInHospital_Y3.csv
+
+packages/myddas/agile.csv
+
+*.pyc
+
+*.cmake#
+
+*.tex
+
+*.c#
+
+packages/swig/yap_wrap.cxx
+
+packages/swig/yap_wrap.h
+
+packages/swig/yap_wrap.cpp
+
+packages/swig/yap.py
+
+*.ipynb
+yap
+packages/python/yap_kernel/x/__init__.py
+x
+packages/python/yap_kernel/x/__main__.py
+
+*.gch
+mxe
+build
--- a/#GitSHA1.c.in#
+++ b/#GitSHA1.c.in#
@ -0,0 +1,2 @@
+eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee#define GIT_SHA1 "@GIT_SHA1@"
+const char g_GIT_SHA1[] = GIT_SHA1;
--- a/.configure-custom.sh
+++ b/.configure-custom.sh
@ -0,0 +1,26 @@
+ENABLE_VARS="brew|yes|WITH_BREW\
+  clpbn|yes|WITH_CLPBN \
+  cplint|yes|WITH_CPLINT \
+  horus|yes|WITH_HORUS \
+  clpr|yes|WITH_CLPR \
+  macports|yes|WITH_MACPORTS\
+  problog|yes|WITH_PROBLOG \
+   jit|no|WITH_JIT \
+   chr|no|WITH_CHR \
+   threads|no|WITH_THREADS"
+WITH_VARS="swig|yes|WITH_SWIG \
+   mpi|yes|WITH_MPI \
+   gecode|yes|WITH_GECODE \
+   docs|yes|WITH_DOCS \
+   r|yes|WITH_R \
+   myddas|yes|WITH_MYDDAS \
+   cudd|yes|WITH_CUDD \
+   xml2|yes|WITH_XML2 \
+   raptor|yes|WITH_RAPTOR \
+   python|yes|WITH_PYTHON \
+   openssl|yes|WITH_OPENSSL\
+   java|yes|WITH_JAVA
+   lbfgs|yes|WITH_LBFGS
+   extensions|yes|WITH_EXTENSIONS
+   readline|yes|WITH_READLINE \
+   gmp|yes|WITH_GMP" 
--- a/.ctags
+++ b/.ctags
@ -0,0 +1,30 @@
+--langdef=Prolog
+--langmap=Prolog:.pl.yap.ypp.prolog.pro
+--regex-Prolog=/^([a-z][A-Za-z0-9_]*:)?([a-z][A-Za-z0-9_]*)\(.*\)[ \t]*(:-|-->)[ \t]*.*/\2/p,predicate,predicate definition/
+--regex-Prolog=/^([a-z][A-Za-z0-9_]*:)?\'(.*)\'\(.*\)[ \t]*(:-|-->)[ \t]*.*/\2/p,predicate,predicate definition/
+--regex-Prolog=/^([a-z][A-Za-z0-9_]*:)?([a-z][A-Za-z0-9_]*)\(.*\)\.[ \t]*.*/\2/p,predicate,predicate definition/
+--regex-Prolog=/^([a-z][A-Za-z0-9_]*:)?\'(.*)\'\(.*\)\.[ \t]*.*/\2/p,predicate,predicate definition/
+--regex-Prolog=/^:-[ \t]+(discontiguous|dynamic|multifile|table|thread_local)[ \t]+([a-z][_a-zA-Z0-9]*:)?([a-z0-9_][_a-zA-Z0-9]*)/\1/p,predicate,predicate metadata/
+--regex-Prolog=/^[ \t]*Yap_InitCPred[ \t]*\"(\$?[A-Za-z0-9_]*)\"([ \t]*).*/\1/p,predicate,predicate definition/
+--langmap=C:+.(h.cmake).(h.config)
+--exclude=\._*
+--exclude=*\.bak
+--exclude=\.svn
+--exclude=\.git
+--exclude=CVS
+--exclude=Debug
+--exclude=Release
+--exclude=Threads
+--exclude=.*tags.*
+--exclude=.*TAGS.*
+--exclude=\.\#.*
+--exclude=_darcs
+--exclude=*~
+--exclude=\#.*
+--exclude=(.)\#*
+--exclude=*.dylib
+--exclude=docs
+--exclude=build
+--exclude=cmake-build-debug
+--exclude=clang
+
--- a/.gitignore
+++ b/.gitignore
@ -9,5 +9,210 @@
 *.o
 *.so
 *.dylib
+*.dll
 docs/yap.info*
 .build
+build
+tags
+TGSautom4te.cache
+cscope.*
+GPATH
+m32
+GRTAGS
+GTAGS
+tmtags*
+.autotools
+.Rhistory
+.zedstate
+config.h
+YapConfig.h
+YapTermConfig.h
+.graffiti
+.#*#
+*/#*#
+*bak
+*rej
+*.db
+groups
+*.ede
+.??*
+*ggtags*
+.atom-build.josn
+.autotools
+.cproject
+.dir-locals.el
+.DS_store
+.project
+.pydevproject
+.Rhistory
+.zedstate
+.graffiti
+.kateproject
+autom4te.cache
+*rej
+#*
+#*#
+config.h
+*.html
+packages/gecode/dev
+JIT/HPP/bkp
+cmake_install.cmake
+cmake_clean.cmake
+*.build
+C/myabsmi.c
+*.ctags#
+*.hs
+CMakeFiles
+*.make
+C/new_iop.c
+*.pdf
+*.log
+*.orig
+JIT/HPP/#JIT_In#
+*.text
+yap
+*startup.yss
+*cmake_files
+C/pl-yap.c
+GitSHA1.c
+.vscode
+CMakeLists.txt.*
+FindPackageLog.txt
+GitSHA1.c
+clang
+cmake-build-debug
+os/YapIOConfig.h
+CodeBlocks
+x
+os/readterm.c.cpp
+
+os/readterm.c.cpp
+
+packages/ProbLog/problog_examples/output/,_query_1_cluster_1.dot
+
+packages/ProbLog/#problog_lbdd.yap#
+
+packages/ProbLog/problog_examples/output/,_query_1_cluster_1.dot
+
+packages/ProbLog/problog_examples/output/out.dat
+
+packages/ProbLog/problog_examples/outputvalues.pl
+
+packages/ProbLog/problogbdd
+
+packages/raptor/raptor_config.h
+
+packages/real/rconfig.h
+
+packages/ProbLog/problog/#completion.yap#
+
+packages/ProbLog/problog_examples/output
+packages/ProbLog/problog_examples/queries
+packages/swig/java/*.java
+packages/swig/java/*.class
+packages/swig/java/*.jar
+packages/swig/java/*wrap*
+*jnilib
+*.jar
+*LOG
+packages/cplint/approx/simplecuddLPADs/LPADBDD
+
+packages/swi-minisat2/˜:ilp
+packages/swig/android/app
+packages/cplint/L
+
+packages/CLPBN/horus/hcli
+tmp
+Eclipse
+packages/bdd/simplecudd/problogbdd
+trace
+packages/bdd/cudd_config.h
+Makefile
+build
+Debug
+debug
+Release
+Build
+xcode
+Threads
+droid
+mxe
+mxe32
+msys2
+caret
+codelite
+configure
+Qt
+cmake/cmake-android
+sublime
+yap-6.3.workspace
+yap-6.3.geany
+YAP.project
+CBlocks
+yPQ
+*.tmp
+YAP.sublime*
+yap32
+Eclipse
+codeblocks
+yap-6.3.tags
+android
+yap.prj
+
+yap.VITORs-MBP.vsc.pui
+vc
+packages/myddas/pl/myddas_odbc.yap
+
+packages/myddas/pl/myddas_postgres.yap
+
+packages/myddas/pl/myddas_sqlite3.ypp
+
+packages/myddas/pl/#myddas_postgres.ypp#
+
+packages/myddas/hh
+
+packages/myddas/DaysInHospital_Y3.csv
+
+packages/myddas/agile.csv
+
+*.pyc
+
+*.cmake#
+
+*.tex
+
+*.c#
+
+packages/swig/yap_wrap.cxx
+
+packages/swig/yap_wrap.h
+
+packages/swig/yap_wrap.cpp
+
+packages/swig/yap.py
+
+*.ipynb
+
+packages/python/yap_kernel/x/__init__.py
+
+packages/python/yap_kernel/x/__main__.py
+
+*.gch
+mxe
+build
+
+library/system/#CMakeLists.txt#
+*.txt#
+cmake/CMakeCache.txt
+
+C/compiling_error.txt
+
+cmake/compile_commands.json
+
+cmake/cudd_config.h
+
+cmake/docs/Doxyfile
+
+*.stackdump
+*.gz
+.Rproj.user
--- a/.gitmodules
+++ b/.gitmodules
@ -1,39 +0,0 @@
-[submodule "packages/chr"]
-	path = packages/chr
-	url = git://yap.git.sourceforge.net/gitroot/yap/chr
-[submodule "packages/clpqr"]
-	path = packages/clpqr
-	url = git://yap.git.sourceforge.net/gitroot/yap/clpqr
-[submodule "packages/jpl"]
-	path = packages/jpl
-	url = git://yap.git.sourceforge.net/gitroot/yap/jpl
-[submodule "packages/zlib"]
-	path = packages/zlib
-	url = git://yap.git.sourceforge.net/gitroot/yap/zlib
-[submodule "packages/http"]
-	path = packages/http
-	url = git://yap.git.sourceforge.net/gitroot/yap/http
-[submodule "packages/clib"]
-	path = packages/clib
-	url = git://yap.git.sourceforge.net/gitroot/yap/clib
-[submodule "packages/sgml"]
-	path = packages/sgml
-	url = git://yap.git.sourceforge.net/gitroot/yap/sgml
-[submodule "packages/RDF"]
-	path = packages/RDF
-	url = git://yap.git.sourceforge.net/gitroot/yap/RDF
-[submodule "packages/semweb"]
-	path = packages/semweb
-	url = git://yap.git.sourceforge.net/gitroot/yap/semweb
-[submodule "packages/plunit"]
-	path = packages/plunit
-	url = git://yap.git.sourceforge.net/gitroot/yap/plunit
-[submodule "packages/R"]
-	path = packages/R
-	url = git://yap.git.sourceforge.net/gitroot/yap/R
-[submodule "packages/YapR"]
-	path = packages/YapR
-	url = git://yap.git.sourceforge.net/gitroot/yap/YapR
-[submodule "packages/pldoc"]
-	path = packages/pldoc
-	url = git://yap.git.sourceforge.net/gitroot/yap/pldoc
--- a/BEAM/eam_am.c
+++ b/BEAM/eam_am.c
@ -140,7 +140,7 @@ int showTime(void);
 struct AND_BOX *choose_leftmost(void);
 extern Cell BEAM_is(void);
 extern void do_eam_indexing(struct Predicates *);
-extern void Yap_plwrite(Term, int (*mywrite) (int, int), int, int);
+extern void Yap_plwrite(Term, struct stream_desc *, int, int);

 #if Debug_Dump_State
   void dump_eam_state(void);
@ -1428,6 +1428,7 @@ static void *OpAddress[]= {
        &&p_db_ref,
        &&p_primitive,
        &&p_cut_by,
+        &&p_save_by,
        &&p_succ,
        &&p_predc,
        &&p_plus,
@ -2511,7 +2512,7 @@ break_debug(contador);
 #endif

 #ifdef DEBUG
-			 Yap_plwrite ((Term) beam_X[1], Yap_DebugPutc, 0, 1200);
+			 Yap_plwrite ((Term) beam_X[1], NULL, 0, GLOBAL_MaxPriority);
 #else
 			 extern int beam_write (void);
 			 beam_write();
@ -3536,6 +3537,7 @@ break_debug(contador);
        p_db_ref:
        p_primitive:
        p_cut_by:
+        p_save_by:
        p_succ:
        p_predc:
        p_plus:
--- a/BEAM/eamamasm.c
+++ b/BEAM/eamamasm.c
@ -12,8 +12,8 @@
 #ifdef BEAM

 #include "Yap.h"
-#include "compile.h"
-#include "clause.h"  
+#include "YapCompile.h"
+#include "clause.h"
 #include "eam.h"
 #include "eamamasm.h"
 #include <stdio.h>
@ -85,7 +85,7 @@ int X_Var(Ventry *ve)
 int var;

 if (ve->KindOfVE == PermVar || ve->KindOfVE == VoidVar ) {
-    printf("Erro no tipo de variavel X ->eamamas.c \n"); 
+    printf("Erro no tipo de variavel X ->eamamas.c \n");
    exit(1);
 }
 	var = ((ve->NoOfVE) & MaskVarAdrs);
@ -99,7 +99,7 @@ int Y_Var(Ventry *ve)
 {
 int var;
 if (ve->KindOfVE != PermVar) {
-    printf("Erro no tipo de variavel Y ->eamamas.c \n"); 
+    printf("Erro no tipo de variavel Y ->eamamas.c \n");
    exit(1);
 }
        var = ((ve->NoOfVE) & MaskVarAdrs);
@ -119,7 +119,7 @@ void eam_pass(CInstr *ppc)
 {
  int alloc_found=0;
  int body=0;
-  
+
 	while (ppc) {
 		switch ((int) ppc->op) {

@ -184,7 +184,7 @@ void eam_pass(CInstr *ppc)
 			   } else {
 			          emit_inst(_unify_val_Y_op);
 			          emit_par(Y_Var((Ventry *) ppc->new4));
-				  
+
 			   }
 		        } else { emit_inst(_unify_void_op); }
 			break;
@ -268,7 +268,7 @@ void eam_pass(CInstr *ppc)
 		case put_atom_op:
 		        emit_inst(_put_atom_op);
 			emit_par(ppc->new1);
-			emit_par(ppc->new4);			
+			emit_par(ppc->new4);
 			break;
 		case put_list_op:
 		        emit_inst(_put_list_op);
@ -349,7 +349,7 @@ void eam_pass(CInstr *ppc)

 		case cut_op:
 		        emit_inst(_cut_op);
-			break;  
+			break;
 		case commit_op:
 		        emit_inst(_commit_op);
 			break;
@ -402,7 +402,7 @@ void eam_pass(CInstr *ppc)
 			}
 			emit_par(ppc->new4);
 			break;
-			
+
 		case direct_safe_call_op:
 		        if (ppc->new1==1) {
  		           emit_inst(_direct_safe_call_unary_op);
@ -434,8 +434,8 @@ void eam_pass(CInstr *ppc)
 			  if (a==NULL) a=Yap_LookupAtom("\n");
 		          emit_inst(_put_atom_op);
 			  emit_par(1);
-			  emit_par((Cell) MkAtomTerm(a));			
-			} 
+			  emit_par((Cell) MkAtomTerm(a));
+			}
 		        emit_inst(_write_call);
 			break;
 		case is_op:
@ -468,50 +468,50 @@ void eam_pass(CInstr *ppc)
 		case remove_box_op:
 		case remove_last_box_op:
 			break;
-		  
+
 		case jump_op:
 		        emit_inst(_jump_op);
 			emit_upar((Cell) Code_Start+ (Cell) labels[ppc->new4]);
 			break;
 		case label_op:
-		        if (pass==0) labels[ppc->new4] = get_addr(); 
+		        if (pass==0) labels[ppc->new4] = get_addr();
 			break;

 		case run_op:
 /* se ficar vazio, retirar no eam_am.c o +5 das linhas pc=clause->code+5 no only_1_clause e no call */
 		        emit_inst(_try_me_op);
 			emit_par(0);
-			emit_par(0); 
 			emit_par(0);
-			emit_par(0); 
+			emit_par(0);
+			emit_par(0);
 		        break;

 		case only_1_clause_op:
 		        emit_inst(_only_1_clause_op);
 		        emit_par(ppc->new4);
 			emit_par(((struct Clauses *)ppc->new4)->predi->arity);
-		        emit_par(((struct Clauses *)ppc->new4)->nr_vars); 
+		        emit_par(((struct Clauses *)ppc->new4)->nr_vars);
 			emit_par(0); /* Nr da alternativa */
 			break;
 		case try_me_op:
 		        emit_inst(_try_me_op);
-			emit_par(ppc->new4); 
+			emit_par(ppc->new4);
 			emit_par(((struct Clauses *)ppc->new4)->predi->arity);
-		        emit_par(((struct Clauses *)ppc->new4)->nr_vars); 
+		        emit_par(((struct Clauses *)ppc->new4)->nr_vars);
 			emit_par(0); /* Nr da alternativa */
 		        break;
 		case retry_me_op:
 		        emit_inst(_retry_me_op);
 			emit_par(ppc->new4);
 			emit_par(((struct Clauses *)ppc->new4)->predi->arity);
-		        emit_par(((struct Clauses *)ppc->new4)->nr_vars); 
+		        emit_par(((struct Clauses *)ppc->new4)->nr_vars);
 			emit_par(ppc->new1);
 		        break;
 		case trust_me_op:
 		        emit_inst(_trust_me_op);
 			emit_par(ppc->new4);
 			emit_par(((struct Clauses *)ppc->new4)->predi->arity);
-		        emit_par(((struct Clauses *)ppc->new4)->nr_vars); 
+		        emit_par(((struct Clauses *)ppc->new4)->nr_vars);
 			emit_par(ppc->new1);
 		        break;

@ -529,18 +529,18 @@ void eam_pass(CInstr *ppc)
 			}
 			body=1;
 			break;
-		
+
 		case prepare_tries:
 		        emit_inst(_prepare_tries);
-			emit_par(ppc->new1); 
-			emit_par(ppc->new4); 
+			emit_par(ppc->new1);
+			emit_par(ppc->new4);
 			break;

 		case exit_op:
 		        emit_inst(_exit_eam);
 			break;

-		case mark_initialised_pvars_op:
+		case mark_initialized_pvars_op:
 		        break;
 		case fetch_args_for_bccall:
 		case bccall_op:
@ -559,7 +559,7 @@ void eam_pass(CInstr *ppc)
 			printf("[ please note that beam still does not support a lot of builtins          ]\n");
 		  }
 		        emit_inst(_fail_op);
-			
+
 		}
 		ppc = ppc->nextInst;
 	}
--- a/BEAM/eamamasm.h
+++ b/BEAM/eamamasm.h
@ -115,15 +115,16 @@
 #define _p_db_ref	(_std_base+8)
 #define _p_primitive	(_std_base+9)
 #define _p_cut_by	(_std_base+10)
-#define _p_succ		(_std_base+11)
-#define _p_predc	(_std_base+12)
-#define _p_plus		(_std_base+13)
-#define _p_minus	(_std_base+14)
-#define _p_times	(_std_base+15)
-#define _p_div		(_std_base+16)
-#define _p_dif		(_std_base+17)
-#define _p_eq		(_std_base+18)
-#define _p_arg		(_std_base+19)
-#define _p_functor	(_std_base+20)
+#define _p_save_by	(_std_base+11)
+#define _p_succ		(_std_base+12)
+#define _p_predc	(_std_base+13)
+#define _p_plus		(_std_base+14)
+#define _p_minus	(_std_base+15)
+#define _p_times	(_std_base+16)
+#define _p_div		(_std_base+17)
+#define _p_dif		(_std_base+18)
+#define _p_eq		(_std_base+19)
+#define _p_arg		(_std_base+20)
+#define _p_functor	(_std_base+21)


--- a/BEAM/eamindex.c
+++ b/BEAM/eamindex.c
@ -12,8 +12,8 @@
 #ifdef BEAM

 #include "Yap.h"
-#include "compile.h"
-#include "clause.h" 
+#include "YapCompile.h"
+#include "clause.h"
 #include "eam.h"
 #include <stdio.h>
 #include <stdlib.h>
@ -40,13 +40,13 @@ int exists_on_table(Cell a,struct HASH_TABLE **table, int i)
 struct HASH_TABLE *t;

   t=table[i];
-   
+
   while(t) {
     if (t->value==a) return(1);
- 
+
     t=t->next;
   }
-   
+
 return(0);
 }

@ -61,20 +61,20 @@ Cell *gera_codigo_try(struct Predicates *predi) /* gerar os try's para o  predic

  emit_new(prepare_tries,predi->nr_alt,predi->arity);
  if (predi->nr_alt==1) {
-      emit_new(only_1_clause_op,0,(unsigned long) c);    
-  } else if (predi->nr_alt>1) { 
+      emit_new(only_1_clause_op,0,(unsigned long) c);
+  } else if (predi->nr_alt>1) {
    while(c!=NULL) {
-      if (nr+1==predi->nr_alt) emit_new(trust_me_op,nr,(unsigned long) c); 
+      if (nr+1==predi->nr_alt) emit_new(trust_me_op,nr,(unsigned long) c);
      else if (nr==0) emit_new(try_me_op,predi->nr_alt,(unsigned long) c);
           else emit_new(retry_me_op,nr,(unsigned long) c);

      c=c->next;
      nr++;
    }
-  } else {  
+  } else {
      emit_new(fail_op,0,0);
  }
-  
+
  return(eam_assemble(StartCode));
 }

@ -91,7 +91,7 @@ Cell *gera_codigo_try_list(struct Predicates *predi) /* gerar os try's para o  p
  c=predi->first;

  emit_new(prepare_tries,nr_preds,predi->arity);
-  if (nr_preds>=1) { 
+  if (nr_preds>=1) {
    while(c!=NULL) {
      if (c->predi==predi && (c->idx==Lista || c->idx==Variavel)) {
 	 if (nr_preds==1) {
@ -108,20 +108,20 @@ Cell *gera_codigo_try_list(struct Predicates *predi) /* gerar os try's para o  p
  } else {
      emit_new(fail_op,0,0);
  }
-  
+
  return(eam_assemble(StartCode));
 }



-struct HASH_TABLE **gera_codigo_try_atom(struct Predicates *predi) 
+struct HASH_TABLE **gera_codigo_try_atom(struct Predicates *predi)
 {
 int j,nr_preds,nr_atoms;
 struct HASH_TABLE **table;
 struct HASH_TABLE *t;
 struct Clauses *cla;

-  nr_atoms=predi->idx_atom; 
+  nr_atoms=predi->idx_atom;
  nr_preds=nr_atoms+predi->idx_var;
  table=malloc(sizeof(struct HASH_TABLE *)*(nr_atoms+1));
  for (j=0;j<=nr_atoms;j++) table[j]=NULL;
@ -132,7 +132,7 @@ struct Clauses *cla;
     Cell a;
     unsigned int index;
     int nr;
- 
+
     a=cla->val;
     if (a && nr_atoms) {
       index=index_of_hash_table_atom(a,nr_atoms);
@ -187,18 +187,18 @@ struct HASH_TABLE **table;
 struct HASH_TABLE *t;
 struct Clauses *cla;

-  nr_appls=predi->idx_functor; 
+  nr_appls=predi->idx_functor;
  nr_preds=nr_appls+predi->idx_var;
  table=malloc(sizeof(struct HASH_TABLE *)*(nr_appls+1));
  for (j=0;j<=nr_appls;j++) table[j]=NULL;
-  
+
  cla=predi->first;
  while(cla) {
   if (cla->idx==Estrutura) {
    Cell a;
     long int index;
     int nr;
- 
+
     a=cla->val;
     if (a && nr_appls) {
       index=index_of_hash_table_appl(a,nr_appls);
@ -257,7 +257,7 @@ Cell *gera_codigo_try_only_vars(struct Predicates *predi) /* gerar os try's de V
  c=predi->first;

  emit_new(prepare_tries,nr_preds,predi->arity);
-  if (nr_preds>=1) { 
+  if (nr_preds>=1) {
    while(c!=NULL) {
      if (c->predi==predi && c->idx==Variavel) {
 	 if (nr_preds==1) {
@ -274,7 +274,7 @@ Cell *gera_codigo_try_only_vars(struct Predicates *predi) /* gerar os try's de V
  } else {
      emit_new(fail_op,0,0);
  }
- 
+
  return(eam_assemble(StartCode));
 }

@ -292,7 +292,7 @@ void do_eam_indexing(struct Predicates *p)
 	   p->idx=1;
   }

-   if((Print_Code & 4) && (Print_Code & 8)) { 
+   if((Print_Code & 4) && (Print_Code & 8)) {
 	   printf("General Case :\n");
 	   eam_showcode(p->code);
   }
@ -309,10 +309,10 @@ void ver_predicados(struct Predicates *p)

   c=p->first;
   while(c!=NULL) {
-     printf("Clausula %d do tipo %d (%d locals %d args) (val=0x%X)\n",++i,c->idx,c->nr_vars,c->predi->arity, (unsigned )c->val);     
+     printf("Clausula %d do tipo %d (%d locals %d args) (val=0x%X)\n",++i,c->idx,c->nr_vars,c->predi->arity, (unsigned )c->val);
     c=c->next;
   }
-  
+

 }

--- a/BEAM/toeam.c
+++ b/BEAM/toeam.c
@ -742,10 +742,10 @@ void ShowCode_new2(int op, int new1,CELL new4)
 	switch (ch = *f++)
 	  {
 	case '1':
-	        Yap_plwrite(MkIntTerm(new1), Yap_DebugPutc, 0, 1200);
+	        Yap_plwrite(MkIntTerm(new1), NULL, 30, 0, GLOBAL_MaxPriority);
 		break;
 	case '4':
-	        Yap_plwrite(MkIntTerm(new4), Yap_DebugPutc, 0, 1200);
+	        Yap_plwrite(MkIntTerm(new4), NULL, 20, 0, GLOBAL_MaxPriority);
 		break;
 	  default:
 	    Yap_DebugPutc (LOCAL_c_error_stream,'%');
--- a/C/absmi.c
+++ b/C/absmi.c
--- a/C/absmi_insts.h
+++ b/C/absmi_insts.h
@ -0,0 +1,88 @@
+/*****************************************************************
+ *                         INSTRUCTIONS                           *
+ *****************************************************************/
+
+#ifdef INDENT_CODE
+{
+  {
+    {
+#endif /* INDENT_CODE */
+
+      BOp(Ystop, l);
+      LOCAL_CBorder = 0;
+      SET_ASP(YREG, E_CB * sizeof(CELL));
+      /* make sure ASP is initialized */
+      saveregs();
+
+#if PUSH_REGS
+      restore_absmi_regs(old_regs);
+#endif
+#if BP_FREE
+      P1REG = PCBACKUP;
+#endif
+      LOCAL_CBorder = 0;
+      return 1;
+      ENDBOp();
+
+      BOp(Nstop, e);
+      SET_ASP(YREG, E_CB * sizeof(CELL));
+      saveregs();
+#if PUSH_REGS
+      restore_absmi_regs(old_regs);
+#endif
+#if BP_FREE
+      P1REG = PCBACKUP;
+#endif
+      return 0;
+      ENDBOp();
+
+/************************************************************************\
+ *      Native Code Execution                                            *
+\************************************************************************/
+
+#if YAP_JIT
+      static void *OpAddress_JIT[] = {
+#define OPCODE(OP, TYPE) &&_##OP
+#include "YapOpcodes.h"
+#undef OPCODE
+      };
+
+      /* native_me  */
+      BOp(jit_handler, J);
+      if (!PREG->y_u.J.jh->fi.bcst.c)
+        PREG->y_u.J.jh->mf.isground = IsGround(PREG);
+      PREG->y_u.J.jh->fi.bcst.c++;
+
+      /* Did PREG reach threshold value to become critical? */
+      if (PREG->y_u.J.jh->fi.bcst.c ==
+              (COUNT)(ExpEnv.config_struc.frequency_bound *
+                      (ExpEnv.config_struc.profiling_startp)) &&
+          !PREG->y_u.J.jh->mf.isground) {
+#if YAP_DBG_PREDS
+        if (ExpEnv.debug_struc.pprint_me.criticals != 0 &&
+            ExpEnv.debug_struc.pprint_me.criticals != 0x1) {
+          fprintf(stderr, "%s:%d\n", __FILE__, __LINE__);
+          fprintf(stderr, "%s", (char *)ExpEnv.debug_struc.pprint_me.criticals);
+        }
+#endif
+        traced_absmi();
+      }
+#if YAP_DBG_PREDS
+      print_main_when_head(PREG, ON_INTERPRETER);
+#endif
+      PREG = NEXTOP(PREG, J);
+      JMPNext();
+      ENDBOp();
+#endif
+
+#include "control_absmi_insts.h"
+#include "cp_absmi_insts.h"
+#include "fail_absmi_insts.h"
+#include "fli_absmi_insts.h"
+#include "index_absmi_insts.h"
+#include "lu_absmi_insts.h"
+#include "meta_absmi_insts.h"
+#include "or_absmi_insts.h"
+#include "prim_absmi_insts.h"
+#include "type_absmi_insts.h"
+#include "unify_absmi_insts.h"
--- a/C/absmi_insts.i
+++ b/C/absmi_insts.i
--- a/C/adtdefs.c
+++ b/C/adtdefs.c
--- a/C/adtdefs.c.new
+++ b/C/adtdefs.c.new
--- a/C/agc.c
+++ b/C/agc.c
@ -32,8 +32,9 @@ static char     SccsId[] = "@(#)agc.c	1.3 3/15/90";
 #define errout GLOBAL_stderr
 #endif

-STATIC_PROTO(void  RestoreEntries, (PropEntry *, int USES_REGS));
-STATIC_PROTO(void  CleanCode, (PredEntry * USES_REGS));
+static void  RestoreEntries(PropEntry *, int USES_REGS);
+static void  CleanCode(PredEntry * USES_REGS);
+static void  RestoreDBTerm(DBTerm *dbr, bool src, int attachments USES_REGS);

 #define AtomMarkedBit 1

@ -148,7 +149,7 @@ AtomAdjust(Atom a)
 #define DelayAddrAdjust(P) (P)
 #define DelayAdjust(P) (P)
 #define GlobalAdjust(P) (P)
-#define DBRefAdjust(P) (P)
+#define DBRefAdjust(P,REF) (P)
 #define DBRefPAdjust(P) (P)
 #define DBTermAdjust(P) (P)
 #define LUIndexAdjust(P) (P)
@ -180,6 +181,7 @@ AtomAdjust(Atom a)
 #define YAdjust(P) (P)
 #define HoldEntryAdjust(P) (P)
 #define CodeCharPAdjust(P) (P)
+#define CodeConstCharPAdjust(P) (P)
 #define CodeVoidPAdjust(P) (P)
 #define HaltHookAdjust(P) (P)

@ -189,28 +191,37 @@ AtomAdjust(Atom a)

 #define RestoreSWIHash()

+static void
+AdjustTermFlag(flag_term *tarr, UInt i)
+{
+  CACHE_REGS
+  if (IsVarTerm(tarr[i].at)) {
+    RestoreDBTerm( tarr[i].DBT, false, 0 PASS_REGS );
+  } else if (IsAtomTerm( tarr[i].at )  )
+    tarr[i].at = AtomTermAdjust(tarr[i].at);
+}
+
+static void RestoreFlags( UInt NFlags )
+{
+  CACHE_REGS
+  size_t i;
+  flag_term *tarr = GLOBAL_Flags;
+
+  if (worker_id == 0)
+    for (i=0; i<GLOBAL_flagCount; i++) {
+      AdjustTermFlag( tarr, i);
+    }
+  tarr = LOCAL_Flags;
+  for (i=0; i<LOCAL_flagCount; i++) {
+    AdjustTermFlag( tarr, i);
+  }
+}
+
 #include "rheap.h"

 static void
 RestoreHashPreds( USES_REGS1 )
 {
-  UInt i;
-
-  for (i = 0; i < PredHashTableSize; i++) {
-    PredEntry *p = PredHash[i];
-
-    if (p)
-      p = PredEntryAdjust(p);
-    while (p) {
-      Prop nextp;
-      
-      if (p->NextOfPE)
-	p->NextOfPE = PropAdjust(p->NextOfPE);
-      nextp = p->NextOfPE;
-      CleanCode(p PASS_REGS);
-      p = RepPredProp(nextp);
-    }
-  }
 }


@ -220,7 +231,7 @@ static void init_reg_copies(USES_REGS1)
  LOCAL_OldLCL0 = LCL0;
  LOCAL_OldTR = TR;
  LOCAL_OldGlobalBase = (CELL *)LOCAL_GlobalBase;
-  LOCAL_OldH = H;
+  LOCAL_OldH = HR;
  LOCAL_OldH0 = H0;
  LOCAL_OldTrailBase = LOCAL_TrailBase;
  LOCAL_OldTrailTop = LOCAL_TrailTop;
@ -244,8 +255,6 @@ RestoreAtomList(Atom atm USES_REGS)
  } while (!EndOfPAEntr(at));
 }

-
-
 static void
 mark_trail(USES_REGS1)
 {
@ -319,16 +328,42 @@ mark_global_cell(CELL *pt)
    /* skip bitmaps */
    switch(reg) {
    case (CELL)FunctorDouble:
-#if SIZEOF_DOUBLE == 2*SIZEOF_LONG_INT
+#if SIZEOF_DOUBLE == 2*SIZEOF_INT_P
      return pt + 4;
 #else
      return pt + 3;
 #endif
+    case (CELL)FunctorString:
+      return pt + 3 + pt[1];
    case (CELL)FunctorBigInt:
      {
 	Int sz = 3 +
 	  (sizeof(MP_INT)+
 	   (((MP_INT *)(pt+2))->_mp_alloc*sizeof(mp_limb_t)))/sizeof(CELL);
+	YAP_Opaque_CallOnGCMark f;
+	YAP_Opaque_CallOnGCRelocate f2;
+	Term t = AbsAppl(pt);
+
+	if ( (f = Yap_blob_gc_mark_handler(t)) ) {
+	  CELL ar[256];
+	  Int i,n = (f)(Yap_BlobTag(t), Yap_BlobInfo(t), ar, 256);
+	  if (n < 0) {
+	    Yap_Error(RESOURCE_ERROR_HEAP,TermNil,"not enough space for slot internal variables in agc");
+	      }
+	  for (i = 0; i< n; i++) {
+	    CELL *pt = ar+i;
+	    CELL reg = *pt;
+	    if (!IsVarTerm(reg) && IsAtomTerm(reg)) {
+	      *pt = AtomTermAdjust(reg);
+	    }
+	  }
+	  if ( (f2 = Yap_blob_gc_relocate_handler(t)) < 0 ) {
+	    int out = (f2)(Yap_BlobTag(t), Yap_BlobInfo(t), ar, n);
+	    if (out < 0)
+	      Yap_Error(RESOURCE_ERROR_HEAP,TermNil,"bad restore of slot internal variables in agc");
+	  }
+	}
+
 	return pt + sz;
      }
    case (CELL)FunctorLongInt:
@ -352,7 +387,7 @@ mark_global(USES_REGS1)
   * the code 
   */
  pt = H0;
-  while (pt < H) {
+  while (pt < HR) {
    pt = mark_global_cell(pt);
  }
 }
@ -374,22 +409,29 @@ clean_atom_list(AtomHashEntry *HashPtr)
  while (atm != NIL) {
    AtomEntry *at =  RepAtom(atm);
    if (AtomResetMark(at) ||
-	at->PropsOfAE != NIL ||
+	( at->PropsOfAE != NIL && !IsBlob(at) ) ||
 	(GLOBAL_AGCHook != NULL && !GLOBAL_AGCHook(atm))) {
      patm = &(at->NextOfAE);
      atm = at->NextOfAE;
    } else {
      NOfAtoms--;
-      if (IsWideAtom(atm)) {
-#ifdef DEBUG_RESTORE3
-	fprintf(stderr, "Purged %p:%S\n", at, at->WStrOfAE);
-#endif
-	GLOBAL_agc_collected += sizeof(AtomEntry)+wcslen(at->WStrOfAE);
-      } else {
+      if (IsBlob(atm)) {
+	YAP_BlobPropEntry *b = RepBlobProp(at->PropsOfAE);
+	if (b->NextOfPE != NIL) {
+	  patm = &(at->NextOfAE);
+	  atm = at->NextOfAE;
+	  continue;
+	}
+	NOfAtoms++;
+	NOfBlobs--;
+	Yap_FreeCodeSpace((char *)b);
+	GLOBAL_agc_collected += sizeof(YAP_BlobPropEntry);
+	GLOBAL_agc_collected += sizeof(AtomEntry)+sizeof(size_t)+at->rep.blob->length;
+      }  else {
 #ifdef DEBUG_RESTORE3
 	fprintf(stderr, "Purged %p:%s patm=%p %p\n", at, at->StrOfAE, patm, at->NextOfAE);
 #endif
-	GLOBAL_agc_collected += sizeof(AtomEntry)+strlen(at->StrOfAE);
+	GLOBAL_agc_collected += sizeof(AtomEntry)+strlen((const char *)at->StrOfAE);
      }
      *patm = atm = at->NextOfAE;
      Yap_FreeCodeSpace((char *)at);
@ -412,15 +454,10 @@ clean_atoms(void)
    clean_atom_list(HashPtr);
    HashPtr++;
  }
-  HashPtr = WideHashChain;
-  for (i = 0; i < WideAtomHashTableSize; ++i) {
-    clean_atom_list(HashPtr);
-    HashPtr++;
-  }
  clean_atom_list(&INVISIBLECHAIN);
  {
    AtomHashEntry list;
-    list.Entry = SWI_Blobs;
+    list.Entry =                                                                                                                                                                                                                                                                                                                                                                                                                                                            Blobs;
    clean_atom_list(&list);
  }
 }
@ -428,24 +465,25 @@ clean_atoms(void)
 static void
 atom_gc(USES_REGS1)
 {
-  int		gc_verbose = Yap_is_gc_verbose();
-  int           gc_trace = 0;
+  bool		gc_verbose = Yap_is_gc_verbose();
+  bool          gc_trace = false;
  

  UInt		time_start, agc_time;
 #if  defined(YAPOR) || defined(THREADS)
  return;
 #endif
+  
  if (Yap_GetValue(AtomGcTrace) != TermNil)
-    gc_trace = 1;
+    gc_trace = true;

  GLOBAL_agc_calls++;
  GLOBAL_agc_collected = 0;
  
  if (gc_trace) {
-    fprintf(GLOBAL_stderr, "%% agc:\n");
+    fprintf(stderr, "%% agc:\n");
  } else if (gc_verbose) {
-    fprintf(GLOBAL_stderr, "%%   Start of atom garbage collection %d:\n", GLOBAL_agc_calls);
+    fprintf(stderr, "%%   Start of atom garbage collection %d:\n", GLOBAL_agc_calls);
  }
  time_start = Yap_cputime();
  /* get the number of active registers */
@ -454,17 +492,18 @@ atom_gc(USES_REGS1)
  mark_stacks(PASS_REGS1);
  restore_codes();
  clean_atoms();
+  NOfBlobsMax = NOfBlobs+(NOfBlobs/2+256< 1024 ? NOfBlobs/2+256 : 1024);
  YAPLeaveCriticalSection();
  agc_time = Yap_cputime()-time_start;
  GLOBAL_tot_agc_time += agc_time;
  GLOBAL_tot_agc_recovered += GLOBAL_agc_collected;
  if (gc_verbose) {
 #ifdef _WIN32
-    fprintf(GLOBAL_stderr, "%%   Collected %I64d bytes.\n", GLOBAL_agc_collected);
+    fprintf(stderr, "%%   Collected %I64d bytes.\n", GLOBAL_agc_collected);
 #else
-    fprintf(GLOBAL_stderr, "%%   Collected %lld bytes.\n", GLOBAL_agc_collected);
+    fprintf(stderr, "%%   Collected %lld bytes.\n", GLOBAL_agc_collected);
 #endif
-    fprintf(GLOBAL_stderr, "%%   GC %d took %g sec, total of %g sec doing GC so far.\n", GLOBAL_agc_calls, (double)agc_time/1000, (double)GLOBAL_tot_agc_time/1000);
+    fprintf(stderr, "%%   GC %d took %g sec, total of %g sec doing GC so far.\n", GLOBAL_agc_calls, (double)agc_time/1000, (double)GLOBAL_tot_agc_time/1000);
  }
 }

@ -496,31 +535,10 @@ p_inform_agc(USES_REGS1)
    Yap_unify(ts, ARG3);
 }

-static Int
-p_agc_threshold(USES_REGS1)
-{
-  Term t = Deref(ARG1);
-  if (IsVarTerm(t)) {
-    return Yap_unify(ARG1, MkIntegerTerm(GLOBAL_AGcThreshold));
-  } else if (!IsIntegerTerm(t)) {
-    Yap_Error(TYPE_ERROR_INTEGER,t,"prolog_flag/2 agc_margin");
-    return FALSE;
-  } else {
-    Int i = IntegerOfTerm(t);
-    if (i<0) {
-      Yap_Error(DOMAIN_ERROR_NOT_LESS_THAN_ZERO,t,"prolog_flag/2 agc_margin");
-      return FALSE;
-    } else {
-      GLOBAL_AGcThreshold = i;
-      return TRUE;
-    }
-  }
-}

 void 
 Yap_init_agc(void)
 {
-  Yap_InitCPred("$atom_gc", 0, p_atom_gc, HiddenPredFlag);
-  Yap_InitCPred("$inform_agc", 3, p_inform_agc, HiddenPredFlag);
-  Yap_InitCPred("$agc_threshold", 1, p_agc_threshold, HiddenPredFlag|SafePredFlag);
+  Yap_InitCPred("$atom_gc", 0, p_atom_gc, 0);
+  Yap_InitCPred("$inform_agc", 3, p_inform_agc, 0);
 }
--- a/C/alloc.c
+++ b/C/alloc.c
--- a/C/amasm.c
+++ b/C/amasm.c
--- a/C/analyst.c
+++ b/C/analyst.c
@ -31,9 +31,9 @@ static char SccsId[] = "%W% %G%";



-STATIC_PROTO(Int p_reset_op_counters, (void));
-STATIC_PROTO(Int p_show_op_counters, (void));
-STATIC_PROTO(Int p_show_ops_by_group, (void));
+static Int p_reset_op_counters(void);
+static Int p_show_op_counters(void);
+static Int p_show_ops_by_group(void);

 static Int 
 p_reset_op_counters()
@ -852,10 +852,35 @@ p_show_sequences(void)
 void 
 Yap_InitAnalystPreds(void)
 {
-  Yap_InitCPred("wam_profile_reset_op_counters", 0, p_reset_op_counters, SafePredFlag |SyncPredFlag);
-  Yap_InitCPred("wam_profile_show_op_counters", 1, p_show_op_counters, SafePredFlag|SyncPredFlag);
-  Yap_InitCPred("wam_profile_show_ops_by_group", 1, p_show_ops_by_group, SafePredFlag |SyncPredFlag);
-  Yap_InitCPred("wam_profile_show_sequences", 1, p_show_sequences, SafePredFlag |SyncPredFlag);
+  Yap_InitCPred("wam_profiler_reset_op_counters", 0, p_reset_op_counters, SafePredFlag |SyncPredFlag);
+/** @pred wam_profiler_reset_op_counters 
+
+
+Reinitialize all counters.
+
+ 
+*/
+  Yap_InitCPred("wam_profiler_show_op_counters", 1, p_show_op_counters, SafePredFlag|SyncPredFlag);
+/** @pred wam_profiler_show_op_counters(+ _A_) 
+
+
+Display the current value for the counters, using label  _A_. The
+label must be an atom.
+
+ 
+*/
+  Yap_InitCPred("wam_profiler_show_ops_by_group", 1, p_show_ops_by_group, SafePredFlag |SyncPredFlag);
+/** @pred wam_profiler_show_ops_by_group(+ _A_) 
+
+
+Display the current value for the counters, organized by groups, using
+label  _A_. The label must be an atom.
+
+
+
+
+ */
+  Yap_InitCPred("wam_profiler_show_sequences", 1, p_show_sequences, SafePredFlag |SyncPredFlag);
 }

 #endif /* ANALYST */
--- a/C/args.c
+++ b/C/args.c
@ -0,0 +1,219 @@
+
+#include "Yap.h"
+#include "Yatom.h"
+
+/**
+ * Scan a list of arguments and output results to a pre-processed vector.
+ *
+ * @param listl: input list
+ * @param def parameter definition
+ *
+ * @return all arguments, some of them set, some of them not.
+ */
+
+static xarg *matchKey(Atom key, xarg *e0, int n, const param_t *def) {
+  int i;
+  for (i = 0; i < n; i++) {
+    if (!strcmp((char *)def->name, (char *)RepAtom(key)->StrOfAE)) {
+      return e0;
+    }
+    def++;
+    e0++;
+  }
+  return NULL;
+}
+
+/**
+ * Returns the index of an argument key, or -1 if not found.
+ *
+ */
+int Yap_ArgKey(Atom key, const param_t *def, int n) {
+  int i;
+  for (i = 0; i < n; i++) {
+    if (!strcmp((char *)def->name, (char *)RepAtom(key)->StrOfAE)) {
+      return i;
+    }
+    def++;
+  }
+  return -1;
+}
+
+#define YAP_XARGINFO(Error, Message)
+
+
+xarg *Yap_ArgListToVector__(const char *file, const char *function, int lineno,
+                            Term listl, const param_t *def, int n,
+                            yap_error_number err) {
+  CACHE_REGS
+  xarg *a;
+      listl = Deref(listl);
+  if (IsVarTerm(listl)) {
+    Yap_ThrowError__(file, function, lineno, INSTANTIATION_ERROR, listl,
+                     "while opening    listl = ArgOfTerm(2, listl ,k)");
+  }
+  a = calloc(n, sizeof(xarg));
+
+  if (!IsPairTerm(listl) && listl != TermNil) {
+    if (IsAtomTerm(listl)) {
+      xarg *na = matchKey(AtomOfTerm(listl), a, n, def);
+      if (!na) {
+        Yap_ThrowError__(file, function, lineno, TYPE_ERROR_LIST, listl, "match key");
+      }
+    } else if (IsApplTerm(listl)) {
+      Functor f = FunctorOfTerm(listl);
+      if (IsExtensionFunctor(f)) {
+        Yap_ThrowError__(file, function, lineno, TYPE_ERROR_LIST, listl, "callable");
+      }
+      arity_t arity = ArityOfFunctor(f);
+      if (arity != 1) {
+        Yap_ThrowError__(file, function, lineno, TYPE_ERROR_LIST, listl, "bad arity");
+      }
+      xarg *na = matchKey(NameOfFunctor(f), a, n, def);
+      if (!na) {
+        Yap_ThrowError__(file, function, lineno, err, listl, "no match");
+      }
+      na->used = true;
+      na->tvalue = ArgOfTerm(1, listl);
+    } else {
+      Yap_ThrowError__(file, function, lineno, TYPE_ERROR_ATOM, listl, "not atom");
+    }
+    listl = MkPairTerm(listl, TermNil);
+  }
+  while (IsPairTerm(listl)) {
+    Term hd = HeadOfTerm(listl);
+    listl = TailOfTerm(listl);
+    if (IsVarTerm(hd)) {
+      Yap_ThrowError__(file, function, lineno, INSTANTIATION_ERROR, hd, "sub-element");
+    }
+    if (IsVarTerm(listl)) {
+      Yap_ThrowError__(file, function, lineno, INSTANTIATION_ERROR, listl, "sub-list");
+    }
+    if (IsAtomTerm(hd)) {
+      xarg *na = matchKey(AtomOfTerm(hd), a, n, def);
+      if (!na)
+        Yap_ThrowError__(file, function, lineno, err, hd, "bad match in list");
+      na->used = true;
+      na->tvalue = TermNil;
+      continue;
+    } else if (IsApplTerm(hd)) {
+      Functor f = FunctorOfTerm(hd);
+      if (IsExtensionFunctor(f)) {
+        Yap_ThrowError__(file, function, lineno, err, hd, "bad compound");
+      }
+      arity_t arity = ArityOfFunctor(f);
+      if (arity != 1) {
+        Yap_ThrowError__(file, function, lineno, DOMAIN_ERROR_OUT_OF_RANGE, hd,
+                         "high arity");
+      }
+      xarg *na = matchKey(NameOfFunctor(f), a, n, def);
+      if (!na) {
+        Yap_ThrowError__(file, function, lineno, err, hd, "no match");
+      }
+      na->used = true;
+      na->tvalue = ArgOfTerm(1, hd);
+    } else {
+      Yap_ThrowError__(file, function, lineno, err, hd, "bad type");
+    }
+  }
+  if (IsVarTerm(listl)) {
+    Yap_ThrowError__(file, function, lineno, INSTANTIATION_ERROR, listl, "unbound");
+  } else if (listl != TermNil) {
+    Yap_ThrowError__(file, function, lineno, TYPE_ERROR_LIST, listl, "bad list");
+  }
+  return a;
+  }
+
+static xarg *matchKey2(Atom key, xarg *e0, int n, const param2_t *def) {
+  int i;
+  for (i = 0; i < n; i++) {
+    if (!strcmp((char *)def->name, (char *)RepAtom(key)->StrOfAE)) {
+      return e0;
+    }
+    def++;
+    e0++;
+  }
+  return NULL;
+}
+/// Yap_ArgList2ToVector is much the same as before,
+/// but assumes parameters also have something called a
+/// scope
+xarg *Yap_ArgList2ToVector__(const char *file, const char *function, int lineno,Term listl, const param2_t *def, int n, yap_error_number err) {
+  CACHE_REGS
+  xarg *a = calloc(n, sizeof(xarg));
+  if (!IsPairTerm(listl) && listl != TermNil) {
+    if (IsVarTerm(listl)) {
+      Yap_ThrowError__(file, function, lineno, INSTANTIATION_ERROR, listl, "unbound");
+    }
+    if (IsAtomTerm(listl)) {
+      xarg *na = matchKey2(AtomOfTerm(listl), a, n, def);
+      if (!na) {
+        Yap_ThrowError__(file, function, lineno, err,
+                         listl, "bad match");
+      }
+    }
+    if (IsApplTerm(listl)) {
+      Functor f = FunctorOfTerm(listl);
+      if (IsExtensionFunctor(f)) {
+        Yap_ThrowError__(file, function, lineno, TYPE_ERROR_PARAMETER, listl,
+                         "bad compound");
+      }
+      arity_t arity = ArityOfFunctor(f);
+      if (arity != 1) {
+        Yap_ThrowError__(file, function, lineno, TYPE_ERROR_LIST, listl, "bad arity");
+      }
+      xarg *na = matchKey2(NameOfFunctor(f), a, n, def);
+      if (!na) {
+        Yap_ThrowError__(file, function, lineno, DOMAIN_ERROR_GENERIC_ARGUMENT,
+                         listl, "bad match");
+      }
+    } else {
+      Yap_ThrowError__(file, function, lineno, TYPE_ERROR_LIST, listl, "");
+    }
+    listl = MkPairTerm(listl, TermNil);
+  }
+  while (IsPairTerm(listl)) {
+    Term hd = HeadOfTerm(listl);
+    if (IsVarTerm(hd)) {
+      Yap_ThrowError__(file, function, lineno, INSTANTIATION_ERROR, hd, "");
+    }
+    if (IsAtomTerm(hd)) {
+      xarg *na = matchKey2(AtomOfTerm(hd), a, n, def);
+      if (!na) {
+        Yap_ThrowError__(file, function, lineno, DOMAIN_ERROR_GENERIC_ARGUMENT,
+                         hd, "bad match");
+      }
+      na->used = true;
+      na->tvalue = TermNil;
+      continue;
+    } else if (IsApplTerm(hd)) {
+      Functor f = FunctorOfTerm(hd);
+      if (IsExtensionFunctor(f)) {
+        Yap_ThrowError__(file, function, lineno, TYPE_ERROR_PARAMETER, hd, "bad compound");
+      }
+      arity_t arity = ArityOfFunctor(f);
+      if (arity != 1) {
+        Yap_ThrowError__(file, function, lineno, DOMAIN_ERROR_GENERIC_ARGUMENT,
+                         hd, "bad arity");
+      }
+      xarg *na = matchKey2(NameOfFunctor(f), a, n, def);
+      if (na) {
+        na->used = 1;
+        na->tvalue = ArgOfTerm(1, hd);
+      } else {
+        Yap_ThrowError__(file, function, lineno, err,
+                         hd, "bad key");
+      }
+      return a;
+    } else {
+      Yap_ThrowError__(file, function, lineno, INSTANTIATION_ERROR, hd, "unbound");
+    }
+    listl = TailOfTerm(listl);
+  }
+  if (IsVarTerm(listl)) {
+    Yap_ThrowError__(file, function, lineno, INSTANTIATION_ERROR, listl, "");
+  }
+  if (TermNil != listl) {
+    Yap_ThrowError__(file, function, lineno, TYPE_ERROR_LIST, listl, "");
+  }
+  return a;
+}
--- a/C/arith0.c
+++ b/C/arith0.c
@ -18,41 +18,103 @@
 static char     SccsId[] = "%W% %G%";
 #endif

-/*
- * This file implements arithmetic operations 
+/**
+   @file arith0.c
+
+*/
+
+//! @{
+
+/**
+   @defgroup arithmetic_operators Arithmetic Functions
+   @ingroup arithmetic
+
+   YAP implements several arithmetic functions, they are defined as
+   fields in three enumerations, such that there is one enumeration
+   per each different arity:  
+
+    - #arith0_op defines constants and arity 0 arithmetic functions
+
+      @copydoc #arith0_op
+
+    - #arith1_op defines single argument arithmetic functions
+
+      @copydoc #arith1_op
+
+    - #arith2_op defines binary arithmetic functions
+
+      @copydoc #arith2_op
+
+  Arithmetic expressions
+  in YAP may use the following operators:
+
+   - <b>pi [ISO]</b><p> @anchor pi_0
+
+     An approximation to the value of <em>pi</em>, that is, the ratio of a circle's circumference to its diameter.
+
+   - <b>e</b><p>    @anchor e_0
+
+     Euler's number, the base of the natural logarithms.
+
+   - <b>epsilon</b><p>  @anchor epsilon_0
+
+     The difference between the float `1.0` and the next largest floating point number.
+
+   - <b>inf</b><p>  @anchor inf_0
+
+     Infinity according to the IEEE Floating-Point standard. Note that evaluating this term will generate a domain error in the `iso` language mode.
+
+     Note also that YAP supports `+inf` and  `-inf`
+
+   - <b>nan (not a number)</b><p>  @anchor nan_0
+
+     Not-a-number according to the IEEE Floating-Point standard. Note that evaluating this term will generate a domain error in the `iso` language mode.
+
+   - <b>random</b><p>  @anchor random_0
+
+     A "random" floating point number between 0 and 1.
+
+   - <b>cputime</b><p>  @anchor cputime_0
+
+     CPU time since YAP was invoked, in seconds.
+
+   - <b>heapused</b><p>  @anchor heapused_0
+
+     Heap (data-base) space used, in bytes.
+
+   - <b>local</b><p>  @anchor local_0
+
+     Local stack in use, in bytes
+
+   - <b>$b</b><p>  @anchor b_0
+
+     current choicepoint
+
+   - <b>$env</b><p>  @anchor env_0
+
+     Environment
+
+   - <b>$tr</b><p>  @anchor tr_0
+
+     Trail in use
+
+   - <b>$free_stack</b><p>  @anchor free_stack_0
+     
+     Amount of free stack space, that is, free space between global and local stacks.
+
+   - <b>global</b><p>  @anchor global_0
+
+     Global stack in use, in bytes.
 *
 */

 #include "Yap.h"
 #include "Yatom.h"
 #include "YapHeap.h"
-#include "eval.h"
+#include "YapEval.h"
+#include "alloc.h"


-#ifndef PI
-#ifdef M_PI
-#define PI M_PI
-#else
-#define PI 3.14159265358979323846
-#endif
-#endif
-
-#ifndef M_E
-#define M_E 2.7182818284590452354
-#endif
-
-#ifndef INFINITY
-#define INFINITY (1.0/0.0)
-#endif
-
-#ifndef NAN
-#define NAN      (0.0/0.0)
-#endif
-
-/* copied from SWI-Prolog */
-#ifndef DBL_EPSILON /* normal for IEEE 64-bit double */
-#define DBL_EPSILON 0.00000000000000022204
-#endif

 static Term
 eval0(Int fi) {
@ -74,12 +136,12 @@ eval0(Int fi) {
  case op_inf:
    {
 #ifdef _MSC_VER /* Microsoft's Visual C++ Compiler */
-      Yap_Error(TYPE_ERROR_EVALUABLE, TermNil, "evaluating infinity");
+      Yap_ArithError(TYPE_ERROR_EVALUABLE, TermNil, "evaluating infinity");
      P = (yamop *)FAILCODE;
      RERROR();
 #else
-      if (yap_flags[LANGUAGE_MODE_FLAG] == 1) {/* iso */
-	Yap_Error(TYPE_ERROR_EVALUABLE, TermNil, "evaluating infinity");
+      if (isoLanguageFlag()) {/* iso */
+	Yap_ArithError(TYPE_ERROR_EVALUABLE, TermNil, "evaluating infinity");
 	P = (yamop *)FAILCODE;
 	RERROR();
      } else {
@ -89,14 +151,12 @@ eval0(Int fi) {
    }
  case op_nan:
    {
-#ifdef _MSC_VER /* Microsoft's Visual C++ Compiler */
-      Yap_Error(TYPE_ERROR_EVALUABLE, TermNil, "evaluating infinity");
-      P = (yamop *)FAILCODE;
+#ifdef _MSC_VER /* Microsoft's Visual C++ Compi<ler */
+      Yap_ArithError(TYPE_ERROR_EVALUABLE, TermNil, "evaluating infinity");
      RERROR();
 #else
-      if (yap_flags[LANGUAGE_MODE_FLAG] == 1) {/* iso */
-	Yap_Error(TYPE_ERROR_EVALUABLE, TermNil, "evaluating not-a-number");
-	P = (yamop *)FAILCODE;
+      if (isoLanguageFlag()) {/* iso */
+	Yap_ArithError(TYPE_ERROR_EVALUABLE, TermNil, "evaluating not-a-number");
 	RERROR();
      } else {
 	RFLOAT(NAN);
@ -112,40 +172,55 @@ eval0(Int fi) {
      RFLOAT((Float)Yap_cputime()/1000.0);
    }
  case op_heapused:
-    RINT(HeapUsed);
+    /// - heapused
+    ///   Heap (data-base) space used, in bytes. In fact YAP either reports
+    ///   the total memory malloced, or the amount of allocated space in
+    ///   predicates.
+    ///
+    RINT(Yap_HeapUsed());
  case op_localsp:
+    /// - local
+    ///   Local stack in use, in bytes
+    ///
 #if YAPOR_SBA
    RINT((Int)ASP);
 #else
    RINT(LCL0 - ASP);
-#endif
-  case op_b:
-#if YAPOR_SBA
-    RINT((Int)B);
-#else
-    RINT(LCL0 - (CELL *)B);
 #endif
  case op_env:
+    /// - $env
+    ///   Environment
+    ///
 #if YAPOR_SBA
    RINT((Int)YENV);
 #else
    RINT(LCL0 - YENV);
 #endif
  case op_tr:
+    /// - $tr
+    ///   Trail in use
+    ///
 #if YAPOR_SBA
    RINT(TR);
 #else
    RINT(((CELL *)TR)-LCL0);
 #endif
  case op_stackfree:
-    RINT(Unsigned(ASP) - Unsigned(H));
+    /// - $free_stack
+    ///   
+    /// Not-a-number according to the IEEE Floating-Point standard. Note that evaluating this term will generate a domain error in the `iso` language mode.
+    RINT(Unsigned(ASP) - Unsigned(HR));
  case op_globalsp:
+    /// - global
+    ///   Global stack in use, in bytes.
+    ///
 #if YAPOR_SBA
-    RINT((Int)H);
+    RINT((Int)HR);
 #else
-    RINT(H - H0);
+    RINT(HR - H0);
 #endif
  }
+  /// end of switch
  RERROR();
 }

@ -170,7 +245,6 @@ static InitConstEntry InitConstTab[] = {
  {"heapused", op_heapused},
  {"local_sp", op_localsp},
  {"global_sp", op_globalsp},
-  {"$last_choice_pt", op_b},
  {"$env", op_env},
  {"$tr", op_tr},
  {"stackfree", op_stackfree},
@ -185,7 +259,7 @@ Yap_InitConstExps(void)
  for (i = 0; i < sizeof(InitConstTab)/sizeof(InitConstEntry); ++i) {
    AtomEntry *ae = RepAtom(Yap_LookupAtom(InitConstTab[i].OpName));
    if (ae == NULL) {
-      Yap_Error(OUT_OF_HEAP_ERROR,TermNil,"at InitConstExps");
+      Yap_EvalError(RESOURCE_ERROR_HEAP,TermNil,"at InitConstExps");
      return;
    }
    WRITE_LOCK(ae->ARWLock);
@ -203,6 +277,7 @@ Yap_InitConstExps(void)
  }
 }

+
 /* This routine is called from Restore to make sure we have the same arithmetic operators */
 int
 Yap_ReInitConstExps(void)
@ -210,3 +285,4 @@ Yap_ReInitConstExps(void)
  return TRUE;
 }

+/// @}
--- a/C/arith1.c
+++ b/C/arith1.c
--- a/C/arith2.c
+++ b/C/arith2.c
@ -18,15 +18,116 @@
 static char     SccsId[] = "%W% %G%";
 #endif

-/*
- * This file implements unary arithmetic operations in YAP
- *
- */
+/**
+
+   @file arith2.c
+
+   @addtogroup arithmetic_operators
+
+These are the binary numeric operators currently supported by YAP.
+
+  - <b> _X_+ _Y_ [ISO]</b><p>
+
+    Sum.
+
+  - <b> _X_- _Y_ [ISO]</b><p>
+
+    Difference.
+
+  - <b> _X_\* _Y_ [ISO]</b><p>
+
+    Product.
+
+  - <b> _X_/ _Y_ [ISO]</b><p>
+
+    Quotient.
+
+  - <b> _X_// _Y_ [ISO]</b><p>
+
+    Integer quotient.
+
+  - <b> _X_ mod  _Y_ [ISO]</b><p> @anchor mod_2
+
+    Integer module operator, always positive.
+
+  - <b> _X_ rem  _Y_ [ISO]</b><p> @anchor rem_2
+
+    Integer remainder, similar to `mod` but always has the same sign as `X`.
+
+  - <b>  _X_ div  _Y_ [ISO]</b><p> @anchor div_2
+
+    Integer division, as if defined by `( _X_ -  _X_ mod  _Y_)//  _Y_`.
+
+  - <b> max( _X_, _Y_) [ISO]</b><p> @anchor max_2
+
+    The greater value of  _X_ and  _Y_.
+
+  - <b> min( _X_, _Y_) [ISO]</b><p> @anchor min_2
+
+    The lesser value of  _X_ and  _Y_.
+
+  - <b> _X_ ^  _Y_ [ISO]</b><p>
+
+     _X_ raised to the power of  _Y_, (from the C-Prolog syntax).
+
+  - <b> exp( _X_, _Y_)</b><p> @anchor exp_2
+
+     _X_ raised to the power of  _Y_, (from the Quintus Prolog syntax).
+
+  - <b> _X_ \*\*  _Y_ [ISO]</b><p>
+
+     _X_ raised to the power of  _Y_  (from ISO).
+
+  - <b> _X_ /\\  _Y_ [ISO]</b><p>
+
+    Integer bitwise conjunction.
+
+  - <b> _X_ \\/  _Y_ [ISO]</b><p>
+
+    Integer bitwise disjunction.
+
+  - <b> _X_ #  _Y_</b><p>
+
+    Integer bitwise exclusive disjunction.
+
+  - <b> _X_ \>\<  _Y_</b><p>
+
+    Integer bitwise exclusive disjunction.
+
+  - <b> xor( _X_ ,  _Y_) [ISO]</b><p> @anchor xor_2
+
+    Integer bitwise exclusive disjunction.
+
+  - <b> _X_ \<\<  _Y_</b><p>
+
+    Integer bitwise left logical shift of  _X_ by  _Y_ places.
+
+  - <b> _X_ \>\>  _Y_ [ISO]</b><p>
+
+    Integer bitwise right logical shift of  _X_ by  _Y_ places.
+
+  - <b> gcd( _X_, _Y_)</b><p> @anchor gcd_2
+
+    The greatest common divisor of the two integers  _X_ and  _Y_.
+
+  - <b> atan( _X_, _Y_)</b><p> @anchor atan_2
+
+    Four-quadrant arc tangent. Also available as `atan2/2`.
+
+  - <b> atan2( _X_, _Y_) [ISO]</b><p> @anchor atan2_2
+
+    Four-quadrant arc tangent.
+
+  - <b>  _X_ rdiv  _Y_ [ISO]</b><p> @anchor rdiv_2
+
+    Rational division.
+
+*/

 #include "Yap.h"
 #include "Yatom.h"
 #include "YapHeap.h"
-#include "eval.h"
+#include "YapEval.h"

 #include "arith2.h"

@ -37,7 +138,7 @@ typedef struct init_un_eval {


 static Term
-p_mod(Term t1, Term t2) {
+p_mod(Term t1, Term t2 USES_REGS) {
  switch (ETypeOfTerm(t1)) {
  case (CELL)long_int_e:
    switch (ETypeOfTerm(t2)) {
@ -49,14 +150,9 @@ p_mod(Term t1, Term t2) {
 	Int mod;

 	if (i2 == 0)
-	  return Yap_ArithError(EVALUATION_ERROR_ZERO_DIVISOR, t2, "X is " Int_FORMAT " mod 0", i1);
+	  Yap_ArithError(EVALUATION_ERROR_ZERO_DIVISOR, t2, "X is " Int_FORMAT " mod 0", i1);
 	if (i1 == Int_MIN && i2 == -1) {
-#ifdef USE_GMP
-	  return Yap_gmp_add_ints(Int_MAX, 1);	  
-#else
-	  return Yap_ArithError(EVALUATION_ERROR_INT_OVERFLOW, t1,
-		    "// /2 with %d and %d", i1, i2);
-#endif
+	  return MkIntTerm(0);
 	}
 	mod = i1%i2;
 	if (mod && (mod ^ i2) < 0)
@ -64,7 +160,7 @@ p_mod(Term t1, Term t2) {
 	RINT(mod);
      }
    case (CELL)double_e:
-      return Yap_ArithError(TYPE_ERROR_INTEGER, t2, "mod/2");
+      Yap_ArithError(TYPE_ERROR_INTEGER, t2, "mod/2");
    case (CELL)big_int_e:
 #ifdef USE_GMP
      return Yap_gmp_mod_int_big(IntegerOfTerm(t1), t2);
@ -74,7 +170,7 @@ p_mod(Term t1, Term t2) {
      break;
    }
  case (CELL)double_e:
-    return Yap_ArithError(TYPE_ERROR_INTEGER, t2, "mod/2");
+    Yap_ArithError(TYPE_ERROR_INTEGER, t1, "mod/2");
  case (CELL)big_int_e:
 #ifdef USE_GMP
    switch (ETypeOfTerm(t2)) {
@ -84,14 +180,14 @@ p_mod(Term t1, Term t2) {
 	Int i2 = IntegerOfTerm(t2);

 	if (i2 == 0)
-	  return Yap_ArithError(EVALUATION_ERROR_ZERO_DIVISOR, t2, "X is ... mod 0");
+	  Yap_ArithError(EVALUATION_ERROR_ZERO_DIVISOR, t2, "X is ... mod 0");
 	return Yap_gmp_mod_big_int(t1, i2);
      }
    case (CELL)big_int_e:
      /* two bignums */
      return Yap_gmp_mod_big_big(t1, t2);
    case double_e:
-      return Yap_ArithError(TYPE_ERROR_INTEGER, t2, "mod/2");
+      Yap_ArithError(TYPE_ERROR_INTEGER, t2, "mod/2");
    default:
      RERROR();
    }
@ -102,7 +198,7 @@ p_mod(Term t1, Term t2) {
 }

 static Term
-p_div2(Term t1, Term t2) {
+p_div2(Term t1, Term t2 USES_REGS) {
  switch (ETypeOfTerm(t1)) {
  case (CELL)long_int_e:
    switch (ETypeOfTerm(t2)) {
@ -114,12 +210,12 @@ p_div2(Term t1, Term t2) {
 	Int res, mod;

 	if (i2 == 0)
-	  return Yap_ArithError(EVALUATION_ERROR_ZERO_DIVISOR, t2, "X is " Int_FORMAT " div 0", i1);
+	  Yap_ArithError(EVALUATION_ERROR_ZERO_DIVISOR, t2, "X is " Int_FORMAT " div 0", i1);
 	if (i1 == Int_MIN && i2 == -1) {
 #ifdef USE_GMP
-	  return Yap_gmp_add_ints(Int_MAX, 1);	  
+	  return Yap_gmp_add_ints(Int_MAX, 1);
 #else
-	  return Yap_ArithError(EVALUATION_ERROR_INT_OVERFLOW, t1,
+	  Yap_ArithError(EVALUATION_ERROR_INT_OVERFLOW, t1,
 		    "// /2 with %d and %d", i1, i2);
 #endif
 	}
@ -130,7 +226,7 @@ p_div2(Term t1, Term t2) {
 	RINT(res);
      }
    case (CELL)double_e:
-      return Yap_ArithError(TYPE_ERROR_INTEGER, t2, "div/2");
+      Yap_ArithError(TYPE_ERROR_INTEGER, t2, "div/2");
    case (CELL)big_int_e:
 #ifdef USE_GMP
      return Yap_gmp_div_int_big(IntegerOfTerm(t1), t2);
@ -140,7 +236,7 @@ p_div2(Term t1, Term t2) {
      break;
    }
  case (CELL)double_e:
-    return Yap_ArithError(TYPE_ERROR_INTEGER, t2, "div/2");
+    Yap_ArithError(TYPE_ERROR_INTEGER, t2, "div/2");
  case (CELL)big_int_e:
 #ifdef USE_GMP
    switch (ETypeOfTerm(t2)) {
@ -150,14 +246,14 @@ p_div2(Term t1, Term t2) {
 	Int i2 = IntegerOfTerm(t2);

 	if (i2 == 0)
-	  return Yap_ArithError(EVALUATION_ERROR_ZERO_DIVISOR, t2, "X is ... div 0");
+	  Yap_ArithError(EVALUATION_ERROR_ZERO_DIVISOR, t2, "X is ... div 0");
 	return Yap_gmp_div2_big_int(t1, i2);
      }
    case (CELL)big_int_e:
      /* two bignums */
      return Yap_gmp_div2_big_big(t1, t2);
    case double_e:
-      return Yap_ArithError(TYPE_ERROR_INTEGER, t2, "mod/2");
+      Yap_ArithError(TYPE_ERROR_INTEGER, t2, "div/2");
    default:
      RERROR();
    }
@ -168,7 +264,7 @@ p_div2(Term t1, Term t2) {
 }

 static Term
-p_rem(Term t1, Term t2) {
+p_rem(Term t1, Term t2 USES_REGS) {
  switch (ETypeOfTerm(t1)) {
  case (CELL)long_int_e:
    switch (ETypeOfTerm(t2)) {
@ -177,23 +273,16 @@ p_rem(Term t1, Term t2) {
      {
 	Int i1 = IntegerOfTerm(t1);
 	Int i2 = IntegerOfTerm(t2);
-	Int mod;

 	if (i2 == 0)
-	  return Yap_ArithError(EVALUATION_ERROR_ZERO_DIVISOR, t2, "X is " Int_FORMAT " rem 0", i1);
+	  Yap_ArithError(EVALUATION_ERROR_ZERO_DIVISOR, t2, "X is " Int_FORMAT " rem 0", i1);
 	if (i1 == Int_MIN && i2 == -1) {
-#ifdef USE_GMP
-	  return Yap_gmp_add_ints(Int_MAX, 1);	  
-#else
-	  return Yap_ArithError(EVALUATION_ERROR_INT_OVERFLOW, t1,
-		    "rem/2 with %d and %d", i1, i2);
-#endif
+	  return MkIntTerm(0);
 	}
-	mod = i1%i2;
 	RINT(i1%i2);
      }
    case (CELL)double_e:
-      return Yap_ArithError(TYPE_ERROR_INTEGER, t2, "mod/2");
+      Yap_ArithError(TYPE_ERROR_INTEGER, t2, "rem/2");
    case (CELL)big_int_e:
 #ifdef USE_GMP
      return Yap_gmp_rem_int_big(IntegerOfTerm(t1), t2);
@ -203,19 +292,19 @@ p_rem(Term t1, Term t2) {
    }
    break;
  case (CELL)double_e:
-    return Yap_ArithError(TYPE_ERROR_INTEGER, t1, "mod/2");
+    Yap_ArithError(TYPE_ERROR_INTEGER, t1, "rem/2");
  case (CELL)big_int_e:
 #ifdef USE_GMP
    switch (ETypeOfTerm(t2)) {
    case long_int_e:
      if (IntegerOfTerm(t2) == 0)
-	return Yap_ArithError(EVALUATION_ERROR_ZERO_DIVISOR, t2, "X is ... rem 0");
+	Yap_ArithError(EVALUATION_ERROR_ZERO_DIVISOR, t2, "X is ... rem 0");
      return Yap_gmp_rem_big_int(t1, IntegerOfTerm(t2));
    case (CELL)big_int_e:
      /* two bignums */
      return Yap_gmp_rem_big_big(t1, t2);
    case double_e:
-      return Yap_ArithError(TYPE_ERROR_INTEGER, t2, "mod/2");
+      Yap_ArithError(TYPE_ERROR_INTEGER, t2, "rem/2");
    default:
      RERROR();
    }
@ -227,11 +316,11 @@ p_rem(Term t1, Term t2) {


 static Term
-p_rdiv(Term t1, Term t2) {
+p_rdiv(Term t1, Term t2 USES_REGS) {
 #ifdef USE_GMP
  switch (ETypeOfTerm(t1)) {
  case (CELL)double_e:
-    return Yap_ArithError(TYPE_ERROR_INTEGER, t2, "rdiv/2");
+    Yap_ArithError(TYPE_ERROR_INTEGER, t2, "rdiv/2");
  case (CELL)long_int_e:
    switch (ETypeOfTerm(t2)) {
    case (CELL)long_int_e:
@ -241,7 +330,7 @@ p_rdiv(Term t1, Term t2) {
 	Int i2 = IntegerOfTerm(t2);

 	if (i2 == 0)
-	  return Yap_ArithError(EVALUATION_ERROR_ZERO_DIVISOR, t2, "X is " Int_FORMAT " rdiv 0", i1);
+	  Yap_ArithError(EVALUATION_ERROR_ZERO_DIVISOR, t2, "X is " Int_FORMAT " rdiv 0", i1);
 	return Yap_gmq_rdiv_int_int(i1, i2);
      }
    case (CELL)big_int_e:
@ -255,13 +344,13 @@ p_rdiv(Term t1, Term t2) {
    switch (ETypeOfTerm(t2)) {
    case long_int_e:
      if (IntegerOfTerm(t2) == 0)
-	return Yap_ArithError(EVALUATION_ERROR_ZERO_DIVISOR, t2, "X is ... rdiv  0");
+	Yap_ArithError(EVALUATION_ERROR_ZERO_DIVISOR, t2, "X is ... rdiv  0");
      /* I know the term is much larger, so: */
      return Yap_gmq_rdiv_big_int(t1, IntegerOfTerm(t2));
    case (CELL)big_int_e:
      return Yap_gmq_rdiv_big_big(t1, t2);
    case double_e:
-      return Yap_ArithError(TYPE_ERROR_INTEGER, t2, "mod/2");
+      Yap_ArithError(TYPE_ERROR_INTEGER, t2, "rdiv/2");
    default:
      RERROR();
    }
@ -278,7 +367,7 @@ p_rdiv(Term t1, Term t2) {
  Floating point division: /
 */
 static Term
-p_fdiv(Term t1, Term t2)
+p_fdiv(Term t1, Term t2 USES_REGS)
 {
  switch (ETypeOfTerm(t1)) {
  case long_int_e:
@ -350,17 +439,17 @@ p_fdiv(Term t1, Term t2)
  xor #
 */
 static Term
-p_xor(Term t1, Term t2)
+p_xor(Term t1, Term t2 USES_REGS)
 {
  switch (ETypeOfTerm(t1)) {
  case long_int_e:
-    
+
    switch (ETypeOfTerm(t2)) {
    case long_int_e:
      /* two integers */
      RINT(IntegerOfTerm(t1) ^ IntegerOfTerm(t2));
    case double_e:
-      return Yap_ArithError(TYPE_ERROR_INTEGER, t2, "#/2");
+      Yap_ArithError(TYPE_ERROR_INTEGER, t2, "#/2");
    case big_int_e:
 #ifdef USE_GMP
      return Yap_gmp_xor_int_big(IntegerOfTerm(t1), t2);
@ -370,7 +459,7 @@ p_xor(Term t1, Term t2)
    }
    break;
  case double_e:
-    return Yap_ArithError(TYPE_ERROR_INTEGER, t1, "#/2");
+    Yap_ArithError(TYPE_ERROR_INTEGER, t1, "#/2");
  case big_int_e:
 #ifdef USE_GMP
    switch (ETypeOfTerm(t2)) {
@ -379,7 +468,7 @@ p_xor(Term t1, Term t2)
    case big_int_e:
      return Yap_gmp_xor_big_big(t1, t2);
    case double_e:
-      return Yap_ArithError(TYPE_ERROR_INTEGER, t2, "#/2");
+      Yap_ArithError(TYPE_ERROR_INTEGER, t2, "#/2");
    default:
      RERROR();
    }
@ -394,7 +483,7 @@ p_xor(Term t1, Term t2)
  atan2: arc tangent x/y
 */
 static Term
-p_atan2(Term t1, Term t2)
+p_atan2(Term t1, Term t2 USES_REGS)
 {
  switch (ETypeOfTerm(t1)) {
  case long_int_e:
@ -473,7 +562,7 @@ p_atan2(Term t1, Term t2)
  power: x^y
 */
 static Term
-p_power(Term t1, Term t2)
+p_power(Term t1, Term t2 USES_REGS)
 {
  switch (ETypeOfTerm(t1)) {
  case long_int_e:
@ -554,7 +643,7 @@ p_power(Term t1, Term t2)
 }

 /* next function is adapted from:
-   Inline C++ integer exponentiation routines 
+   Inline C++ integer exponentiation routines
   Version 1.01
   Copyright (C) 1999-2004 John C. Bowman <bowman@math.ualberta.ca>
 */
@ -565,9 +654,9 @@ ipow(Int x, Int p)

  if (p == 0) return ((CELL)1);
  if (x == 0 && p > 0) return 0L;
-  if(p < 0) 
+  if(p < 0)
    return (-p % 2) ? x : ((CELL)1);
-	
+
  r = ((CELL)1);
  for(;;) {
    if(p & 1) {
@ -589,7 +678,7 @@ ipow(Int x, Int p)
  power: x^y
 */
 static Term
-p_exp(Term t1, Term t2)
+p_exp(Term t1, Term t2 USES_REGS)
 {
  switch (ETypeOfTerm(t1)) {
  case long_int_e:
@ -598,12 +687,13 @@ p_exp(Term t1, Term t2)
      {
 	Int i1 = IntegerOfTerm(t1);
 	Int i2 = IntegerOfTerm(t2);
-	Int pow = ipow(i1,i2);
+	Int pow;

 	if (i2 < 0) {
-	  return Yap_ArithError(DOMAIN_ERROR_NOT_LESS_THAN_ZERO, t2,
+	  Yap_ArithError(DOMAIN_ERROR_NOT_LESS_THAN_ZERO, t2,
 		    "%d ^ %d", i1, i2);
 	}
+    pow = ipow(i1,i2);
 #ifdef USE_GMP
 	/* two integers */
 	if ((i1 && !pow)) {
@ -681,7 +771,7 @@ p_exp(Term t1, Term t2)
 }

 static Int
-gcd(Int m11,Int m21)
+gcd(Int m11,Int m21 USES_REGS)
 {
  /* Blankinship algorithm, provided by Miguel Filgueiras */
  Int m12=1, m22=0, k;
@ -731,7 +821,7 @@ Int gcdmult(Int m11,Int m21,Int *pm11)	/* *pm11 gets multiplier of m11 */
  module gcd
 */
 static Term
-p_gcd(Term t1, Term t2)
+p_gcd(Term t1, Term t2 USES_REGS)
 {
  switch (ETypeOfTerm(t1)) {
  case long_int_e:
@ -743,10 +833,10 @@ p_gcd(Term t1, Term t2)
 	i1 = (i1 >= 0 ? i1 : -i1);
 	i2 = (i2 >= 0 ? i2 : -i2);

-	RINT(gcd(i1,i2));
+	RINT(gcd(i1,i2 PASS_REGS));
      }
    case double_e:
-      return Yap_ArithError(TYPE_ERROR_INTEGER, t2, "gcd/2");
+      Yap_ArithError(TYPE_ERROR_INTEGER, t2, "gcd/2");
    case big_int_e:
 #ifdef USE_GMP
      return Yap_gmp_gcd_int_big(IntegerOfTerm(t1), t2);
@ -756,7 +846,7 @@ p_gcd(Term t1, Term t2)
    }
    break;
  case double_e:
-    return Yap_ArithError(TYPE_ERROR_INTEGER, t1, "gcd/2");
+    Yap_ArithError(TYPE_ERROR_INTEGER, t1, "gcd/2");
  case big_int_e:
 #ifdef USE_GMP
    switch (ETypeOfTerm(t2)) {
@ -765,7 +855,7 @@ p_gcd(Term t1, Term t2)
    case big_int_e:
      return Yap_gmp_gcd_big_big(t1, t2);
    case double_e:
-      return Yap_ArithError(TYPE_ERROR_INTEGER, t2, "gcd/2");
+      Yap_ArithError(TYPE_ERROR_INTEGER, t2, "gcd/2");
    default:
      RERROR();
    }
@ -969,56 +1059,57 @@ p_max(Term t1, Term t2)
 }

 static Term
-eval2(Int fi, Term t1, Term t2) {
+eval2(Int fi, Term t1, Term t2 USES_REGS) {
  arith2_op f = fi;
  switch (f) {
  case op_plus:
-    return p_plus(t1, t2);
+    return p_plus(t1, t2 PASS_REGS);
  case op_minus:
-    return p_minus(t1, t2);
+    return p_minus(t1, t2 PASS_REGS);
  case op_times:
-    return p_times(t1, t2);
+    return p_times(t1, t2 PASS_REGS);
  case op_div:
-    return p_div(t1, t2);
+    return p_div(t1, t2 PASS_REGS);
  case op_idiv:
-    return p_div2(t1, t2);
+    return p_div2(t1, t2 PASS_REGS);
  case op_and:
-    return p_and(t1, t2);
+    return p_and(t1, t2 PASS_REGS);
  case op_or:
-    return p_or(t1, t2);
+    return p_or(t1, t2 PASS_REGS);
  case op_sll:
-    return p_sll(t1, t2);
+    return p_sll(t1, t2 PASS_REGS);
  case op_slr:
-    return p_slr(t1, t2);
+    return p_slr(t1, t2 PASS_REGS);
  case op_mod:
-    return p_mod(t1, t2);
+    return p_mod(t1, t2 PASS_REGS);
  case op_rem:
-    return p_rem(t1, t2);
+    return p_rem(t1, t2 PASS_REGS);
  case op_fdiv:
-    return p_fdiv(t1, t2);
+    return p_fdiv(t1, t2 PASS_REGS);
  case op_xor:
-    return p_xor(t1, t2);
+    return p_xor(t1, t2 PASS_REGS);
  case op_atan2:
-    return p_atan2(t1, t2);
+    return p_atan2(t1, t2 PASS_REGS);
  case op_power:
-    return p_exp(t1, t2);
+    return p_exp(t1, t2 PASS_REGS);
  case op_power2:
-    return p_power(t1, t2);
+    return p_power(t1, t2 PASS_REGS);
  case op_gcd:
-    return p_gcd(t1, t2);
+    return p_gcd(t1, t2 PASS_REGS);
  case op_min:
    return p_min(t1, t2);
  case op_max:
    return p_max(t1, t2);
  case op_rdiv:
-    return p_rdiv(t1, t2);
+    return p_rdiv(t1, t2 PASS_REGS);
  }
  RERROR();
 }

 Term Yap_eval_binary(Int f, Term t1, Term t2)
 {
-  return eval2(f,t1,t2);
+  CACHE_REGS
+  return eval2(f,t1,t2 PASS_REGS);
 }

 static InitBinEntry InitBinTab[] = {
@ -1051,132 +1142,131 @@ static InitBinEntry InitBinTab[] = {
  {"rdiv", op_rdiv}
 };

-static Int 
+static Int
 p_binary_is( USES_REGS1 )
 {				/* X is Y	 */
  Term t = Deref(ARG2);
-  Term t1, t2;
+  Term t1, t2, tout;

  if (IsVarTerm(t)) {
-    Yap_ArithError(INSTANTIATION_ERROR,t, "X is Y");
+    Yap_ArithError(INSTANTIATION_ERROR,t, "VAR(X , Y)");
    return(FALSE);
  }
-  t1 = Yap_Eval(Deref(ARG3));
-  if (!Yap_FoundArithError(t1, ARG3)) {
-    return FALSE;
-  }
+          Yap_ClearExs();
+    t1 = Yap_Eval(Deref(ARG3));
  t2 = Yap_Eval(Deref(ARG4));
-  if (!Yap_FoundArithError(t2, ARG4)) {
-    return FALSE;
-  }
  if (IsIntTerm(t)) {
-    Term tout = Yap_FoundArithError(eval2(IntOfTerm(t), t1, t2), 0L);
-    if (!tout)
-      return FALSE;
+    Int i = IntOfTerm(t);
+    bool go;
+    do {
+      go = false;
+	  tout = eval2(i, t1, t2 PASS_REGS);
+      go = Yap_CheckArithError();
+    }  while (go);
    return Yap_unify_constant(ARG1,tout);
  }
  if (IsAtomTerm(t)) {
    Atom name = AtomOfTerm(t);
    ExpEntry *p;
-    Term out;
-
+    bool go;
+    int j;
    if (EndOfPAEntr(p = RepExpProp(Yap_GetExpProp(name, 2)))) {
-      Term ti[2];
-
-      /* error */
-      ti[0] = t;
-      ti[1] = MkIntTerm(1);
-      t = Yap_MkApplTerm(FunctorSlash, 2, ti);
-      Yap_Error(TYPE_ERROR_EVALUABLE, t,
-		"functor %s/%d for arithmetic expression",
-		RepAtom(name)->StrOfAE,2);
-      P = FAILCODE;
-      return(FALSE);
+      Yap_EvalError(TYPE_ERROR_EVALUABLE, t, "`%s ", name->StrOfAE
+			   );
    }
-    if (!(out=Yap_FoundArithError(eval2(p->FOfEE, t1, t2), 0L)))
-      return FALSE;
-    return Yap_unify_constant(ARG1,out);
+    j = p->FOfEE;
+
+    do {
+      go = false;
+          Yap_ClearExs();
+	  tout = eval2(j, t1, t2 PASS_REGS);
+      go = Yap_CheckArithError();
+    }  while (go);
+    return Yap_unify_constant(ARG1,tout);
  }
  return FALSE;
 }

-static Int 
+
+
+static Int
 do_arith23(arith2_op op USES_REGS)
 {				/* X is Y	 */
  Term t = Deref(ARG1);
-  Int out;
-  Term t1, t2;
+  bool go;
+  Term t1, t2, out;

  if (IsVarTerm(t)) {
-    Yap_ArithError(INSTANTIATION_ERROR,t, "X is Y");
+    Yap_EvalError(INSTANTIATION_ERROR,t, "X is Y");
    return(FALSE);
  }
-  t1 = Yap_Eval(t);
-  if (t1 == 0L)
-    return FALSE;
+    do {
+      go = false;
+  Yap_ClearExs();
+      t1 = Yap_Eval(t);
  t2 = Yap_Eval(Deref(ARG2));
-  if (t2 == 0L)
-    return FALSE;
-  if (!(out=Yap_FoundArithError(eval2(op, t1, t2), 0L)))
-    return FALSE;
+  out= eval2(op, t1, t2 PASS_REGS);
+
+    go = Yap_CheckArithError();
+  } while (go);
  return Yap_unify_constant(ARG3,out);
 }

-static Int 
+static Int
 export_p_plus( USES_REGS1 )
 {				/* X is Y	 */
  return do_arith23(op_plus PASS_REGS);
 }

-static Int 
+static Int
 export_p_minus( USES_REGS1 )
 {				/* X is Y	 */
  return do_arith23(op_minus PASS_REGS);
 }

-static Int 
+static Int
 export_p_times( USES_REGS1 )
 {				/* X is Y	 */
  return do_arith23(op_times PASS_REGS);
 }

-static Int 
+static Int
 export_p_div( USES_REGS1 )
 {				/* X is Y	 */
  return do_arith23(op_div PASS_REGS);
 }

-static Int 
+static Int
 export_p_and( USES_REGS1 )
 {				/* X is Y	 */
  return do_arith23(op_and PASS_REGS);
 }

-static Int 
+static Int
 export_p_or( USES_REGS1 )
 {				/* X is Y	 */
  return do_arith23(op_or PASS_REGS);
 }

-static Int 
+static Int
 export_p_slr( USES_REGS1 )
 {				/* X is Y	 */
  return do_arith23(op_slr PASS_REGS);
 }

-static Int 
+static Int
 export_p_sll( USES_REGS1 )
 {				/* X is Y	 */
  return do_arith23(op_sll PASS_REGS);
 }

-static Int 
+static Int
 p_binary_op_as_integer( USES_REGS1 )
 {				/* X is Y	 */
  Term t = Deref(ARG1);

  if (IsVarTerm(t)) {
-    Yap_Error(INSTANTIATION_ERROR,t, "X is Y");
+    Yap_EvalError(INSTANTIATION_ERROR,t, "X is Y");
    return(FALSE);
  }
  if (IsIntTerm(t)) {
@ -1185,7 +1275,6 @@ p_binary_op_as_integer( USES_REGS1 )
  if (IsAtomTerm(t)) {
    Atom name = AtomOfTerm(t);
    ExpEntry *p;
-
    if (EndOfPAEntr(p = RepExpProp(Yap_GetExpProp(name, 2)))) {
      return Yap_unify(ARG1,ARG2);
    }
@ -1194,6 +1283,12 @@ p_binary_op_as_integer( USES_REGS1 )
  return(FALSE);
 }

+Atom
+Yap_NameOfBinaryOp(int i)
+{
+  return Yap_LookupAtom(InitBinTab[i].OpName);
+}
+

 void
 Yap_InitBinaryExps(void)
@ -1204,7 +1299,7 @@ Yap_InitBinaryExps(void)
  for (i = 0; i < sizeof(InitBinTab)/sizeof(InitBinEntry); ++i) {
    AtomEntry *ae = RepAtom(Yap_LookupAtom(InitBinTab[i].OpName));
    if (ae == NULL) {
-      Yap_Error(OUT_OF_HEAP_ERROR,TermNil,"at InitBinaryExps");
+      Yap_EvalError(RESOURCE_ERROR_HEAP,TermNil,"at InitBinaryExps");
      return;
    }
    WRITE_LOCK(ae->ARWLock);
@ -1238,4 +1333,3 @@ Yap_ReInitBinaryExps(void)
 {
  return(TRUE);
 }
-
--- a/C/arrays.c
+++ b/C/arrays.c
--- a/C/atomic.c
+++ b/C/atomic.c
--- a/C/attvar.c
+++ b/C/attvar.c
--- a/C/bb.c
+++ b/C/bb.c
@ -18,6 +18,37 @@
 static char     SccsId[] = "%W% %G%";
 #endif

+/**
+ * @file   bb.c
+ * @author VITOR SANTOS COSTA <vsc@VITORs-MBP-2.lan>
+ * @date   Mon Apr 30 09:32:54 2018
+ * 
+ * @brief  blackboard
+ * 
+ * @namespace prolog
+ * 
+ */
+
+
+/** @defgroup BlackBoard The Blackboard
+@ingroup builtins
+@{
+
+YAP implements a blackboard in the style of the SICStus Prolog
+blackboard. The blackboard uses the same underlying mechanism as the
+internal data-base but has several important differences:
+
+ It is module aware, in contrast to the internal data-base.
+ Keys can only be atoms or integers, and not compound terms.
+ A single term can be stored per key.
+ An atomic update operation is provided; this is useful for
+parallelism.
+
+
+
+ 
+*/
+
 #include "Yap.h"
 #include "clause.h"
 #ifndef NULL
@ -40,7 +71,7 @@ PutBBProp(AtomEntry *ae, Term mod USES_REGS)		/* get BBentry for at; */
    p = (BBProp)Yap_AllocAtomSpace(sizeof(*p));
    if (p == NULL) {
      WRITE_UNLOCK(ae->ARWLock);
-      Yap_Error(OUT_OF_HEAP_ERROR,ARG1,"could not allocate space in bb_put/2");
+      Yap_Error(RESOURCE_ERROR_HEAP,ARG1,"could not allocate space in bb_put/2");
      return(NULL);
    }
    AddPropToAtom(ae, (PropEntry *)p);
@ -71,7 +102,7 @@ PutIntBBProp(Int key, Term mod USES_REGS)	/* get BBentry for at; */
 	pp++;
      }
    } else {
-      Yap_Error(OUT_OF_HEAP_ERROR,ARG1,"could not allocate space in bb_put/2");
+      Yap_Error(RESOURCE_ERROR_HEAP,ARG1,"could not allocate space in bb_put/2");
      return(NULL);
    }
  }
@ -88,7 +119,7 @@ PutIntBBProp(Int key, Term mod USES_REGS)	/* get BBentry for at; */
    p = (BBProp)Yap_AllocAtomSpace(sizeof(*p));
    if (p == NULL) {
      YAPLeaveCriticalSection();
-      Yap_Error(OUT_OF_HEAP_ERROR,ARG1,"could not allocate space in bb_put/2");
+      Yap_Error(RESOURCE_ERROR_HEAP,ARG1,"could not allocate space in bb_put/2");
      return(NULL);
    }
    p->ModuleOfBB = mod;
@ -159,7 +190,7 @@ resize_bb_int_keys(UInt new_size) {
  new = (Prop *)Yap_AllocCodeSpace(sizeof(Prop)*new_size);
  if (new == NULL) {
    YAPLeaveCriticalSection();
-    Yap_Error(OUT_OF_HEAP_ERROR,ARG1,"could not allocate space");
+    Yap_Error(RESOURCE_ERROR_HEAP,ARG1,"could not allocate space");
    return(FALSE);
  }
  for (i = 0; i < new_size; i++) {
@ -263,6 +294,14 @@ BBPut(Term t0, Term t2)
  }
 }

+/** @pred  bb_put(+ _Key_,? _Term_) 
+
+
+Store term table  _Term_ in the blackboard under key  _Key_. If a
+previous term was stored under key  _Key_ it is simply forgotten.
+
+ 
+*/
 static Int
 p_bb_put( USES_REGS1 )
 {
@ -294,6 +333,14 @@ BBGet(Term t, UInt arity USES_REGS)
  }
 }

+/** @pred  bb_get(+ _Key_,? _Term_) 
+
+
+Unify  _Term_ with a term stored in the blackboard under key
+ _Key_, or fail silently if no such term exists.
+
+ 
+*/
 static Int
 p_bb_get( USES_REGS1 )
 {
@ -313,6 +360,14 @@ p_bb_get( USES_REGS1 )
  return Yap_unify(ARG2,out);
 }

+/** @pred  bb_delete(+ _Key_,? _Term_) 
+
+
+Delete any term stored in the blackboard under key  _Key_ and unify
+it with  _Term_. Fail silently if no such term exists.
+
+ 
+*/
 static Int
 p_bb_delete( USES_REGS1 )
 {
@ -333,6 +388,14 @@ p_bb_delete( USES_REGS1 )
  return Yap_unify(ARG2,out);
 }

+/** @pred  bb_update( +_Key_, ?_Term_, ?_New_) 
+
+
+Atomically  unify a term stored in the blackboard under key  _Key_
+with  _Term_, and if the unification succeeds replace it by
+ _New_. Fail silently if no such term exists or if unification fails.
+
+ */
 static Int
 p_bb_update( USES_REGS1 )
 {
@ -375,6 +438,9 @@ Yap_InitBBPreds(void)
  Yap_InitCPred("bb_get", 2, p_bb_get, 0);
  Yap_InitCPred("bb_delete", 2, p_bb_delete, 0);
  Yap_InitCPred("bb_update", 3, p_bb_update, 0);
-  Yap_InitCPred("$resize_bb_int_keys", 1, p_resize_bb_int_keys, SafePredFlag|SyncPredFlag|HiddenPredFlag);
+  Yap_InitCPred("$resize_bb_int_keys", 1, p_resize_bb_int_keys, SafePredFlag|SyncPredFlag);
 }

+/**
+ @}
+*/
--- a/C/bignum.c
+++ b/C/bignum.c
@ -1,22 +1,33 @@
 /*************************************************************************
-*									 *
-*	 YAP Prolog 							 *
-*									 *
-*	Yap Prolog was developed at NCCUP - Universidade do Porto	 *
-*									 *
-* Copyright L.Damas, V.S.Costa and Universidade do Porto 1985-1997	 *
-*									 *
-**************************************************************************
-*									 *
-* File:		arith1.c						 *
-* Last rev:								 *
-* mods:									 *
-* comments:	bignum support through gmp				 *
-*									 *
-*************************************************************************/
+ *									 *
+ *	 YAP Prolog 							 *
+ *									 *
+ *	Yap Prolog was developed at NCCUP - Universidade do Porto	 *
+ *									 *
+ * Copyright L.Damas, V.S.Costa and Universidade do Porto 1985-1997	 *
+ *									 *
+ **************************************************************************
+ *									 *
+ * File:		arith1.c *
+ * Last rev:								 *
+ * mods: *
+ * comments:	bignum support through gmp				 *
+ *									 *
+ *************************************************************************/
 #ifdef SCCS
-static char     SccsId[] = "%W% %G%";
+static char SccsId[] = "%W% %G%";
 #endif
+/**
+ * @file   bignum.c
+ * @author VITOR SANTOS COSTA <vsc@VITORs-MBP-2.lan>
+ * @date   Mon Apr 30 09:34:59 2018
+ * 
+ * @brief  BigNums and More
+ * @namespace prolog
+ * 
+ * 
+ * 
+ */

 #include "Yap.h"
 #include "Yatom.h"
@ -26,284 +37,397 @@ static char     SccsId[] = "%W% %G%";
 #endif

 #include "YapHeap.h"
+#include "YapText.h"

 #ifdef USE_GMP

-#include "eval.h"
+#include "YapEval.h"
 #include "alloc.h"

-Term
-Yap_MkBigIntTerm(MP_INT *big)
-{
+Term Yap_MkBigIntTerm(MP_INT *big) {
  CACHE_REGS
  Int nlimbs;
-  MP_INT *dst = (MP_INT *)(H+2);
-  CELL *ret = H;
+  MP_INT *dst = (MP_INT *)(HR + 2);
+  CELL *ret = HR;
+  Int bytes;

  if (mpz_fits_slong_p(big)) {
    long int out = mpz_get_si(big);
    return MkIntegerTerm((Int)out);
  }
-  nlimbs = (big->_mp_alloc)*(sizeof(mp_limb_t)/CellSize);
-  if (nlimbs > (ASP-ret)-1024) {
+  //  bytes = big->_mp_alloc * sizeof(mp_limb_t);
+  //  nlimbs = ALIGN_YAPTYPE(bytes,CELL)/CellSize;
+  // this works, but it shouldn't need to do this...
+  nlimbs = big->_mp_alloc;
+  bytes = nlimbs * sizeof(CELL);
+  if (nlimbs > (ASP - ret) - 1024) {
    return TermNil;
  }
-  H[0] = (CELL)FunctorBigInt;
-  H[1] = BIG_INT;
+  HR[0] = (CELL)FunctorBigInt;
+  HR[1] = BIG_INT;

  dst->_mp_size = big->_mp_size;
-  dst->_mp_alloc = big->_mp_alloc;
-  memmove((void *)(dst+1), (const void *)(big->_mp_d), nlimbs*CellSize);
-  H = (CELL *)(dst+1)+nlimbs;
-  H[0] = EndSpecials;
-  H++;
+  dst->_mp_alloc = nlimbs * (CellSize / sizeof(mp_limb_t));
+  memmove((void *)(dst + 1), (const void *)(big->_mp_d), bytes);
+  HR = (CELL *)(dst + 1) + nlimbs;
+  HR[0] = EndSpecials;
+  HR++;
  return AbsAppl(ret);
 }

+MP_INT *Yap_BigIntOfTerm(Term t) {
+  MP_INT *new = (MP_INT *)(RepAppl(t) + 2);

-MP_INT *
-Yap_BigIntOfTerm(Term t)
-{
-  MP_INT *new = (MP_INT *)(RepAppl(t)+2);
-
-  new->_mp_d = (mp_limb_t *)(new+1);
-  return(new);
+  new->_mp_d = (mp_limb_t *)(new + 1);
+  return (new);
 }

-Term
-Yap_MkBigRatTerm(MP_RAT *big)
-{
+Term Yap_MkBigRatTerm(MP_RAT *big) {
  CACHE_REGS
  Int nlimbs;
-  MP_INT *dst = (MP_INT *)(H+2);
+  MP_INT *dst = (MP_INT *)(HR + 2);
  MP_INT *num = mpq_numref(big);
  MP_INT *den = mpq_denref(big);
  MP_RAT *rat;
-  CELL *ret = H;
+  CELL *ret = HR;

  if (mpz_cmp_si(den, 1) == 0)
    return Yap_MkBigIntTerm(num);
-  if ((num->_mp_alloc+den->_mp_alloc)*(sizeof(mp_limb_t)/CellSize) > (ASP-ret)-1024) {
+  if ((num->_mp_alloc + den->_mp_alloc) * (sizeof(mp_limb_t) / CellSize) >
+      (ASP - ret) - 1024) {
    return TermNil;
  }
-  H[0] = (CELL)FunctorBigInt;
-  H[1] = BIG_RATIONAL;
+  HR[0] = (CELL)FunctorBigInt;
+  HR[1] = BIG_RATIONAL;
  dst->_mp_size = 0;
-  rat = (MP_RAT *)(dst+1);
+  rat = (MP_RAT *)(dst + 1);
  rat->_mp_num._mp_size = num->_mp_size;
  rat->_mp_num._mp_alloc = num->_mp_alloc;
-  nlimbs = (num->_mp_alloc)*(sizeof(mp_limb_t)/CellSize);
-  memmove((void *)(rat+1), (const void *)(num->_mp_d), nlimbs*CellSize);
+  nlimbs = (num->_mp_alloc) * (sizeof(mp_limb_t) / CellSize);
+  memmove((void *)(rat + 1), (const void *)(num->_mp_d), nlimbs * CellSize);
  rat->_mp_den._mp_size = den->_mp_size;
  rat->_mp_den._mp_alloc = den->_mp_alloc;
-  H = (CELL *)(rat+1)+nlimbs;
-  nlimbs = (den->_mp_alloc)*(sizeof(mp_limb_t)/CellSize);
-  memmove((void *)(H), (const void *)(den->_mp_d), nlimbs*CellSize);
-  H += nlimbs;
-  dst->_mp_alloc = (H-(CELL *)(dst+1));
-  H[0] = EndSpecials;
-  H++;
+  HR = (CELL *)(rat + 1) + nlimbs;
+  nlimbs = (den->_mp_alloc) * (sizeof(mp_limb_t) / CellSize);
+  memmove((void *)(HR), (const void *)(den->_mp_d), nlimbs * CellSize);
+  HR += nlimbs;
+  dst->_mp_alloc = (HR - (CELL *)(dst + 1));
+  HR[0] = EndSpecials;
+  HR++;
  return AbsAppl(ret);
 }

-MP_RAT *
-Yap_BigRatOfTerm(Term t)
-{
-  MP_RAT *new = (MP_RAT *)(RepAppl(t)+2+sizeof(MP_INT)/sizeof(CELL));
+MP_RAT *Yap_BigRatOfTerm(Term t) {
+  MP_RAT *new = (MP_RAT *)(RepAppl(t) + 2 + sizeof(MP_INT) / sizeof(CELL));
  mp_limb_t *nt;

-  nt = new->_mp_num._mp_d = (mp_limb_t *)(new+1);
+  nt = new->_mp_num._mp_d = (mp_limb_t *)(new + 1);
  nt += new->_mp_num._mp_alloc;
  new->_mp_den._mp_d = nt;
  return new;
 }

-Term 
-Yap_RatTermToApplTerm(Term t)
-{
+Term Yap_RatTermToApplTerm(Term t) {
  Term ts[2];
  MP_RAT *rat = Yap_BigRatOfTerm(t);

-  ts[0] =  Yap_MkBigIntTerm(mpq_numref(rat));
-  ts[1] =  Yap_MkBigIntTerm(mpq_denref(rat));
-  return Yap_MkApplTerm(FunctorRDiv,2,ts);
+  ts[0] = Yap_MkBigIntTerm(mpq_numref(rat));
+  ts[1] = Yap_MkBigIntTerm(mpq_denref(rat));
+  return Yap_MkApplTerm(FunctorRDiv, 2, ts);
 }

 #endif

-Term
-Yap_AllocExternalDataInStack(CELL tag, size_t bytes)
-{
+Term Yap_AllocExternalDataInStack(CELL tag, size_t bytes, void *pt) {
  CACHE_REGS
  Int nlimbs;
-  MP_INT *dst = (MP_INT *)(H+2);
-  CELL *ret = H;
-
-  nlimbs = ALIGN_YAPTYPE(bytes,CELL)/CellSize;
-  if (nlimbs > (ASP-ret)-1024) {
+  MP_INT *dst = (MP_INT *)(HR + 2);
+  CELL *ret = HR;
+ CELL **blobp;
+  
+  nlimbs = ALIGN_BY_TYPE(bytes, CELL) / CellSize;
+  if (nlimbs > (ASP - ret) - 1024) {
    return TermNil;
  }
-  H[0] = (CELL)FunctorBigInt;
-  H[1] = tag;
+  HR[0] = (CELL)FunctorBigInt;
+  HR[1] = tag;
  dst->_mp_size = 0;
  dst->_mp_alloc = nlimbs;
-  H = (CELL *)(dst+1)+nlimbs;
-  H[0] = EndSpecials;
-  H++;
-  if (tag != EXTERNAL_BLOB) {
-    TrailTerm(TR) = AbsPair(ret);
-    TR++;
-  }
+  HR = (CELL *)(dst + 1) + nlimbs;
+  HR[0] = EndSpecials;
+  HR++;
+  blobp = (CELL **)pt;
+  *blobp = (CELL *)(dst + 1);
  return AbsAppl(ret);
 }

-int Yap_CleanOpaqueVariable(CELL *pt)
-{
+int Yap_CleanOpaqueVariable(CELL d) {
  CELL blob_info, blob_tag;
-  MP_INT *blobp;
+
+  CELL *pt = RepAppl(HeadOfTerm(d));
 #ifdef DEBUG
  /* sanity checking */
  if (pt[0] != (CELL)FunctorBigInt) {
-    Yap_Error(SYSTEM_ERROR, TermNil, "CleanOpaqueVariable bad call");
+    Yap_Error(SYSTEM_ERROR_INTERNAL, TermNil, "CleanOpaqueVariable bad call");
    return FALSE;
  }
 #endif
  blob_tag = pt[1];
-  if (blob_tag < USER_BLOB_START ||
-      blob_tag >= USER_BLOB_END) {
-    Yap_Error(SYSTEM_ERROR, AbsAppl(pt), "clean opaque: bad blob with tag " UInt_FORMAT ,blob_tag);
+  if (blob_tag < USER_BLOB_START || blob_tag >= USER_BLOB_END) {
+    Yap_Error(SYSTEM_ERROR_INTERNAL, AbsAppl(pt),
+              "clean opaque: bad blob with tag " UInt_FORMAT, blob_tag);
    return FALSE;
  }
-  blob_info = blob_tag - USER_BLOB_START;
+  blob_info = blob_tag;
  if (!GLOBAL_OpaqueHandlers)
-    return FALSE;
-  blobp = (MP_INT *)(pt+2);
+    return false;
  if (!GLOBAL_OpaqueHandlers[blob_info].fail_handler)
-    return TRUE;
-  return (GLOBAL_OpaqueHandlers[blob_info].fail_handler)((void *)(blobp+1));
+    return true;
+  return (GLOBAL_OpaqueHandlers[blob_info].fail_handler)(d);
 }

-Opaque_CallOnWrite
-Yap_blob_write_handler_from_slot(Int slot)
-{
-  CACHE_REGS
+YAP_Opaque_CallOnWrite Yap_blob_write_handler(Term t) {
  CELL blob_info, blob_tag;
-  MP_INT *blobp;
-  Term t = Yap_GetFromSlot(slot PASS_REGS);
  CELL *pt = RepAppl(t);

 #ifdef DEBUG
  /* sanity checking */
  if (pt[0] != (CELL)FunctorBigInt) {
-    Yap_Error(SYSTEM_ERROR, TermNil, "CleanOpaqueVariable bad call");
+    Yap_Error(SYSTEM_ERROR_INTERNAL, TermNil, "CleanOpaqueVariable bad call");
    return FALSE;
  }
 #endif
  blob_tag = pt[1];
-  if (blob_tag < USER_BLOB_START ||
-      blob_tag >= USER_BLOB_END) {
-    Yap_Error(SYSTEM_ERROR, AbsAppl(pt), "clean opaque: bad blob with tag " UInt_FORMAT ,blob_tag);
+  if (blob_tag < USER_BLOB_START || blob_tag >= USER_BLOB_END) {
+    Yap_Error(SYSTEM_ERROR_INTERNAL, AbsAppl(pt),
+              "clean opaque: bad blob with tag " UInt_FORMAT, blob_tag);
    return FALSE;
  }
-  blob_info = blob_tag - USER_BLOB_START;
-  if (!GLOBAL_OpaqueHandlers)
+  blob_info = blob_tag;
+  if (!GLOBAL_OpaqueHandlers) {
    return NULL;
-  blobp = (MP_INT *)(pt+2);
+  }
  return GLOBAL_OpaqueHandlers[blob_info].write_handler;
 }

-extern Int Yap_blob_tag_from_slot(Int slot)
-{
-  CACHE_REGS
-  Term t = Yap_GetFromSlot(slot PASS_REGS);
+YAP_Opaque_CallOnGCMark Yap_blob_gc_mark_handler(Term t) {
+  CELL blob_info, blob_tag;
  CELL *pt = RepAppl(t);

 #ifdef DEBUG
  /* sanity checking */
  if (pt[0] != (CELL)FunctorBigInt) {
-    Yap_Error(SYSTEM_ERROR, TermNil, "CleanOpaqueVariable bad call");
+    Yap_Error(SYSTEM_ERROR_INTERNAL, TermNil, "CleanOpaqueVariable bad call");
+    return FALSE;
+  }
+#endif
+  blob_tag = pt[1];
+  if (blob_tag < USER_BLOB_START || blob_tag >= USER_BLOB_END) {
+    return NULL;
+  }
+  blob_info = blob_tag;
+  if (!GLOBAL_OpaqueHandlers)
+    return NULL;
+  return GLOBAL_OpaqueHandlers[blob_info].mark_handler;
+}
+
+YAP_Opaque_CallOnGCRelocate Yap_blob_gc_relocate_handler(Term t) {
+  CELL blob_info, blob_tag;
+  CELL *pt = RepAppl(t);
+
+#ifdef DEBUG
+  /* sanity checking */
+  if (pt[0] != (CELL)FunctorBigInt) {
+    Yap_Error(SYSTEM_ERROR_INTERNAL, TermNil, "CleanOpaqueVariable bad call");
+    return FALSE;
+  }
+#endif
+  blob_tag = pt[1];
+  if (blob_tag < USER_BLOB_START || blob_tag >= USER_BLOB_END) {
+    Yap_Error(SYSTEM_ERROR_INTERNAL, AbsAppl(pt),
+              "clean opaque: bad blob with tag " UInt_FORMAT, blob_tag);
+    return FALSE;
+  }
+  blob_info = blob_tag;
+  if (!GLOBAL_OpaqueHandlers)
+    return NULL;
+  return GLOBAL_OpaqueHandlers[blob_info].relocate_handler;
+}
+
+extern Int Yap_blob_tag(Term t) {
+  CELL *pt = RepAppl(t);
+
+#ifdef DEBUG
+  /* sanity checking */
+  if (pt[0] != (CELL)FunctorBigInt) {
+    Yap_Error(SYSTEM_ERROR_INTERNAL, TermNil, "CleanOpaqueVariable bad call");
    return FALSE;
  }
 #endif
  return pt[1];
 }

-void *
-Yap_blob_info_from_slot(Int slot)
-{
-  CACHE_REGS
-  CELL blob_info, blob_tag;
+void *Yap_blob_info(Term t) {
  MP_INT *blobp;
-  Term t = Yap_GetFromSlot(slot PASS_REGS);
  CELL *pt = RepAppl(t);

 #ifdef DEBUG
  /* sanity checking */
  if (pt[0] != (CELL)FunctorBigInt) {
-    Yap_Error(SYSTEM_ERROR, TermNil, "CleanOpaqueVariable bad call");
+    Yap_Error(SYSTEM_ERROR_INTERNAL, TermNil, "CleanOpaqueVariable bad call");
    return FALSE;
  }
 #endif
-  blob_tag = pt[1];
-  if (blob_tag < USER_BLOB_START ||
-      blob_tag >= USER_BLOB_END) {
-    Yap_Error(SYSTEM_ERROR, AbsAppl(pt), "clean opaque: bad blob with tag " UInt_FORMAT ,blob_tag);
-    return FALSE;
-  }
-  blob_info = blob_tag - USER_BLOB_START;
  if (!GLOBAL_OpaqueHandlers)
    return FALSE;
-  blobp = (MP_INT *)(pt+2);
-  return (void *)(blobp+1);
+  blobp = (MP_INT *)(pt + 2);
+  return (void *)(blobp + 1);
 }

-Term
-Yap_MkULLIntTerm(YAP_ULONG_LONG n)
-{
+Term Yap_MkULLIntTerm(YAP_ULONG_LONG n) {
 #if __GNUC__ && USE_GMP
-    mpz_t new;
-    char tmp[256];
-    Term t;
+  mpz_t new;
+  char tmp[256];
+  Term t;

 #ifdef _WIN32
-    snprintf(tmp,256,"%I64u",n);
+  snprintf(tmp, 256, "%I64u", n);
 #elif HAVE_SNPRINTF
-    snprintf(tmp,256,"%llu",n);
-#else    
-    sprintf(tmp,"%llu",n);
-#endif
-    /* try to scan it as a bignum */
-    mpz_init_set_str (new, tmp, 10);
-    if (mpz_fits_slong_p(new)) {
-      return MkIntegerTerm(mpz_get_si(new));
-    }
-    t = Yap_MkBigIntTerm(new);
-    mpz_clear(new);
-    return t;
+  snprintf(tmp, 256, "%llu", n);
 #else
-    return MkIntegerTerm(n);
+  sprintf(tmp, "%llu", n);
+#endif
+  /* try to scan it as a bignum */
+  mpz_init_set_str(new, tmp, 10);
+  if (mpz_fits_slong_p(new)) {
+    CACHE_REGS
+    return MkIntegerTerm(mpz_get_si(new));
+  }
+  t = Yap_MkBigIntTerm(new);
+  mpz_clear(new);
+  return t;
+#else
+  CACHE_REGS
+  return MkIntegerTerm(n);
 #endif
 }

-static Int 
-p_is_bignum( USES_REGS1 )
-{
+CELL *Yap_HeapStoreOpaqueTerm(Term t) {
+  CELL *ptr = RepAppl(t);
+  size_t sz;
+  void *new;
+
+  if (ptr[0] == (CELL)FunctorBigInt) {
+    sz = sizeof(MP_INT) + 2 * CellSize +
+         ((MP_INT *)(ptr + 2))->_mp_alloc * sizeof(mp_limb_t);
+  } else { /* string */
+    sz = sizeof(CELL) * (2 + ptr[1]);
+  }
+  new = Yap_AllocCodeSpace(sz);
+  if (!new) {
+    Yap_Error(RESOURCE_ERROR_HEAP, TermNil,
+              "subgoal_search_loop: no space for %s", StringOfTerm(t));
+  } else {
+    if (ptr[0] == (CELL)FunctorBigInt) {
+      MP_INT *new = (MP_INT *)(RepAppl(t) + 2);
+
+      new->_mp_d = (mp_limb_t *)(new + 1);
+    }
+    memmove(new, ptr, sz);
+  }
+  return new;
+}
+
+size_t Yap_OpaqueTermToString(Term t, char *str, size_t max) {
+  size_t str_index = 0;
+  CELL *li = RepAppl(t);
+  unsigned char *ptr = (unsigned char *)StringOfTerm(AbsAppl(li));
+  if (li[0] == (CELL)FunctorString) {
+    str_index += sprintf(&str[str_index], "\"");
+    do {
+      utf8proc_int32_t chr;
+      ptr += get_utf8(ptr, -1, &chr);
+      if (chr == '\0')
+        break;
+      str_index += sprintf(str + str_index, "%C", chr);
+    } while (TRUE);
+    str_index += sprintf(str + str_index, "\"");
+  } else {
+    CELL big_tag = li[1];
+
+    if (big_tag == ARRAY_INT || big_tag == ARRAY_FLOAT) {
+      str_index += sprintf(&str[str_index], "{...}");
+#ifdef USE_GMP
+    } else if (big_tag == BIG_INT) {
+      MP_INT *big = Yap_BigIntOfTerm(AbsAppl(li));
+      char *s = mpz_get_str(&str[str_index], 10, big);
+      str_index += strlen(&s[str_index]);
+    } else if (big_tag == BIG_RATIONAL) {
+      MP_RAT *big = Yap_BigRatOfTerm(AbsAppl(li));
+      char *s = mpq_get_str(&str[str_index], 10, big);
+      str_index += strlen(&s[str_index]);
+#endif
+    }
+    /*
+      else if (big_tag >= USER_BLOB_START && big_tag < USER_BLOB_END) {
+      Opaque_CallOnWrite f;
+      CELL blob_info;
+
+      blob_info = big_tag - USER_BLOB_START;
+      if (GLOBAL_OpaqueHandlers &&
+      (f= GLOBAL_OpaqueHandlers[blob_info].write_handler)) {
+      (f)(wglb->stream, big_tag, ExternalBlobFromTerm(t), 0);
+      return;
+      }
+      } */
+    str_index += sprintf(&str[str_index], "0");
+  }
+  return str_index;
+}
+
+static Int p_is_bignum(USES_REGS1) {
 #ifdef USE_GMP
  Term t = Deref(ARG1);
-  return(
-	 IsNonVarTerm(t) && 
-	 IsApplTerm(t) && 
-	 FunctorOfTerm(t) == FunctorBigInt &&
-	 RepAppl(t)[1] == BIG_INT
-	 );
+  return (IsNonVarTerm(t) && IsApplTerm(t) &&
+          FunctorOfTerm(t) == FunctorBigInt && RepAppl(t)[1] == BIG_INT);
 #else
  return FALSE;
 #endif
 }

-static Int 
-p_has_bignums( USES_REGS1 )
-{
+static Int p_is_string(USES_REGS1) {
+  Term t = Deref(ARG1);
+  return (IsNonVarTerm(t) && IsApplTerm(t) &&
+          FunctorOfTerm(t) == FunctorString);
+}
+
+static Int p_nb_set_bit(USES_REGS1) {
+#ifdef USE_GMP
+  Term t = Deref(ARG1);
+  Term ti = Deref(ARG2);
+  Int i;
+
+  if (!(IsNonVarTerm(t) && IsApplTerm(t) && FunctorOfTerm(t) == FunctorBigInt &&
+        RepAppl(t)[1] == BIG_INT))
+    return FALSE;
+  if (!IsIntegerTerm(ti)) {
+    return FALSE;
+  }
+  if (!IsIntegerTerm(ti)) {
+    return FALSE;
+  }
+  i = IntegerOfTerm(ti);
+  if (i < 0) {
+    return FALSE;
+  }
+  Yap_gmp_set_bit(i, t);
+  return TRUE;
+#else
+  return FALSE;
+#endif
+}
+
+static Int p_has_bignums(USES_REGS1) {
 #ifdef USE_GMP
  return TRUE;
 #else
@ -311,9 +435,27 @@ p_has_bignums( USES_REGS1 )
 #endif
 }

-static Int 
-p_is_rational( USES_REGS1 )
-{
+static Int p_is_opaque(USES_REGS1) {
+  Term t = Deref(ARG1);
+  if (IsVarTerm(t))
+    return FALSE;
+  if (IsApplTerm(t)) {
+    Functor f = FunctorOfTerm(t);
+    CELL *pt;
+
+    if (f != FunctorBigInt)
+      return FALSE;
+    pt = RepAppl(t);
+    return (pt[1] != BIG_RATIONAL || pt[1] != BIG_INT);
+  }
+  return FALSE;
+}
+
+  /** @pred  rational( ?:T )
+
+  Checks whether _T_ is a rational number.
+  */
+ static Int p_is_rational(USES_REGS1) {
  Term t = Deref(ARG1);
  if (IsVarTerm(t))
    return FALSE;
@ -328,14 +470,12 @@ p_is_rational( USES_REGS1 )
    if (f != FunctorBigInt)
      return FALSE;
    pt = RepAppl(t);
-    return (  pt[1] == BIG_RATIONAL || pt[1] == BIG_INT );
+    return (pt[1] == BIG_RATIONAL || pt[1] == BIG_INT);
  }
  return FALSE;
 }

-static Int 
-p_rational( USES_REGS1 )
-{
+static Int p_rational(USES_REGS1) {
 #ifdef USE_GMP
  Term t = Deref(ARG1);
  Functor f;
@ -355,164 +495,26 @@ p_rational( USES_REGS1 )
    return FALSE;
  rat = Yap_BigRatOfTerm(t);
  while ((t1 = Yap_MkBigIntTerm(mpq_numref(rat))) == TermNil ||
-	 (t2 = Yap_MkBigIntTerm(mpq_denref(rat))) == TermNil) {
-    UInt size =
-      (mpq_numref(rat)->_mp_alloc)*(sizeof(mp_limb_t)/CellSize) +
-      (mpq_denref(rat)->_mp_alloc)*(sizeof(mp_limb_t)/CellSize);
+         (t2 = Yap_MkBigIntTerm(mpq_denref(rat))) == TermNil) {
+    UInt size = (mpq_numref(rat)->_mp_alloc) * (sizeof(mp_limb_t) / CellSize) +
+                (mpq_denref(rat)->_mp_alloc) * (sizeof(mp_limb_t) / CellSize);
    if (!Yap_gcl(size, 3, ENV, P)) {
-      Yap_Error(OUT_OF_STACK_ERROR, t, LOCAL_ErrorMessage);
+      Yap_Error(RESOURCE_ERROR_STACK, t, LOCAL_ErrorMessage);
      return FALSE;
    }
  }
-  return 
-    Yap_unify(ARG2, t1) &&
-    Yap_unify(ARG3, t2);
+  return Yap_unify(ARG2, t1) && Yap_unify(ARG3, t2);
 #else
  return FALSE;
 #endif
 }

-int
-Yap_IsStringTerm(Term t)
-{
-  CELL fl;
-  if (IsVarTerm(t))
-    return FALSE;
-  if (!IsApplTerm(t))
-    return FALSE;
-  if (FunctorOfTerm(t) != FunctorBigInt)
-    return FALSE;
-
-  fl = RepAppl(t)[1];
-  return fl == BLOB_STRING || fl == BLOB_WIDE_STRING;
-}
-
-int
-Yap_IsWideStringTerm(Term t)
-{
-  CELL fl;
-  if (IsVarTerm(t))
-    return FALSE;
-  if (!IsApplTerm(t))
-    return FALSE;
-  if (FunctorOfTerm(t) != FunctorBigInt)
-    return FALSE;
-
-  fl = RepAppl(t)[1];
-  return fl == BLOB_WIDE_STRING;
-}
-
-Term
-Yap_MkBlobStringTerm(const char *s, size_t len)
-{
-  CACHE_REGS
-  CELL *ret = H;
-  size_t sz;
-  MP_INT *dst = (MP_INT *)(H+2);
-  blob_string_t *sp;
-  size_t siz;
-  char *dest;
-
-  sz = strlen(s);
-  if (len > 0 && sz > len) sz = len;
-  if (len/sizeof(CELL) > (ASP-ret)-1024) {
-    return TermNil;
-  }
-  H[0] = (CELL)FunctorBigInt;
-  H[1] = BLOB_STRING;
-  siz = ALIGN_YAPTYPE((len+1+sizeof(blob_string_t)),CELL);
-  dst->_mp_size = 0L;
-  dst->_mp_alloc = siz/sizeof(mp_limb_t);
-  sp = (blob_string_t *)(dst+1);
-  sp->len = sz;
-  dest = (char *)(sp+1);
-  strncpy(dest, s, sz);
-  dest[sz] = '\0';
-  H += (siz + 2*sizeof(CELL)+sizeof(MP_INT)+sizeof(Functor))/sizeof(CELL);
-  H[-1] = EndSpecials;
-  return AbsAppl(ret);
-}
-
-Term
-Yap_MkBlobWideStringTerm(const wchar_t *s, size_t len)
-{
-  CACHE_REGS
-  CELL *ret = H;
-  size_t sz;
-  MP_INT *dst = (MP_INT *)(H+2);
-  blob_string_t *sp = (blob_string_t *)(dst+1);
-  size_t siz, i = 0;
-
-  H[0] = (CELL)FunctorBigInt;
-  dst->_mp_size = 0L;
-  sz = wcslen(s);
-  if (len > 0 && sz > len) {
-    sz = len;
-  }
-  if ((len/sizeof(CELL)) > (ASP-ret)-1024) {
-    return TermNil;
-  }
-  while (i < sz) {
-    if (s[i++] >= 255) break;
-  }
-  if (i == sz) {
-    /* we have a standard ascii string */
-    char *target;
-    size_t i = 0;
-
-    H[1] = BLOB_STRING;
-    siz = ALIGN_YAPTYPE((sz+1+sizeof(blob_string_t)),CELL);
-    dst->_mp_alloc = siz/sizeof(mp_limb_t);
-    sp->len = sz;
-    target = (char *)(sp+1);
-    for (i = 0 ; i < sz; i++) {
-      target[i] = s[i];
-    }
-    target[sz] = '\0';
-    H += (siz+2*sizeof(CELL)+sizeof(MP_INT)+sizeof(Functor))/sizeof(CELL);
-  } else {
-    wchar_t * target;
-
-    H[1] = BLOB_WIDE_STRING;
-    siz = ALIGN_YAPTYPE((sz+1)*sizeof(wchar_t)+sizeof(blob_string_t),CELL);
-    dst->_mp_alloc = siz/sizeof(mp_limb_t);
-    sp->len = sz;
-    target = (wchar_t *)(sp+1); 
-    wcsncpy(target, s, sz);
-    target[sz] = '\0';
-    H += (siz + 2*sizeof(CELL)+sizeof(MP_INT)+sizeof(Functor))/sizeof(CELL);
-  }
-  H[-1] = EndSpecials;
-  return AbsAppl(ret);
-}
-
-char *
-Yap_BlobStringOfTerm(Term t)
-{
-  blob_string_t *new = (blob_string_t *)(RepAppl(t)+2+sizeof(MP_INT)/sizeof(CELL));
-  return (char *)(new+1);
-}
-
-wchar_t *
-Yap_BlobWideStringOfTerm(Term t)
-{
-  blob_string_t *new = (blob_string_t *)(RepAppl(t)+2+sizeof(MP_INT)/sizeof(CELL));
-  return (wchar_t *)(new+1);
-}
-
-char *
-Yap_BlobStringOfTermAndLength(Term t, size_t *sp)
-{
-  blob_string_t *new = (blob_string_t *)(RepAppl(t)+2+sizeof(MP_INT)/sizeof(CELL));
-  *sp = new->len;
-  return (char *)(new+1);
-}
-
-void
-Yap_InitBigNums(void)
-{
-  Yap_InitCPred("$has_bignums", 0, p_has_bignums, SafePredFlag|HiddenPredFlag);
-  Yap_InitCPred("$bignum", 1, p_is_bignum, SafePredFlag|HiddenPredFlag);
+void Yap_InitBigNums(void) {
+  Yap_InitCPred("$has_bignums", 0, p_has_bignums, SafePredFlag);
+  Yap_InitCPred("$bignum", 1, p_is_bignum, SafePredFlag);
  Yap_InitCPred("rational", 3, p_rational, 0);
  Yap_InitCPred("rational", 1, p_is_rational, SafePredFlag);
+  Yap_InitCPred("string", 1, p_is_string, SafePredFlag);
+  Yap_InitCPred("opaque", 1, p_is_opaque, SafePredFlag);
+  Yap_InitCPred("nb_set_bit", 2, p_nb_set_bit, SafePredFlag);
 }
--- a/C/blobs.c
+++ b/C/blobs.c
@ -0,0 +1,247 @@
+//
+//  blobs.c
+//  yap
+//
+//  Created by VITOR SANTOS COSTA on 09/05/15.
+//  Copyright (c) 2015 VITOR SANTOS COSTA. All rights reserved.
+//
+
+#include <stdio.h>
+#include <string.h>
+
+#include "Yap.h"
+#include "Yatom.h"
+#include "iopreds.h"
+#include "yapio.h"
+
+/* for freeBSD9.1 */
+#define _WITH_DPRINTF
+
+#include "YapBlobs.h"
+
+static blob_type_t unregistered_blob_atom = {
+    YAP_BLOB_MAGIC_B, PL_BLOB_NOCOPY | PL_BLOB_TEXT, "unregistered"};
+
+char *Yap_blob_to_string(AtomEntry *ref, const char *s0, size_t sz) {
+  // int rc;
+  char *s = (char *)s0;
+
+#if HAVE_FMEMOPEN
+  blob_type_t *type = RepBlobProp(ref->PropsOfAE)->blob_type;
+  if (type->write) {
+    FILE *f = fmemopen(s, sz, "w");
+    if (f == NULL) {
+      // could not find stream;
+      return NULL;
+    }
+    Atom at = AbsAtom(ref);
+    int rc = type->write(f, at, 0);
+    if (rc < 0) {
+      Yap_Error(EVALUATION_ERROR_UNDEFINED, MkAtomTerm(at),
+                "failure in user-defined blob to string code");
+    }
+    fclose(f); // return the final result.
+    return s;
+  } else {
+#endif
+#if __APPLE__
+    size_t sz0 = strlcpy(s, (char *)RepAtom(AtomSWIStream)->StrOfAE, sz);
+#else
+  size_t sz0;
+  char *f = (char *)memmove(s, (char *)RepAtom(AtomSWIStream)->StrOfAE, sz);
+  f[0] = '\0';
+  sz0 = f - s;
+#endif
+    s = s + sz0;
+    sz -= sz0;
+#if defined(__linux__) || defined(__APPLE__)
+    snprintf(s + strlen(s), sz0, "(%p)", ref);
+#else
+  snprintf(s + strlen(s), sz0, "(0x%p)", ref);
+#endif
+    return s;
+#if HAVE_FMEMOPEN
+  }
+  return NULL;
+#endif
+}
+
+int Yap_write_blob(AtomEntry *ref, FILE *stream) {
+  blob_type_t *type = RepBlobProp(ref->PropsOfAE)->blob_type;
+
+  if (type->write) {
+
+    Atom at = AbsAtom(ref);
+    return type->write(stream, at, 0);
+  } else {
+#if defined(__linux__) || defined(__APPLE__)
+    return fprintf(stream, "\'%s\'(%p)", RepAtom(AtomSWIStream)->StrOfAE, ref);
+#else
+    return fprintf(stream, "\'%s\'(0x%p)", RepAtom(AtomSWIStream)->StrOfAE,
+                   ref);
+#endif
+  }
+  return 0;
+}
+
+bool YAP_is_blob(Term t, blob_type_t **type) {
+  CACHE_REGS
+  Term yt = Yap_GetFromSlot(t);
+  Atom a;
+  YAP_BlobPropEntry *b;
+
+  if (IsVarTerm(yt))
+    return FALSE;
+  if (!IsAtomTerm(yt))
+    return FALSE;
+  a = AtomOfTerm(yt);
+  if (!IsBlob(a))
+    return FALSE;
+  b = RepBlobProp(a->PropsOfAE);
+  *type = b->blob_type;
+  return TRUE;
+}
+
+/* void check_chain(void); */
+
+/* void check_chain(void) { */
+/*   AtomEntry *ae, *old; */
+/*     ae = Blobs; */
+/*     old = NULL; */
+/*     while (ae) { */
+/*       old = ae; */
+/*       ae = RepAtom(ae->NextOfAE); */
+/*     } */
+/* } */
+
+AtomEntry *Yap_lookupBlob(void *blob, size_t len, void *type0, int *new) {
+  YAP_BlobPropEntry *b;
+  AtomEntry *ae;
+  blob_type_t *type = type0;
+  if (new)
+    *new = FALSE;
+
+  LOCK(Blobs_Lock);
+  if (type->flags & PL_BLOB_UNIQUE) {
+    /* just keep a linked chain for now */
+    ae = Blobs;
+    while (ae) {
+      if (ae->PropsOfAE && RepBlobProp(ae->PropsOfAE)->blob_type == type &&
+          ae->rep.blob->length == len &&
+          !memcmp(ae->rep.blob->data, blob, len)) {
+        UNLOCK(Blobs_Lock);
+        return ae;
+      }
+      ae = RepAtom(ae->NextOfAE);
+    }
+  }
+  if (new)
+    *new = TRUE;
+  b = (YAP_BlobPropEntry *)Yap_AllocCodeSpace(sizeof(YAP_BlobPropEntry));
+  if (!b) {
+    UNLOCK(Blobs_Lock);
+    return NULL;
+  }
+  b->NextOfPE = NIL;
+  b->KindOfPE = BlobProperty;
+  b->blob_type = type;
+  ae =
+      (AtomEntry *)Yap_AllocCodeSpace(sizeof(AtomEntry) + len + sizeof(size_t));
+  if (!ae) {
+    UNLOCK(Blobs_Lock);
+    return NULL;
+  }
+  NOfBlobs++;
+  INIT_RWLOCK(ae->ARWLock);
+  ae->PropsOfAE = AbsBlobProp(b);
+  ae->NextOfAE = AbsAtom(Blobs);
+  ae->rep.blob->length = len;
+  memmove(ae->rep.blob->data, blob, len);
+  Blobs = ae;
+  if (NOfBlobs > NOfBlobsMax) {
+    Yap_signal(YAP_CDOVF_SIGNAL);
+  }
+  UNLOCK(Blobs_Lock);
+  return ae;
+}
+
+bool YAP_unify_blob(Term *t, void *blob, size_t len, blob_type_t *type) {
+  AtomEntry *ae;
+
+  if (!blob)
+    return FALSE;
+  ae = Yap_lookupBlob(blob, len, type, NULL);
+  if (!ae) {
+    return FALSE;
+  }
+  if (type->acquire) {
+    type->acquire(AbsAtom(ae));
+  }
+  *t = MkAtomTerm(AbsAtom(ae));
+  return true;
+}
+
+bool YAP_get_blob(Term t, void **blob, size_t *len, blob_type_t **type) {
+  CACHE_REGS
+  Atom a;
+  Term tt;
+  AtomEntry *ae;
+
+  tt = Yap_GetFromSlot(t);
+  if (IsVarTerm(tt))
+    return FALSE;
+  if (!IsAtomTerm(tt))
+    return FALSE;
+  a = AtomOfTerm(tt);
+  if (!IsBlob(a))
+    return FALSE;
+  ae = RepAtom(a);
+  if (type)
+    *type = RepBlobProp(ae->PropsOfAE)->blob_type;
+  if (len)
+    *len = ae->rep.blob[0].length;
+  if (blob)
+    *blob = ae->rep.blob[0].data;
+  return TRUE;
+}
+
+void *YAP_blob_data(YAP_Atom at, size_t *len, blob_type_t **type) {
+Atom x = at;
+  if (!IsBlob(x)) {
+
+    if (len)
+      *len = strlen_utf8(x->UStrOfAE);
+    if (type)
+      *type = &unregistered_blob_atom;
+    return x->StrOfAE;
+  }
+  if (len)
+    *len = x->rep.blob[0].length;
+  if (type)
+    *type = RepBlobProp(x->PropsOfAE)->blob_type;
+  return x->rep.blob[0].data;
+}
+
+void YAP_register_blob_type(blob_type_t *type) {
+  type->next = (void *)BlobTypes;
+  BlobTypes = (void *)type;
+}
+
+blob_type_t *YAP_find_blob_type(const char *name) {
+  AtomEntry *a = RepAtom(Yap_LookupAtom(name));
+  if (!IsBlob(a)) {
+    return &unregistered_blob_atom;
+  }
+  return RepBlobProp(a->PropsOfAE)->blob_type;
+}
+
+bool YAP_unregister_blob_type(blob_type_t *type) {
+  fprintf(stderr, "YAP_unregister_blob_type not implemented yet\n");
+  return FALSE;
+}
+
+void Yap_install_blobs(void) {}
+
+/**
+ * @}
+ */
--- a/C/c_interface.c
+++ b/C/c_interface.c
--- a/C/cdmgr.c
+++ b/C/cdmgr.c
--- a/os/libtai/THANKS
+++ b/os/libtai/THANKS
--- a/C/clause_list.c
+++ b/C/clause_list.c
@ -3,94 +3,89 @@
 #include "tracer.h"
 #ifdef YAPOR
 #include "or.macros.h"
-#endif	/* YAPOR */
+#endif /* YAPOR */
 #include "clause_list.h"

 /* need to fix overflow handling */

-static void
-mk_blob(int sz USES_REGS)
-{
+static void mk_blob(int sz USES_REGS) {
  MP_INT *dst;
- 
-  H[0] = (CELL)FunctorBigInt;
-  H[1] = CLAUSE_LIST;
-  dst = (MP_INT *)(H+2);
+
+  HR[0] = (CELL)FunctorBigInt;
+  HR[1] = CLAUSE_LIST;
+  dst = (MP_INT *)(HR + 2);
  dst->_mp_size = 0L;
  dst->_mp_alloc = sz;
-  H += (1+sizeof(MP_INT)/sizeof(CELL));
-  H[sz] = EndSpecials;
-  H += sz+1;
+  HR += (1 + sizeof(MP_INT) / sizeof(CELL));
+  HR[sz] = EndSpecials;
+  HR += sz + 1;
 }

-static CELL *
-extend_blob(CELL *start, int sz USES_REGS)
-{
+static CELL *extend_blob(CELL *start, int sz USES_REGS) {
  UInt osize;
  MP_INT *dst;
-  
-  if (H + sz > ASP)
+
+  if (HR + sz > ASP)
    return NULL;
-  dst = (MP_INT *)(start+2);
+  dst = (MP_INT *)(start + 2);
  osize = dst->_mp_alloc;
-  start += (1+sizeof(MP_INT)/sizeof(CELL));
-  start[sz+osize] = EndSpecials;
+  start += (1 + sizeof(MP_INT) / sizeof(CELL));
+  start[sz + osize] = EndSpecials;
  dst->_mp_alloc += sz;
-  H += sz;
-  return start+osize;
+  HR += sz;
+  return start + osize;
 }

 /*init of ClasuseList*/
-X_API clause_list_t
-Yap_ClauseListInit(clause_list_t in)
-{
-  CACHE_REGS
-  in->n = 0;
-  in->start = H;
+ clause_list_t Yap_ClauseListInit(clause_list_t in) {
+  CACHE_REGS in->n = 0;
+  in->start = HR;
  mk_blob(0 PASS_REGS);
-  in->end = H;
+  in->end = HR;
  return in;
 }

 /*add clause to ClauseList
 returns FALSE on error*/
-X_API int
-Yap_ClauseListExtend(clause_list_t cl, void * clause, void *pred)
-{
+  int Yap_ClauseListExtend(clause_list_t cl, void *clause, void *pred) {
  CACHE_REGS
  PredEntry *ap = (PredEntry *)pred;

  /*  fprintf(stderr,"cl=%p\n",clause); */
-  if (cl->end != H)
+  if (cl->end != HR)
    return FALSE;
  if (cl->n == 0) {
    void **ptr;
-    if (!(ptr = (void **)extend_blob(cl->start,1 PASS_REGS))) return FALSE;
+    if (!(ptr = (void **)extend_blob(cl->start, 1 PASS_REGS)))
+      return FALSE;
    ptr[0] = clause;
-  } else if (cl->n == 1)  {
+  } else if (cl->n == 1) {
    yamop **ptr;
    yamop *code_p, *fclause;
-    
-    if (!(ptr = (yamop **)extend_blob(cl->start,2*(CELL)NEXTOP((yamop *)NULL,Otapl)/sizeof(CELL)-1 PASS_REGS))) return FALSE;
+
+    if (!(ptr = (yamop **)extend_blob(
+              cl->start, 2 * (CELL)NEXTOP((yamop *)NULL, Otapl) / sizeof(CELL) -
+                             1 PASS_REGS)))
+      return FALSE;
    fclause = ptr[-1];
-    code_p = (yamop *)(ptr-1);
+    code_p = (yamop *)(ptr - 1);
    code_p->opc = Yap_opcode(_try_clause);
-    code_p->u.Otapl.d = fclause;
-    code_p->u.Otapl.s = ap->ArityOfPE;
-    code_p->u.Otapl.p = ap;
+    code_p->y_u.Otapl.d = fclause;
+    code_p->y_u.Otapl.s = ap->ArityOfPE;
+    code_p->y_u.Otapl.p = ap;
 #ifdef TABLING
-    code_p->u.Otapl.te = ap->TableOfPred;
+    code_p->y_u.Otapl.te = ap->TableOfPred;
 #endif
 #ifdef YAPOR
    INIT_YAMOP_LTT(code_p, 0);
 #endif /* YAPOR */
-    code_p = NEXTOP(code_p,Otapl);
+    code_p = NEXTOP(code_p, Otapl);
    code_p->opc = Yap_opcode(_trust);
-    code_p->u.Otapl.d = clause;
-    code_p->u.Otapl.s = ap->ArityOfPE;
-    code_p->u.Otapl.p = ap;
+    code_p->y_u.Otapl.d = clause;
+    code_p->y_u.Otapl.s = ap->ArityOfPE;
+    code_p->y_u.Otapl.p = ap;
 #ifdef TABLING
-    code_p->u.Otapl.te = ap->TableOfPred;
+    code_p->y_u.Otapl.te = ap->TableOfPred;
 #endif
 #ifdef YAPOR
    INIT_YAMOP_LTT(code_p, 0);
@ -98,72 +93,61 @@ Yap_ClauseListExtend(clause_list_t cl, void * clause, void *pred)
  } else {
    yamop *code_p;

-    if (!(code_p = (yamop *)extend_blob(cl->start,((CELL)NEXTOP((yamop *)NULL,Otapl))/sizeof(CELL) PASS_REGS))) return FALSE;
+    if (!(code_p = (yamop *)extend_blob(cl->start,
+                                        ((CELL)NEXTOP((yamop *)NULL, Otapl)) /
+                                            sizeof(CELL) PASS_REGS)))
+      return FALSE;
    code_p->opc = Yap_opcode(_trust);
-    code_p->u.Otapl.d = clause;
-    code_p->u.Otapl.s = ap->ArityOfPE;
-    code_p->u.Otapl.p = ap;
+    code_p->y_u.Otapl.d = clause;
+    code_p->y_u.Otapl.s = ap->ArityOfPE;
+    code_p->y_u.Otapl.p = ap;
 #ifdef TABLING
-    code_p->u.Otapl.te = ap->TableOfPred;
+    code_p->y_u.Otapl.te = ap->TableOfPred;
 #endif
 #ifdef YAPOR
    INIT_YAMOP_LTT(code_p, 0);
 #endif /* YAPOR */
-    code_p = PREVOP(code_p,Otapl);
+    code_p = PREVOP(code_p, Otapl);
    code_p->opc = Yap_opcode(_retry);
  }
-  cl->end = H;
+  cl->end = HR;
  cl->n++;
  return TRUE;
 }

 /*closes the clause list*/
-X_API void
-Yap_ClauseListClose(clause_list_t cl)
-{
-  /* no need to do nothing */
+ void Yap_ClauseListClose(clause_list_t cl) { /* no need to do nothing */
 }

 /*destroys the clause list freeing memory*/
-X_API int
-Yap_ClauseListDestroy(clause_list_t cl)
-{
+ int Yap_ClauseListDestroy(clause_list_t cl) {
  CACHE_REGS
-  if (cl->end != H)
+  if (cl->end != HR)
    return FALSE;
-  H = cl->start;
+  HR = cl->start;
  return TRUE;
 }

 /*destroys clause list and returns only first clause*/
-X_API void *
-Yap_ClauseListToClause(clause_list_t cl)
-{
+ void *Yap_ClauseListToClause(clause_list_t cl) {
  CACHE_REGS
  void **ptr;
-  if (cl->end != H)
+  if (cl->end != HR)
    return NULL;
  if (cl->n != 1)
    return NULL;
-  if (!(ptr = (void **)extend_blob(cl->start,0 PASS_REGS))) return NULL;
+  if (!(ptr = (void **)extend_blob(cl->start, 0 PASS_REGS)))
+    return NULL;
  return ptr[-1];
 }

 /*return pointer to start of try-retry-trust sequence*/
-X_API void *
-Yap_ClauseListCode(clause_list_t cl)
-{
+ void *Yap_ClauseListCode(clause_list_t cl) {
  CELL *ptr;
  ptr = (CELL *)cl->start;
-  ptr += (1+sizeof(MP_INT)/sizeof(CELL));
+  ptr += (1 + sizeof(MP_INT) / sizeof(CELL));
  return (void *)ptr;
 }

 /* where to fail */
-X_API void *
-Yap_FAILCODE(void)
-{
-  return (void *)FAILCODE;
-}
-
-
+ void *Yap_FAILCODE(void) { return (void *)FAILCODE; }
--- a/C/cmppreds.c
+++ b/C/cmppreds.c
--- a/C/compiler.c
+++ b/C/compiler.c
--- a/C/computils.c
+++ b/C/computils.c
@ -54,25 +54,24 @@ static char SccsId[] = "%W% %G%";

 /*
 * This file includes a set of utilities, useful to the several compilation
- * modules 
+ * modules
 */

 #include "Yap.h"
 #include "Yatom.h"
 #include "YapHeap.h"
-#include "compile.h"
+#define COMPILER_NAMES 1
+#include "YapCompile.h"
+#undef COMPILER_NAMES 
+#include "YapCompile.h"
 #include "yapio.h"
 #if HAVE_STRING_H
 #include <string.h>
 #endif

-#ifdef DEBUG
-STATIC_PROTO (void ShowOp, (char *, struct PSEUDO *));
-#endif /* DEBUG */
-
 /*
 * The compiler creates an instruction chain which will be assembled after
- * afterwards 
+ * afterwards
 */


@ -81,7 +80,7 @@ typedef struct mem_blk {
  union {
    struct mem_blk *next;
    double fill;
-  } u;
+  } ublock;
  char contents[1];
 } MemBlk;

@ -110,7 +109,7 @@ AllocCMem (UInt size, struct intermediates *cip)
      if (LOCAL_CMemFirstBlock) {
 	p = LOCAL_CMemFirstBlock;
 	blksz = LOCAL_CMemFirstBlockSz;
-	p->u.next = NULL;
+	p->ublock.next = NULL;
      } else {
 	if (blksz < FIRST_CMEM_BLK_SIZE)
 	  blksz = FIRST_CMEM_BLK_SIZE;
@ -132,7 +131,7 @@ AllocCMem (UInt size, struct intermediates *cip)
 	siglongjmp(cip->CompilerBotch, OUT_OF_HEAP_BOTCH);
      }
    }
-    p->u.next = cip->blks;
+    p->ublock.next = cip->blks;
    cip->blks = p;
    cip->blk_cur = p->contents;
    cip->blk_top = (char *)p+blksz;
@ -144,15 +143,15 @@ AllocCMem (UInt size, struct intermediates *cip)
  }
 #else
  char *p;
-  p = cip->freep;
-  cip->freep += size;
  if (ASP <= CellPtr (cip->freep) + 256) {
    CACHE_REGS
-    LOCAL_Error_Size = 256+((char *)cip->freep - (char *)H);
+    LOCAL_Error_Size = 256+((char *)cip->freep - (char *)HR);
    save_machine_regs();
    siglongjmp(cip->CompilerBotch, OUT_OF_STACK_BOTCH);
  }
-  return (p);
+  p = cip->freep;
+  cip->freep += size;
+  return p;
 #endif
 }

@ -163,7 +162,7 @@ Yap_ReleaseCMem (struct intermediates *cip)
  CACHE_REGS
  struct mem_blk *p = cip->blks;
  while (p) {
-    struct mem_blk *nextp = p->u.next;
+    struct mem_blk *nextp = p->ublock.next;
    if (p != LOCAL_CMemFirstBlock)
      Yap_FreeCodeSpace((ADDR)p);
    p = nextp;
@ -219,7 +218,7 @@ is_a_test(Term arg, Term mod)
 	  return TRUE;
 	}
 	return FALSE;
-      }      
+      }
      return pe->PredFlags & (TestPredFlag|BinaryPredFlag);
    }
  }
@ -288,6 +287,72 @@ Yap_emit_4ops (compiler_vm_op o, CELL r1, CELL r2, CELL r3, CELL r4, struct inte
    }
 }

+void
+Yap_emit_5ops (compiler_vm_op o, CELL r1, CELL r2, CELL r3, CELL r4, CELL r5, struct intermediates *cip)
+{
+  PInstr *p;
+  p = (PInstr *) AllocCMem (sizeof (*p)+3*sizeof(CELL), cip);
+  p->op = o;
+  p->rnd1 = r1;
+  p->rnd2 = r2;
+  p->rnd3 = r3;
+  p->rnd4 = r4;
+  p->rnd5 = r5;
+  p->nextInst = NIL;
+  if (cip->cpc == NIL)
+    cip->cpc = cip->CodeStart = p;
+  else
+    {
+      cip->cpc->nextInst = p;
+      cip->cpc = p;
+    }
+}
+
+void
+Yap_emit_6ops (compiler_vm_op o, CELL r1, CELL r2, CELL r3, CELL r4, CELL r5, CELL r6, struct intermediates *cip)
+{
+  PInstr *p;
+  p = (PInstr *) AllocCMem (sizeof (*p)+4*sizeof(CELL), cip);
+  p->op = o;
+  p->rnd1 = r1;
+  p->rnd2 = r2;
+  p->rnd3 = r3;
+  p->rnd4 = r4;
+  p->rnd5 = r5;
+  p->rnd6 = r6;
+  p->nextInst = NIL;
+  if (cip->cpc == NIL)
+    cip->cpc = cip->CodeStart = p;
+  else
+    {
+      cip->cpc->nextInst = p;
+      cip->cpc = p;
+    }
+}
+
+void
+Yap_emit_7ops (compiler_vm_op o, CELL r1, CELL r2, CELL r3, CELL r4, CELL r5, CELL r6, CELL r7, struct intermediates *cip)
+{
+  PInstr *p;
+  p = (PInstr *) AllocCMem (sizeof (*p)+5*sizeof(CELL), cip);
+  p->op = o;
+  p->rnd1 = r1;
+  p->rnd2 = r2;
+  p->rnd3 = r3;
+  p->rnd4 = r4;
+  p->rnd5 = r5;
+  p->rnd6 = r6;
+  p->rnd7 = r7;
+  p->nextInst = NIL;
+  if (cip->cpc == NIL)
+    cip->cpc = cip->CodeStart = p;
+  else
+    {
+      cip->cpc->nextInst = p;
+      cip->cpc = p;
+    }
+}
+
 CELL *
 Yap_emit_extra_size (compiler_vm_op o, CELL r1, int size, struct intermediates *cip)
 {
@ -331,6 +396,9 @@ bip_name(Int op, char *s)
  case _cut_by:
    strcpy(s,"cut_by");
    break;
+  case _save_by:
+    strcpy(s,"save_by");
+    break;
  case _db_ref:
    strcpy(s,"db_ref");
    break;
@ -412,14 +480,51 @@ write_address(CELL address)
    sprintf(buf,"%p",(void *)address);
 #endif
    p[31] = '\0'; /* so that I don't have to worry */
-    Yap_DebugErrorPutc('0');
-    Yap_DebugErrorPutc('x');
+    //Yap_DebugErrorPutc('0');
+    //Yap_DebugErrorPutc('x');
    while (*p != '\0') {
      Yap_DebugErrorPutc(*p++);
    }
  }
 }

+static void
+write_special_label(special_label_op arg, special_label_id rn, UInt lab)
+{
+  switch (arg) {
+  case SPECIAL_LABEL_INIT:
+    Yap_DebugErrorPuts("init,");
+    switch (rn) {
+    case SPECIAL_LABEL_EXCEPTION:
+      Yap_DebugErrorPuts("exception,");
+      break;
+    case SPECIAL_LABEL_SUCCESS:
+       Yap_DebugErrorPuts("success,");
+      break;
+    case SPECIAL_LABEL_FAILURE:
+      Yap_DebugErrorPuts("fail,");
+      break;
+    }
+    write_address(lab);
+  case SPECIAL_LABEL_SET:
+    Yap_DebugErrorPuts("set,");
+    break;
+  case SPECIAL_LABEL_CLEAR:
+    Yap_DebugErrorPuts("clear,");
+    switch (rn) {
+    case SPECIAL_LABEL_EXCEPTION:
+      Yap_DebugErrorPuts("exception");
+      break;
+    case SPECIAL_LABEL_SUCCESS:
+       Yap_DebugErrorPuts("success");
+      break;
+    case SPECIAL_LABEL_FAILURE:
+      Yap_DebugErrorPuts("fail");
+      break;
+    }
+  }
+}
+
 static void
 write_functor(Functor f)
 {
@ -428,8 +533,12 @@ write_functor(Functor f)
      Yap_DebugPlWrite(MkAtomTerm(AtomDBREF));
    } else if (f == FunctorLongInt) {
      Yap_DebugPlWrite(MkAtomTerm(AtomLONGINT));
+    } else if (f == FunctorBigInt) {
+      Yap_DebugPlWrite(MkAtomTerm(AtomLONGINT));
    } else if (f == FunctorDouble) {
      Yap_DebugPlWrite(MkAtomTerm(AtomDOUBLE));
+    } else if (f == FunctorString) {
+      Yap_DebugPlWrite(MkAtomTerm(AtomSTRING));
    }
  } else {
    Yap_DebugPlWrite(MkAtomTerm(NameOfFunctor (f)));
@ -438,14 +547,37 @@ write_functor(Functor f)
  }
 }

-static void
-ShowOp (char *f, struct PSEUDO *cpc)
+
+static void send_pred(PredEntry *p)
 {
+  Functor f = p->FunctorOfPred;
+  UInt arity = p->ArityOfPE;
+             Term mod = TermProlog;
+
+            if (p->ModuleOfPred) mod = p->ModuleOfPred;
+             Yap_DebugPlWrite (mod);
+             Yap_DebugErrorPutc (':');
+             if (arity == 0)
+               Yap_DebugPlWrite (MkAtomTerm ((Atom)f));
+            else
+              Yap_DebugPlWrite (MkAtomTerm (NameOfFunctor (f)));
+             Yap_DebugErrorPutc ('/');
+            Yap_DebugPlWrite (MkIntTerm (arity));
+}
+
+
+static void
+ShowOp (compiler_vm_op ic, const char *f, struct PSEUDO *cpc)
+{
+  CACHE_REGS
  char ch;
  Int arg = cpc->rnd1;
  Int rn = cpc->rnd2;
  CELL *cptr = cpc->arnds;

+  if (ic != label_op && ic != label_ctl_op && ic != name_op) {
+    Yap_DebugErrorPutc ('\t');
+  }
  while ((ch = *f++) != 0)
    {
      if (ch == '%')
@ -459,6 +591,19 @@ ShowOp (char *f, struct PSEUDO *cpc)
 		Yap_DebugPlWrite(MkIntTerm(arg));
 		break;
 #endif
+	  case '2':
+	    {
+	      Ventry *v = (Ventry *) cpc->rnd3;
+	      Yap_DebugErrorPutc (v->KindOfVE == PermVar ? 'Y' : 'X');
+	      Yap_DebugPlWrite (MkIntTerm ((v->NoOfVE) & MaskVarAdrs));
+	      Yap_DebugErrorPutc (',');
+	      Yap_DebugErrorPutc ('A');
+	      Yap_DebugPlWrite (MkIntegerTerm (cpc->rnd4));
+	      Yap_DebugErrorPutc (',');
+	      send_pred( RepPredProp((Prop)(cpc->rnd5)) );
+	    }
+	    break;
+
 	  case 'a':
 	  case 'n':
 	    Yap_DebugPlWrite ((Term) arg);
@ -472,10 +617,13 @@ ShowOp (char *f, struct PSEUDO *cpc)
 		Yap_DebugPlWrite(MkIntegerTerm((Int)(*ptr++)));
 	      }
 	    }
-	    break;		
+	    break;
 	  case 'l':
 	    write_address (arg);
 	    break;
+	  case 'L':
+	    write_special_label (arg, rn, cpc->rnd3);
+	    break;
 	  case 'B':
 	    {
 	      char s[32];
@ -493,10 +641,12 @@ ShowOp (char *f, struct PSEUDO *cpc)
 	  case 'v':
 	    {
 	      Ventry *v = (Ventry *) arg;
-	      Yap_DebugErrorPutc (v->KindOfVE == PermVar ? 'Y' : 'X');
-	      Yap_DebugPlWrite (MkIntTerm ((v->NoOfVE) & MaskVarAdrs));
+          if (v) {
+            Yap_DebugErrorPutc (v->KindOfVE == PermVar ? 'Y' : 'X');
+            Yap_DebugPlWrite (MkIntTerm ((v->NoOfVE) & MaskVarAdrs));
+          }
 	    }
-	    break;	
+	    break;
 	  case 'N':
 	    {
 	      Ventry *v;
@ -508,50 +658,17 @@ ShowOp (char *f, struct PSEUDO *cpc)
 	      Yap_DebugPlWrite (MkIntTerm ((v->NoOfVE) & MaskVarAdrs));
 	    }
 	    break;
-	  case 'm':
-	    Yap_DebugPlWrite (MkAtomTerm ((Atom) arg));
-	    Yap_DebugErrorPutc ('/');
-	    Yap_DebugPlWrite (MkIntTerm (rn));
-	    break;
+         case 'm':
+           Yap_DebugPlWrite (MkAtomTerm ((Atom) arg));
+           Yap_DebugErrorPutc ('/');
+           Yap_DebugPlWrite (MkIntTerm (rn));
+           break;
 	  case 'p':
-	    {
-	      PredEntry *p = RepPredProp ((Prop) arg);
-	      Functor f = p->FunctorOfPred;
-	      UInt arity = p->ArityOfPE;
-	      Term mod;
-
-	      if (p->ModuleOfPred)
-		mod = p->ModuleOfPred;
-	      else
-		mod = TermProlog;
-	      Yap_DebugPlWrite (mod);
-	      Yap_DebugErrorPutc (':');
-	      if (arity == 0)
-		Yap_DebugPlWrite (MkAtomTerm ((Atom)f));
-	      else
-		Yap_DebugPlWrite (MkAtomTerm (NameOfFunctor (f)));
-	      Yap_DebugErrorPutc ('/');
-	      Yap_DebugPlWrite (MkIntTerm (arity));
-	    }
-	    break;
-	  case 'P':
-	    {
-	      PredEntry *p = RepPredProp((Prop) rn);
-	      Functor f = p->FunctorOfPred;
-	      UInt arity = p->ArityOfPE;
-	      Term mod = TermProlog;
-
-	      if (p->ModuleOfPred) mod = p->ModuleOfPred;
-	      Yap_DebugPlWrite (mod);
-	      Yap_DebugErrorPutc (':');
-	      if (arity == 0)
-		Yap_DebugPlWrite (MkAtomTerm ((Atom)f));
-	      else
-		Yap_DebugPlWrite (MkAtomTerm (NameOfFunctor (f)));
-	      Yap_DebugErrorPutc ('/');
-	      Yap_DebugPlWrite (MkIntTerm (arity));
-	    }
-	    break;
+	   send_pred( RepPredProp((Prop)(arg) ));
+           break;
+         case 'P':
+	   send_pred( RepPredProp((Prop)(rn) ));
+           break;
 	  case 'f':
 	    write_functor((Functor)arg);
 	    break;
@ -559,6 +676,10 @@ ShowOp (char *f, struct PSEUDO *cpc)
 	    Yap_DebugErrorPutc ('A');
 	    Yap_DebugPlWrite (MkIntTerm (rn));
 	    break;
+	  case 'S':
+	    Yap_DebugErrorPutc ('S');
+	    Yap_DebugPlWrite (MkIntTerm (rn));
+	    break;
 	  case 'h':
 	    {
 	      CELL my_arg = *cptr++;
@ -581,6 +702,8 @@ ShowOp (char *f, struct PSEUDO *cpc)
 		  Yap_DebugPlWrite(MkAtomTerm(AtomLONGINT));
 		} else if (fun == FunctorDouble) {
 		  Yap_DebugPlWrite(MkAtomTerm(AtomDOUBLE));
+		} else if (fun == FunctorString) {
+		  Yap_DebugPlWrite(MkAtomTerm(AtomSTRING));
 		}
 	      } else {
 		Yap_DebugPlWrite (MkAtomTerm(NameOfFunctor(fun)));
@ -598,7 +721,7 @@ ShowOp (char *f, struct PSEUDO *cpc)
 	    Yap_DebugPlWrite (MkIntTerm (rn & 1));
 	    break;
 	  case 'w':
-	    Yap_DebugPlWrite (arg);
+	    Yap_DebugPlWrite (MkIntTerm(arg));
 	    break;
 	  case 'o':
 	    Yap_DebugPlWrite ((Term) * cptr++);
@ -653,212 +776,23 @@ ShowOp (char *f, struct PSEUDO *cpc)
  Yap_DebugErrorPutc ('\n');
 }

-static char *opformat[] =
-{
-  "nop",
-  "get_var\t\t%v,%r",
-  "put_var\t\t%v,%r",
-  "get_val\t\t%v,%r",
-  "put_val\t\t%v,%r",
-  "get_atom\t%a,%r",
-  "put_atom\t%a,%r",
-  "get_num\t\t%n,%r",
-  "put_num\t\t%n,%r",
-  "get_float\t\t%w,%r",
-  "put_float\t\t%w,%r",
-  "get_dbterm\t%w,%r",
-  "put_dbterm\t%w,%r",
-  "get_longint\t\t%w,%r",
-  "put_longint\t\t%w,%r",
-  "get_bigint\t\t%l,%r",
-  "put_bigint\t\t%l,%r",
-  "get_list\t%r",
-  "put_list\t%r",
-  "get_struct\t%f,%r",
-  "put_struct\t%f,%r",
-  "put_unsafe\t%v,%r",
-  "unify_var\t%v",
-  "write_var\t%v",
-  "unify_val\t%v",
-  "write_val\t%v",
-  "unify_atom\t%a",
-  "write_atom\t%a",
-  "unify_num\t%n",
-  "write_num\t%n",
-  "unify_float\t%w",
-  "write_float\t%w",
-  "unify_dbterm\t%w",
-  "write_dbterm\t%w",
-  "unify_longint\t%w",
-  "write_longint\t%w",
-  "unify_bigint\t%l",
-  "write_bigint\t%l",
-  "unify_list",
-  "write_list",
-  "unify_struct\t%f",
-  "write_struct\t%f",
-  "write_unsafe\t%v",
-  "unify_local\t%v",
-  "write local\t%v",
-  "unify_last_list",
-  "write_last_list",
-  "unify_last_struct\t%f",
-  "write_last_struct\t%f",
-  "unify_last_var\t%v",
-  "unify_last_val\t%v",
-  "unify_last_local\t%v",
-  "unify_last_atom\t%a",
-  "unify_last_num\t%n",
-  "unify_last_float\t%w", 
-  "unify_last_dbterm\t%w",
-  "unify_last_longint\t%w",
-  "unify_last_bigint\t%l",
-  "ensure_space",
-  "native_code",
-  "function_to_var\t%v,%B",
-  "function_to_val\t%v,%B",
-  "function_to_0\t%B",
-  "align_float",
-  "fail",
-  "cut",
-  "cutexit",
-  "allocate",
-  "deallocate",
-  "try_me_else\t\t%l\t%x",
-  "jump\t\t%l",
-  "jump\t\t%l",
-  "proceed",
-  "call\t\t%p,%d,%z",
-  "execute\t\t%p",
-  "sys\t\t%p",
-  "%l:",
-  "name\t\t%m,%d",
-  "pop\t\t%l",
-  "retry_me_else\t\t%l\t%x",
-  "trust_me_else_fail\t%x",
-  "either_me\t\t%l,%d,%z",
-  "or_else\t\t%l,%z",
-  "or_last",
-  "push_or",
-  "pushpop_or",
-  "pop_or",
-  "save_by\t\t%v",
-  "commit_by\t\t%v",
-  "patch_by\t\t%v",
-  "try\t\t%g\t%x",
-  "retry\t\t%g\t%x",
-  "trust\t\t%g\t%x",
-  "try_in\t\t%g\t%x",
-  "jump_if_var\t\t%g",
-  "jump_if_nonvar\t\t%g",
-  "cache_arg\t%r",
-  "cache_sub_arg\t%d",
-  "user_index",
-  "switch_on_type\t%h\t%h\t%h\t%h",
-  "switch_on_constant\t%i\n%c",
-  "if_constant\t%i\n%c",
-  "switch_on_functor\t%i\n%e",
-  "if_functor\t%i\n%e",
-  "if_not_then\t%i\t%h\t%h\t%h",
-  "index_on_dbref",
-  "index_on_blob",
-  "index_on_long",
-  "check_var\t %r",
-  "save_pair\t%v",
-  "save_appl\t%v",
-  "pvar_bitmap\t%l,%b",
-  "pvar_live_regs\t%l,%b",
-  "fetch_reg1_reg2\t%N,%N",
-  "fetch_constant_reg\t%l,%N",
-  "fetch_reg_constant\t%l,%N",
-  "fetch_integer_reg\t%d,%N",
-  "fetch_reg_integer\t%d,%N",
-  "enter_profiling\t\t%g",
-  "retry_profiled\t\t%g",
-  "count_call_op\t\t%g",
-  "count_retry_op\t\t%g",
-  "restore_temps\t\t%l",
-  "restore_temps_and_skip\t\t%l",
-  "enter_lu",
-  "empty_call\t\t%l,%d",
-#ifdef YAPOR
-  "sync",
-#endif /* YAPOR */
-#ifdef TABLING
-  "table_new_answer",
-  "table_try_single\t%g\t%x",
-#endif /* TABLING */
-#ifdef TABLING_INNER_CUTS
-  "clause_with_cut",
-#endif /* TABLING_INNER_CUTS */
-#ifdef BEAM
-  "run_op %1,%4",
-  "body_op %1",
-  "endgoal_op",
-  "try_me_op %1,%4",
-  "retry_me_op %1,%4",
-  "trust_me_op %1,%4",
-  "only_1_clause_op %1,%4",
-  "create_first_box_op %1,%4",
-  "create_box_op %1,%4",
-  "create_last_box_op %1,%4",
-  "remove_box_op %1,%4",
-  "remove_last_box_op %1,%4",
-  "prepare_tries",
-  "std_base_op %1,%4",
-  "direct_safe_call",
-  "skip_while_var_op",
-  "wait_while_var_op",
-  "force_wait_op",
-  "write_op",
-  "is_op",
-  "equal_op",
-  "exit",
-#endif
-  "fetch_args_for_bccall\t%v",
-  "binary_cfunc\t\t%v,%P",
-  "blob\t%O",
-  "label_control\t"
-#ifdef SFUNC
-  ,
-  "get_s_f_op\t%f,%r",
-  "put_s_f_op\t%f,%r",
-  "unify_s_f_op\t%f",
-  "write_s_f_op\t%f",
-  "unify_s_var\t%v,%r",
-  "write_s_var\t%v,%r",
-  "unify_s_val\t%v,%r",
-  "write_s_val\t%v,%r",
-  "unify_s_a\t%a,%r",
-  "write_s_a\t%a,%r",
-  "get_s_end",
-  "put_s_end",
-  "unify_s_end",
-  "write_s_end"
-#endif
-};
-
-
 void
 Yap_ShowCode (struct intermediates *cint)
 {
  CACHE_REGS
-  CELL *oldH = H;
  struct PSEUDO *cpc;

  cpc = cint->CodeStart;
  /* MkIntTerm and friends may build terms in the global stack */
-  H = (CELL *)cint->freep;
+  HR = (CELL *)cint->freep;
  while (cpc) {
    compiler_vm_op ic = cpc->op;
    if (ic != nop_op) {
-      ShowOp (opformat[ic], cpc);
+      ShowOp (ic, opDesc[ic], cpc);
    }
    cpc = cpc->nextInst;
  }
  Yap_DebugErrorPutc ('\n');
-  H = oldH;
 }

 #endif /* DEBUG */
-
--- a/C/control_absmi_insts.h
+++ b/C/control_absmi_insts.h
@ -0,0 +1,561 @@
+/************************************************************************\
+ *      Cut & Commit Inst
+
+ructions                                       *
+\************************************************************************/
+
+#ifdef INDENT_CODE
+{
+  {
+    {
+#endif /* INDENT_CODE */
+
+      /* cut                              */
+      Op(cut, s);
+#ifdef COROUTINING
+      CACHE_Y_AS_ENV(YREG);
+	  check_stack(NoStackCut, HR);
+      ENDCACHE_Y_AS_ENV();
+    do_cut:
+#endif
+      SET_ASP(YREG, PREG->y_u.s.s);
+      PREG = NEXTOP(NEXTOP(NEXTOP(PREG, s),Osbpp),l);
+      /* assume cut is always in stack */
+      saveregs();
+      prune((choiceptr)YREG[E_CB] PASS_REGS);
+      setregs();
+      GONext();
+
+#ifdef COROUTINING
+    NoStackCut:
+      PROCESS_INT(interrupt_cut, do_cut);
+#endif
+
+      ENDOp();
+
+      /* cut_t                            */
+      /* cut_t does the same as cut */
+      Op(cut_t, s);
+#ifdef COROUTINING
+      CACHE_Y_AS_ENV(YREG);
+      check_stack(NoStackCutT, HR);
+      ENDCACHE_Y_AS_ENV();
+    do_cut_t:
+#endif
+      SET_ASP(YREG, PREG->y_u.s.s);
+      /* assume cut is always in stack */
+      saveregs();
+      prune((choiceptr)YREG[E_CB] PASS_REGS);
+      setregs();
+      PREG = NEXTOP(NEXTOP(NEXTOP(PREG, s),Osbpp),l);
+      GONext();
+
+#ifdef COROUTINING
+    NoStackCutT:
+      PROCESS_INT(interrupt_cut_t, do_cut_t);
+#endif
+
+      ENDOp();
+
+      /* cut_e                            */
+      Op(cut_e, s);
+#ifdef COROUTINING
+      CACHE_Y_AS_ENV(YREG);
+      check_stack(NoStackCutE, HR);
+      ENDCACHE_Y_AS_ENV();
+    do_cut_e:
+#endif
+      SET_ASP(YREG, PREG->y_u.s.s);
+      PREG = NEXTOP(NEXTOP(NEXTOP(PREG, s),Osbpp),l);
+      saveregs();
+      prune((choiceptr)SREG[E_CB] PASS_REGS);
+      setregs();
+      GONext();
+
+#ifdef COROUTINING
+    NoStackCutE:
+      PROCESS_INT(interrupt_cut_e, do_cut_e);
+#endif
+
+      ENDOp();
+
+      /* save_b_x      Xi                 */
+      Op(save_b_x, x);
+      BEGD(d0);
+      d0 = PREG->y_u.x.x;
+#if defined(YAPOR_SBA) && defined(FROZEN_STACKS)
+      XREG(d0) = MkIntegerTerm((Int)B);
+#else
+      XREG(d0) = MkIntegerTerm(LCL0-(CELL *) (B));
+#endif /* YAPOR_SBA && FROZEN_STACKS */
+      PREG = NEXTOP(PREG, x);
+      ENDD(d0);
+      GONext();
+      ENDOp();
+
+      /* save_b_y      Yi                 */
+      Op(save_b_y, y);
+#if defined(YAPOR_SBA)
+      INITIALIZE_PERMVAR(YREG+PREG->y_u.y.y,MkIntegerTerm((Int)B));
+#else
+      INITIALIZE_PERMVAR(YREG+PREG->y_u.y.y,MkIntegerTerm(LCL0-(CELL *)(B)));
+#endif /* YAPOR_SBA*/
+      PREG = NEXTOP(PREG, y);
+      GONext();
+      ENDOp();
+
+      /* commit_b_x    Xi                 */
+      Op(commit_b_x, xps);
+#ifdef COROUTINING
+      CACHE_Y_AS_ENV(YREG);
+      check_stack(NoStackCommitX, HR);
+      ENDCACHE_Y_AS_ENV();
+    do_commit_b_x:
+#endif
+      BEGD(d0);
+      d0 = XREG(PREG->y_u.xps.x);
+      deref_head(d0, commit_b_x_unk);
+    commit_b_x_nvar:
+      /* skip a void call and a label */
+      SET_ASP(YREG, PREG->y_u.xps.s);
+      PREG = NEXTOP(NEXTOP(NEXTOP(PREG, xps),Osbpp),l);
+      {
+        choiceptr pt0;
+#if defined(YAPOR_SBA) && defined(FROZEN_STACKS)
+        pt0 = (choiceptr)IntegerOfTerm(d0);
+#else
+        pt0 = (choiceptr)(LCL0-IntegerOfTerm(d0));
+#endif /* YAPOR_SBA && FROZEN_STACKS */
+        saveregs();
+        prune(pt0 PASS_REGS);
+        setregs();
+      }
+      GONext();
+
+      BEGP(pt1);
+      deref_body(d0, pt1, commit_b_x_unk, commit_b_x_nvar);
+      ENDP(pt1);
+      /* never cut to a variable */
+      /* Abort */
+      FAIL();
+      ENDD(d0);
+
+#ifdef COROUTINING
+      /* Problem: have I got an environment or not? */
+    NoStackCommitX:
+      PROCESS_INT(interrupt_commit_x, do_commit_b_x);
+#endif
+      ENDOp();
+
+      /* commit_b_y    Yi                 */
+      Op(commit_b_y, yps);
+#ifdef COROUTINING
+      CACHE_Y_AS_ENV(YREG);
+      check_stack(NoStackCommitY, HR);
+      ENDCACHE_Y_AS_ENV();
+    do_commit_b_y:
+#endif
+      BEGD(d0);
+      d0 = YREG[PREG->y_u.yps.y];
+      deref_head(d0, commit_b_y_unk);
+    commit_b_y_nvar:
+      SET_ASP(YREG, PREG->y_u.yps.s);
+      PREG = NEXTOP(NEXTOP(NEXTOP(PREG, yps),Osbpp),l);
+      {
+        choiceptr pt0;
+#if defined(YAPOR_SBA) && defined(FROZEN_STACKS)
+        pt0 = (choiceptr)IntegerOfTerm(d0);
+#else
+        pt0 = (choiceptr)(LCL0-IntegerOfTerm(d0));
+#endif
+        saveregs();
+        prune(pt0 PASS_REGS);
+        setregs();
+      }
+      GONext();
+
+      BEGP(pt1);
+      deref_body(d0, pt1, commit_b_y_unk, commit_b_y_nvar);
+      ENDP(pt1);
+      /* never cut to a variable */
+      /* Abort */
+      FAIL();
+      ENDD(d0);
+
+#ifdef COROUTINING
+      /* This is easier: I know there is an environment so I cannot do allocate */
+    NoStackCommitY:
+      PROCESS_INT(interrupt_commit_y, do_commit_b_y);
+#endif
+      ENDOp();
+
+      /*************************************************************************
+       *      Call / Proceed instructions                                      *
+       *************************************************************************/
+
+      /* Macros for stack trimming                                            */
+
+      /* execute     Label               */
+      BOp(execute, Osbpp);
+      {
+        PredEntry *pt0;
+        CACHE_Y_AS_ENV(YREG);
+        pt0 = PREG->y_u.Osbpp.p;
+#ifndef NO_CHECKING
+        check_stack(NoStackExecute, HR);
+        goto skip_do_execute;
+#endif
+      do_execute:
+        FETCH_Y_FROM_ENV(YREG);
+        pt0 = PREG->y_u.Osbpp.p;
+      skip_do_execute:
+#ifdef LOW_LEVEL_TRACER
+        if (Yap_do_low_level_trace) {
+          low_level_trace(enter_pred,pt0,XREGS+1);
+        }
+#endif  /* LOW_LEVEL_TRACE */
+        CACHE_A1();
+        ALWAYS_LOOKAHEAD(pt0->OpcodeOfPred);
+        BEGD(d0);
+        d0 = (CELL)B;
+        PREG = pt0->CodeOfPred;
+        /* for profiler */
+        save_pc();
+        ENV_YREG[E_CB] = d0;
+        ENDD(d0);
+#ifdef DEPTH_LIMIT
+        if (DEPTH <= MkIntTerm(1)) {/* I assume Module==0 is prolog */
+          if (pt0->ModuleOfPred) {
+            if (DEPTH == MkIntTerm(0)) {
+              FAIL();
+            } else { DEPTH = RESET_DEPTH(); }
+          }
+        } else if (pt0->ModuleOfPred)
+          DEPTH -= MkIntConstant(2);
+#endif  /* DEPTH_LIMIT */
+        /* this is the equivalent to setting up the stack */
+        ALWAYS_GONext();
+        ALWAYS_END_PREFETCH();
+        ENDCACHE_Y_AS_ENV();
+      }
+
+    NoStackExecute:
+      PROCESS_INT(interrupt_execute, do_execute);
+
+      ENDBOp();
+
+      /* dexecute    Label               */
+      /* joint deallocate and execute */
+      BOp(dexecute, Osbpp);
+#ifdef LOW_LEVEL_TRACER
+      if (Yap_do_low_level_trace)
+        low_level_trace(enter_pred,PREG->y_u.Osbpp.p,XREGS+1);
+#endif  /* LOW_LEVEL_TRACER */
+      CACHE_Y_AS_ENV(YREG);
+      {
+        PredEntry *pt0;
+
+        CACHE_A1();
+        pt0 = PREG->y_u.Osbpp.p;
+#ifndef NO_CHECKING
+        /* check stacks */
+        check_stack(NoStackDExecute, HR);
+        goto skip_dexecute;
+#endif
+      continue_dexecute:
+        FETCH_Y_FROM_ENV(YREG);
+        pt0 = PREG->y_u.Osbpp.p;
+      skip_dexecute:
+#ifdef DEPTH_LIMIT
+        if (DEPTH <= MkIntTerm(1)) {/* I assume Module==0 is primitives */
+          if (pt0->ModuleOfPred) {
+            if (DEPTH == MkIntTerm(0)) {
+              FAIL();
+            } else {
+	      DEPTH = RESET_DEPTH();
+	    }
+          }
+        } else if (pt0->ModuleOfPred)
+          DEPTH -= MkIntConstant(2);
+#endif  /* DEPTH_LIMIT */
+        PREG = pt0->CodeOfPred;
+        /* for profiler */
+        save_pc();
+        ALWAYS_LOOKAHEAD(pt0->OpcodeOfPred);
+        /* do deallocate */
+        CPREG = (yamop *) ENV_YREG[E_CP];
+        ENV_YREG = ENV = (CELL *) ENV_YREG[E_E];
+#ifdef FROZEN_STACKS
+        {
+          choiceptr top_b = PROTECT_FROZEN_B(B);
+#ifdef YAPOR_SBA
+          if (ENV_YREG > (CELL *) top_b || ENV_YREG < HR) ENV_YREG = (CELL *) top_b;
+#else
+          if (ENV_YREG > (CELL *) top_b) ENV_YREG = (CELL *) top_b;
+#endif /* YAPOR_SBA */
+          else ENV_YREG = (CELL *)((CELL)ENV_YREG + ENV_Size(CPREG));
+        }
+#else
+        if (ENV_YREG > (CELL *)B) {
+          ENV_YREG = (CELL *)B;
+        }
+        else {
+          ENV_YREG = (CELL *) ((CELL) ENV_YREG + ENV_Size(CPREG));
+        }
+#endif /* FROZEN_STACKS */
+        WRITEBACK_Y_AS_ENV();
+        /* setup GB */
+        ENV_YREG[E_CB] = (CELL) B;
+        ALWAYS_GONext();
+        ALWAYS_END_PREFETCH();
+      }
+      ENDCACHE_Y_AS_ENV();
+
+    NoStackDExecute:
+      PROCESS_INT(interrupt_dexecute, continue_dexecute);
+
+      ENDBOp();
+
+      BOp(fcall, Osbpp);
+      CACHE_Y_AS_ENV(YREG);
+      ENV_YREG[E_CP] = (CELL) CPREG;
+      ENV_YREG[E_E] = (CELL) ENV;
+#ifdef DEPTH_LIMIT
+      ENV_YREG[E_DEPTH] = DEPTH;
+#endif  /* DEPTH_LIMIT */
+      ENDCACHE_Y_AS_ENV();
+      ENDBOp();
+
+      BOp(call, Osbpp);
+#ifdef LOW_LEVEL_TRACER
+      if (Yap_do_low_level_trace) {
+        low_level_trace(enter_pred,PREG->y_u.Osbpp.p,XREGS+1);
+      }
+#endif  /* LOW_LEVEL_TRACER */
+      CACHE_Y_AS_ENV(YREG);
+      {
+        PredEntry *pt;
+        CACHE_A1();
+        pt = PREG->y_u.Osbpp.p;
+#ifndef NO_CHECKING
+        check_stack(NoStackCall, HR);
+        goto skip_call;
+#endif
+      call_body:
+        /* external jump if we don;t want to creep */
+        FETCH_Y_FROM_ENV(YREG);
+        pt = PREG->y_u.Osbpp.p;
+      skip_call:
+        ENV = ENV_YREG;
+        /* Try to preserve the environment */
+        ENV_YREG = (CELL *) (((char *) ENV_YREG) + PREG->y_u.Osbpp.s);
+        CPREG = NEXTOP(PREG, Osbpp);
+        ALWAYS_LOOKAHEAD(pt->OpcodeOfPred);
+        PREG = pt->CodeOfPred;
+        /* for profiler */
+        save_pc();
+#ifdef DEPTH_LIMIT
+        if (DEPTH <= MkIntTerm(1)) {/* I assume Module==0 is primitives */
+          if (pt->ModuleOfPred) {
+            if (DEPTH == MkIntTerm(0)) {
+              FAIL();
+            } else {
+	      DEPTH = RESET_DEPTH();
+	    }
+          }
+        } else if (pt->ModuleOfPred)
+          DEPTH -= MkIntConstant(2);
+#endif  /* DEPTH_LIMIT */
+#ifdef FROZEN_STACKS
+        {
+          choiceptr top_b = PROTECT_FROZEN_B(B);
+#ifdef YAPOR_SBA
+          if (ENV_YREG > (CELL *) top_b || ENV_YREG < HR) ENV_YREG = (CELL *) top_b;
+#else
+          if (ENV_YREG > (CELL *) top_b) ENV_YREG = (CELL *) top_b;
+#endif /* YAPOR_SBA */
+        }
+#else
+        if (ENV_YREG > (CELL *) B) {
+          ENV_YREG = (CELL *) B;
+        }
+#endif /* FROZEN_STACKS */
+        WRITEBACK_Y_AS_ENV();
+        /* setup GB */
+        ENV_YREG[E_CB] = (CELL) B;
+#ifdef YAPOR
+        SCH_check_requests();
+#endif  /* YAPOR */
+        ALWAYS_GONext();
+        ALWAYS_END_PREFETCH();
+      }
+      ENDCACHE_Y_AS_ENV();
+      ENDBOp();
+
+      BOp(procceed, p);
+      CACHE_Y_AS_ENV(YREG);
+      ALWAYS_LOOKAHEAD(CPREG->opc);
+      PREG = CPREG;
+      /* for profiler */
+      save_pc();
+      ENV_YREG = ENV;
+#ifdef DEPTH_LIMIT
+      DEPTH = ENV_YREG[E_DEPTH];
+#endif
+      WRITEBACK_Y_AS_ENV();
+      ALWAYS_GONext();
+      ALWAYS_END_PREFETCH();
+      ENDCACHE_Y_AS_ENV();
+
+    NoStackCall:
+      PROCESS_INT(interrupt_call, call_body);
+
+      ENDBOp();
+
+      Op(allocate, e);
+      CACHE_Y_AS_ENV(YREG);
+      PREG = NEXTOP(PREG, e);
+      ENV_YREG[E_CP] = (CELL) CPREG;
+      ENV_YREG[E_E] = (CELL) ENV;
+#ifdef DEPTH_LIMIT
+      ENV_YREG[E_DEPTH] = DEPTH;
+#endif  /* DEPTH_LIMIT */
+      ENV = ENV_YREG;
+      ENDCACHE_Y_AS_ENV();
+      GONext();
+      ENDOp();
+
+      Op(deallocate, p);
+      CACHE_Y_AS_ENV(YREG);
+      // do this before checking
+      SREG = YREG;
+      check_trail(TR);
+#ifndef NO_CHECKING
+      /* check stacks */
+      check_stack(NoStackDeallocate, HR);
+#endif
+      PREG = NEXTOP(PREG, p);
+      /* other instructions do depend on S being set by deallocate
+         :-( */
+      CPREG = (yamop *) ENV_YREG[E_CP];
+      ENV = ENV_YREG = (CELL *) ENV_YREG[E_E];
+#ifdef DEPTH_LIMIT
+      DEPTH = ENV_YREG[E_DEPTH];
+#endif  /* DEPTH_LIMIT */
+#ifdef FROZEN_STACKS
+      {
+        choiceptr top_b = PROTECT_FROZEN_B(B);
+#ifdef YAPOR_SBA
+        if (ENV_YREG > (CELL *) top_b || ENV_YREG < HR) ENV_YREG = (CELL *) top_b;
+#else
+        if (ENV_YREG > (CELL *) top_b) ENV_YREG = (CELL *) top_b;
+#endif /* YAPOR_SBA */
+        else ENV_YREG = (CELL *)((CELL) ENV_YREG + ENV_Size(CPREG));
+      }
+#else
+      if (ENV_YREG > (CELL *) B)
+        ENV_YREG = (CELL *) B;
+      else
+        ENV_YREG = (CELL *) ((CELL) ENV_YREG + ENV_Size(CPREG));
+#endif /* FROZEN_STACKS */
+      WRITEBACK_Y_AS_ENV();
+      ENDCACHE_Y_AS_ENV();
+      GONext();
+
+    NoStackDeallocate:
+      BEGD(d0);
+#ifdef SHADOW_S
+      Yap_REGS.S_ = YREG;
+#endif
+      PREG = NEXTOP(PREG,p);
+      saveregs();
+      d0 = interrupt_deallocate( PASS_REGS1 );
+      setregs();
+      PREG = PREVOP(PREG,p);
+#ifdef SHADOW_S
+      SREG = Yap_REGS.S_;
+#endif
+      // return to original deallocate
+      if (!d0) FAIL();
+      JMPNext();
+      ENDD(d0);
+      ENDOp();
+
+      /**********************************************
+       *        OPTYap instructions                  *
+       **********************************************/
+
+#ifdef YAPOR
+#include "or.insts.h"
+#endif /* YAPOR */
+#ifdef TABLING
+#include "tab.insts.h"
+#include "tab.tries.insts.h"
+#endif /* TABLING */
+
+
+
+#ifdef BEAM
+      extern int eam_am(PredEntry *);
+
+      Op(retry_eam, e);
+      printf("Aqui estou eu..................\n");
+      if (!eam_am(2)) {
+        abort_eam("Falhei\n");
+        FAIL();
+      }
+
+      goto procceed;
+      PREG = NEXTOP(PREG, e);
+      GONext();
+      ENDOp();
+
+      Op(run_eam, os);
+      if (inp==-9000) { /* use indexing to find out valid alternatives */
+        extern CELL *beam_ALTERNATIVES;
+        *beam_ALTERNATIVES= (CELL *) PREG->y_u.os.opcw;
+        beam_ALTERNATIVES++;
+        if (OLD_B!=B) goto fail;
+#if PUSH_REGS
+        Yap_regp=old_regs;
+#endif
+        return(0);
+      }
+
+      saveregs();
+      if (!eam_am((PredEntry *) PREG->y_u.os.s)) FAIL();
+      setregs();
+
+      /* cut */
+      BACKUP_B();
+      while (POP_CHOICE_POINT(B->cp_b)) {
+        POP_EXECUTE();
+      }
+      B = B->cp_b;  /* cut_fail */
+      HB = B->cp_h; /* cut_fail */
+      RECOVER_B();
+
+      if (0) { register choiceptr ccp;
+        /* initialize ccp */
+#define NORM_CP(CP)            ((choiceptr)(CP))
+
+        YREG = (CELL *) (NORM_CP(YREG) - 1);
+        ccp = NORM_CP(YREG);
+        store_yaam_reg_cpdepth(ccp);
+        ccp->cp_tr = TR;
+        ccp->cp_ap = BEAM_RETRY_CODE;
+        ccp->cp_h  = HR;
+        ccp->cp_b  = B;
+        ccp->cp_env= ENV;
+        ccp->cp_cp = CPREG;
+        B = ccp;
+        SET_BB(B);
+      }
+      goto procceed;
+      PREG = NEXTOP(PREG, os);
+      GONext();
+      ENDOp();
+#endif
+
+
+
--- a/C/corout.c
+++ b/C/corout.c
@ -15,7 +15,7 @@
 *									 *
 *************************************************************************/
 #ifdef SCCS
-static char SccsId[]="%W% %G%";
+static char SccsId[] = "%W% %G%";
 #endif

 #include "Yap.h"
@ -30,23 +30,20 @@ static char SccsId[]="%W% %G%";
 #ifdef COROUTINING

 /* check if variable was there */
-static Term AddVarIfNotThere(Term var , Term dest USES_REGS)
-{
+static Term AddVarIfNotThere(Term var, Term dest USES_REGS) {
  Term test = dest;
  while (test != TermNil) {
-    if ((RepPair(test))[0] == var) return(dest);
-    else test = (RepPair(test))[1];
+    if ((RepPair(test))[0] == var)
+      return (dest);
+    else
+      test = (RepPair(test))[1];
  }
-  return(MkPairTerm(var,dest));
+  return (MkPairTerm(var, dest));
 }

-
 /* This routine verifies whether two complex structures can unify. */
-static int can_unify_complex(register CELL *pt0,
-		register CELL *pt0_end,
-		register CELL *pt1,
-		Term  *Vars USES_REGS)
-{
+static int can_unify_complex(register CELL *pt0, register CELL *pt0_end,
+                             register CELL *pt1, Term *Vars USES_REGS) {

  /* This is really just unification, folks */
  tr_fr_ptr saved_TR;
@ -60,133 +57,141 @@ static int can_unify_complex(register CELL *pt0,
  saved_TR = TR;
  saved_B = B;
  saved_HB = HB;
-  HB = H;
+  HB = HR;

- loop:
+loop:
  while (pt0 < pt0_end) {
    register CELL d0, d1;
-    ++ pt0;
-    ++ pt1;
+    ++pt0;
+    ++pt1;
    d0 = Derefa(pt0);
    d1 = Derefa(pt1);
    if (IsVarTerm(d0)) {
      if (IsVarTerm(d1)) {
-	if (d0 != d1) {
-	  /* we need to suspend on both variables ! */
-	  *Vars = AddVarIfNotThere(d0, AddVarIfNotThere(d1,*Vars PASS_REGS) PASS_REGS);
-	  /* bind the two variables, we would have to do that to unify
-	     them */
-	  if (d1 > d0) { /* youngest */
-	    /* we don't want to wake up goals */
-	    Bind_Global((CELL *)d1, d0);
-	  } else {
-	    Bind_Global((CELL *)d0, d1);
-	  }
-	}
-	/* continue the loop */
-	continue;
-      }
-      else {
-	/* oh no, some more variables! */
-	*Vars = AddVarIfNotThere(d0, *Vars PASS_REGS);
+        if (d0 != d1) {
+          /* we need to suspend on both variables ! */
+          *Vars = AddVarIfNotThere(d0, AddVarIfNotThere(d1, *Vars PASS_REGS)
+                                           PASS_REGS);
+          /* bind the two variables, we would have to do that to unify
+             them */
+          if (d1 > d0) { /* youngest */
+            /* we don't want to wake up goals */
+            Bind_Global_NonAtt((CELL *)d1, d0);
+          } else {
+            Bind_Global_NonAtt((CELL *)d0, d1);
+          }
+        }
+        /* continue the loop */
+        continue;
+      } else {
+        /* oh no, some more variables! */
+        *Vars = AddVarIfNotThere(d0, *Vars PASS_REGS);
      }
      /* now bind it */
-      Bind_Global((CELL *)d0, d1);
+      Bind_Global_NonAtt((CELL *)d0, d1);
      /* continue the loop */
-    } else if (IsVarTerm(d1))  {
+    } else if (IsVarTerm(d1)) {
      *Vars = AddVarIfNotThere(d1, *Vars PASS_REGS);
      /* and bind it */
-      Bind_Global((CELL *)d1, d0);
+      Bind_Global_NonAtt((CELL *)d1, d0);
      /* continue the loop */
    } else {
-      if (d0 == d1) continue;
+      if (d0 == d1)
+        continue;
      if (IsAtomOrIntTerm(d0) || IsAtomOrIntTerm(d1)) {
-	  if (d0 != d1) goto comparison_failed;
-	/* else continue the loop */
-      }
-      else if (IsPairTerm(d0)) {
-	if (!IsPairTerm(d1)) goto comparison_failed;
+        if (d0 != d1)
+          goto comparison_failed;
+        /* else continue the loop */
+      } else if (IsPairTerm(d0)) {
+        if (!IsPairTerm(d1))
+          goto comparison_failed;
 #ifdef RATIONAL_TREES
-	to_visit[0] = pt0;
-	to_visit[1] = pt0_end;
-	to_visit[2] = pt1;
-	to_visit[3] = (CELL *)*pt0;
-	to_visit += 4;
-	*pt0 = d1;
+        to_visit[0] = pt0;
+        to_visit[1] = pt0_end;
+        to_visit[2] = pt1;
+        to_visit[3] = (CELL *)*pt0;
+        to_visit += 4;
+        *pt0 = d1;
 #else
-	/* store the terms to visit */
-	if (pt0 < pt0_end) {
-	  to_visit[0] = pt0;
-	  to_visit[1] = pt0_end;
-	  to_visit[2] = pt1;
-	  to_visit += 3;
-	}
+        /* store the terms to visit */
+        if (pt0 < pt0_end) {
+          to_visit[0] = pt0;
+          to_visit[1] = pt0_end;
+          to_visit[2] = pt1;
+          to_visit += 3;
+        }
 #endif
-	pt0 = RepPair(d0) - 1;
-	pt0_end = RepPair(d0) + 1;
-	pt1 = RepPair(d1) - 1;
-	continue;
-      }
-      else if (IsApplTerm(d0)) {
-	register Functor f;
-	register CELL *ap2, *ap3;
-	if (!IsApplTerm(d1)) {
-	  goto comparison_failed;
-	} else {
-	  /* store the terms to visit */
-	  ap2 = RepAppl(d0);
-	  ap3 = RepAppl(d1);
-	  f = (Functor)(*ap2);
-	  /* compare functors */
-	  if (f != (Functor)*ap3) {
-	    goto comparison_failed;
-	  }
-	  if (IsExtensionFunctor(f)) {
-	    switch((CELL)f) {
-	    case (CELL)FunctorDBRef:
-	      if (d0 == d1) continue;
-	      goto comparison_failed;
-	    case (CELL)FunctorLongInt:
-	      if (ap2[1] == ap3[1]) continue;
-	      goto comparison_failed;
-	    case (CELL)FunctorDouble:
-	      if (FloatOfTerm(d0) == FloatOfTerm(d1)) continue;
-	      goto comparison_failed;
+        pt0 = RepPair(d0) - 1;
+        pt0_end = RepPair(d0) + 1;
+        pt1 = RepPair(d1) - 1;
+        continue;
+      } else if (IsApplTerm(d0)) {
+        register Functor f;
+        register CELL *ap2, *ap3;
+        if (!IsApplTerm(d1)) {
+          goto comparison_failed;
+        } else {
+          /* store the terms to visit */
+          ap2 = RepAppl(d0);
+          ap3 = RepAppl(d1);
+          f = (Functor)(*ap2);
+          /* compare functors */
+          if (f != (Functor)*ap3) {
+            goto comparison_failed;
+          }
+          if (IsExtensionFunctor(f)) {
+            switch ((CELL)f) {
+            case (CELL) FunctorDBRef:
+              if (d0 == d1)
+                continue;
+              goto comparison_failed;
+            case (CELL) FunctorLongInt:
+              if (ap2[1] == ap3[1])
+                continue;
+              goto comparison_failed;
+            case (CELL) FunctorDouble:
+              if (FloatOfTerm(d0) == FloatOfTerm(d1))
+                continue;
+              goto comparison_failed;
+            case (CELL) FunctorString:
+              if (strcmp((char *)StringOfTerm(d0), (char *)StringOfTerm(d1)) ==
+                  0)
+                continue;
+              goto comparison_failed;
 #ifdef USE_GMP
-	    case (CELL)FunctorBigInt:
-	      if (Yap_gmp_tcmp_big_big(d0,d1) == 0) continue;
-	      goto comparison_failed;
+            case (CELL) FunctorBigInt:
+              if (Yap_gmp_tcmp_big_big(d0, d1) == 0)
+                continue;
+              goto comparison_failed;
 #endif /* USE_GMP */
-	    default:
-	      goto comparison_failed;
-	    }
-	  }
+            default:
+              goto comparison_failed;
+            }
+          }
 #ifdef RATIONAL_TREES
-	to_visit[0] = pt0;
-	to_visit[1] = pt0_end;
-	to_visit[2] = pt1;
-	to_visit[3] = (CELL *)*pt0;
-	to_visit += 4;
-	*pt0 = d1;
+          to_visit[0] = pt0;
+          to_visit[1] = pt0_end;
+          to_visit[2] = pt1;
+          to_visit[3] = (CELL *)*pt0;
+          to_visit += 4;
+          *pt0 = d1;
 #else
-	  /* store the terms to visit */
-	  if (pt0 < pt0_end) {
-	    to_visit[0] = pt0;
-	    to_visit[1] = pt0_end;
-	    to_visit[2] = pt1;
-	    to_visit += 3;
-	  }
+          /* store the terms to visit */
+          if (pt0 < pt0_end) {
+            to_visit[0] = pt0;
+            to_visit[1] = pt0_end;
+            to_visit[2] = pt1;
+            to_visit += 3;
+          }
 #endif
-	  d0 = ArityOfFunctor(f);
-	  pt0 = ap2;
-	  pt0_end = ap2 + d0;
-	  pt1 = ap3;
-	  continue;
-	}
+          d0 = ArityOfFunctor(f);
+          pt0 = ap2;
+          pt0_end = ap2 + d0;
+          pt1 = ap3;
+          continue;
+        }
      }
-
    }
-
  }
  /* Do we still have compound terms to visit */
  if (to_visit > (CELL **)to_visit_base) {
@ -214,9 +219,9 @@ static int can_unify_complex(register CELL *pt0,
    pt1 = (CELL *)(TrailTerm(--TR));
    RESET_VARIABLE(pt1);
  }
-  return(TRUE);
+  return (TRUE);

- comparison_failed:
+comparison_failed:
  /* failure */
  Yap_ReleasePreAllocCodeSpace((ADDR)to_visit);
 #ifdef RATIONAL_TREES
@ -229,15 +234,18 @@ static int can_unify_complex(register CELL *pt0,
  }
 #endif
  /* restore B, and later HB */
-  B  = saved_B;
+  B = saved_B;
  HB = saved_HB;
+  /* untrail all bindings made by IUnify */
+  while (TR != saved_TR) {
+    pt1 = (CELL *)(TrailTerm(--TR));
+    RESET_VARIABLE(pt1);
+  }
  /* the system will take care of TR for me, no need to worry here! */
-  return(FALSE);
+  return (FALSE);
 }

-static int
-can_unify(Term t1, Term t2, Term *Vars USES_REGS)
-{
+static int can_unify(Term t1, Term t2, Term *Vars USES_REGS) {
  t1 = Deref(t1);
  t2 = Deref(t2);
  if (t1 == t2) {
@ -248,16 +256,16 @@ can_unify(Term t1, Term t2, Term *Vars USES_REGS)
    /* we know for sure  they can't be different */
    if (IsVarTerm(t2)) {
      /* we need to suspend on both variables because otherwise
-	 Y = susp(_) would not wakeup susp ! */
-      *Vars = MkPairTerm(t1,MkPairTerm(t2,TermNil));
+         Y = susp(_) would not wakeup susp ! */
+      *Vars = MkPairTerm(t1, MkPairTerm(t2, TermNil));
      return TRUE;
    } else {
-      *Vars = MkPairTerm(t1,TermNil);
+      *Vars = MkPairTerm(t1, TermNil);
      return TRUE;
    }
  } else if (IsVarTerm(t2)) {
    /* wait until t2 is bound */
-    *Vars = MkPairTerm(t2,TermNil);
+    *Vars = MkPairTerm(t2, TermNil);
    return TRUE;
  }
  /* Two standard terms at last! */
@ -273,53 +281,59 @@ can_unify(Term t1, Term t2, Term *Vars USES_REGS)
    }
  } else if (IsPairTerm(t1)) {
    if (IsPairTerm(t2)) {
-      return(can_unify_complex(RepPair(t1)-1, RepPair(t1)+1,
-			       RepPair(t2)-1, Vars PASS_REGS));
-    } else return FALSE;
+      return (can_unify_complex(RepPair(t1) - 1, RepPair(t1) + 1,
+                                RepPair(t2) - 1, Vars PASS_REGS));
+    } else
+      return FALSE;
  } else {
    Functor f = FunctorOfTerm(t1);
    if (f != FunctorOfTerm(t2))
      return FALSE;
    if (IsExtensionFunctor(f)) {
-      switch((CELL)f) {
-      case (CELL)FunctorDBRef:
-	if (t1 == t2) return FALSE;
-	return FALSE;
-      case (CELL)FunctorLongInt:
-	if (RepAppl(t1)[1] == RepAppl(t2)[1]) return(TRUE);
-	return FALSE;
-      case (CELL)FunctorDouble:
-	if (FloatOfTerm(t1) == FloatOfTerm(t2)) return(TRUE);
-	return FALSE;
+      switch ((CELL)f) {
+      case (CELL) FunctorDBRef:
+        if (t1 == t2)
+          return FALSE;
+        return FALSE;
+      case (CELL) FunctorLongInt:
+        if (RepAppl(t1)[1] == RepAppl(t2)[1])
+          return (TRUE);
+        return FALSE;
+      case (CELL) FunctorString:
+        if (strcmp((char *)StringOfTerm(t1), (char *)StringOfTerm(t2)) == 0)
+          return (TRUE);
+        return FALSE;
+      case (CELL) FunctorDouble:
+        if (FloatOfTerm(t1) == FloatOfTerm(t2))
+          return (TRUE);
+        return FALSE;
 #ifdef USE_GMP
-      case (CELL)FunctorBigInt:
-	if (Yap_gmp_tcmp_big_big(t1,t2) == 0) return(TRUE);
-	return(FALSE);
+      case (CELL) FunctorBigInt:
+        if (Yap_gmp_tcmp_big_big(t1, t2) == 0)
+          return (TRUE);
+        return (FALSE);
 #endif /* USE_GMP */
      default:
-	return FALSE;
+        return FALSE;
      }
    }
    /* Two complex terms with the same functor */
-    return can_unify_complex(RepAppl(t1),
-			     RepAppl(t1)+ArityOfFunctor(f),
-			     RepAppl(t2), Vars PASS_REGS);
+    return can_unify_complex(RepAppl(t1), RepAppl(t1) + ArityOfFunctor(f),
+                             RepAppl(t2), Vars PASS_REGS);
  }
 }

 /* This routine verifies whether a complex has variables. */
-static int non_ground_complex(register CELL *pt0,
-		register CELL *pt0_end,
-		Term  *Var USES_REGS)
-{
+static int non_ground_complex(register CELL *pt0, register CELL *pt0_end,
+                              Term *Var USES_REGS) {

  register CELL **to_visit = (CELL **)Yap_PreAllocCodeSpace();
  CELL **to_visit_base = to_visit;

- loop:
+loop:
  while (pt0 < pt0_end) {
    register CELL d0;
-    ++ pt0;
+    ++pt0;
    d0 = Derefa(pt0);
    if (IsVarTerm(d0)) {
      *Var = d0;
@ -327,7 +341,7 @@ static int non_ground_complex(register CELL *pt0,
    }
    if (IsPairTerm(d0)) {
      if (to_visit + 1024 >= (CELL **)AuxSp) {
-	goto aux_overflow;
+        goto aux_overflow;
      }
 #ifdef RATIONAL_TREES
      to_visit[0] = pt0;
@ -338,15 +352,14 @@ static int non_ground_complex(register CELL *pt0,
 #else
      /* store the terms to visit */
      if (pt0 < pt0_end) {
-	to_visit[0] = pt0;
-	to_visit[1] = pt0_end;
-	to_visit += 2;
+        to_visit[0] = pt0;
+        to_visit[1] = pt0_end;
+        to_visit += 2;
      }
 #endif
      pt0 = RepPair(d0) - 1;
      pt0_end = RepPair(d0) + 1;
-    }
-    else if (IsApplTerm(d0)) {
+    } else if (IsApplTerm(d0)) {
      register Functor f;
      register CELL *ap2;

@ -355,10 +368,10 @@ static int non_ground_complex(register CELL *pt0,
      f = (Functor)(*ap2);

      if (IsExtensionFunctor(f)) {
-	continue;
+        continue;
      }
      if (to_visit + 1024 >= (CELL **)AuxSp) {
-	goto aux_overflow;
+        goto aux_overflow;
      }
 #ifdef RATIONAL_TREES
      to_visit[0] = pt0;
@ -369,9 +382,9 @@ static int non_ground_complex(register CELL *pt0,
 #else
      /* store the terms to visit */
      if (pt0 < pt0_end) {
-	to_visit[0] = pt0;
-	to_visit[1] = pt0_end;
-	to_visit += 2;
+        to_visit[0] = pt0;
+        to_visit[1] = pt0_end;
+        to_visit += 2;
      }
 #endif
      d0 = ArityOfFunctor(f);
@ -400,7 +413,7 @@ static int non_ground_complex(register CELL *pt0,
  Yap_ReleasePreAllocCodeSpace((ADDR)to_visit);
  return FALSE;

- var_found:
+var_found:
  /* the term is non-ground */
  Yap_ReleasePreAllocCodeSpace((ADDR)to_visit);
 #ifdef RATIONAL_TREES
@ -414,7 +427,7 @@ static int non_ground_complex(register CELL *pt0,
  /* the system will take care of TR for me, no need to worry here! */
  return TRUE;

- aux_overflow:
+aux_overflow:
  /* unwind stack */
  Yap_ReleasePreAllocCodeSpace((ADDR)to_visit);
 #ifdef RATIONAL_TREES
@ -427,9 +440,7 @@ static int non_ground_complex(register CELL *pt0,
  return -1;
 }

-static int
-non_ground(Term t, Term *Var USES_REGS)
-{
+static int non_ground(Term t, Term *Var USES_REGS) {
  int out = -1;
  while (out < 0) {
    t = Deref(t);
@ -441,24 +452,24 @@ non_ground(Term t, Term *Var USES_REGS)
    if (IsPrimitiveTerm(t)) {
      return FALSE;
    } else if (IsPairTerm(t)) {
-      out = non_ground_complex(RepPair(t)-1, RepPair(t)+1, Var PASS_REGS);
+      out = non_ground_complex(RepPair(t) - 1, RepPair(t) + 1, Var PASS_REGS);
      if (out >= 0)
-	return out;
+        return out;
    } else {
      Functor f = FunctorOfTerm(t);
      if (IsExtensionFunctor(f)) {
-	return FALSE;
+        return FALSE;
      }
      out = non_ground_complex(RepAppl(t),
-			       RepAppl(t)+ArityOfFunctor(FunctorOfTerm(t)),
-			       Var PASS_REGS);
+                               RepAppl(t) + ArityOfFunctor(FunctorOfTerm(t)),
+                               Var PASS_REGS);
      if (out >= 0)
-	return out;
+        return out;
    }
    if (!Yap_ExpandPreAllocCodeSpace(0, NULL, TRUE)) {
-      Yap_Error(OUT_OF_AUXSPACE_ERROR, ARG1, "overflow in ground");
+      Yap_Error(RESOURCE_ERROR_AUXILIARY_STACK, ARG1, "overflow in ground");
      return FALSE;
-    }      
+    }
  }
  return FALSE;
 }
@ -467,8 +478,7 @@ non_ground(Term t, Term *Var USES_REGS)

 /* check whether the two terms unify and return what variables should
   be bound before the terms are exactly equal */
-static Int p_can_unify( USES_REGS1 )
-{
+static Int p_can_unify(USES_REGS1) {
 #ifdef COROUTINING
  Term r = TermNil;
  if (!can_unify(ARG1, ARG2, &r PASS_REGS))
@ -480,60 +490,53 @@ static Int p_can_unify( USES_REGS1 )
 }

 /* if the term is not ground return a variable in the term */
-static Int p_non_ground( USES_REGS1 )
-{
+static Int p_non_ground(USES_REGS1) {
 #ifdef COROUTINING
  Term r = TermNil;
  if (!non_ground(ARG1, &r PASS_REGS))
-    return(FALSE);
+    return (FALSE);
  return (Yap_unify(ARG2, r));
 #else
-  return(FALSE);
+  return (FALSE);
 #endif
 }

 /* if the term is not ground return a variable in the term */
-static Int p_coroutining( USES_REGS1 )
-{
+static Int p_coroutining(USES_REGS1) {
 #ifdef COROUTINING
-  return(TRUE);
+  return (TRUE);
 #else
-  return(FALSE);
+  return (FALSE);
 #endif
 }

 #if COROUTINING
-static Term
-ListOfWokenGoals( USES_REGS1 ) {
+static Term ListOfWokenGoals(USES_REGS1) {
  return Yap_ReadTimedVar(LOCAL_WokenGoals);
 }

-Term
-Yap_ListOfWokenGoals(void) {
+Term Yap_ListOfWokenGoals(void) {
  CACHE_REGS
-  return ListOfWokenGoals( PASS_REGS1 );
+  return ListOfWokenGoals(PASS_REGS1);
 }
 #endif

 /* return a list of awoken goals */
-static Int p_awoken_goals( USES_REGS1 )
-{
+static Int p_awoken_goals(USES_REGS1) {
 #ifdef COROUTINING
  Term WGs = Yap_ReadTimedVar(LOCAL_WokenGoals);
  if (WGs == TermNil) {
-    return(FALSE);
+    return (FALSE);
  }
-  WGs = ListOfWokenGoals( PASS_REGS1 );
+  WGs = ListOfWokenGoals(PASS_REGS1);
  Yap_UpdateTimedVar(LOCAL_WokenGoals, TermNil);
-  return(Yap_unify(ARG1,WGs));
+  return (Yap_unify(ARG1, WGs));
 #else
-  return(FALSE);
+  return (FALSE);
 #endif
 }

-static Int
-p_yap_has_rational_trees( USES_REGS1 )
-{
+static Int p_yap_has_rational_trees(USES_REGS1) {
 #if RATIONAL_TREES
  return TRUE;
 #else
@ -541,9 +544,7 @@ p_yap_has_rational_trees( USES_REGS1 )
 #endif
 }

-static Int
-p_yap_has_coroutining( USES_REGS1 )
-{
+static Int p_yap_has_coroutining(USES_REGS1) {
 #if COROUTINING
  return TRUE;
 #else
@ -551,24 +552,21 @@ p_yap_has_coroutining( USES_REGS1 )
 #endif
 }

-void
-Yap_InitCoroutPreds( void )
-{
+void Yap_InitCoroutPreds(void) {
 #ifdef COROUTINING
-  Atom            at;
-  PredEntry      *pred;
+  Atom at;
+  PredEntry *pred;

  at = AtomWakeUpGoal;
-  pred = RepPredProp(PredPropByFunc(Yap_MkFunctor(at, 2),0));
+  pred = RepPredProp(PredPropByFunc(Yap_MkFunctor(at, 2), 0));
  WakeUpCode = pred;
 #endif
  Yap_InitAttVarPreds();
-  Yap_InitCPred("$yap_has_rational_trees", 0, p_yap_has_rational_trees, SafePredFlag|HiddenPredFlag);
-  Yap_InitCPred("$yap_has_coroutining", 0, p_yap_has_coroutining, SafePredFlag|HiddenPredFlag);
-  Yap_InitCPred("$can_unify", 3, p_can_unify, SafePredFlag|HiddenPredFlag);
-  Yap_InitCPred("$non_ground", 2, p_non_ground, SafePredFlag|HiddenPredFlag);
-  Yap_InitCPred("$coroutining", 0, p_coroutining, SafePredFlag|HiddenPredFlag);
-  Yap_InitCPred("$awoken_goals", 1, p_awoken_goals, SafePredFlag|HiddenPredFlag);
+  Yap_InitCPred("$yap_has_rational_trees", 0, p_yap_has_rational_trees,
+                SafePredFlag);
+  Yap_InitCPred("$yap_has_coroutining", 0, p_yap_has_coroutining, SafePredFlag);
+  Yap_InitCPred("$can_unify", 3, p_can_unify, SafePredFlag);
+  Yap_InitCPred("$non_ground", 2, p_non_ground, SafePredFlag);
+  Yap_InitCPred("$coroutining", 0, p_coroutining, SafePredFlag);
+  Yap_InitCPred("$awoken_goals", 1, p_awoken_goals, SafePredFlag);
 }
-
-
--- a/C/cp_absmi_insts.h
+++ b/C/cp_absmi_insts.h
--- a/C/cut_c.c
+++ b/C/cut_c.c
@ -1,12 +1,10 @@
-#ifdef CUT_C
-
 #include "Yap.h"
 #include "cut_c.h"
 #include <stdio.h>

-void cut_c_initialize(void){
+void cut_c_initialize(int wid){
  CACHE_REGS
-  Yap_REGS.CUT_C_TOP=(cut_c_str_ptr)LOCAL_LocalBase;
+    Yap_REGS.CUT_C_TOP=(cut_c_str_ptr)REMOTE_LocalBase(wid);
 }

 /*Removes a choice_point from the stack*/
@ -33,5 +31,3 @@ void cut_c_push(cut_c_str_ptr new_top){
  Yap_REGS.CUT_C_TOP=new_top;
  return;
 }
-
-#endif /*CUT_C*/
--- a/C/dbase.c
+++ b/C/dbase.c
--- a/C/dbload.c
+++ b/C/dbload.c
@ -0,0 +1,459 @@
+/*************************************************************************
+ *									 *
+ *	 YAP Prolog 							 *
+ *									 *
+ *	Yap Prolog was developed at NCCUP - Universidade do Porto	 *
+ *									 *
+ * Copyright L.Damas, V.S.Costa and Universidade do Porto 1985-1997	 *
+ *									 *
+ **************************************************************************
+ *									 *
+ * File:		cdmgr.c *
+ * comments:	Code manager						 *
+ *									 *
+ * Last rev:     $Date: 2008-07-22 23:34:44 $,$Author: vsc $              8
+ *************************************************************************/
+
+#include "Yap.h"
+#include "YapEval.h"
+#include "clause.h"
+#include "tracer.h"
+#include "yapio.h"
+
+#include <Yatom.h>
+#include <assert.h>
+#include <heapgc.h>
+#include <iopreds.h>
+
+
+
+#ifdef DEBUG
+static UInt total_megaclause, total_released, nof_megaclauses;
+#endif
+
+/******************************************************************
+
+                Mega Clauses
+
+******************************************************************/
+
+#define OrArgAdjust(P)
+#define TabEntryAdjust(P)
+#define DoubleInCodeAdjust(D)
+#define IntegerInCodeAdjust(D)
+#define IntegerAdjust(D) (D)
+#define PtoPredAdjust(X) (X)
+#define PtoOpAdjust(X) (X)
+#define PtoLUClauseAdjust(P) (P)
+#define PtoLUIndexAdjust(P) (P)
+#define XAdjust(X) (X)
+#define YAdjust(X) (X)
+#define AtomTermAdjust(X) (X)
+#define CellPtoHeapAdjust(X) (X)
+#define FuncAdjust(X) (X)
+#define CodeAddrAdjust(X) (X)
+#define CodeComposedTermAdjust(X) (X)
+#define ConstantAdjust(X) (X)
+#define ArityAdjust(X) (X)
+#define OpcodeAdjust(X) (X)
+#define ModuleAdjust(X) (X)
+#define ExternalFunctionAdjust(X) (X)
+#define AdjustSwitchTable(X, Y, Z)
+#define DBGroundTermAdjust(X) (X)
+#define rehash(A, B, C)
+
+static Term BlobTermInCodeAdjust(Term t) {
+  CACHE_REGS
+#if TAGS_FAST_OPS
+  return t - LOCAL_ClDiff;
+#else
+  return t + LOCAL_ClDiff;
+#endif
+}
+
+static Term ConstantTermAdjust(Term t) {
+  if (IsAtomTerm(t))
+    return AtomTermAdjust(t);
+  return t;
+}
+
+#include "rclause.h"
+
+
+void Yap_BuildMegaClause(PredEntry *ap) {
+  CACHE_REGS
+  StaticClause *cl;
+  UInt sz;
+  MegaClause *mcl;
+  yamop *ptr;
+  size_t required;
+  UInt has_blobs = 0;
+
+  if (ap->PredFlags & (DynamicPredFlag | LogUpdatePredFlag | MegaClausePredFlag
+#ifdef TABLING
+		       | TabledPredFlag
+#endif /* TABLING */
+		       | UDIPredFlag) ||
+      ap->cs.p_code.FirstClause == NULL || ap->cs.p_code.NOfClauses < 16) {
+    return;
+  }
+  cl = ClauseCodeToStaticClause(ap->cs.p_code.FirstClause);
+  sz = cl->ClSize;
+  while (TRUE) {
+    if (!(cl->ClFlags & FactMask))
+      return; /* no mega clause, sorry */
+    if (cl->ClSize != sz)
+      return; /* no mega clause, sorry */
+    if (cl->ClCode == ap->cs.p_code.LastClause)
+      break;
+    has_blobs |= (cl->ClFlags & HasBlobsMask);
+    cl = cl->ClNext;
+  }
+  /* ok, we got the chance for a mega clause */
+  if (has_blobs) {
+    sz -= sizeof(StaticClause);
+  } else {
+    sz -= (UInt)NEXTOP((yamop *)NULL, p) + sizeof(StaticClause);
+  }
+  required = sz * ap->cs.p_code.NOfClauses + sizeof(MegaClause) +
+             (UInt)NEXTOP((yamop *)NULL, l);
+  while (!(mcl = (MegaClause *)Yap_AllocCodeSpace(required))) {
+    if (!Yap_growheap(FALSE, required, NULL)) {
+      /* just fail, the system will keep on going */
+      return;
+    }
+  }
+#ifdef DEBUG
+  total_megaclause += required;
+  cl = ClauseCodeToStaticClause(ap->cs.p_code.FirstClause);
+  total_released += ap->cs.p_code.NOfClauses * cl->ClSize;
+  nof_megaclauses++;
+#endif
+  Yap_ClauseSpace += required;
+  /* cool, it's our turn to do the conversion */
+  mcl->ClFlags = MegaMask | has_blobs;
+  mcl->ClSize = required;
+  mcl->ClPred = ap;
+  mcl->ClItemSize = sz;
+  mcl->ClNext = NULL;
+  cl = ClauseCodeToStaticClause(ap->cs.p_code.FirstClause);
+  mcl->ClLine = cl->usc.ClLine;
+  ptr = mcl->ClCode;
+  while (TRUE) {
+    memmove((void *)ptr, (void *)cl->ClCode, sz);
+    if (has_blobs) {
+      LOCAL_ClDiff = (char *)(ptr) - (char *)cl->ClCode;
+      restore_opcodes(ptr, NULL PASS_REGS);
+    }
+    ptr = (yamop *)((char *)ptr + sz);
+    if (cl->ClCode == ap->cs.p_code.LastClause)
+      break;
+    cl = cl->ClNext;
+  }
+  ptr->opc = Yap_opcode(_Ystop);
+  cl = ClauseCodeToStaticClause(ap->cs.p_code.FirstClause);
+  /* recover the space spent on the original clauses */
+  while (TRUE) {
+    StaticClause *ncl, *curcl = cl;
+
+    ncl = cl->ClNext;
+    Yap_InformOfRemoval(cl);
+    Yap_ClauseSpace -= cl->ClSize;
+    Yap_FreeCodeSpace((ADDR)cl);
+    if (curcl->ClCode == ap->cs.p_code.LastClause)
+      break;
+    cl = ncl;
+  }
+  ap->cs.p_code.FirstClause = ap->cs.p_code.LastClause = mcl->ClCode;
+  ap->PredFlags |= MegaClausePredFlag;
+  Yap_inform_profiler_of_clause(mcl, (char *)mcl + required, ap, GPROF_MEGA);
+}
+
+void Yap_split_megaclause(PredEntry *ap) {
+  StaticClause *start = NULL, *prev = NULL;
+  MegaClause *mcl;
+  yamop *ptr;
+  UInt ncls = ap->cs.p_code.NOfClauses, i;
+
+  mcl = ClauseCodeToMegaClause(ap->cs.p_code.FirstClause);
+  if (mcl->ClFlags & ExoMask) {
+    Yap_Error(PERMISSION_ERROR_MODIFY_STATIC_PROCEDURE, Yap_PredicateToIndicator(ap),
+              "while deleting clause from exo predicate %s/%d\n",
+              RepAtom(NameOfFunctor(ap->FunctorOfPred))->StrOfAE,
+              ap->ArityOfPE);
+    return;
+  }
+  for (i = 0, ptr = mcl->ClCode; i < ncls; i++) {
+    StaticClause *new = (StaticClause *)Yap_AllocCodeSpace(
+        sizeof(StaticClause) + mcl->ClItemSize +
+        (UInt)NEXTOP((yamop *)NULL, p));
+    if (new == NULL) {
+      if (!Yap_growheap(FALSE,
+                        (sizeof(StaticClause) + mcl->ClItemSize) * (ncls - i),
+                        NULL)) {
+        while (start) {
+          StaticClause *cl = start;
+          start = cl->ClNext;
+          Yap_InformOfRemoval(cl);
+          Yap_ClauseSpace -= cl->ClSize;
+          Yap_FreeCodeSpace((char *)cl);
+        }
+        if (ap->ArityOfPE) {
+          Yap_Error(RESOURCE_ERROR_HEAP, TermNil,
+                    "while breaking up mega clause for %s/%d\n",
+                    RepAtom(NameOfFunctor(ap->FunctorOfPred))->StrOfAE,
+                    ap->ArityOfPE);
+        } else {
+          Yap_Error(RESOURCE_ERROR_HEAP, TermNil,
+                    "while breaking up mega clause for %s\n",
+                    RepAtom((Atom)ap->FunctorOfPred)->StrOfAE);
+        }
+        return;
+      }
+      break;
+    }
+    Yap_ClauseSpace +=
+        sizeof(StaticClause) + mcl->ClItemSize + (UInt)NEXTOP((yamop *)NULL, p);
+    new->ClFlags = StaticMask | FactMask;
+    new->ClSize = mcl->ClItemSize;
+    new->usc.ClLine = Yap_source_line_no();
+    new->ClNext = NULL;
+    memmove((void *)new->ClCode, (void *)ptr, mcl->ClItemSize);
+    if (prev) {
+      prev->ClNext = new;
+    } else {
+      start = new;
+    }
+    ptr = (yamop *)((char *)ptr + mcl->ClItemSize);
+    prev = new;
+  }
+  ap->PredFlags &= ~MegaClausePredFlag;
+  ap->cs.p_code.FirstClause = start->ClCode;
+  ap->cs.p_code.LastClause = prev->ClCode;
+}
+
+
+static UInt compute_dbcl_size(arity_t arity) {
+  UInt sz;
+  switch (arity) {
+  case 2:
+    sz = (UInt)NEXTOP((yamop *)NULL, cc);
+    break;
+  case 3:
+    sz = (UInt)NEXTOP((yamop *)NULL, ccc);
+    break;
+  case 4:
+    sz = (UInt)NEXTOP((yamop *)NULL, cccc);
+    break;
+  case 5:
+    sz = (UInt)NEXTOP((yamop *)NULL, ccccc);
+    break;
+  case 6:
+    sz = (UInt)NEXTOP((yamop *)NULL, cccccc);
+    break;
+  default:
+    sz = arity * (UInt)NEXTOP((yamop *)NULL, xc);
+    break;
+  }
+  return (UInt)NEXTOP((yamop *)sz, p);
+}
+
+#define DerefAndCheck(t, V)                                                    \
+  t = Deref(V);                                                                \
+  if (IsVarTerm(t) || !(IsAtomOrIntTerm(t)))                                   \
+    Yap_Error(TYPE_ERROR_ATOM, t0, "load_db");
+
+static int store_dbcl_size(yamop *pc, arity_t arity, Term t0, PredEntry *pe) {
+  Term t;
+  CELL *tp = RepAppl(t0) + 1;
+  switch (arity) {
+  case 2:
+    pc->opc = Yap_opcode(_get_2atoms);
+    DerefAndCheck(t, tp[0]);
+    pc->y_u.cc.c1 = t;
+    DerefAndCheck(t, tp[1]);
+    pc->y_u.cc.c2 = t;
+    pc = NEXTOP(pc, cc);
+    break;
+  case 3:
+    pc->opc = Yap_opcode(_get_3atoms);
+    DerefAndCheck(t, tp[0]);
+    pc->y_u.ccc.c1 = t;
+    DerefAndCheck(t, tp[1]);
+    pc->y_u.ccc.c2 = t;
+    DerefAndCheck(t, tp[2]);
+    pc->y_u.ccc.c3 = t;
+    pc = NEXTOP(pc, ccc);
+    break;
+  case 4:
+    pc->opc = Yap_opcode(_get_4atoms);
+    DerefAndCheck(t, tp[0]);
+    pc->y_u.cccc.c1 = t;
+    DerefAndCheck(t, tp[1]);
+    pc->y_u.cccc.c2 = t;
+    DerefAndCheck(t, tp[2]);
+    pc->y_u.cccc.c3 = t;
+    DerefAndCheck(t, tp[3]);
+    pc->y_u.cccc.c4 = t;
+    pc = NEXTOP(pc, cccc);
+    break;
+  case 5:
+    pc->opc = Yap_opcode(_get_5atoms);
+    DerefAndCheck(t, tp[0]);
+    pc->y_u.ccccc.c1 = t;
+    DerefAndCheck(t, tp[1]);
+    pc->y_u.ccccc.c2 = t;
+    DerefAndCheck(t, tp[2]);
+    pc->y_u.ccccc.c3 = t;
+    DerefAndCheck(t, tp[3]);
+    pc->y_u.ccccc.c4 = t;
+    DerefAndCheck(t, tp[4]);
+    pc->y_u.ccccc.c5 = t;
+    pc = NEXTOP(pc, ccccc);
+    break;
+  case 6:
+    pc->opc = Yap_opcode(_get_6atoms);
+    DerefAndCheck(t, tp[0]);
+    pc->y_u.cccccc.c1 = t;
+    DerefAndCheck(t, tp[1]);
+    pc->y_u.cccccc.c2 = t;
+    DerefAndCheck(t, tp[2]);
+    pc->y_u.cccccc.c3 = t;
+    DerefAndCheck(t, tp[3]);
+    pc->y_u.cccccc.c4 = t;
+    DerefAndCheck(t, tp[4]);
+    pc->y_u.cccccc.c5 = t;
+    DerefAndCheck(t, tp[5]);
+    pc->y_u.cccccc.c6 = t;
+    pc = NEXTOP(pc, cccccc);
+    break;
+  default: {
+    arity_t i;
+    for (i = 0; i < arity; i++) {
+      pc->opc = Yap_opcode(_get_atom);
+#if PRECOMPUTE_REGADDRESS
+      pc->y_u.xc.x = (CELL)(XREGS + (i + 1));
+#else
+      pc->y_u.xc.x = i + 1;
+#endif
+      DerefAndCheck(t, tp[0]);
+      pc->y_u.xc.c = t;
+      tp++;
+      pc = NEXTOP(pc, xc);
+    }
+  } break;
+  }
+  pc->opc = Yap_opcode(_procceed);
+  pc->y_u.p.p = pe;
+  return TRUE;
+}
+
+static Int
+    p_dbload_get_space(USES_REGS1) { /* '$number_of_clauses'(Predicate,M,N) */
+  Term t = Deref(ARG1);
+  Term mod = Deref(ARG2);
+  Term tn = Deref(ARG3);
+  arity_t arity;
+  Prop pe;
+  PredEntry *ap;
+  UInt sz;
+  MegaClause *mcl;
+  yamop *ptr;
+  UInt ncls;
+  UInt required;
+
+  if (IsVarTerm(mod) || !IsAtomTerm(mod)) {
+    return (FALSE);
+  }
+  if (IsAtomTerm(t)) {
+    Atom a = AtomOfTerm(t);
+    arity = 0;
+    pe = PredPropByAtom(a, mod);
+  } else if (IsApplTerm(t)) {
+    register Functor f = FunctorOfTerm(t);
+    arity = ArityOfFunctor(f);
+    pe = PredPropByFunc(f, mod);
+  } else {
+    return FALSE;
+  }
+  if (EndOfPAEntr(pe))
+    return FALSE;
+  ap = RepPredProp(pe);
+  if (ap->PredFlags & (DynamicPredFlag | LogUpdatePredFlag
+#ifdef TABLING
+                       | TabledPredFlag
+#endif /* TABLING */
+                       )) {
+    Yap_Error(PERMISSION_ERROR_MODIFY_STATIC_PROCEDURE,  Yap_PredicateToIndicator(ap),
+              "dbload_get_space/4");
+    return FALSE;
+  }
+  if (IsVarTerm(tn) || !IsIntegerTerm(tn)) {
+    return FALSE;
+  }
+  ncls = IntegerOfTerm(tn);
+  if (ncls <= 1) {
+    return FALSE;
+  }
+
+  sz = compute_dbcl_size(arity);
+  required = sz * ncls + sizeof(MegaClause) + (UInt)NEXTOP((yamop *)NULL, l);
+#ifdef DEBUG
+  total_megaclause += required;
+  nof_megaclauses++;
+#endif
+  while (!(mcl = (MegaClause *)Yap_AllocCodeSpace(required))) {
+    if (!Yap_growheap(FALSE, required, NULL)) {
+      /* just fail, the system will keep on going */
+      return FALSE;
+    }
+  }
+  Yap_ClauseSpace += required;
+  /* cool, it's our turn to do the conversion */
+  mcl->ClFlags = MegaMask;
+  mcl->ClSize = sz * ncls;
+  mcl->ClPred = ap;
+  mcl->ClItemSize = sz;
+  mcl->ClNext = NULL;
+  ap->cs.p_code.FirstClause = ap->cs.p_code.LastClause = mcl->ClCode;
+  ap->PredFlags |= (MegaClausePredFlag);
+  ap->cs.p_code.NOfClauses = ncls;
+  if (ap->PredFlags & (SpiedPredFlag | CountPredFlag | ProfiledPredFlag)) {
+    ap->OpcodeOfPred = Yap_opcode(_spy_pred);
+  } else {
+    ap->OpcodeOfPred = INDEX_OPCODE;
+  }
+  ap->CodeOfPred = ap->cs.p_code.TrueCodeOfPred =
+      (yamop *)(&(ap->OpcodeOfPred));
+  ptr = (yamop *)((ADDR)mcl->ClCode + ncls * sz);
+  ptr->opc = Yap_opcode(_Ystop);
+  return Yap_unify(ARG4, MkIntegerTerm((Int)mcl));
+}
+
+static Int p_dbassert(USES_REGS1) { /* '$number_of_clauses'(Predicate,M,N) */
+  Term thandle = Deref(ARG2);
+  Term tn = Deref(ARG3);
+  PredEntry *pe;
+  MegaClause *mcl;
+  Int n;
+
+  if (IsVarTerm(thandle) || !IsIntegerTerm(thandle)) {
+    return FALSE;
+  }
+  mcl = (MegaClause *)IntegerOfTerm(thandle);
+  if (IsVarTerm(tn) || !IsIntegerTerm(tn)) {
+    return FALSE;
+  }
+  n = IntegerOfTerm(tn);
+  pe = mcl->ClPred;
+  return store_dbcl_size((yamop *)((ADDR)mcl->ClCode + n * (mcl->ClItemSize)),
+                         pe->ArityOfPE, Deref(ARG1), pe);
+}
+
+void Yap_InitDBLoadPreds(void) {
+  CACHE_REGS
+    //CurrentModule = DBLOAD_MODULE;
+  Yap_InitCPred("$dbload_get_space", 4, p_dbload_get_space, 0L);
+  Yap_InitCPred("$dbassert", 3, p_dbassert, 0L);
+  //CurrentModule = cm;
+}
--- a/C/depth_bound.c
+++ b/C/depth_bound.c
@ -18,18 +18,25 @@
 static char     SccsId[] = "%W% %G%";
 #endif /* SCCS */

+#include <math.h>
+
 #include "Yap.h"
+#include "Yatom.h"
+#include "YapEval.h"

 #ifdef DEPTH_LIMIT

 #include "Yatom.h"

-STD_PROTO(static Int p_get_depth_limit, ( USES_REGS1 ));
-STD_PROTO(static Int p_set_depth_limit, ( USES_REGS1 ));
+static Int p_get_depth_limit( USES_REGS1 );
+static Int p_set_depth_limit( USES_REGS1 );

 static Int p_get_depth_limit( USES_REGS1 )
 {
-  return(Yap_unify_constant(ARG1, MkIntTerm(IntOfTerm(DEPTH/2))));
+  Int d = IntOfTerm(DEPTH);
+  if (d % 2 == 1) 
+    return(Yap_unify(ARG1, MkFloatTerm(INFINITY)));
+  return(Yap_unify_constant(ARG1, MkIntTerm(d/2)));
 }

 static Int p_set_depth_limit( USES_REGS1 )
@ -40,8 +47,12 @@ static Int p_set_depth_limit( USES_REGS1 )
    Yap_Error(INSTANTIATION_ERROR, d, "set-depth_limit");
    return(FALSE);
  } else if (!IsIntegerTerm(d)) {
-    Yap_Error(TYPE_ERROR_INTEGER, d, "set-depth_limit");
-    return(FALSE);
+    if (IsFloatTerm(d) && isinf(FloatOfTerm(d))) {
+      d = RESET_DEPTH();
+    } else {
+      Yap_Error(TYPE_ERROR_INTEGER, d, "set-depth_limit");
+      return(FALSE);
+    }
  }
  d = MkIntTerm(IntegerOfTerm(d)*2);

@ -59,6 +70,10 @@ static Int p_set_depth_limit_for_next_call( USES_REGS1 )
    Yap_Error(INSTANTIATION_ERROR, d, "set-depth_limit");
    return(FALSE);
  } else if (!IsIntegerTerm(d)) {
+    if (IsFloatTerm(d) && isinf(FloatOfTerm(d))) {
+      DEPTH = RESET_DEPTH();
+      return TRUE;
+    }
    Yap_Error(TYPE_ERROR_INTEGER, d, "set-depth_limit");
    return(FALSE);
  }
@ -72,8 +87,8 @@ static Int p_set_depth_limit_for_next_call( USES_REGS1 )
 void Yap_InitItDeepenPreds(void)
 {
  Yap_InitCPred("get_depth_limit", 1, p_get_depth_limit, SafePredFlag);
-  Yap_InitCPred("$set_depth_limit", 1, p_set_depth_limit, HiddenPredFlag);
-  Yap_InitCPred("$set_depth_limit_for_next_call", 1, p_set_depth_limit_for_next_call, HiddenPredFlag);
+  Yap_InitCPred("$set_depth_limit", 1, p_set_depth_limit, 0);
+  Yap_InitCPred("$set_depth_limit_for_next_call", 1, p_set_depth_limit_for_next_call, 0);
 }

 #endif
--- a/C/dlmalloc.c
+++ b/C/dlmalloc.c
@ -180,7 +180,7 @@ void
 Yap_add_memory_hole(ADDR start, ADDR end)
 {
  if (Yap_NOfMemoryHoles == MAX_DLMALLOC_HOLES) {
-    Yap_Error(OPERATING_SYSTEM_ERROR, 0L, "Unexpected Too Much Memory Fragmentation: please contact YAP maintainers");
+    Yap_Error(SYSTEM_ERROR_OPERATING_SYSTEM, 0L, "Unexpected Too Much Memory Fragmentation: please contact YAP maintainers");
    return;
  }
  Yap_MemoryHoles[Yap_NOfMemoryHoles].start = start;
@ -1978,7 +1978,7 @@ Void_t* rEALLOc(oldmem, bytes) Void_t* oldmem; size_t bytes;
          assert(ncopies >= 3);
          
          if (ncopies > 9)
-            memcpy(d, s, copysize);
+            memmove(d, s, copysize);
          
          else {
            *(d+0) = *(s+0);
@ -2077,7 +2077,7 @@ Void_t* rEALLOc(oldmem, bytes) Void_t* oldmem; size_t bytes;
      /* Must alloc, copy, free. */
      newmem = mALLOc(nb - MALLOC_ALIGN_MASK);
      if (newmem != 0) {
-        memcpy(newmem, oldmem, oldsize - 2*SIZE_SZ);
+        memmove(newmem, oldmem, oldsize - 2*SIZE_SZ);
        fREe(oldmem);
      }
    }
--- a/C/errors.c
+++ b/C/errors.c
--- a/C/eval.c
+++ b/C/eval.c
@ -15,17 +15,34 @@
 *									 *
 *************************************************************************/
 #ifdef SCCS
-static char     SccsId[] = "%W% %G%";
+static char SccsId[] = "%W% %G%";
 #endif
-
-/*
- * This file implements arithmetic operations 
+/**
+ * @file   eval.c
+ * @author VITOR SANTOS COSTA <vsc@VITORs-MBP-2.lan>
+ * @date   Mon Apr 30 09:37:59 2018
+ * 
+ * @brief  is/2
 *
+ *
+ * @namespace prolog
+ * 
+ * 
+ * 
 */
+
+//! @{
+
+/**
+   @defgroup arithmetic_preds Arithmetic Predicates
+   @ingroup arithmetic
+
+*/
 #include "Yap.h"
-#include "Yatom.h"
+
 #include "YapHeap.h"
-#include "eval.h"
+#include "Yatom.h"
+#include "YapEval.h"
 #if HAVE_STDARG_H
 #include <stdarg.h>
 #endif
@ -33,150 +50,503 @@ static char     SccsId[] = "%W% %G%";
 #if HAVE_UNISTD_H
 #include <unistd.h>
 #endif
+#if HAVE_FENV_H
+#include <fenv.h>
+#endif

+static Term Eval(Term t1 USES_REGS);

+static Term get_matrix_element(Term t1, Term t2 USES_REGS) {
+  if (!IsPairTerm(t2)) {
+    if (t2 == MkAtomTerm(AtomLength)) {
+      Int sz = 1;
+      while (IsApplTerm(t1)) {
+        Functor f = FunctorOfTerm(t1);
+        if (NameOfFunctor(f) != AtomNil) {
+          return MkIntegerTerm(sz);
+        }
+        sz *= ArityOfFunctor(f);
+        t1 = ArgOfTerm(1, t1);
+      }
+      return MkIntegerTerm(sz);
+    }
+    Yap_ArithError(TYPE_ERROR_EVALUABLE, t2, "X is Y^[A]");
+    return FALSE;
+  }
+  while (IsPairTerm(t2)) {
+    Int indx;
+    Term indxt = Eval(HeadOfTerm(t2) PASS_REGS);
+    if (!IsIntegerTerm(indxt)) {
+      Yap_ArithError(TYPE_ERROR_EVALUABLE, t2, "X is Y^[A]");
+      return FALSE;
+    }
+    indx = IntegerOfTerm(indxt);
+    if (!IsApplTerm(t1)) {
+      Yap_ArithError(TYPE_ERROR_EVALUABLE, t1, "X is Y^[A]");
+      return FALSE;
+    } else {
+      Functor f = FunctorOfTerm(t1);
+      if (ArityOfFunctor(f) < indx) {
+        Yap_ArithError(TYPE_ERROR_EVALUABLE, t1, "X is Y^[A]");
+        return FALSE;
+      }
+    }
+    t1 = ArgOfTerm(indx, t1);
+    t2 = TailOfTerm(t2);
+  }
+  if (t2 != TermNil) {
+    Yap_ArithError(TYPE_ERROR_EVALUABLE, t2, "X is Y^[A]");
+    return FALSE;
+  }
+  return Eval(t1 PASS_REGS);
+}
+
+static Term Eval(Term t USES_REGS) {
+  eval_context_t ctx;
+  ctx.p = LOCAL_ctx;

-static Term
-Eval(Term t USES_REGS)
-{
  if (IsVarTerm(t)) {
-    LOCAL_ArithError = TRUE;
-    return Yap_ArithError(INSTANTIATION_ERROR,t,"in arithmetic");
+    Yap_ArithError(INSTANTIATION_ERROR, t, "in arithmetic");
  } else if (IsNumTerm(t)) {
    return t;
  } else if (IsAtomTerm(t)) {
    ExpEntry *p;
-    Atom name  = AtomOfTerm(t);
+    Atom name = AtomOfTerm(t);

    if (EndOfPAEntr(p = RepExpProp(Yap_GetExpProp(name, 0)))) {
-      /* error */
-      return Yap_ArithError(TYPE_ERROR_EVALUABLE, t,
-			    "atom %s for arithmetic expression",
-			    RepAtom(name)->StrOfAE);
+      Yap_ArithError(TYPE_ERROR_EVALUABLE, takeIndicator(t),
+                            "atom %s in arithmetic expression",
+                            RepAtom(name)->StrOfAE);
    }
    return Yap_eval_atom(p->FOfEE);
  } else if (IsApplTerm(t)) {
    Functor fun = FunctorOfTerm(t);
-    if ((Atom)fun == AtomFoundVar) {
-      return Yap_ArithError(TYPE_ERROR_EVALUABLE, TermNil,
-			    "cyclic term in arithmetic expression");
+    if (fun == FunctorString) {
+      const char *s = (const char *)StringOfTerm(t);
+      if (s[1] == '\0')
+        return MkIntegerTerm(s[0]);
+      Yap_ArithError(TYPE_ERROR_EVALUABLE, t,
+                            "string in arithmetic expression");
+    } else if ((Atom)fun == AtomFoundVar) {
+      Yap_ArithError(TYPE_ERROR_EVALUABLE, TermNil,
+                            "cyclic term in arithmetic expression");
    } else {
      Int n = ArityOfFunctor(fun);
-      Atom name  = NameOfFunctor(fun);
+      Atom name = NameOfFunctor(fun);
      ExpEntry *p;
      Term t1, t2;
-      
-      if (EndOfPAEntr(p = RepExpProp(Yap_GetExpProp(name, n)))) {
-	Term ti[2];

-	/* error */
-	ti[0] = t;
-	ti[1] = MkIntegerTerm(n);
-	t = Yap_MkApplTerm(FunctorSlash, 2, ti);
-	return Yap_ArithError(TYPE_ERROR_EVALUABLE, t,
-			      "functor %s/%d for arithmetic expression",
-			      RepAtom(name)->StrOfAE,n);
+      if (EndOfPAEntr(p = RepExpProp(Yap_GetExpProp(name, n)))) {
+        Yap_ArithError(TYPE_ERROR_EVALUABLE, takeIndicator(t),
+                              "functor %s/%d for arithmetic expression",
+                              RepAtom(name)->StrOfAE, n);
      }
+      if (p->FOfEE == op_power && p->ArityOfEE == 2) {
+        t2 = ArgOfTerm(2, t);
+        if (IsPairTerm(t2)) {
+          return get_matrix_element(ArgOfTerm(1, t), t2 PASS_REGS);
+        }
+      }
+      ctx.f = fun;
+      ctx.fp = RepAppl(t);
+      LOCAL_ctx = &ctx;
      *RepAppl(t) = (CELL)AtomFoundVar;
-      t1 = Eval(ArgOfTerm(1,t) PASS_REGS);
-      if (t1 == 0L) {
-	*RepAppl(t) = (CELL)fun;
-	return FALSE;
-      }
+      t1 = Eval(ArgOfTerm(1, t) PASS_REGS);
      if (n == 1) {
-	*RepAppl(t) = (CELL)fun;
-	return Yap_eval_unary(p->FOfEE, t1);
+        *RepAppl(t) = (CELL)fun;
+        LOCAL_ctx = ctx.p;
+        return Yap_eval_unary(p->FOfEE, t1);
      }
-      t2 = Eval(ArgOfTerm(2,t) PASS_REGS);
+      t2 = Eval(ArgOfTerm(2, t) PASS_REGS);
      *RepAppl(t) = (CELL)fun;
-      if (t2 == 0L)
-	return FALSE;
-      return Yap_eval_binary(p->FOfEE,t1,t2);
+      LOCAL_ctx = ctx.p;
+      return Yap_eval_binary(p->FOfEE, t1, t2);
    }
-  } /* else if (IsPairTerm(t)) */ {
+  } /* else if (IsPairTerm(t)) */
+  {
    if (TailOfTerm(t) != TermNil) {
-      return Yap_ArithError(TYPE_ERROR_EVALUABLE, t,
-			    "string must contain a single character to be evaluated as an arithmetic expression");
+      Yap_ArithError(TYPE_ERROR_EVALUABLE, t,
+                            "string must contain a single character to be "
+                            "evaluated as an arithmetic expression");
    }
    return Eval(HeadOfTerm(t) PASS_REGS);
  }
 }

-Term
-Yap_InnerEval(Term t)
-{
-  CACHE_REGS
+Term Yap_InnerEval__(Term t USES_REGS) {
  return Eval(t PASS_REGS);
-}
+ }

 #ifdef BEAM
 Int BEAM_is(void);

-Int
-BEAM_is(void)
-{				/* X is Y	 */
+Int BEAM_is(void) { /* X is Y	 */
  union arith_ret res;
  blob_type bt;

  bt = Eval(Deref(XREGS[2]), &res);
-  if (bt==db_ref_e) return (NULL);
-  return (EvalToTerm(bt,&res));
+  if (bt == db_ref_e)
+    return (NULL);
+  return (EvalToTerm(bt, &res));
 }

 #endif

-static Int
-p_is( USES_REGS1 )
-{				/* X is Y	 */
+/**
+   @pred is( X:number, + Y:ground) is det
+
+   This predicate succeeds iff the result of evaluating the expression
+   _Y_ unifies with  _X_. This is the predicate normally used to
+   perform evaluation of arithmetic expressions:
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+X is 2+3*4
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+    succeeds with `X = 14`.
+
+    Consult @ref arithmetic_operators for the complete list of
+arithmetic_operators
+
+*/
+
+/// @memberof is/2
+static Int p_is(USES_REGS1) { /* X is Y	 */
+  Term out = TermNil;
+  bool go;
+  Term t = Deref(ARG2);
+  if (IsVarTerm(t)) {
+    Yap_ThrowError(INSTANTIATION_ERROR, t, "var(Y) in X is Y");
+    return (FALSE);
+  }
+  do {
+    go = false;
+    out = Yap_Eval(t PASS_REGS);
+    go = Yap_CheckArithError();
+  } while (go);
+  return Yap_unify_constant(ARG1, out);
+}
+
+/**
+ @pred isnan(? X:float) is det
+
+   Interface to the IEE754 `isnan` test.
+*/
+
+/// @memberof isnan/1
+static Int p_isnan(USES_REGS1) { /* X isnan Y	 */
  Term out = 0L;
-  
-  while (!(out = Eval(Deref(ARG2) PASS_REGS))) {
+
+  while (!(out = Eval(Deref(ARG1) PASS_REGS))) {
    if (LOCAL_Error_TYPE == RESOURCE_ERROR_STACK) {
      LOCAL_Error_TYPE = YAP_NO_ERROR;
-      if (!Yap_gcl(LOCAL_Error_Size, 2, ENV, CP)) {
-	Yap_Error(RESOURCE_ERROR_STACK, ARG2, LOCAL_ErrorMessage);
-	return FALSE;
+      if (!Yap_gcl(LOCAL_Error_Size, 1, ENV, CP)) {
+        Yap_EvalError(RESOURCE_ERROR_STACK, TermNil, LOCAL_ErrorMessage);
+        return FALSE;
      }
    } else {
-      Yap_Error(LOCAL_Error_TYPE, LOCAL_Error_Term, LOCAL_ErrorMessage);
+      Yap_EvalError(LOCAL_Error_TYPE, ARG1, LOCAL_ErrorMessage);
      return FALSE;
    }
  }
-  return Yap_unify_constant(ARG1,out);
+  if (IsVarTerm(out)) {
+    Yap_EvalError(INSTANTIATION_ERROR, out, "isnan/1");
+    return FALSE;
+  }
+  if (!IsFloatTerm(out)) {
+    Yap_EvalError(TYPE_ERROR_FLOAT, out, "isnan/1");
+    return FALSE;
+  }
+  return isnan(FloatOfTerm(out));
 }

-Int
-Yap_ArithError(yap_error_number type, Term where, char *format,...)
-{
+/**
+   @pred isinf(? X:float) is det
+
+   Interface to the IEE754 `isinf` test.
+*/
+
+/// @memberof isnan/1
+static Int p_isinf(USES_REGS1) { /* X is Y        */
+  Term out = 0L;
+
+  while (!(out = Eval(Deref(ARG1) PASS_REGS))) {
+    if (LOCAL_Error_TYPE == RESOURCE_ERROR_STACK) {
+      LOCAL_Error_TYPE = YAP_NO_ERROR;
+      if (!Yap_gcl(LOCAL_Error_Size, 1, ENV, CP)) {
+        Yap_EvalError(RESOURCE_ERROR_STACK, ARG2, LOCAL_ErrorMessage);
+        return FALSE;
+      }
+    } else {
+      Yap_EvalError(LOCAL_Error_TYPE, ARG1, LOCAL_ErrorMessage);
+      return FALSE;
+    }
+  }
+  if (IsVarTerm(out)) {
+    Yap_EvalError(INSTANTIATION_ERROR, out, "isinf/1");
+    return FALSE;
+  }
+  if (!IsFloatTerm(out)) {
+    Yap_EvalError(TYPE_ERROR_FLOAT, out, "isinf/1");
+    return FALSE;
+  }
+  return isinf(FloatOfTerm(out));
+}
+
+/**
+   @pred logsum(+ Log1:float, + Log2:float, - Out:float ) is det
+
+True if  _Log1_ is the logarithm of the positive number  _A1_,
+ _Log2_ is the logarithm of the positive number  _A2_, and
+ _Out_ is the logarithm of the sum of the numbers  _A1_ and
+ _A2_. Useful in probability computation.
+*/
+
+/// @memberof logsum/3
+static Int p_logsum(USES_REGS1) { /* X is Y        */
+  Term t1 = Deref(ARG1);
+  Term t2 = Deref(ARG2);
+  int done = FALSE;
+  Float f1, f2;
+
+  while (!done) {
+    if (IsFloatTerm(t1)) {
+      f1 = FloatOfTerm(t1);
+      done = TRUE;
+    } else if (IsIntegerTerm(t1)) {
+      f1 = IntegerOfTerm(t1);
+      done = TRUE;
+#if USE_GMP
+    } else if (IsBigIntTerm(t1)) {
+      f1 = Yap_gmp_to_float(t1);
+      done = TRUE;
+#endif
+    } else {
+      while (!(t1 = Eval(t1 PASS_REGS))) {
+        if (LOCAL_Error_TYPE == RESOURCE_ERROR_STACK) {
+          LOCAL_Error_TYPE = YAP_NO_ERROR;
+          if (!Yap_gcl(LOCAL_Error_Size, 1, ENV, CP)) {
+            Yap_EvalError(RESOURCE_ERROR_STACK, ARG2, LOCAL_ErrorMessage);
+            return FALSE;
+          }
+        } else {
+          Yap_EvalError(LOCAL_Error_TYPE, ARG1, LOCAL_ErrorMessage);
+          return FALSE;
+        }
+      }
+    }
+  }
+  done = FALSE;
+  while (!done) {
+    if (IsFloatTerm(t2)) {
+      f2 = FloatOfTerm(t2);
+      done = TRUE;
+    } else if (IsIntegerTerm(t2)) {
+      f2 = IntegerOfTerm(t2);
+      done = TRUE;
+#if USE_GMP
+    } else if (IsBigIntTerm(t2)) {
+      f2 = Yap_gmp_to_float(t2);
+      done = TRUE;
+#endif
+    } else {
+      while (!(t2 = Eval(t2 PASS_REGS))) {
+        if (LOCAL_Error_TYPE == RESOURCE_ERROR_STACK) {
+          LOCAL_Error_TYPE = YAP_NO_ERROR;
+          if (!Yap_gcl(LOCAL_Error_Size, 2, ENV, CP)) {
+            Yap_EvalError(RESOURCE_ERROR_STACK, ARG2, LOCAL_ErrorMessage);
+            return FALSE;
+          }
+        } else {
+          Yap_EvalError(LOCAL_Error_TYPE, ARG1, LOCAL_ErrorMessage);
+          return FALSE;
+        }
+      }
+    }
+  }
+  if (f1 >= f2) {
+    Float fi = exp(f2 - f1);
+    return Yap_unify(ARG3, MkFloatTerm(f1 + log(1 + fi)));
+  } else {
+    Float fi = exp(f1 - f2);
+    return Yap_unify(ARG3, MkFloatTerm(f2 + log(1 + fi)));
+  }
+}
+
+void Yap_EvalError__(const char *file, const char *function, int lineno,
+                       yap_error_number type, Term where, ...) {
  CACHE_REGS
  va_list ap;
+  char *format, buf[MAX_ERROR_MSG_SIZE];

-  LOCAL_ArithError = TRUE;
-  LOCAL_Error_TYPE = type;
-  LOCAL_Error_Term = where;
-  if (!LOCAL_ErrorMessage)
-    LOCAL_ErrorMessage = LOCAL_ErrorSay;
-  va_start (ap, format);
+  va_start(ap, where);
+  format = va_arg(ap, char *);
  if (format != NULL) {
-#if   HAVE_VSNPRINTF
-    (void) vsnprintf(LOCAL_ErrorMessage, MAX_ERROR_MSG_SIZE, format, ap);
+#if HAVE_VSNPRINTF
+    (void)vsnprintf(buf, MAX_ERROR_MSG_SIZE, format, ap);
 #else
-    (void) vsprintf(LOCAL_ErrorMessage, format, ap);
+    (void)vsprintf(buf, format, ap);
 #endif
  } else {
-    LOCAL_ErrorMessage[0] = '\0';
+    buf[0] = '\0';
  }
-  va_end (ap);
-  return 0L;
+  va_end(ap);
+  Yap_Error__(false, file, function, lineno, type, where, buf);
 }

-void
-Yap_InitEval(void)
-{
+/**
+
+   @pred between(+ Low:int, + High:int, ? Value:int) is nondet
+
+   _Low_ and  _High_ are integers,  _High_ \>= _Low_. If
+   _Value_ is an integer,  _Low_ =\< _Value_
+   =\< _High_. When  _Value_ is a variable it is successively
+   bound to all integers between  _Low_ and  _High_. If
+   _High_ is inf or infinite between/3 is true iff
+   _Value_ \>=  _Low_, a feature that is particularly interesting
+   for generating integers from a certain value.
+
+*/
+
+/// @memberof between/3
+static Int cont_between(USES_REGS1) {
+  Term t1 = EXTRA_CBACK_ARG(3, 1);
+  Term t2 = EXTRA_CBACK_ARG(3, 2);
+
+  Yap_unify(ARG3, t1);
+  if (IsIntegerTerm(t1)) {
+    Int i1;
+    Term tn;
+
+    if (t1 == t2)
+      cut_succeed();
+    i1 = IntegerOfTerm(t1);
+    tn = add_int(i1, 1 PASS_REGS);
+    EXTRA_CBACK_ARG(3, 1) = tn;
+    HB = B->cp_h = HR;
+    return TRUE;
+  } else {
+    Term t[2];
+    Term tn;
+    Int cmp;
+
+    cmp = Yap_acmp(t1, t2 PASS_REGS);
+    if (cmp == 0)
+      cut_succeed();
+    t[0] = t1;
+    t[1] = MkIntTerm(1);
+    tn = Eval(Yap_MkApplTerm(FunctorPlus, 2, t) PASS_REGS);
+    EXTRA_CBACK_ARG(3, 1) = tn;
+    HB = B->cp_h = HR;
+    return TRUE;
+  }
+}
+
+/// @memberof between/3
+static Int init_between(USES_REGS1) {
+  Term t1 = Deref(ARG1);
+  Term t2 = Deref(ARG2);
+
+  if (IsVarTerm(t1)) {
+    Yap_EvalError(INSTANTIATION_ERROR, t1, "between/3");
+    return FALSE;
+  }
+  if (IsVarTerm(t2)) {
+    Yap_EvalError(INSTANTIATION_ERROR, t1, "between/3");
+    return FALSE;
+  }
+  if (!IsIntegerTerm(t1) && !IsBigIntTerm(t1)) {
+    Yap_EvalError(TYPE_ERROR_INTEGER, t1, "between/3");
+    return FALSE;
+  }
+  if (!IsIntegerTerm(t2) && !IsBigIntTerm(t2) && t2 != MkAtomTerm(AtomInf) &&
+      t2 != MkAtomTerm(AtomInfinity)) {
+    Yap_EvalError(TYPE_ERROR_INTEGER, t2, "between/3");
+    return FALSE;
+  }
+  if (IsIntegerTerm(t1) && IsIntegerTerm(t2)) {
+    Int i1 = IntegerOfTerm(t1);
+    Int i2 = IntegerOfTerm(t2);
+    Term t3;
+
+    t3 = Deref(ARG3);
+    if (!IsVarTerm(t3)) {
+      if (!IsIntegerTerm(t3)) {
+        if (!IsBigIntTerm(t3)) {
+          Yap_EvalError(TYPE_ERROR_INTEGER, t3, "between/3");
+          return FALSE;
+        }
+        cut_fail();
+      } else {
+        Int i3 = IntegerOfTerm(t3);
+        if (i3 >= i1 && i3 <= i2)
+          cut_succeed();
+        cut_fail();
+      }
+    }
+    if (i1 > i2)
+      cut_fail();
+    if (i1 == i2) {
+      Yap_unify(ARG3, t1);
+      cut_succeed();
+    }
+  } else if (IsIntegerTerm(t1) && IsAtomTerm(t2)) {
+    Int i1 = IntegerOfTerm(t1);
+    Term t3;
+
+    t3 = Deref(ARG3);
+    if (!IsVarTerm(t3)) {
+      if (!IsIntegerTerm(t3)) {
+        if (!IsBigIntTerm(t3)) {
+          Yap_EvalError(TYPE_ERROR_INTEGER, t3, "between/3");
+          return FALSE;
+        }
+        cut_fail();
+      } else {
+        Int i3 = IntegerOfTerm(t3);
+        if (i3 >= i1)
+          cut_succeed();
+        cut_fail();
+      }
+    }
+  } else {
+    Term t3 = Deref(ARG3);
+    Int cmp;
+
+    if (!IsVarTerm(t3)) {
+      if (!IsIntegerTerm(t3) && !IsBigIntTerm(t3)) {
+        Yap_EvalError(TYPE_ERROR_INTEGER, t3, "between/3");
+        return FALSE;
+      }
+      if (Yap_acmp(t3, t1 PASS_REGS) >= 0 && Yap_acmp(t2, t3 PASS_REGS) >= 0 &&
+          P != FAILCODE)
+        cut_succeed();
+      cut_fail();
+    }
+    cmp = Yap_acmp(t1, t2 PASS_REGS);
+    if (cmp > 0)
+      cut_fail();
+    if (cmp == 0) {
+      Yap_unify(ARG3, t1);
+      cut_succeed();
+    }
+  }
+  EXTRA_CBACK_ARG(3, 1) = t1;
+  EXTRA_CBACK_ARG(3, 2) = t2;
+  return cont_between(PASS_REGS1);
+}
+
+void Yap_InitEval(void) {
  /* here are the arithmetical predicates */
  Yap_InitConstExps();
  Yap_InitUnaryExps();
  Yap_InitBinaryExps();
  Yap_InitCPred("is", 2, p_is, 0L);
+  Yap_InitCPred("isnan", 1, p_isnan, TestPredFlag);
+  Yap_InitCPred("isinf", 1, p_isinf, TestPredFlag);
+  Yap_InitCPred("logsum", 3, p_logsum, TestPredFlag);
+  Yap_InitCPredBack("between", 3, 2, init_between, cont_between, 0);
 }

+/**
+ *
+ * @}
+*/
--- a/C/exec.c
+++ b/C/exec.c
--- a/C/exo.c
+++ b/C/exo.c
@ -0,0 +1,787 @@
+
+/*************************************************************************
+*									 *
+*	 YAP Prolog 							 *
+*									 *
+*	Yap Prolog was developed at NCCUP - Universidade do Porto	 *
+*									 *
+* Copyright L.Damas, V.S.Costa and Universidade do Porto 1985-1997	 *
+*									 *
+**************************************************************************
+*									 *
+* File:		exo.c							 *
+* comments:	Exo compilation						 *
+*									 *
+* Last rev:     $Date: 2008-07-22 23:34:44 $,$Author: vsc $		 *				 *
+* $Log: not supported by cvs2svn $				 	 *
+*                                                                        *
+*									 *
+*************************************************************************/
+
+#include "Yap.h"
+#include "clause.h"
+#include "yapio.h"
+#include "YapEval.h"
+#include "tracer.h"
+#ifdef YAPOR
+#include "or.macros.h"
+#endif	/* YAPOR */
+#ifdef TABLING
+#include "tab.macros.h"
+#endif /* TABLING */
+#if HAVE_STRING_H
+#include <string.h>
+#endif
+#if HAVE_STRING_H
+#include <string.h>
+#endif
+#if HAVE_STDBOOL_H
+#include <stdbool.h>
+#endif
+
+bool YAP_NewExo( PredEntry *ap, size_t data, struct udi_info *udi);
+bool YAP_AssertTuples( PredEntry *pe, const Term *ts, size_t offset, size_t m);
+
+//static int exo_write=FALSE;
+
+//void do_write(void) { exo_write=TRUE;}
+
+#define MAX_ARITY 256
+
+#if SIZEOF_INT_P==4
+#define FNV32_PRIME (16777619UL)
+#define FNV32_OFFSET (0x811c9dc5UL)
+#define FNV_PRIME FNV32_PRIME
+#define FNV_OFFSET FNV32_OFFSET
+#elif SIZEOF_INT_P==8
+#define FNV64_PRIME (1099511628211)
+#if SIZEOF_LONG_INT==4
+#define FNV64_OFFSET (14695981039346656037ULL)
+#else
+#define FNV64_OFFSET (14695981039346656037UL)
+#endif
+#define FNV_PRIME FNV64_PRIME
+#define FNV_OFFSET FNV64_OFFSET
+#endif
+
+/*MurmurHash3 from: https://code.google.com/p/smhasher/wiki/MurmurHash3*/
+BITS32 rotl32 ( BITS32, int8_t);
+
+inline BITS32 rotl32 ( BITS32 x, int8_t r )
+{
+  return (x << r) | (x >> (32 - r));
+}
+#define ROTL32(x,y)     rotl32(x,y)
+//-----------------------------------------------------------------------------
+// Finalization mix - force all bits of a hash block to avalanche
+
+BITS32 fmix32 ( BITS32 );
+inline BITS32 fmix32 ( BITS32 h )
+{
+  h ^= h >> 16;
+  h *= 0x85ebca6b;
+  h ^= h >> 13;
+  h *= 0xc2b2ae35;
+  h ^= h >> 16;
+
+  return h;
+}
+//-----------------------------------------------------------------------------
+INLINE_ONLY BITS32
+HASH_MURMUR3_32 (UInt arity, CELL *cl, UInt bnds[], UInt sz);
+
+INLINE_ONLY BITS32
+HASH_MURMUR3_32 (UInt arity, CELL *cl, UInt bnds[], UInt sz)
+{
+  UInt hash;
+  UInt  j=0;
+  int len = 0;
+  const BITS32 c1 = 0xcc9e2d51;
+  const BITS32 c2 = 0x1b873593;
+
+  hash = FNV_OFFSET; /*did not find what seed to use yet*/
+
+  while (j < arity) {
+    if (bnds[j]) {
+      unsigned char *i=(unsigned char*)(cl+j);
+      unsigned char *m=(unsigned char*)(cl+(j+1));
+
+      while (i < m) {
+	BITS32 k1 = i[0];
+
+	k1 *= c1;
+	k1 = ROTL32(k1,15);
+	k1 *= c2;
+
+	hash ^= k1;
+	hash = ROTL32(hash,13);
+	hash = hash*5+0xe6546b64;
+        i++;
+	len++;
+      }
+    }
+    j++;
+  }
+
+  //----------
+  // tail not used becouse len is block multiple
+
+  //----------
+  // finalization
+
+  hash ^= len;
+
+  hash = fmix32(hash);
+
+  return hash;
+}
+
+/*DJB2*/
+#define DJB2_OFFSET 5381
+
+INLINE_ONLY BITS32
+HASH_DJB2(UInt arity, CELL *cl, UInt bnds[], UInt sz);
+
+INLINE_ONLY BITS32
+HASH_DJB2(UInt arity, CELL *cl, UInt bnds[], UInt sz)
+{
+  BITS32 hash;
+  UInt  j=0;
+
+  hash = DJB2_OFFSET;
+  while (j < arity) {
+    if (bnds[j]) {
+      unsigned char *i=(unsigned char*)(cl+j);
+      unsigned char *m=(unsigned char*)(cl+(j+1));
+
+      while (i < m) {
+	BITS32 h5 = hash << 5;
+	hash += h5 + i[0]; /* hash * 33 + i[0] */
+	i++;
+      }
+    }
+    j++;
+  }
+  return hash;
+}
+
+INLINE_ONLY BITS32
+HASH_RS(UInt arity, CELL *cl, UInt bnds[], UInt sz);
+
+/* RS Hash Function */
+INLINE_ONLY BITS32
+HASH_RS(UInt arity, CELL *cl, UInt bnds[], UInt sz)
+{
+  UInt hash=0;
+  UInt j=0;
+
+  UInt b = 378551;
+  UInt a = 63689;
+
+  while (j < arity) {
+    if (bnds[j]) {
+      unsigned char *i=(unsigned char*)(cl+j);
+      unsigned char *m=(unsigned char*)(cl+(j+1));
+
+      while (i < m) {
+	hash = hash * a + i[0];
+	a    = a * b;
+	i++;
+      }
+    }
+    j++;
+  }
+  return hash;
+}
+
+INLINE_ONLY BITS32
+HASH_FVN_1A(UInt arity, CELL *cl, UInt bnds[], UInt sz);
+
+/* Simple hash function:
+   FVN-1A
+   first component is the base key.
+   hash0 spreads extensions coming from different elements.
+   spread over j quadrants.
+ */
+INLINE_ONLY BITS32
+HASH_FVN_1A(UInt arity, CELL *cl, UInt bnds[], UInt sz)
+{
+  UInt hash;
+  UInt  j=0;
+
+  hash = FNV_OFFSET;
+  while (j < arity) {
+    if (bnds[j]) {
+      unsigned char *i=(unsigned char*)(cl+j);
+      unsigned char *m=(unsigned char*)(cl+(j+1));
+
+      while (i < m) {
+	hash = hash ^ i[0];
+	hash = hash * FNV_PRIME;
+	i++;
+      }
+    }
+    j++;
+  }
+  return hash;
+}
+
+//#define TEST_HASH_DJB 1
+
+#if defined TEST_HASH_MURMUR
+# define HASH(...) HASH_MURMUR3_32(__VA_ARGS__)
+#elif defined TEST_HASH_DJB
+# define HASH(...)    HASH_DJB2(__VA_ARGS__)
+#elif defined TEST_HASH_RS
+# define HASH(...) HASH_RS(__VA_ARGS__)
+#else
+/* Default: TEST_HASH_FVN */
+# define HASH(...) HASH_FVN_1A(__VA_ARGS__)
+# define HASH1(...) HASH_MURMUR3_32(__VA_ARGS__)
+#endif
+
+static BITS32
+NEXT(UInt arity, CELL *cl, UInt bnds[], UInt sz, BITS32 hash)
+{
+  int i = 0;
+  BITS32 hash1;
+
+  while (bnds[i]==0) i++;
+  hash1 = HASH1(arity, cl, bnds, sz);
+  return (hash +  hash1 +cl[i]);
+}
+
+/* search for matching elements */
+static int
+MATCH(CELL *clp, CELL *kvp, UInt arity, UInt bnds[])
+{
+  UInt j = 0;
+  while (j< arity) {
+    if ( bnds[j] && clp[j] != kvp[j])
+      return FALSE;
+    j++;
+  }
+  return TRUE;
+}
+
+static void
+ADD_TO_TRY_CHAIN(CELL *kvp, CELL *cl, struct index_t *it)
+{
+  BITS32 old = EXO_ADDRESS_TO_OFFSET(it, kvp);
+  BITS32 new = EXO_ADDRESS_TO_OFFSET(it, cl);
+  BITS32 *links = it->links;
+  BITS32 tmp = links[old]; /* points to the end of the chain */
+
+  if (!tmp) {
+    links[old] = links[new] = new;
+  } else {
+    links[new] = links[tmp];
+    links[tmp] = new;
+    links[old] = new;
+  }
+}
+
+/* This is the critical routine, it builds the hash table *
+ * each HT field stores a key pointer which is actually
+ * a pointer to the point in the clause where one can find the element.
+ *
+ * The cls table indexes all elements that can be reached using that key.
+ *
+ * Insert:
+ * j = first
+ * not match cij -> insert, open new chain
+ * match ci..j ck..j -> find j = minarg(cij \= c2j),
+ * else j = +inf -> c2+ci
+ * Lookup:
+ * j= first
+ * not match cij -> fail
+ * match ci..j ck..j -> find j = minarg(cij \= c2j)
+ * else
+ */
+static int
+INSERT(CELL *cl, struct index_t *it, UInt arity, UInt base, UInt bnds[])
+{
+  CELL *kvp;
+  BITS32 hash;
+  int coll_count = 0;
+
+
+  hash = HASH(arity, cl, bnds, it->hsize);
+ next:
+  kvp = EXO_OFFSET_TO_ADDRESS(it, it->key [hash % it->hsize]);
+  if (kvp == NULL) {
+    /* simple case, new entry */
+    it->nentries++;
+    it->key[hash % it->hsize ] = EXO_ADDRESS_TO_OFFSET(it, cl);
+    if (coll_count > it -> max_col_count)
+      it->max_col_count = coll_count;
+    return TRUE;
+  } else if (MATCH(kvp, cl, arity, bnds))  {
+    it->ntrys++;
+    ADD_TO_TRY_CHAIN(kvp, cl, it);
+    return TRUE;
+  } else {
+    coll_count++;
+    it->ncollisions++;
+    //  printf("#");
+    hash =  NEXT(arity, cl, bnds, it->hsize, hash);
+    //if (exo_write) printf("N=%ld\n", hash);
+    goto next;
+  }
+}
+
+static yamop *
+LOOKUP(struct index_t *it, UInt arity, UInt j, UInt bnds[])
+{
+  CACHE_REGS
+  CELL *kvp;
+  BITS32 hash;
+
+  /* j is the firs bound element */
+  /* check if we match */
+  hash = HASH(arity, XREGS+1, bnds, it->hsize);
+ next:
+  /* loop to insert element */
+  kvp = EXO_OFFSET_TO_ADDRESS(it, it->key[hash % it->hsize]);
+  if (kvp == NULL) {
+    /* simple case, no element */
+    return FAILCODE;
+  } else if (MATCH(kvp, XREGS+1, arity, bnds))  {
+    S = kvp;
+    if (!it->is_key && it->links[EXO_ADDRESS_TO_OFFSET(it, S)])
+      return it->code;
+    else
+      return NEXTOP(NEXTOP(it->code,lp),lp);
+  } else {
+    /* collision */
+    hash =  NEXT(arity, XREGS+1, bnds, it->hsize, hash);
+    goto next;
+  }
+}
+
+static int
+fill_hash(UInt bmap, struct index_t *it, UInt bnds[])
+{
+  UInt i;
+  UInt arity = it->arity;
+  CELL *cl = it->cls;
+
+  for (i=0; i < it->nels; i++) {
+    if (!INSERT(cl, it, arity, 0, bnds))
+      return FALSE;
+    cl += arity;
+  }
+  for (i=0; i < it->hsize; i++) {
+    if (it->key[i]) {
+      BITS32 offset = it->key[i];
+      BITS32 last = it->links[offset];
+      if (last) {
+      /* the chain used to point straight to the last, and the last back to the original first */
+	it->links[offset] = it->links[last];
+	it->links[last] = 0;
+      }
+    }
+  }
+  return TRUE;
+}
+
+static struct index_t *
+add_index(struct index_t **ip, UInt bmap, PredEntry *ap, UInt count)
+{
+  CACHE_REGS
+  UInt ncls = ap->cs.p_code.NOfClauses, j;
+  CELL *base = NULL;
+  struct index_t *i;
+  size_t sz, dsz;
+  yamop *ptr;
+  UInt *bnds = LOCAL_ibnds;
+
+  sz =   (CELL)NEXTOP(NEXTOP((yamop*)NULL,lp),lp)+ap->ArityOfPE*(CELL)NEXTOP((yamop *)NULL,x) +(CELL)NEXTOP(NEXTOP((yamop *)NULL,p),l);
+  if (!(i = (struct index_t *)Yap_AllocCodeSpace(sizeof(struct index_t)+sz))) {
+    CACHE_REGS
+    save_machine_regs();
+    LOCAL_Error_Size = 3*ncls*sizeof(CELL);
+    LOCAL_ErrorMessage = "not enough space to index";
+    Yap_Error(RESOURCE_ERROR_HEAP, TermNil, LOCAL_ErrorMessage);
+    return NULL;
+  }
+  i->is_key = FALSE;
+  i->next = *ip;
+  i->prev = NULL;
+  i->nels = ncls;
+  i->arity = ap->ArityOfPE;
+  i->ap = ap;
+  i->bmap = bmap;
+  i->is_key = FALSE;
+  i->hsize = 2*ncls;
+  dsz = sizeof(BITS32)*(ncls+1+i->hsize);
+  if (count) {
+    if (!(base = (CELL *)Yap_AllocCodeSpace(dsz))) {
+      CACHE_REGS
+      save_machine_regs();
+      LOCAL_Error_Size = dsz;
+      LOCAL_ErrorMessage = "not enough space to generate indices";
+      Yap_FreeCodeSpace((void *)i);
+      Yap_Error(RESOURCE_ERROR_HEAP, TermNil, LOCAL_ErrorMessage);
+      return NULL;
+    }
+    memset(base, 0, dsz);
+  }
+  i->size = sz+dsz+sizeof(struct index_t);
+  i->key = (BITS32 *)base;
+  i->links = (BITS32 *)base+i->hsize;
+  i->ncollisions = i->nentries = i->ntrys = 0;
+  i->cls = (CELL *)((ADDR)ap->cs.p_code.FirstClause+2*sizeof(struct index_t *));
+  i->bcls= i->cls-i->arity;
+  i->udi_free_args = 0;
+  i->is_udi = FALSE;
+  i->udi_arg = 0;
+  *ip = i;
+  while (count) {
+    if (!fill_hash(bmap, i, bnds)) {
+      size_t sz;
+      i->hsize += ncls;
+      if (i->is_key) {
+	sz = i->hsize*sizeof(BITS32);
+      } else {
+	sz = (ncls+1+i->hsize)*sizeof(BITS32);
+      }
+      if (base != (CELL *)Yap_ReallocCodeSpace((char *)base, sz))
+	return FALSE;
+      memset(base, 0, sz);
+      i->key = (BITS32 *)base;
+      i->links = (BITS32 *)(base+i->hsize);
+      i->ncollisions = i->nentries = i->ntrys = 0;
+      continue;
+    }
+#if DEBUG
+  fprintf(stderr, "entries=" UInt_FORMAT " collisions=" UInt_FORMAT" (max="  UInt_FORMAT ") trys=" UInt_FORMAT "\n", i->nentries, i->ncollisions,  i->max_col_count, i->ntrys);
+#endif
+    if (!i->ntrys && !i->is_key) {
+      i->is_key = TRUE;
+      if (base != (CELL *)Yap_ReallocCodeSpace((char *)base, i->hsize*sizeof(BITS32)))
+	return FALSE;
+    }
+    /* our hash table is just too large */
+    if (( i->nentries+i->ncollisions  )*10 < i->hsize) {
+      size_t sz;
+      i->hsize = ( i->nentries+i->ncollisions  )*10;
+      if (i->is_key) {
+	sz = i->hsize*sizeof(BITS32);
+      } else {
+	sz = (ncls+1+i->hsize)*sizeof(BITS32);
+      }
+      if (base != (CELL *)Yap_ReallocCodeSpace((char *)base, sz))
+	return FALSE;
+      memset(base, 0, sz);
+      i->key = (BITS32 *)base;
+      i->links = (BITS32 *)base+i->hsize;
+      i->ncollisions = i->nentries = i->ntrys = 0;
+    } else {
+      break;
+    }
+  }
+  ptr = (yamop *)(i+1);
+  i->code = ptr;
+  if (count)
+    ptr->opc = Yap_opcode(_try_exo);
+  else
+    ptr->opc = Yap_opcode(_try_all_exo);
+  ptr->y_u.lp.l = (yamop *)i;
+  ptr->y_u.lp.p = ap;
+  ptr = NEXTOP(ptr, lp);
+  if (count)
+    ptr->opc = Yap_opcode(_retry_exo);
+  else
+    ptr->opc = Yap_opcode(_retry_all_exo);
+  ptr->y_u.lp.p = ap;
+  ptr->y_u.lp.l = (yamop *)i;
+  ptr = NEXTOP(ptr, lp);
+  for (j = 0; j < i->arity; j++) {
+    ptr->opc = Yap_opcode(_get_atom_exo);
+#if PRECOMPUTE_REGADDRESS
+    ptr->y_u.x.x = (CELL) (XREGS + (j+1));
+#else
+    ptr->y_u.x.x = j+1;
+#endif
+    ptr = NEXTOP(ptr, x);
+  }
+  ptr->opc = Yap_opcode(_procceed);
+  ptr->y_u.p.p = ap;
+  ptr = NEXTOP(ptr, p);
+  ptr->opc = Yap_opcode(_Ystop);
+  ptr->y_u.l.l = i->code;
+  Yap_inform_profiler_of_clause((char *)(i->code), (char *)NEXTOP(ptr,l), ap, GPROF_INDEX);
+  if (ap->PredFlags & UDIPredFlag) {
+    Yap_new_udi_clause( ap, NULL, (Term)ip);
+  } else {
+    i->is_udi = FALSE;
+  }
+  return i;
+}
+
+yamop  *
+Yap_ExoLookup(PredEntry *ap USES_REGS)
+{
+  UInt arity = ap->ArityOfPE;
+  UInt bmap = 0L, bit = 1, count = 0, j, j0 = 0;
+  struct index_t **ip = (struct index_t **)(ap->cs.p_code.FirstClause);
+  struct index_t *i = *ip;
+
+  for (j=0; j< arity; j++, bit<<=1) {
+    Term t = Deref(XREGS[j+1]);
+    if (!IsVarTerm(t)) {
+      bmap += bit;
+      LOCAL_ibnds[j] = TRUE;
+      if (!count) j0= j;
+      count++;
+    } else {
+      LOCAL_ibnds[j] = FALSE;
+    }
+    XREGS[j+1] = t;
+  }
+
+  while (i) {
+    //    if (i->is_key && (i->bmap & bmap)  == i->bmap) {
+    //  break;
+    // }
+    if (i->bmap == bmap) {
+      break;
+    }
+    ip = &i->next;
+    i = i->next;
+  }
+  if (!i) {
+    i = add_index(ip, bmap, ap, count);
+  }
+  if (count) {
+    yamop *code = LOOKUP(i, arity, j0, LOCAL_ibnds);
+    if (code == FAILCODE)
+      return code;
+    if (i->is_udi)
+      return ((CEnterExoIndex)i->udi_first)(i PASS_REGS);
+    else
+      return code;
+  } else if(i->is_udi) {
+    return ((CEnterExoIndex)i->udi_first)(i PASS_REGS);
+  } else {
+    return i->code;
+  }
+}
+
+CELL
+Yap_NextExo(choiceptr cptr, struct index_t *it)
+{
+  CACHE_REGS
+  BITS32 offset = ADDRESS_TO_LINK(it,(BITS32 *)((CELL *)(B+1))[it->arity]);
+  BITS32 next = it->links[offset];
+  ((CELL *)(B+1))[it->arity] = (CELL)LINK_TO_ADDRESS(it, next);
+  S = it->cls+it->arity*offset;
+  return next;
+}
+
+static MegaClause *
+exodb_get_space( Term t, Term mod, Term tn )
+{
+  UInt            arity;
+  Prop            pe;
+  PredEntry      *ap;
+  MegaClause *mcl;
+  UInt ncls;
+  UInt required;
+  struct index_t **li;
+
+
+  if (IsVarTerm(mod)  || !IsAtomTerm(mod)) {
+    return NULL;
+  }
+  if (IsAtomTerm(t)) {
+    Atom a = AtomOfTerm(t);
+    arity = 0;
+    pe = PredPropByAtom(a, mod);
+  } else if (IsApplTerm(t)) {
+    register Functor f = FunctorOfTerm(t);
+    arity = ArityOfFunctor(f);
+    pe = PredPropByFunc(f, mod);
+  } else {
+    return NULL;
+  }
+  if (EndOfPAEntr(pe)) 
+    return NULL;
+  ap = RepPredProp(pe);
+  if (ap->PredFlags & (DynamicPredFlag|LogUpdatePredFlag
+#ifdef TABLING
+                       |TabledPredFlag
+#endif /* TABLING */
+                       )) {
+    Yap_Error(PERMISSION_ERROR_MODIFY_STATIC_PROCEDURE,t,"dbload_get_space/4");
+    return NULL;
+  }
+  if (IsVarTerm(tn)  || !IsIntegerTerm(tn)) {
+    return NULL;
+  }
+  ncls = IntegerOfTerm(tn);
+  if (ncls <= 1) {
+    return NULL;
+  }
+
+  required = ncls*arity*sizeof(CELL)+sizeof(MegaClause)+2*sizeof(struct index_t *);
+  while (!(mcl = (MegaClause *)Yap_AllocCodeSpace(required))) {
+    if (!Yap_growheap(FALSE, required, NULL)) {
+      /* just fail, the system will keep on going */
+      return NULL;
+    }
+  }
+  Yap_ClauseSpace += required;
+  /* cool, it's our turn to do the conversion */
+  mcl->ClFlags = MegaMask|ExoMask;
+  mcl->ClSize = required;
+  mcl->ClPred = ap;
+  mcl->ClItemSize = arity*sizeof(CELL);
+  mcl->ClNext = NULL;
+  li = (struct index_t **)(mcl->ClCode);
+  li[0] = li[1] = NULL;
+  ap->cs.p_code.FirstClause =
+    ap->cs.p_code.LastClause =
+    mcl->ClCode;
+  ap->PredFlags |= MegaClausePredFlag;
+  ap->cs.p_code.NOfClauses = ncls;
+  if (ap->PredFlags & (SpiedPredFlag|CountPredFlag|ProfiledPredFlag)) {
+    ap->OpcodeOfPred = Yap_opcode(_spy_pred);
+  } else {
+    ap->OpcodeOfPred = Yap_opcode(_enter_exo);
+  }
+  ap->CodeOfPred = ap->cs.p_code.TrueCodeOfPred = (yamop *)(&(ap->OpcodeOfPred));
+  return mcl;
+}
+
+bool
+YAP_NewExo( PredEntry *ap, size_t data, struct udi_info *udi)
+{
+  MegaClause *mcl;
+  size_t required;
+  struct index_t **li;
+
+  if (data <= ap->ArityOfPE*sizeof(CELL)) {
+    return false;
+  }
+  // data = ncls*arity*sizeof(CELL);
+  required = data+sizeof(MegaClause)+2*sizeof(struct index_t *);
+  while (!(mcl = (MegaClause *)Yap_AllocCodeSpace(required))) {
+    if (!Yap_growheap(FALSE, required, NULL)) {
+      /* just fail, the system will keep on going */
+      return false;
+    }
+  }
+  Yap_ClauseSpace += required;
+  /* cool, it's our turn to do the conversion */
+  mcl->ClFlags = MegaMask|ExoMask;
+  mcl->ClSize = required;
+  mcl->ClPred = ap;
+  mcl->ClItemSize = ap->ArityOfPE*sizeof(CELL);
+  mcl->ClNext = NULL;
+  li = (struct index_t **)(mcl->ClCode);
+  li[0] = li[1] = NULL;
+  ap->cs.p_code.FirstClause =
+    ap->cs.p_code.LastClause =
+    mcl->ClCode;
+  ap->PredFlags |= MegaClausePredFlag;
+  ap->cs.p_code.NOfClauses = 0;
+  if (ap->PredFlags & (SpiedPredFlag|CountPredFlag|ProfiledPredFlag)) {
+    ap->OpcodeOfPred = Yap_opcode(_spy_pred);
+  } else {
+    ap->OpcodeOfPred = Yap_opcode(_enter_exo);
+  }
+  ap->CodeOfPred = ap->cs.p_code.TrueCodeOfPred = (yamop *)(&(ap->OpcodeOfPred));
+  return true;
+}
+
+static Int
+p_exodb_get_space( USES_REGS1 )
+{				/* '$number_of_clauses'(Predicate,M,N) */
+  void *mcl;
+
+  if ((mcl = exodb_get_space(Deref(ARG1), Deref(ARG2), Deref(ARG3))) == NULL)
+    return FALSE;
+
+  return Yap_unify(ARG4, MkIntegerTerm((Int)mcl));
+}
+
+#define DerefAndCheck(t, V)			\
+  t = Deref(V); if(IsVarTerm(t) || !(IsAtomOrIntTerm(t))) Yap_Error(TYPE_ERROR_ATOMIC, t0, "load_db");
+
+static Int
+store_exo(yamop *pc, UInt arity, Term t0)
+{
+  Term t;
+  CELL *tp = RepAppl(t0)+1,
+    *cpc = (CELL *)pc;
+  UInt i;
+  for (i = 0; i< arity; i++) {
+    DerefAndCheck(t, tp[0]);
+    *cpc = t;
+    //    Yap_DebugPlWrite(t); fprintf(stderr,"\n");
+    tp++;
+    cpc++;
+  }
+  //fprintf(stderr,"\n");
+  return TRUE;
+}
+
+bool
+YAP_AssertTuples( PredEntry *pe, const Term *ts, size_t offset, size_t m)
+{
+  MegaClause *mcl = ClauseCodeToMegaClause(pe->cs.p_code.FirstClause);
+  size_t           i;
+  ADDR   base = (ADDR)mcl->ClCode+2*sizeof(struct index_t *);
+  for (i=0; i<m; i++) {
+    yamop *ptr = (yamop *)(base+offset*(mcl->ClItemSize));
+    store_exo( ptr, pe->ArityOfPE, ts[i]);
+  }
+  return true;
+}
+
+static void
+exoassert( void *handle, Int n, Term term )
+{                               /* '$number_of_clauses'(Predicate,M,N) */
+  PredEntry       *pe;
+  MegaClause      *mcl;
+
+
+  mcl = (MegaClause *) handle;
+  pe = mcl->ClPred;
+  store_exo((yamop *)((ADDR)mcl->ClCode+2*sizeof(struct index_t *)+n*(mcl->ClItemSize)),pe->ArityOfPE, term);
+}
+
+static Int
+p_exoassert( USES_REGS1 )
+{				/* '$number_of_clauses'(Predicate,M,N) */
+  Term            thandle = Deref(ARG2);
+  Term            tn = Deref(ARG3);
+  MegaClause      *mcl;
+  Int              n;
+
+
+  if (IsVarTerm(thandle)  || !IsIntegerTerm(thandle)) {
+    return FALSE;
+  }
+  mcl = (MegaClause *)IntegerOfTerm(thandle);
+  if (IsVarTerm(tn)  || !IsIntegerTerm(tn)) {
+    return FALSE;
+  }
+  n = IntegerOfTerm(tn);
+  exoassert(mcl,n,Deref(ARG1));
+  return TRUE;
+}
+
+void
+Yap_InitExoPreds(void)
+{
+  CACHE_REGS
+  Term cm = CurrentModule;
+
+  CurrentModule = DBLOAD_MODULE;
+  Yap_InitCPred("exo_db_get_space", 4, p_exodb_get_space, 0L);
+  Yap_InitCPred("exoassert", 3, p_exoassert, 0L);
+  CurrentModule = cm;
+}
--- a/C/exo_udi.c
+++ b/C/exo_udi.c
@ -0,0 +1,588 @@
+/*************************************************************************
+*									 *
+*	 YAP Prolog 							 *
+*									 *
+*	Yap Prolog was developed at NCCUP - Universidade do Porto	 *
+*									 *
+* Copyright L.Damas, V.S.Costa and Universidade do Porto 1985-1997	 *
+*									 *
+**************************************************************************
+*									 *
+* File:		exo.c							 *
+* comments:	Exo compilation						 *
+*									 *
+* Last rev:     $Date: 2008-07-22 23:34:44 $,$Author: vsc $		 *				 *
+* $Log: not supported by cvs2svn $				 	 *
+*                                                                        *
+*									 *
+*************************************************************************/
+
+#include "Yap.h"
+#include "clause.h"
+#include "yapio.h"
+#include "YapEval.h"
+#include "tracer.h"
+#include "attvar.h"
+#ifdef YAPOR
+#include "or.macros.h"
+#endif	/* YAPOR */
+#ifdef TABLING
+#include "tab.macros.h"
+#endif /* TABLING */
+#if HAVE_STRING_H
+#include <string.h>
+#endif
+#include <udi.h>
+
+
+static int
+compar(const void *ip0, const void *jp0) {
+  CACHE_REGS
+  BITS32 *ip = (BITS32 *)ip0, *jp = (BITS32 *)jp0;
+  Term i = EXO_OFFSET_TO_ADDRESS(LOCAL_exo_it, *ip)[LOCAL_exo_arg];
+  Term j = EXO_OFFSET_TO_ADDRESS(LOCAL_exo_it, *jp)[LOCAL_exo_arg];
+  //fprintf(stderr, "%ld-%ld\n", IntOfTerm(i), IntOfTerm(j)); 
+  return IntOfTerm(i)-IntOfTerm(j);
+}
+
+static Int
+cmp_extra_args(CELL *si, CELL *sj, struct index_t *it)
+{
+  UInt m = it->udi_free_args;
+  UInt m0 = 1, x;
+  
+  for (x=0; x< it->arity; x++) {
+    if (m0 & m) {
+      if (si[x] != sj[x]) {
+	if (IsIntTerm(si[x]))
+	  return IntOfTerm(si[x])-IntOfTerm(sj[x]);
+	return AtomOfTerm(si[x])-AtomOfTerm(sj[x]);
+      }
+      m -= m0;
+      if (m == 0)
+	return 0;
+    }
+    m0 <<= 1;
+  }
+  return 0;
+}
+
+static int
+compar2(const void *ip0, const void *jp0) {
+  CACHE_REGS
+  BITS32 *ip = (BITS32 *)ip0, *jp = (BITS32 *)jp0;
+  struct index_t *it = LOCAL_exo_it;
+  Term* si = EXO_OFFSET_TO_ADDRESS(it, *ip);
+  Term* sj = EXO_OFFSET_TO_ADDRESS(it, *jp);
+  int cmp = cmp_extra_args(si, sj, it);
+  if (cmp)
+    return cmp;
+  return IntOfTerm(si[LOCAL_exo_arg])-IntOfTerm(sj[LOCAL_exo_arg]);
+}
+
+static int
+compare(const BITS32 *ip, Int j USES_REGS) {
+  Term i = EXO_OFFSET_TO_ADDRESS(LOCAL_exo_it, *ip)[LOCAL_exo_arg];
+  //fprintf(stderr, "%ld-%ld\n", IntOfTerm(i), j); 
+  return IntOfTerm(i)-j;
+}
+
+static UInt free_args(UInt b[], UInt arity, UInt i) {
+  UInt j;
+  UInt rc = 0;
+
+  for (j=0; j<arity; j++) {
+    if (i !=j && b[j] == 0)
+      rc |= 1<<j;
+  }
+  return rc;
+}
+
+static BITS32*
+NEXT_DIFFERENT(BITS32 *pt0, BITS32 *pte, struct index_t *it)
+{
+  Term* si = EXO_OFFSET_TO_ADDRESS(it, pt0[0]);
+  Term* sj;
+
+  do {
+    pt0++;
+    if (pt0 == pte)
+      return NULL;
+    sj = EXO_OFFSET_TO_ADDRESS(it, *pt0);
+  } while (!cmp_extra_args(si, sj, it));
+  return pt0;
+}
+
+static BITS32*
+PREV_DIFFERENT(BITS32 *pt0, BITS32 *pte, struct index_t *it)
+{
+  Term* si = EXO_OFFSET_TO_ADDRESS(it, pt0[0]);
+  Term* sj;
+
+  do {
+    pt0--;
+    if (pt0 == pte)
+      return NULL;
+    sj = EXO_OFFSET_TO_ADDRESS(it, *pt0);
+  } while (!cmp_extra_args(si, sj, it));
+  return pt0;
+}
+
+static BITS32*
+NEXT_MIN(BITS32 *pt0, BITS32 *pte, Term tmin, Term tmax, struct index_t *it)
+{
+  Term* si = EXO_OFFSET_TO_ADDRESS(it, pt0[0]);
+  int do_min, do_max;
+  Int min = 0, max = 0;
+
+  if (IsVarTerm(tmin)) {
+    do_min = FALSE;
+  } else {
+    do_min = TRUE;
+    min = IntOfTerm(tmin);
+  }
+  if (IsVarTerm(tmax)) {
+    do_max = FALSE;
+  } else {
+    do_max = TRUE;
+    max = IntOfTerm(tmax);
+  }
+
+  while ((do_min && IntOfTerm(si[it->udi_arg]) < min) ||
+	 (do_max && IntOfTerm(si[it->udi_arg]) > max)) {
+    pt0++;
+    if (pt0 == pte)
+      return NULL;
+    si = EXO_OFFSET_TO_ADDRESS(it, *pt0);
+  }
+  return pt0;
+}
+
+static BITS32*
+NEXT_MAX(BITS32 *pt0, BITS32 *pte, Term tmin, Term tmax, struct index_t *it)
+{
+  Term* si = EXO_OFFSET_TO_ADDRESS(it, pt0[0]);
+  int do_min, do_max;
+  Int min = 0, max = 0;
+
+  if (IsVarTerm(tmin)) {
+    do_min = FALSE;
+  } else {
+    do_min = TRUE;
+    min = IntOfTerm(tmin);
+  }
+  if (IsVarTerm(tmax)) {
+    do_max = FALSE;
+  } else {
+    do_max = TRUE;
+    max = IntOfTerm(tmax);
+  }
+
+  while ((do_min && IntOfTerm(si[it->udi_arg]) < min) ||
+	 (do_max && IntOfTerm(si[it->udi_arg]) > max)) {
+    pt0--;
+    if (pt0 == pte)
+      return NULL;
+    si = EXO_OFFSET_TO_ADDRESS(it, *pt0);
+  }
+  return pt0;
+}
+
+static void
+IntervalUDIRefitIndex(struct index_t **ip, UInt b[] USES_REGS)
+{
+  size_t sz;
+  struct index_t *it = *ip;
+  yamop *code;
+
+  /* hard-wired implementation for the Interval case */
+  Int i = it->udi_arg;
+  /* it is bound, use hash */
+  if (it->bmap & b[i]) return;
+  /* no constraints, nothing to gain */
+  //if (!IsAttVar(VarOfTerm(Deref(XREGS[i+1])))) return;
+  LOCAL_exo_it = it;
+  LOCAL_exo_base = it->bcls;
+  LOCAL_exo_arity = it->arity;
+  LOCAL_exo_arg = i;
+  it->udi_free_args = free_args(b, it->arity, i);
+  if (!it->key) {
+    UInt ncls = it->ap->cs.p_code.NOfClauses, i;
+    BITS32 *sorted;
+    /* handle ll variables */
+    sz = sizeof(BITS32)*(ncls);
+    /* allocate space */
+    if (!(it->udi_data = (BITS32*)Yap_AllocCodeSpace(sz)))
+      return;
+    sorted = (BITS32*)it->udi_data;
+    for (i=0; i< ncls; i++)
+      sorted[i] = i;
+    qsort(sorted, (size_t)ncls, sizeof(BITS32), compar); 
+    it->links = NULL;
+  } else {
+    BITS32 *sorted0, *sorted;
+    
+    /* be conservative */
+    if (it->udi_free_args)
+      sz = sizeof(BITS32)*(2*it->ntrys+3*it->nentries);
+    else
+      sz = sizeof(BITS32)*(it->ntrys+2*it->nentries);
+    /* allocate space */
+    if (!(it->udi_data = (BITS32*)malloc(sz)))
+      return;
+    sorted0 = sorted = (BITS32 *)it->udi_data;
+    sorted++; /* leave an initial hole */
+    for (i=0; i < it->hsize; i++) {
+      if (it->key[i]) {
+	BITS32 *s0 = sorted;
+	BITS32 offset = it->key[i], offset0 = offset;
+	
+	*sorted++ = 0;
+	do {
+	  *sorted++ = offset;
+	  offset = it->links[offset];
+	} while (offset);
+	// S = EXO_OFFSET_TO_ADDRESS(it, offset0); Yap_DebugPlWrite(S[0]);
+	// fprintf(stderr, " key[i]=%d offset=%d  %d\n", it->key[i], offset0, (sorted-s0)-1);
+	if (sorted-s0 == 2) {
+	  it->links[offset0] = 0;
+	  sorted = s0;
+	} else {
+	  /* number of elements comes first */
+	  *s0 = sorted - (s0+1);
+	  qsort(s0+1, (size_t)*s0, sizeof(BITS32), compar); 
+	  it->links[offset0] = s0-sorted0;
+	  if (it->udi_free_args) {
+	    memmove(sorted, s0+1, sizeof(BITS32)*(*s0));
+	    qsort(sorted, (size_t)*s0, sizeof(BITS32), compar2); 
+	    sorted += *s0;
+	  }
+	}
+      }
+    }
+    sz = sizeof(BITS32)*(sorted-sorted0);
+    it->udi_data = (BITS32 *)realloc((char *)it->udi_data, sz);
+  }
+  it->is_udi = i+1;
+  code = it->code;
+  code->opc = Yap_opcode(_try_exo_udi);
+  code = NEXTOP(code, lp);
+  code->opc = Yap_opcode(_retry_exo_udi);
+}
+
+ static BITS32 *
+ binary_search(BITS32 *start, BITS32 *end, Int x USES_REGS)
+ {
+   BITS32 *mid;
+   while (start < end) {
+     int cmp;
+     mid = start + (end-start)/2;
+     cmp = compare(mid, x PASS_REGS);
+     if (!cmp)
+       return mid;
+     if (cmp > 0) {
+       end = mid-1;
+     } else
+       start = mid+1;
+   }
+   return start;
+ }
+
+ static yamop *
+Interval(struct index_t *it, Term min, Term max, Term op, BITS32 off USES_REGS)
+ {
+   BITS32 *c;
+   BITS32 n;
+   BITS32 *pt;
+   BITS32 *end;
+   Atom at;
+
+   LOCAL_exo_it = it;
+   LOCAL_exo_base = it->bcls;
+   LOCAL_exo_arity = it->arity;
+   LOCAL_exo_arg = it->udi_arg;
+   if (!it->links) {
+     c = (BITS32 *)it->udi_data;
+     n = it->nels;
+     pt  = c;
+     end  = c+(n-1);
+   } else if (it->links[off]) {
+     c = (BITS32 *)it->udi_data;
+     n = c[it->links[off]];
+     pt = c;
+     end  = c+(it->links[off]+n);
+     // fprintf(stderr," %d links %d=%d \n", off, it->links[off], n);
+   } else {
+     if (!IsVarTerm(min)) {
+       Int x;
+       if (!IsIntegerTerm(min)) {
+	 min = Yap_Eval(min);
+	 if (!IsIntegerTerm(min)) {
+	   Yap_Error(TYPE_ERROR_INTEGER, min, "data-base constraint");
+	   return FAILCODE;
+	 }
+       }
+       x = IntegerOfTerm(min);
+       if (x >= IntegerOfTerm(S[LOCAL_exo_arg])) {
+	 return FAILCODE;
+       }     
+     }
+     if (!IsVarTerm(max)) {
+       Int x;
+       if (!IsIntegerTerm(max)) {
+	 max = Yap_Eval(max);
+	 if (!IsIntegerTerm(max)) {
+	   Yap_Error(TYPE_ERROR_INTEGER, max, "data-base constraint");
+	   return FAILCODE;
+	 }
+       }
+       x = IntegerOfTerm(max);
+       if (x <= IntegerOfTerm(S[LOCAL_exo_arg])) {
+	 return FAILCODE;
+       }     
+     }
+     return NEXTOP(NEXTOP(it->code,lp),lp);
+   }
+
+   if (!IsVarTerm(min)) {
+     Int x;
+     if (!IsIntegerTerm(min)) {
+      min = Yap_Eval(min);
+      if (!IsIntegerTerm(min)) {
+	Yap_Error(TYPE_ERROR_INTEGER, min, "data-base constraint");
+	return FAILCODE;
+      }
+     }
+     x = IntegerOfTerm(min);
+     if (n > 8) {
+       int cmp;
+       pt = binary_search(pt, end, x PASS_REGS);
+       while ( pt < end+1 && (cmp = compare(pt, x PASS_REGS)) <= 0 ) {
+	 if (cmp > 0) break;
+	 pt++;
+       }
+     } else {
+       while ( pt < end+1 && compare(pt, x PASS_REGS) <= 0 ) {
+	 pt++;
+       }
+     }
+     if (pt > end) 
+       return FAILCODE;
+   }
+   if (!IsVarTerm(max)) {
+     Int x;
+     BITS32 *pt1;
+     Int n = end-pt;
+
+     if (!IsIntegerTerm(max)) {
+      max = Yap_Eval(max);
+      if (!IsIntegerTerm(max)) {
+	Yap_Error(TYPE_ERROR_INTEGER, max, "data-base constraint");
+	return FAILCODE;
+      }
+     }
+     x = IntegerOfTerm(max);
+     if (n > 8) {
+       int cmp;
+       pt1 = binary_search(pt, end, x PASS_REGS);
+       while ( pt1 >= pt && (cmp = compare(pt1, x PASS_REGS)) >= 0 ) {
+	 if (cmp < 0) break;
+	 pt1--;
+       }
+     } else {
+       pt1 = end;
+       while ( pt1 >= pt && compare(pt1, x PASS_REGS) >= 0 ) {
+	 pt1--;
+       }
+     }
+     if (pt1 < pt) 
+       return FAILCODE;
+     end = pt1;
+   }
+   if (IsVarTerm(op)) {
+     S = EXO_OFFSET_TO_ADDRESS(it, pt[0]);
+     if (pt < end ) {
+       YENV[-1] = (CELL)( end );
+       YENV[-2] = (CELL)( pt+1 );
+       YENV -= 2;
+       return it->code;
+     }
+     return NEXTOP(NEXTOP(it->code,lp),lp);
+   }
+   at = AtomOfTerm(op);
+   if (at == AtomAny || at == AtomMinimum) {
+     S = EXO_OFFSET_TO_ADDRESS(it, pt[0]);
+   } else if (at == AtomMaximum) {
+     S = EXO_OFFSET_TO_ADDRESS(it, end[0]);
+   } else if (at == AtomUnique) {
+     if (end-2 > pt)
+       return FAILCODE;
+     S = EXO_OFFSET_TO_ADDRESS(it, pt[0]);
+   } else if (at == AtomMin) {
+     S = EXO_OFFSET_TO_ADDRESS(it, pt[0]);
+     if (it->udi_free_args) {
+       BITS32 *ptn;
+       pt  = c+(it->links[off]+n+1);
+       end = pt+n;
+       pt = NEXT_MIN(pt, end, min, max, it);
+       if (!pt)
+	 return FAILCODE;
+       S = EXO_OFFSET_TO_ADDRESS(it, pt[0]);
+       ptn = NEXT_DIFFERENT(pt, end, it);
+       if (ptn) 
+	 ptn = NEXT_MIN(ptn, end, min, max, it);
+       if ( ptn ) {
+	 YENV[-1] = min;    // what we are doing
+	 YENV[-2] = max;    // what we are doing
+	 YENV[-3] = (CELL) end;    // what we are doing
+	 YENV[-4] = MkAtomTerm(AtomMin);    // what we are doing
+	 YENV[-5] = (CELL)( ptn );    // where we are in pt0 array
+	 YENV -= 5;
+	 return it->code;
+       }
+     }
+     return NEXTOP(NEXTOP(it->code,lp),lp);
+   } else if (at == AtomMax) {
+     S = EXO_OFFSET_TO_ADDRESS(it, pt[0]);
+     if (it->udi_free_args) {
+       BITS32 *ptn;
+       end  = c+(it->links[off]+n);
+       pt = end+n;
+       pt = NEXT_MAX(pt, end, min, max, it);
+       if (!pt)
+	 return FAILCODE;
+       S = EXO_OFFSET_TO_ADDRESS(it, pt[0]);
+       ptn = PREV_DIFFERENT(pt, end, it);
+       if (ptn) 
+	 ptn = NEXT_MAX(ptn, end, min, max, it);
+       if ( ptn ) {
+	 YENV[-1] = min;    // what we are doing
+	 YENV[-2] = max;    // what we are doing
+	 YENV[-3] = (CELL) end;    // what we are doing
+	 YENV[-4] = MkAtomTerm(AtomMax);    // what we are doing
+	 YENV[-5] = (CELL)( ptn );    // where we are in pt0 array
+	 YENV -= 5;
+	 return it->code;
+       }
+     }
+     return NEXTOP(NEXTOP(it->code,lp),lp);
+   }
+   return NEXTOP(NEXTOP(it->code,lp),lp);
+ }
+
+static yamop *
+IntervalEnterUDIIndex(struct index_t *it USES_REGS)
+{
+  Int i = it->udi_arg;
+  Term  t = XREGS[i+1], a1;
+  BITS32 off = EXO_ADDRESS_TO_OFFSET(it, S);
+  //  printf("off=%d it=%p %p---%p\n", off, it, it->cls, S);
+  attvar_record *attv;
+
+  t = Deref(t);
+  if (!IsVarTerm(t))
+    return FALSE;
+  if(!IsAttVar(VarOfTerm(t)))
+    return Interval(it, MkVarTerm(), MkVarTerm(), MkVarTerm(), off PASS_REGS);
+  attv = RepAttVar(VarOfTerm(t));
+  t =  attv->Atts;
+  a1 = ArgOfTerm(2,t);
+  if (IsVarTerm(a1)) {
+    Yap_Error(INSTANTIATION_ERROR, t, "executing exo_interval constraints");
+    return FAILCODE;
+  } else if (!IsApplTerm(a1)) {
+    Yap_Error(TYPE_ERROR_COMPOUND, a1, "executing exo_interval constraints");
+    return FAILCODE;
+  } else {
+    return Interval(it, ArgOfTerm(1,a1), ArgOfTerm(2,a1), ArgOfTerm(3,a1), off PASS_REGS);
+  }
+}
+
+static int
+IntervalRetryUDIIndex(struct index_t *it USES_REGS)
+{
+  CELL *w = (CELL*)(B+1)+it->arity;
+  if (IsVarTerm(w[2])) {
+    BITS32 *end = (BITS32 *) w[2],
+      *pt = (BITS32 *) w[1];
+    BITS32 f = *pt;
+
+    S = EXO_OFFSET_TO_ADDRESS(it, f);
+    if (pt++ == end) return FALSE;
+    w[1] = (CELL)pt;
+  } else {
+    BITS32 *pt0 = (BITS32 *)w[1];
+    BITS32 *pte = (BITS32 *)w[3];
+    Atom what = AtomOfTerm(w[2]);
+    Term min = w[5];
+    Term max = w[4];
+
+    S = EXO_OFFSET_TO_ADDRESS(it, pt0[0]);
+    if ( what == AtomMin ) {
+      pt0 = NEXT_DIFFERENT(pt0, pte, it);
+      if (pt0) 
+	pt0 = NEXT_MIN(pt0, pte, min, max, it); 
+    } else {
+      pt0 = PREV_DIFFERENT(pt0, pte, it);
+      if (pt0) 
+	pt0 = NEXT_MAX(pt0, pte, min, max, it); 
+    }
+    if (!pt0) {
+      return FALSE;
+    }
+    w[1] = (CELL)pt0;
+  }
+  return TRUE;
+}
+
+
+static struct udi_control_block IntervalCB;
+
+typedef struct exo_udi_access_t {
+  CRefitExoIndex refit;
+} exo_udi_encaps_t;
+
+static struct exo_udi_access_t ExoCB;
+
+static void *
+IntervalUdiInit (Term spec, int arg, int arity) {
+  ExoCB.refit = IntervalUDIRefitIndex;
+  return (void *)&ExoCB;
+}
+
+static void *
+IntervalUdiInsert (void *control,
+                Term term, int arg, void *data)
+{
+  CACHE_REGS
+
+  struct index_t **ip = (struct index_t **)term;
+  (*ip)->udi_arg = arg-1;
+  (ExoCB.refit)(ip, LOCAL_ibnds PASS_REGS);
+  (*ip)->udi_first = (void *)IntervalEnterUDIIndex;
+  (*ip)->udi_next = (void *)IntervalRetryUDIIndex;
+  return control;
+}
+
+static int IntervalUdiDestroy(void *control)
+{
+  return TRUE;
+}
+
+
+
+void Yap_udi_Interval_init(void) {
+  UdiControlBlock cb = &IntervalCB;
+  Atom name = Yap_LookupAtom("exo_interval");
+  memset((void *) cb,0, sizeof(*cb));
+
+  /*TODO: ask vitor why this gives a warning*/
+  cb->decl= (YAP_Atom)name;
+  Yap_MkEmptyWakeUp(name);
+  cb->init= IntervalUdiInit;
+  cb->insert=IntervalUdiInsert;
+  cb->search=NULL;
+  cb->destroy=IntervalUdiDestroy;
+
+  Yap_UdiRegister(cb);
+}
--- a/C/fail_absmi_insts.h
+++ b/C/fail_absmi_insts.h
@ -0,0 +1,414 @@
+/*****************************************************************
+ *        Failure                                                 *
+ *****************************************************************/
+
+#ifdef INDENT_CODE
+{
+#endif /* INDENT_CODE */
+
+  /* trust_fail                       */
+  BOp(trust_fail, e);
+  {
+    while (POP_CHOICE_POINT(B->cp_b)) {
+      POP_EXECUTE();
+    }
+  }
+#ifdef YAPOR
+  {
+    choiceptr cut_pt;
+    cut_pt = B->cp_b;
+    CUT_prune_to(cut_pt);
+    B = cut_pt;
+  }
+#else
+  B = B->cp_b;
+#endif /* YAPOR */
+  goto fail;
+  ENDBOp();
+
+#ifdef YAPOR
+shared_fail:
+  B = Get_LOCAL_top_cp();
+  SET_BB(PROTECT_FROZEN_B(B));
+  goto fail;
+#endif /* YAPOR */
+
+  /* fail                             */
+  PBOp(op_fail, e);
+
+  if (PP) {
+    UNLOCK(PP->PELock);
+    PP = NULL;
+  }
+#ifdef COROUTINING
+  CACHE_Y_AS_ENV(YREG);
+  check_stack(NoStackFail, HR);
+  ENDCACHE_Y_AS_ENV();
+#endif
+
+fail : {
+  register tr_fr_ptr pt0 = TR;
+#if defined(YAPOR) || defined(THREADS)
+  if (PP) {
+    UNLOCK(PP->PELock);
+    PP = NULL;
+  }
+#endif
+  PREG = B->cp_ap;
+  save_pc();
+  CACHE_TR(B->cp_tr);
+  PREFETCH_OP(PREG);
+failloop:
+  if (pt0 == S_TR) {
+    SP = SP0;
+#ifdef LOW_LEVEL_TRACER
+    if (Yap_do_low_level_trace) {
+      int go_on = true;
+      yamop *ipc = PREG;
+
+      while (go_on) {
+        op_numbers opnum = Yap_op_from_opcode(ipc->opc);
+
+        go_on = false;
+        switch (opnum) {
+#ifdef TABLING
+        case _table_load_answer:
+          low_level_trace(retry_table_loader, LOAD_CP(B)->cp_pred_entry, NULL);
+          break;
+        case _table_try_answer:
+        case _table_retry_me:
+        case _table_trust_me:
+        case _table_retry:
+        case _table_trust:
+        case _table_completion:
+#ifdef THREADS_CONSUMER_SHARING
+        case _table_answer_resolution_completion:
+#endif /* THREADS_CONSUMER_SHARING */
+#ifdef DETERMINISTIC_TABLING
+          if (IS_DET_GEN_CP(B))
+            low_level_trace(retry_table_generator, DET_GEN_CP(B)->cp_pred_entry,
+                            NULL);
+          else
+#endif /* DETERMINISTIC_TABLING */
+            low_level_trace(retry_table_generator, GEN_CP(B)->cp_pred_entry,
+                            (CELL *)(GEN_CP(B) + 1));
+          break;
+        case _table_answer_resolution:
+          low_level_trace(retry_table_consumer, CONS_CP(B)->cp_pred_entry,
+                          NULL);
+          break;
+        case _trie_trust_var:
+        case _trie_retry_var:
+        case _trie_trust_var_in_pair:
+        case _trie_retry_var_in_pair:
+        case _trie_trust_val:
+        case _trie_retry_val:
+        case _trie_trust_val_in_pair:
+        case _trie_retry_val_in_pair:
+        case _trie_trust_atom:
+        case _trie_retry_atom:
+        case _trie_trust_atom_in_pair:
+        case _trie_retry_atom_in_pair:
+        case _trie_trust_null:
+        case _trie_retry_null:
+        case _trie_trust_null_in_pair:
+        case _trie_retry_null_in_pair:
+        case _trie_trust_pair:
+        case _trie_retry_pair:
+        case _trie_trust_appl:
+        case _trie_retry_appl:
+        case _trie_trust_appl_in_pair:
+        case _trie_retry_appl_in_pair:
+        case _trie_trust_extension:
+        case _trie_retry_extension:
+        case _trie_trust_double:
+        case _trie_retry_double:
+        case _trie_trust_longint:
+        case _trie_retry_longint:
+        case _trie_trust_gterm:
+        case _trie_retry_gterm:
+          low_level_trace(retry_table_loader, UndefCode, NULL);
+          break;
+#endif /* TABLING */
+        case _or_else:
+        case _or_last:
+          low_level_trace(retry_or, NULL, NULL);
+          break;
+        case _retry2:
+        case _retry3:
+        case _retry4:
+          ipc = NEXTOP(ipc, l);
+          go_on = true;
+          break;
+        case _jump:
+          ipc = ipc->y_u.l.l;
+          go_on = true;
+          break;
+        case _retry_c:
+        case _retry_userc:
+          low_level_trace(retry_pred, ipc->y_u.OtapFs.p, B->cp_args);
+          break;
+        case _retry_profiled:
+        case _count_retry:
+          ipc = NEXTOP(ipc, p);
+          go_on = true;
+          break;
+        case _retry_me:
+        case _trust_me:
+        case _count_retry_me:
+        case _count_trust_me:
+        case _profiled_retry_me:
+        case _profiled_trust_me:
+        case _retry_and_mark:
+        case _profiled_retry_and_mark:
+        case _retry:
+        case _trust:
+          low_level_trace(retry_pred, ipc->y_u.Otapl.p, B->cp_args);
+          break;
+        case _try_logical:
+        case _retry_logical:
+        case _profiled_retry_logical:
+        case _count_retry_logical:
+        case _trust_logical:
+        case _profiled_trust_logical:
+        case _count_trust_logical:
+          low_level_trace(retry_pred, ipc->y_u.OtILl.d->ClPred, B->cp_args);
+          break;
+        case _Nstop:
+        case _Ystop:
+          low_level_trace(retry_pred, NULL, B->cp_args);
+          break;
+        default:
+          break;
+        }
+      }
+    }
+#endif /* LOW_LEVEL_TRACER */
+#ifdef FROZEN_STACKS
+#ifdef YAPOR_SBA
+    if (pt0 < TR_FZ || pt0 > (ADDR)CurrentTrailTop + MinTrailGap)
+#else
+    if (pt0 < TR_FZ)
+#endif /* YAPOR_SBA */
+    {
+      TR = TR_FZ;
+      TRAIL_LINK(pt0);
+    } else
+#endif /* FROZEN_STACKS */
+      RESTORE_TR();
+    GONext();
+  }
+  BEGD(d1);
+  d1 = TrailTerm(pt0 - 1);
+  pt0--;
+  if (IsVarTerm(d1)) {
+#if defined(YAPOR_SBA) && defined(YAPOR)
+    /* clean up the trail when we backtrack */
+    if (Unsigned((Int)(d1) - (Int)(H_FZ)) >
+        Unsigned((Int)(B_FZ) - (Int)(H_FZ))) {
+      RESET_VARIABLE(STACK_TO_SBA(d1));
+    } else
+#endif
+      /* normal variable */
+      RESET_VARIABLE(d1);
+    goto failloop;
+  }
+/* pointer to code space */
+/* or updatable variable */
+  if (IsPairTerm(d1))
+  {
+    register CELL flags;
+    CELL *pt1 = RepPair(d1);
+#ifdef LIMIT_TABLING
+    if ((ADDR)pt1 == LOCAL_TrailBase) {
+      sg_fr_ptr sg_fr = (sg_fr_ptr)TrailVal(pt0);
+      TrailTerm(pt0) = AbsPair((CELL *)(pt0 - 1));
+      SgFr_state(sg_fr)--; /* complete_in_use --> complete : compiled_in_use -->
+                              compiled */
+      insert_into_global_sg_fr_list(sg_fr);
+      goto failloop;
+    }
+#endif               /* LIMIT_TABLING */
+#ifdef FROZEN_STACKS /* TRAIL */
+    /* avoid frozen segments */
+    if (
+#ifdef YAPOR_SBA
+        (ADDR)pt1 >= HeapTop
+#else
+        IN_BETWEEN(LOCAL_TrailBase, pt1, (ADDR)CurrentTrailTop + MinTrailGap)
+#endif /* YAPOR_SBA */
+    ) {
+      pt0 = (tr_fr_ptr)pt1;
+      goto failloop;
+    } else
+#endif /* FROZEN_STACKS */
+        if (IN_BETWEEN(H0, pt1, LCL0)) {
+      if (IsAttVar(pt1)) {
+        goto failloop;
+      } else {
+        TR = pt0;
+
+Yap_CleanOpaqueVariable(d1);
+
+        goto failloop;
+      }
+    }
+#ifdef FROZEN_STACKS /* TRAIL */
+    /* don't reset frozen variables */
+    else if (pt0 < TR_FZ)
+      goto failloop;
+#endif
+    flags = *pt1;
+#if MULTIPLE_STACKS
+    if (FlagOn(DBClMask, flags)) {
+      DBRef dbr = DBStructFlagsToDBStruct(pt1);
+      int erase;
+
+      LOCK(dbr->lock);
+      DEC_DBREF_COUNT(dbr);
+      erase = (dbr->Flags & ErasedMask) && (dbr->ref_count == 0);
+      UNLOCK(dbr->lock);
+      if (erase) {
+        saveregs();
+        Yap_ErDBE(dbr);
+        setregs();
+      }
+    } else {
+      if (flags & LogUpdMask) {
+        if (flags & IndexMask) {
+          LogUpdIndex *cl = ClauseFlagsToLogUpdIndex(pt1);
+          int erase;
+#if PARALLEL_YAP
+          PredEntry *ap = cl->ClPred;
+#endif
+
+          PELOCK(8, ap);
+          DEC_CLREF_COUNT(cl);
+          erase = (cl->ClFlags & ErasedMask) && !(cl->ClRefCount);
+          if (erase) {
+            saveregs();
+            /* at this point,
+we are the only ones accessing the clause,
+hence we don't need to have a lock it */
+            Yap_ErLogUpdIndex(cl);
+            setregs();
+          } else if (cl->ClFlags & DirtyMask) {
+            saveregs();
+            /* at this point,
+we are the only ones accessing the clause,
+hence we don't need to have a lock it */
+            Yap_CleanUpIndex(cl);
+            setregs();
+          }
+          UNLOCK(ap->PELock);
+        } else {
+          LogUpdClause *cl = ClauseFlagsToLogUpdClause(pt1);
+          int erase;
+          PredEntry *ap = cl->ClPred;
+          /* BB support */
+          if (ap) {
+
+            PELOCK(9, ap);
+            DEC_CLREF_COUNT(cl);
+            erase = (cl->ClFlags & ErasedMask) && !(cl->ClRefCount);
+            if (erase) {
+              saveregs();
+              /* at this point,
+we are the only ones accessing the clause,
+hence we don't need to have a lock it */
+              Yap_ErLogUpdCl(cl);
+              setregs();
+            }
+            UNLOCK(ap->PELock);
+          }
+        }
+      } else {
+        DynamicClause *cl = ClauseFlagsToDynamicClause(pt1);
+        int erase;
+
+        LOCK(cl->ClLock);
+        DEC_CLREF_COUNT(cl);
+        erase = (cl->ClFlags & ErasedMask) && !(cl->ClRefCount);
+        UNLOCK(cl->ClLock);
+        if (erase) {
+          saveregs();
+          /* at this point,
+we are the only ones accessing the clause,
+hence we don't need to have a lock it */
+          Yap_ErCl(cl);
+          setregs();
+        }
+      }
+    }
+#else
+    ResetFlag(InUseMask, flags);
+    *pt1 = flags;
+    if (FlagOn((ErasedMask | DirtyMask), flags)) {
+      if (FlagOn(DBClMask, flags)) {
+        saveregs();
+        Yap_ErDBE(DBStructFlagsToDBStruct(pt1));
+        setregs();
+      } else {
+        saveregs();
+        if (flags & LogUpdMask) {
+          if (flags & IndexMask) {
+            if (FlagOn(ErasedMask, flags)) {
+              Yap_ErLogUpdIndex(ClauseFlagsToLogUpdIndex(pt1));
+            } else {
+              Yap_CleanUpIndex(ClauseFlagsToLogUpdIndex(pt1));
+            }
+          } else {
+            Yap_ErLogUpdCl(ClauseFlagsToLogUpdClause(pt1));
+          }
+        } else {
+          Yap_ErCl(ClauseFlagsToDynamicClause(pt1));
+        }
+        setregs();
+      }
+    }
+#endif
+    goto failloop;
+  }
+#ifdef MULTI_ASSIGNMENT_VARIABLES
+  else /* if (IsApplTerm(d1)) */
+  {
+    CELL *pt = RepAppl(d1);
+/* AbsAppl means */
+/* multi-assignment variable */
+/* so the next cell is the old value */
+#ifdef FROZEN_STACKS
+    --pt0;
+    pt[0] = TrailVal(pt0);
+#else
+    pt[0] = TrailTerm(pt0 - 1);
+    pt0 -= 2;
+#endif /* FROZEN_STACKS */
+    goto failloop;
+  }
+#endif
+  ENDD(d1);
+  ENDCACHE_TR();
+}
+
+#ifdef COROUTINING
+NoStackFail:
+  BEGD(d0);
+#ifdef SHADOW_S
+  Yap_REGS.S_ = SREG;
+#endif
+  saveregs();
+  d0 = interrupt_fail(PASS_REGS1);
+  setregs();
+#ifdef SHADOW_S
+  SREG = Yap_REGS.S_;
+#endif
+  if (!d0)
+    FAIL();
+  JMPNext();
+  ENDD(d0);
+
+#endif /* COROUTINING */
+  ENDPBOp();
+#ifdef INDENT_CODE
+}
+#endif /* INDENT_CODE */
--- a/C/flags.c
+++ b/C/flags.c
--- a/C/fli_absmi_insts.h
+++ b/C/fli_absmi_insts.h
@ -0,0 +1,646 @@
+/************************************************************************\
+ *    Call C predicates instructions                                   *
+\************************************************************************/
+
+#ifdef INDENT_CODE
+{
+  {
+    {
+#endif /* INDENT_CODE */
+
+      BOp(call_cpred, Osbpp);
+#if __ANDROID__ && STRONG_DEBUG
+      char *s;
+      Atom name;
+      if (PREG->y_u.Osbpp.p->ArityOfPE) {
+        Functor f = PREG->y_u.Osbpp.p->FunctorOfPred;
+        name = f->NameOfFE;
+      } else {
+        name = (Atom)(PREG->y_u.Osbpp.p->FunctorOfPred);
+      }
+      s = name->StrOfAE;
+
+      LOG(" %s ", s);
+#endif
+      check_trail(TR);
+      if (!(PREG->y_u.Osbpp.p->PredFlags &
+            (SafePredFlag | NoTracePredFlag | HiddenPredFlag))) {
+        CACHE_Y_AS_ENV(YREG);
+        check_stack(NoStackCCall, HR);
+        ENDCACHE_Y_AS_ENV();
+      }
+    do_c_call :
+#ifdef FROZEN_STACKS
+    {
+      choiceptr top_b = PROTECT_FROZEN_B(B);
+
+#ifdef YAPOR_SBA
+      if (YREG > (CELL *)top_b || YREG < HR)
+        ASP = (CELL *)top_b;
+#else
+      if (YREG > (CELL *)top_b)
+        ASP = (CELL *)top_b;
+#endif /* YAPOR_SBA */
+      else
+        ASP = (CELL *)(((char *)YREG) + PREG->y_u.Osbpp.s);
+    }
+#else
+      SET_ASP(YREG, PREG->y_u.Osbpp.s);
+/* for slots to work */
+#endif /* FROZEN_STACKS */
+#ifdef LOW_LEVEL_TRACER
+      if (Yap_do_low_level_trace)
+        low_level_trace(enter_pred, PREG->y_u.Osbpp.p, XREGS + 1);
+#endif /* LOW_LEVEL_TRACE */
+      BEGD(d0);
+      CPredicate f = PREG->y_u.Osbpp.p->cs.f_code;
+      PREG = NEXTOP(PREG, Osbpp);
+      saveregs();
+      d0 = f(PASS_REGS1);
+      setregs();
+#ifdef SHADOW_S
+      SREG = Yap_REGS.S_;
+#endif
+      if (!d0) {
+        FAIL();
+      }
+      CACHE_A1();
+      ENDD(d0);
+      JMPNext();
+
+    NoStackCCall:
+      PROCESS_INT(interrupt_call, do_c_call);
+
+      ENDBOp();
+
+      /* execute     Label               */
+      BOp(execute_cpred, Osbpp);
+      check_trail(TR);
+      {
+        PredEntry *pt0;
+
+        BEGD(d0);
+        CACHE_Y_AS_ENV(YREG);
+#ifndef NO_CHECKING
+        check_stack(NoStackExecuteC, HR);
+      do_executec :
+#endif
+#ifdef FROZEN_STACKS
+      {
+        choiceptr top_b = PROTECT_FROZEN_B(B);
+
+#ifdef YAPOR_SBA
+        if (YREG > (CELL *)top_b || YREG < HR)
+          ASP = (CELL *)top_b;
+#else
+        if (YREG > (CELL *)top_b)
+          ASP = (CELL *)top_b;
+#endif /* YAPOR_SBA */
+        else
+          ASP = YREG + E_CB;
+      }
+#else
+        SET_ASP(YREG, E_CB * sizeof(CELL));
+/* for slots to work */
+#endif /* FROZEN_STACKS */
+        pt0 = PREG->y_u.Osbpp.p;
+#ifdef LOW_LEVEL_TRACER
+        if (Yap_do_low_level_trace) {
+          low_level_trace(enter_pred, pt0, XREGS + 1);
+        }
+#endif /* LOW_LEVEL_TRACE */
+        CACHE_A1();
+        BEGD(d0);
+        d0 = (CELL)B;
+        /* for profiler */
+        save_pc();
+        ENV_YREG[E_CB] = d0;
+        ENDD(d0);
+#ifdef DEPTH_LIMIT
+        if (DEPTH <= MkIntTerm(1)) { /* I assume Module==0 is prolog */
+          if (pt0->ModuleOfPred) {
+            if (DEPTH == MkIntTerm(0)) {
+              FAIL();
+            } else {
+              DEPTH = RESET_DEPTH();
+            }
+          }
+        } else if (pt0->ModuleOfPred) {
+          DEPTH -= MkIntConstant(2);
+        }
+#endif /* DEPTH_LIMIT */
+        /* now call C-Code */
+        {
+          CPredicate f = PREG->y_u.Osbpp.p->cs.f_code;
+          yamop *oldPREG = PREG;
+          saveregs();
+          d0 = f(PASS_REGS1);
+          setregs();
+#ifdef SHADOW_S
+          SREG = Yap_REGS.S_;
+#endif
+          if (!d0) {
+            FAIL();
+          }
+          if (oldPREG == PREG) {
+            /* we did not update PREG */
+            /* we can proceed */
+            PREG = CPREG;
+            ENV_YREG = ENV;
+#ifdef DEPTH_LIMIT
+            DEPTH = ENV_YREG[E_DEPTH];
+#endif
+            WRITEBACK_Y_AS_ENV();
+          } else {
+            /* call the new code  */
+            CACHE_A1();
+          }
+        }
+        JMPNext();
+        ENDCACHE_Y_AS_ENV();
+        ENDD(d0);
+      }
+
+    NoStackExecuteC:
+      PROCESS_INT(interrupt_execute, do_executec);
+      ENDBOp();
+
+      /* Like previous, the only difference is that we do not */
+      /* trust the C-function we are calling and hence we must */
+      /* guarantee that *all* machine registers are saved and */
+      /* restored */
+      BOp(call_usercpred, Osbpp);
+      CACHE_Y_AS_ENV(YREG);
+      check_stack(NoStackUserCall, HR);
+      ENDCACHE_Y_AS_ENV();
+    do_user_call:
+#ifdef LOW_LEVEL_TRACER
+      if (Yap_do_low_level_trace) {
+        low_level_trace(enter_pred, PREG->y_u.Osbpp.p, XREGS + 1);
+      }
+#endif /* LOW_LEVEL_TRACE */
+#ifdef FROZEN_STACKS
+      {
+        choiceptr top_b = PROTECT_FROZEN_B(B);
+#ifdef YAPOR_SBA
+        if (YREG > (CELL *)top_b || YREG < HR)
+          ASP = (CELL *)top_b;
+#else
+        if (YREG > (CELL *)top_b)
+          ASP = (CELL *)top_b;
+#endif /* YAPOR_SBA */
+        else
+          ASP = (CELL *)(((char *)YREG) + PREG->y_u.Osbpp.s);
+      }
+#else
+      SET_ASP(YREG, PREG->y_u.Osbpp.s);
+/* for slots to work */
+#endif /* FROZEN_STACKS */
+      {
+        /* make sure that we can still have access to our old PREG after calling
+         * user defined goals and backtracking or failing */
+        yamop *savedP;
+
+        LOCAL_PrologMode |= UserCCallMode;
+        {
+          PredEntry *p = PREG->y_u.Osbpp.p;
+
+          PREG = NEXTOP(PREG, Osbpp);
+          savedP = PREG;
+          saveregs();
+          save_machine_regs();
+
+          SREG = (CELL *)YAP_Execute(p, p->cs.f_code);
+        }
+        setregs();
+        LOCAL_PrologMode &= ~UserCCallMode;
+        restore_machine_regs();
+        PREG = savedP;
+      }
+      if (Yap_HasException()) {
+        Yap_RaiseException();
+        SREG = NULL;
+      }
+      if (!SREG) {
+        FAIL();
+      }
+      /* in case we call Execute */
+      YENV = ENV;
+      YREG = ENV;
+      JMPNext();
+
+    NoStackUserCall:
+      PROCESS_INT(interrupt_call, do_user_call);
+
+      ENDBOp();
+
+      BOp(call_c_wfail, slpp);
+#ifdef LOW_LEVEL_TRACER
+      if (Yap_do_low_level_trace) {
+        low_level_trace(enter_pred, PREG->y_u.slpp.p, XREGS + 1);
+      }
+#endif /* LOW_LEVEL_TRACE */
+#ifdef FROZEN_STACKS
+      {
+        choiceptr top_b = PROTECT_FROZEN_B(B);
+#ifdef YAPOR_SBA
+        if (YREG > (CELL *)top_b || YREG < HR)
+          ASP = (CELL *)top_b;
+#else
+        if (YREG > (CELL *)top_b)
+          ASP = (CELL *)top_b;
+#endif /* YAPOR_SBA */
+        else {
+          BEGD(d0);
+          d0 = PREG->y_u.slpp.s;
+          ASP = ((CELL *)YREG) + d0;
+          ENDD(d0);
+        }
+      }
+#else
+      if (YREG > (CELL *)B)
+        ASP = (CELL *)B;
+      else {
+        BEGD(d0);
+        d0 = PREG->y_u.slpp.s;
+        ASP = ((CELL *)YREG) + d0;
+        ENDD(d0);
+      }
+#endif /* FROZEN_STACKS */
+      {
+        CPredicate f = PREG->y_u.slpp.p->cs.f_code;
+        saveregs();
+        SREG = (CELL *)((f)(PASS_REGS1));
+        setregs();
+      }
+      if (!SREG) {
+        /* be careful about error handling */
+        if (PREG != FAILCODE)
+          PREG = PREG->y_u.slpp.l;
+      } else {
+        PREG = NEXTOP(PREG, slpp);
+      }
+      CACHE_A1();
+      JMPNext();
+      ENDBOp();
+
+      BOp(try_c, OtapFs);
+#ifdef YAPOR
+      CUT_wait_leftmost();
+#endif /* YAPOR */
+      CACHE_Y(YREG);
+      /* Alocate space for the cut_c structure*/
+      CUT_C_PUSH(NEXTOP(NEXTOP(PREG, OtapFs), OtapFs), S_YREG);
+      S_YREG = S_YREG - PREG->y_u.OtapFs.extra;
+      store_args(PREG->y_u.OtapFs.s);
+      store_yaam_regs(NEXTOP(P, OtapFs), 0);
+      B = B_YREG;
+#ifdef YAPOR
+      SCH_set_load(B_YREG);
+#endif /* YAPOR */
+      SET_BB(B_YREG);
+      ENDCACHE_Y();
+
+    TRYCC:
+      ASP = (CELL *)B;
+      {
+        CPredicate f = (CPredicate)(PREG->y_u.OtapFs.f);
+        saveregs();
+        SREG = (CELL *)((f)(PASS_REGS1));
+        /* This last instruction changes B B*/
+        while (POP_CHOICE_POINT(B)) {
+          cut_c_pop();
+        }
+        setregs();
+      }
+      if (!SREG) {
+        /* Removes the cut functions from the stack
+           without executing them because we have fail
+           and not cuted the predicate*/
+        while (POP_CHOICE_POINT(B))
+          cut_c_pop();
+        FAIL();
+      }
+      if ((CELL *)B == YREG && ASP != (CELL *)B) {
+        /* as Luis says, the predicate that did the try C might
+         * have left some data on the stack. We should preserve
+         * it, unless the builtin also did cut */
+        YREG = ASP;
+        HBREG = PROTECT_FROZEN_H(B);
+        SET_BB(B);
+      }
+      PREG = CPREG;
+      YREG = ENV;
+      JMPNext();
+      ENDBOp();
+
+      BOp(retry_c, OtapFs);
+#ifdef YAPOR
+      CUT_wait_leftmost();
+#endif /* YAPOR */
+      CACHE_Y(B);
+      CPREG = B_YREG->cp_cp;
+      ENV = B_YREG->cp_env;
+      HR = PROTECT_FROZEN_H(B);
+#ifdef DEPTH_LIMIT
+      DEPTH = B->cp_depth;
+#endif
+      HBREG = HR;
+      restore_args(PREG->y_u.OtapFs.s);
+      ENDCACHE_Y();
+      goto TRYCC;
+      ENDBOp();
+
+      BOp(cut_c, OtapFs);
+/*This is a phantom instruction. This is not executed by the WAM*/
+#ifdef DEBUG
+      /*If WAM executes this instruction, probably there's an error
+        when we put this instruction, cut_c, after retry_c*/
+      printf("ERROR: Should not print this message FILE: absmi.c %d\n",
+             __LINE__);
+#endif /*DEBUG*/
+      ENDBOp();
+
+      BOp(try_userc, OtapFs);
+#ifdef YAPOR
+      CUT_wait_leftmost();
+#endif /* YAPOR */
+      CACHE_Y(YREG);
+      /* Alocate space for the cut_c structure*/
+      CUT_C_PUSH(NEXTOP(NEXTOP(PREG, OtapFs), OtapFs), S_YREG);
+      S_YREG = S_YREG - PREG->y_u.OtapFs.extra;
+      store_args(PREG->y_u.OtapFs.s);
+      store_yaam_regs(NEXTOP(PREG, OtapFs), 0);
+      B = B_YREG;
+#ifdef YAPOR
+      SCH_set_load(B_YREG);
+#endif
+      SET_BB(B_YREG);
+      ENDCACHE_Y();
+      LOCAL_PrologMode = UserCCallMode;
+      ASP = YREG;
+      saveregs();
+      save_machine_regs();
+      SREG = (CELL *)YAP_ExecuteFirst(PREG->y_u.OtapFs.p,
+                                      (CPredicate)(PREG->y_u.OtapFs.f));
+      Yap_ResetException( worker_id );
+      restore_machine_regs();
+      setregs();
+      LOCAL_PrologMode &= UserMode;
+      if (!SREG) {
+        FAIL();
+      }
+      if ((CELL *)B == YREG && ASP != (CELL *)B) {
+        /* as Luis says, the predicate that did the try C might
+         * have left some data on the stack. We should preserve
+         * it, unless the builtin also did cut */
+        YREG = ASP;
+        HBREG = PROTECT_FROZEN_H(B);
+      }
+      PREG = CPREG;
+      YREG = ENV;
+      CACHE_A1();
+      JMPNext();
+      ENDBOp();
+
+      BOp(retry_userc, OtapFs);
+#ifdef YAPOR
+      CUT_wait_leftmost();
+#endif /* YAPOR */
+      CACHE_Y(B);
+      CPREG = B_YREG->cp_cp;
+      ENV = B_YREG->cp_env;
+      HR = PROTECT_FROZEN_H(B);
+#ifdef DEPTH_LIMIT
+      DEPTH = B->cp_depth;
+#endif
+      HBREG = HR;
+      restore_args(PREG->y_u.OtapFs.s);
+      ENDCACHE_Y();
+
+      LOCAL_PrologMode |= UserCCallMode;
+      SET_ASP(YREG, E_CB * sizeof(CELL));
+      saveregs();
+      save_machine_regs();
+      SREG = (CELL *)YAP_ExecuteNext(PREG->y_u.OtapFs.p,
+                                     (CPredicate)(PREG->y_u.OtapFs.f));
+      Yap_ResetException( worker_id);
+      restore_machine_regs();
+      setregs();
+      LOCAL_PrologMode &= ~UserCCallMode;
+      if (!SREG) {
+        /* Removes the cut functions from the stack
+           without executing them because we have fail
+           and not cuted the predicate*/
+        while (POP_CHOICE_POINT(B))
+          cut_c_pop();
+        FAIL();
+      }
+      if ((CELL *)B == YREG && ASP != (CELL *)B) {
+        /* as Luis says, the predicate that did the try C might
+         * have left some data on the stack. We should preserve
+         * it, unless the builtin also did cut */
+        YREG = ASP;
+        HBREG = PROTECT_FROZEN_H(B);
+      }
+      PREG = CPREG;
+      YREG = ENV;
+      CACHE_A1();
+      JMPNext();
+      ENDBOp();
+
+      BOp(cut_userc, OtapFs);
+/*This is a phantom instruction. This is not executed by the WAM*/
+#ifdef DEBUG
+      /*If WAM executes this instruction, probably there's an error
+        when we put this instruction, cut_userc, after retry_userc*/
+      printf("ERROR: Should not print this message FILE: absmi.c %d\n",
+             __LINE__);
+#endif /*DEBUG*/
+      CACHE_A1();
+      JMPNext();
+      ENDBOp();
+
+      /************************************************************************\
+       *    support instructions                                             *
+\************************************************************************/
+
+      BOp(lock_pred, e);
+      {
+        PredEntry *ap = PredFromDefCode(PREG);
+        PELOCK(10, ap);
+        PP = ap;
+        if (!ap->cs.p_code.NOfClauses) {
+          UNLOCKPE(11, ap);
+          FAIL();
+        }
+        /*
+          we do not lock access to the predicate,
+          we must take extra care here
+        */
+        if (ap->cs.p_code.NOfClauses > 1 &&
+            !(ap->PredFlags & IndexedPredFlag)) {
+          /* update ASP before calling IPred */
+          SET_ASP(YREG, E_CB * sizeof(CELL));
+          saveregs();
+          Yap_IPred(ap, 0, CP);
+          /* IPred can generate errors, it thus must get rid of the lock itself
+           */
+          setregs();
+          CACHE_A1();
+          /* for profiler */
+          save_pc();
+        }
+        PREG = ap->cs.p_code.TrueCodeOfPred;
+      }
+      JMPNext();
+      ENDBOp();
+
+      BOp(index_pred, e);
+      {
+        PredEntry *ap = PredFromDefCode(PREG);
+#if defined(YAPOR) || defined(THREADS)
+        /*
+          we do not lock access to the predicate,
+          we must take extra care here
+        */
+        if (!PP) {
+          PELOCK(11, ap);
+        }
+        if (ap->OpcodeOfPred != INDEX_OPCODE) {
+          /* someone was here before we were */
+          if (!PP) {
+            UNLOCKPE(11, ap);
+          }
+          PREG = ap->CodeOfPred;
+          /* for profiler */
+          save_pc();
+          JMPNext();
+        }
+#endif
+        /* update ASP before calling IPred */
+        SET_ASP(YREG, E_CB * sizeof(CELL));
+        saveregs();
+        Yap_IPred(ap, 0, CP);
+        /* IPred can generate errors, it thus must get rid of the lock itself */
+        setregs();
+        CACHE_A1();
+        PREG = ap->CodeOfPred;
+        /* for profiler */
+        save_pc();
+#if defined(YAPOR) || defined(THREADS)
+        if (!PP)
+#endif
+          UNLOCKPE(14, ap);
+      }
+      JMPNext();
+      ENDBOp();
+
+#if THREADS
+      BOp(thread_local, e);
+      {
+        PredEntry *ap = PredFromDefCode(PREG);
+        ap = Yap_GetThreadPred(ap PASS_REGS);
+        PREG = ap->CodeOfPred;
+        /* for profiler */
+        save_pc();
+      }
+      JMPNext();
+      ENDBOp();
+#endif
+
+      BOp(expand_index, e);
+      {
+        PredEntry *pe = PredFromExpandCode(PREG);
+        yamop *pt0;
+
+        /* update ASP before calling IPred */
+        SET_ASP(YREG, E_CB * sizeof(CELL));
+#if defined(YAPOR) || defined(THREADS)
+        if (!PP) {
+          PELOCK(12, pe);
+        }
+        if (!same_lu_block(PREG_ADDR, PREG)) {
+          PREG = *PREG_ADDR;
+          if (!PP) {
+            UNLOCKPE(15, pe);
+          }
+          JMPNext();
+        }
+#endif
+#ifdef SHADOW_S
+        S = SREG;
+#endif /* SHADOW_S */
+        saveregs();
+        pt0 = Yap_ExpandIndex(pe, 0);
+        /* restart index */
+        setregs();
+#ifdef SHADOW_S
+        SREG = S;
+#endif /* SHADOW_S */
+        PREG = pt0;
+#if defined(YAPOR) || defined(THREADS)
+        if (!PP) {
+          UNLOCKPE(12, pe);
+        }
+#endif
+        JMPNext();
+      }
+      ENDBOp();
+
+      BOp(expand_clauses, sssllp);
+      {
+        PredEntry *pe = PREG->y_u.sssllp.p;
+        yamop *pt0;
+
+        /* update ASP before calling IPred */
+        SET_ASP(YREG, E_CB * sizeof(CELL));
+#if defined(YAPOR) || defined(THREADS)
+        if (PP == NULL) {
+          PELOCK(13, pe);
+        }
+        if (!same_lu_block(PREG_ADDR, PREG)) {
+          PREG = *PREG_ADDR;
+          if (!PP) {
+            UNLOCKPE(16, pe);
+          }
+          JMPNext();
+        }
+#endif
+        saveregs();
+        pt0 = Yap_ExpandIndex(pe, 0);
+        /* restart index */
+        setregs();
+        PREG = pt0;
+#if defined(YAPOR) || defined(THREADS)
+        if (!PP) {
+          UNLOCKPE(18, pe);
+        }
+#endif
+        JMPNext();
+      }
+      ENDBOp();
+
+      BOp(undef_p, e);
+      /* save S for module name */
+      if (LOCAL_DoingUndefp) {
+	PREG=FAILCODE;
+	JMPNext();
+      }
+        LOCAL_DoingUndefp = true;
+	saveregs();
+      undef_goal(PASS_REGS1);
+      setregs();
+      /* for profiler */
+        LOCAL_DoingUndefp = false;
+      CACHE_A1();
+      JMPNext();
+      ENDBOp();
+
+      BOp(spy_pred, e);
+      saveregs();
+      spy_goal(PASS_REGS1);
+      setregs();
+      CACHE_A1();
+      JMPNext();
+      ENDBOp();
--- a/C/globals.c
+++ b/C/globals.c
--- a/C/gmp_support.c
+++ b/C/gmp_support.c
@ -18,7 +18,7 @@
 #include "Yap.h"
 #include "Yatom.h"
 #include "YapHeap.h"
-#include "eval.h"
+#include "YapEval.h"
 #if HAVE_STRING_H
 #include <string.h>
 #endif
@ -32,7 +32,7 @@ MkBigAndClose(MP_INT *new)
  Term t = Yap_MkBigIntTerm(new);
  mpz_clear(new);
  if (t == TermNil) {
-    return Yap_ArithError(RESOURCE_ERROR_STACK, t, ">>/2");
+    Yap_ArithError(RESOURCE_ERROR_STACK, t, ">>/2");
  }
  return t;
 }
@ -43,7 +43,7 @@ MkRatAndClose(MP_RAT *new)
  Term t = Yap_MkBigRatTerm(new);
  mpq_clear(new);
  if (t == TermNil) {
-    return Yap_ArithError(RESOURCE_ERROR_STACK, t, ">>/2");
+    Yap_ArithError(RESOURCE_ERROR_STACK, t, ">>/2");
  }
  return t;
 }
@ -132,6 +132,14 @@ Yap_gmp_add_int_big(Int i, Term t)
  }
 }

+/* add i + b using temporary bigint new */
+void
+Yap_gmp_set_bit(Int i, Term t)
+{
+  MP_INT *b = Yap_BigIntOfTerm(t);
+  mpz_setbit(b, i);
+}
+
 /* sub i - b using temporary bigint new */
 Term 
 Yap_gmp_sub_int_big(Int i, Term t)
@ -231,11 +239,11 @@ Yap_gmp_div_big_int(Term t, Int i)
    MP_INT *b = Yap_BigIntOfTerm(t);

    mpz_init_set(&new, b);
-    if (yap_flags[INTEGER_ROUNDING_FLAG] == 0) {
+    if ( (-3 / 2) == -2 ) {
      if (i > 0) {
 	mpz_tdiv_q_ui(&new, &new, i);
      } else if (i == 0) {
-	return Yap_ArithError(EVALUATION_ERROR_ZERO_DIVISOR, MkIntTerm(0), "// /2");
+	Yap_ArithError(EVALUATION_ERROR_ZERO_DIVISOR, MkIntTerm(0), "// /2");
      } else {
 	/* we do not handle MIN_INT */
 	mpz_tdiv_q_ui(&new, &new, -i);
@ -245,7 +253,7 @@ Yap_gmp_div_big_int(Term t, Int i)
      if (i > 0) {
 	mpz_fdiv_q_ui(&new, &new, i);
      } else if (i == 0) {
-	return Yap_ArithError(EVALUATION_ERROR_ZERO_DIVISOR, MkIntTerm(0), "// /2");
+	Yap_ArithError(EVALUATION_ERROR_ZERO_DIVISOR, MkIntTerm(0), "// /2");
      } else {
 	/* we do not handle MIN_INT */
 	mpz_fdiv_q_ui(&new, &new, -i);
@ -277,7 +285,7 @@ Yap_gmp_div2_big_int(Term t, Int i)
    if (i > 0) {
      mpz_fdiv_q_ui(&new, &new, i);
    } else if (i == 0) {
-      return Yap_ArithError(EVALUATION_ERROR_ZERO_DIVISOR, MkIntTerm(0), "// /2");
+      Yap_ArithError(EVALUATION_ERROR_ZERO_DIVISOR, MkIntTerm(0), "// /2");
    } else {
      /* we do not handle MIN_INT */
      mpz_fdiv_q_ui(&new, &new, -i);
@ -303,7 +311,7 @@ Yap_gmp_and_int_big(Int i, Term t)
  CELL *pt = RepAppl(t);
  MP_INT *b;
  if (pt[1] != BIG_INT) {
-    return Yap_ArithError(TYPE_ERROR_INTEGER, t, "/\\/2");    
+    Yap_ArithError(TYPE_ERROR_INTEGER, t, "/\\/2");    
  }
  b = Yap_BigIntOfTerm(t);

@ -320,7 +328,7 @@ Yap_gmp_ior_int_big(Int i, Term t)
  CELL *pt = RepAppl(t);
  MP_INT *b;
  if (pt[1] != BIG_INT) {
-    return Yap_ArithError(TYPE_ERROR_INTEGER, t, "\\/ /2");
+    Yap_ArithError(TYPE_ERROR_INTEGER, t, "\\/ /2");
  }
  b = Yap_BigIntOfTerm(t);

@ -330,7 +338,8 @@ Yap_gmp_ior_int_big(Int i, Term t)
 }

 #if USE_GMP
-#if !defined(HAVE_MPZ_XOR)
+// cross-compilers...
+#if !defined(HAVE_MPZ_XOR) && !defined(mpz_xor)
 static void
 mpz_xor(MP_INT *new, MP_INT *r1, MP_INT *r2)
 {
@ -358,7 +367,7 @@ Yap_gmp_xor_int_big(Int i, Term t)
  CELL *pt = RepAppl(t);
  MP_INT *b;
  if (pt[1] != BIG_INT) {
-    return Yap_ArithError(TYPE_ERROR_INTEGER, t, "#/2");
+    Yap_ArithError(TYPE_ERROR_INTEGER, t, "#/2");
  }
  b = Yap_BigIntOfTerm(t);

@ -377,16 +386,17 @@ Yap_gmp_sll_big_int(Term t, Int i)
    MP_INT *b = Yap_BigIntOfTerm(t);

    if (i > 0) {
-      mpz_init_set(&new, b);
-      mpz_mul_2exp(&new, &new, i);
+      mpz_init(&new);
+      mpz_mul_2exp(&new, b, i);
    } else if (i == 0) {
      return t;
    } else {
-      mpz_init_set(&new, b);
+      mpz_init(&new);
      if (i == Int_MIN) {
-	return Yap_ArithError(RESOURCE_ERROR_HUGE_INT, MkIntegerTerm(i), "<</2");
+	CACHE_REGS
+	Yap_ArithError(RESOURCE_ERROR_HUGE_INT, MkIntegerTerm(i), "<</2");
      }
-      mpz_tdiv_q_2exp(&new, &new, -i);
+      mpz_fdiv_q_2exp(&new, b, -i);
    }
    return MkBigAndClose(&new);
  } else {
@ -535,7 +545,7 @@ Yap_gmp_div_big_big(Term t1, Term t2)
    MP_INT *b2 = Yap_BigIntOfTerm(t2);

    mpz_init_set(&new, b1);
-    if (yap_flags[INTEGER_ROUNDING_FLAG] == 0) {
+    if ( (-3 / 2) == -2 ) {
      mpz_tdiv_q(&new, &new, b2);
    } else {
      mpz_fdiv_q(&new, &new, b2);
@ -618,9 +628,9 @@ Yap_gmp_and_big_big(Term t1, Term t2)
    return MkBigAndClose(&new);
  } else {
    if (pt1[1] != BIG_INT) {
-      return Yap_ArithError(TYPE_ERROR_INTEGER, t1, "/\\/2");    
+      Yap_ArithError(TYPE_ERROR_INTEGER, t1, "/\\/2");    
    }
-    return Yap_ArithError(TYPE_ERROR_INTEGER, t2, "/\\/2");    
+    Yap_ArithError(TYPE_ERROR_INTEGER, t2, "/\\/2");    
  }
 }

@ -639,9 +649,9 @@ Yap_gmp_ior_big_big(Term t1, Term t2)
    return MkBigAndClose(&new);
  } else {
    if (pt1[1] != BIG_INT) {
-      return Yap_ArithError(TYPE_ERROR_INTEGER, t1, "\\/ /2");    
+      Yap_ArithError(TYPE_ERROR_INTEGER, t1, "\\/ /2");    
    }
-    return Yap_ArithError(TYPE_ERROR_INTEGER, t2, "\\/ /2");    
+    Yap_ArithError(TYPE_ERROR_INTEGER, t2, "\\/ /2");    
  }
 }

@ -660,9 +670,9 @@ Yap_gmp_xor_big_big(Term t1, Term t2)
    return MkBigAndClose(&new);
  } else {
    if (pt1[1] != BIG_INT) {
-      return Yap_ArithError(TYPE_ERROR_INTEGER, t1, "\\/ /2");    
+      Yap_ArithError(TYPE_ERROR_INTEGER, t1, "\\/ /2");    
    }
-    return Yap_ArithError(TYPE_ERROR_INTEGER, t2, "\\/ /2");    
+    Yap_ArithError(TYPE_ERROR_INTEGER, t2, "\\/ /2");    
  }
 }

@ -681,9 +691,9 @@ Yap_gmp_mod_big_big(Term t1, Term t2)
    return MkBigAndClose(&new);
  } else {
    if (pt1[1] != BIG_INT) {
-      return Yap_ArithError(TYPE_ERROR_INTEGER, t1, "mod/2");    
+      Yap_ArithError(TYPE_ERROR_INTEGER, t1, "mod/2");    
    }
-    return Yap_ArithError(TYPE_ERROR_INTEGER, t2, "mod/2");    
+    Yap_ArithError(TYPE_ERROR_INTEGER, t2, "mod/2");    
  }
 }

@ -692,7 +702,7 @@ Yap_gmp_mod_big_int(Term t, Int i2)
 {
  CELL *pt = RepAppl(t);
  if (pt[1] != BIG_INT) {
-    return Yap_ArithError(TYPE_ERROR_INTEGER, t, "mod/2");
+    Yap_ArithError(TYPE_ERROR_INTEGER, t, "mod/2");
  } else {
    MP_INT *b = Yap_BigIntOfTerm(t);
    MP_INT new;
@ -706,9 +716,10 @@ Yap_gmp_mod_big_int(Term t, Int i2)
 Term 
 Yap_gmp_mod_int_big(Int i1, Term t)
 {
+  CACHE_REGS
  CELL *pt = RepAppl(t);
  if (pt[1] != BIG_INT) {
-    return Yap_ArithError(TYPE_ERROR_INTEGER, t, "mod/2");
+    Yap_ArithError(TYPE_ERROR_INTEGER, t, "mod/2");
  } else {
    MP_INT *b = Yap_BigIntOfTerm(t);
    /* integer is much smaller */
@ -757,9 +768,9 @@ Yap_gmp_rem_big_big(Term t1, Term t2)
    return MkBigAndClose(&new);
  } else {
    if (pt1[1] != BIG_INT) {
-      return Yap_ArithError(TYPE_ERROR_INTEGER, t1, "rem/2");    
+      Yap_ArithError(TYPE_ERROR_INTEGER, t1, "rem/2");    
    }
-    return Yap_ArithError(TYPE_ERROR_INTEGER, t2, "rem/2");    
+    Yap_ArithError(TYPE_ERROR_INTEGER, t2, "rem/2");    
  }
 }

@ -768,7 +779,7 @@ Yap_gmp_rem_big_int(Term t, Int i2)
 {
  CELL *pt = RepAppl(t);
  if (pt[1] != BIG_INT) {
-    return Yap_ArithError(TYPE_ERROR_INTEGER, t, "mod/2");
+    Yap_ArithError(TYPE_ERROR_INTEGER, t, "rem/2");
  } else {
    MP_INT *b = Yap_BigIntOfTerm(t);
    MP_INT new;
@ -782,9 +793,10 @@ Yap_gmp_rem_big_int(Term t, Int i2)
 Term 
 Yap_gmp_rem_int_big(Int i1, Term t)
 {
+  CACHE_REGS
  CELL *pt = RepAppl(t);
  if (pt[1] != BIG_INT) {
-    return Yap_ArithError(TYPE_ERROR_INTEGER, t, "mod/2");
+    Yap_ArithError(TYPE_ERROR_INTEGER, t, "rem/2");
  } else {
    /* integer is much smaller */
    return MkIntegerTerm(i1);
@ -806,18 +818,19 @@ Yap_gmp_gcd_big_big(Term t1, Term t2)
    return MkBigAndClose(&new);
  } else {
    if (pt1[1] != BIG_INT) {
-      return Yap_ArithError(TYPE_ERROR_INTEGER, t1, "gcd/2");    
+      Yap_ArithError(TYPE_ERROR_INTEGER, t1, "gcd/2");    
    }
-    return Yap_ArithError(TYPE_ERROR_INTEGER, t2, "gcd/2");    
+    Yap_ArithError(TYPE_ERROR_INTEGER, t2, "gcd/2");    
  }
 }

 Term 
 Yap_gmp_gcd_int_big(Int i, Term t)
 {
+  CACHE_REGS
  CELL *pt = RepAppl(t);
  if (pt[1] != BIG_INT) {
-    return Yap_ArithError(TYPE_ERROR_INTEGER, t, "mod/2");
+    Yap_ArithError(TYPE_ERROR_INTEGER, t, "gcd/2");
  } else {
    /* integer is much smaller */
    if (i > 0) {
@ -855,6 +868,7 @@ Yap_gmp_to_float(Term t)
 Term
 Yap_gmp_add_float_big(Float d, Term t)
 {
+  CACHE_REGS
  CELL *pt = RepAppl(t);
  if (pt[1] == BIG_INT) {
    MP_INT *b = Yap_BigIntOfTerm(t);
@ -868,6 +882,7 @@ Yap_gmp_add_float_big(Float d, Term t)
 Term
 Yap_gmp_sub_float_big(Float d, Term t)
 {
+  CACHE_REGS
  CELL *pt = RepAppl(t);
  if (pt[1] == BIG_INT) {
    MP_INT *b = Yap_BigIntOfTerm(t);
@ -881,6 +896,7 @@ Yap_gmp_sub_float_big(Float d, Term t)
 Term
 Yap_gmp_sub_big_float(Term t, Float d)
 {
+  CACHE_REGS
  CELL *pt = RepAppl(t);
  if (pt[1] == BIG_INT) {
    MP_INT *b = Yap_BigIntOfTerm(t);
@ -894,6 +910,7 @@ Yap_gmp_sub_big_float(Term t, Float d)
 Term
 Yap_gmp_mul_float_big(Float d, Term t)
 {
+  CACHE_REGS
  CELL *pt = RepAppl(t);
  if (pt[1] == BIG_INT) {
    MP_INT *b = Yap_BigIntOfTerm(t);
@ -907,6 +924,7 @@ Yap_gmp_mul_float_big(Float d, Term t)
 Term
 Yap_gmp_fdiv_float_big(Float d, Term t)
 {
+  CACHE_REGS
  CELL *pt = RepAppl(t);
  if (pt[1] == BIG_INT) {
    MP_INT *b = Yap_BigIntOfTerm(t);
@ -920,6 +938,7 @@ Yap_gmp_fdiv_float_big(Float d, Term t)
 Term
 Yap_gmp_fdiv_big_float(Term t, Float d)
 {
+  CACHE_REGS
  CELL *pt = RepAppl(t);
  if (pt[1] == BIG_INT) {
    MP_INT *b = Yap_BigIntOfTerm(t);
@ -943,6 +962,7 @@ Yap_gmp_exp_int_int(Int i1, Int i2)
 Term
 Yap_gmp_exp_big_int(Term t, Int i)
 {
+  CACHE_REGS
  MP_INT new;
  
  CELL *pt = RepAppl(t);
@ -969,9 +989,10 @@ Yap_gmp_exp_big_int(Term t, Int i)
 Term
 Yap_gmp_exp_int_big(Int i, Term t)
 {
+  CACHE_REGS
  CELL *pt = RepAppl(t);
  if (pt[1] == BIG_INT) {
-    return Yap_ArithError(RESOURCE_ERROR_HUGE_INT, t, "^/2");
+    Yap_ArithError(RESOURCE_ERROR_HUGE_INT, t, "^/2");
  } else {
    MP_INT *b = Yap_BigIntOfTerm(t);
    Float dbl = mpz_get_d(b);
@ -982,12 +1003,13 @@ Yap_gmp_exp_int_big(Int i, Term t)
 Term 
 Yap_gmp_exp_big_big(Term t1, Term t2)
 {
+  CACHE_REGS
  CELL *pt1 = RepAppl(t1);
  CELL *pt2 = RepAppl(t2);
  Float dbl1, dbl2;

  if (pt1[1] == BIG_INT && pt2[1] == BIG_INT) {
-    return Yap_ArithError(RESOURCE_ERROR_HUGE_INT, t2, "^/2");
+    Yap_ArithError(RESOURCE_ERROR_HUGE_INT, t2, "^/2");
  } else {
    if (pt1[1] != BIG_INT) {
      dbl1 = mpz_get_d(Yap_BigIntOfTerm(t1));
@ -1116,6 +1138,7 @@ Yap_gmq_rdiv_big_big(Term t1, Term t2)
 Term 
 Yap_gmp_fdiv_int_big(Int i1, Term t2)
 {
+  CACHE_REGS
  MP_RAT new;
  MP_RAT *b1, *b2;
  MP_RAT bb1, bb2;
@ -1142,6 +1165,7 @@ Yap_gmp_fdiv_int_big(Int i1, Term t2)
 Term 
 Yap_gmp_fdiv_big_int(Term t2, Int i1)
 {
+  CACHE_REGS
  MP_RAT new;
  MP_RAT *b1, *b2;
  MP_RAT bb1, bb2;
@ -1168,6 +1192,7 @@ Yap_gmp_fdiv_big_int(Term t2, Int i1)
 Term 
 Yap_gmp_fdiv_big_big(Term t1, Term t2)
 {
+  CACHE_REGS
  CELL *pt1 = RepAppl(t1);
  CELL *pt2 = RepAppl(t2);
  MP_RAT new;
@ -1209,6 +1234,19 @@ Yap_gmp_cmp_big_int(Term t, Int i)
  }
 }

+int 
+Yap_gmp_cmp_int_big(Int i, Term t)
+{
+  CELL *pt = RepAppl(t);
+  if (pt[1] == BIG_INT) {
+    MP_INT *b = Yap_BigIntOfTerm(t);
+    return -mpz_cmp_si(b,i);
+  } else {
+    MP_RAT *b = Yap_BigRatOfTerm(t);
+    return -mpq_cmp_si(b,i,1);
+  }
+}
+
 int 
 Yap_gmp_cmp_big_float(Term t, Float d)
 {
@ -1279,6 +1317,18 @@ Yap_gmp_tcmp_big_int(Term t, Int i)
  }
 }

+int 
+Yap_gmp_tcmp_int_big(Int i, Term t)
+{
+  CELL *pt = RepAppl(t);
+  if (pt[1] == BIG_INT) {
+    MP_INT *b = Yap_BigIntOfTerm(t);
+    return -mpz_cmp_si(b,i);
+  } else {
+    return 1;
+  }
+}
+
 int 
 Yap_gmp_tcmp_big_float(Term t, Float d)
 {
@ -1303,51 +1353,6 @@ Yap_gmp_tcmp_big_big(Term t1, Term t2)
      return 1;
    } else if (pt1[1] == BIG_RATIONAL) {
      b1 = Yap_BigRatOfTerm(t1);
-    } else if (pt1[1] == BLOB_STRING) {
-      char *s1 = Yap_BlobStringOfTerm(t1);
-      if (pt2[1] == BLOB_STRING) {
-	char *s2 = Yap_BlobStringOfTerm(t2);
-	return strcmp(s1,s2);
-      } else if (pt2[1] == BLOB_WIDE_STRING) {
-	wchar_t *wcs2 = Yap_BlobWideStringOfTerm(t2), *wcs1, *tmp1;
-	int out;
-	size_t n = strlen(s1);
-	if (!(wcs1 = (wchar_t *)malloc((n+1)*sizeof(wchar_t)))) {
-	  Yap_Error(OUT_OF_HEAP_ERROR, t1, "compare/3");	  
-	  return 0;
-	}
-	tmp1 = wcs1;
-	while (*s1) {
-	  *tmp1++ = *s1++;
-	}
-	out = wcscmp(wcs1, wcs2);
-	free(wcs1);
-	return out;
-      }
-      b1 = Yap_BigRatOfTerm(t1);
-    } else if (pt1[1] == BLOB_WIDE_STRING) {
-      wchar_t *wcs1 = Yap_BlobWideStringOfTerm(t1);
-      if (pt2[1] == BLOB_STRING) {
-	char *s2 = Yap_BlobStringOfTerm(t2);
-	wchar_t *wcs2, *tmp2;
-	int out;
-	size_t n = strlen(s2);
-	if (!(wcs2 = (wchar_t *)malloc((n+1)*sizeof(wchar_t)))) {
-	  Yap_Error(OUT_OF_HEAP_ERROR, t2, "compare/3");	  
-	  return 0;
-	}
-	tmp2 = wcs2;
-	while (*s2) {
-	  *tmp2++ = *s2++;
-	}
-	out = wcscmp(wcs1, wcs2);
-	free(wcs2);
-	return out;
-      } else if (pt2[1] == BLOB_WIDE_STRING) {
-	wchar_t *wcs2 = Yap_BlobWideStringOfTerm(t2);
-	return wcscmp(wcs1,wcs2);
-      }
-      b1 = Yap_BigRatOfTerm(t1);
    } else {
      return pt1-pt2;
    }
@ -1471,7 +1476,7 @@ Yap_gmp_unot_big(Term t)
    mpz_com(&new, &new);
    return MkBigAndClose(&new);
  } else {
-    return Yap_ArithError(TYPE_ERROR_INTEGER, t, "#/1");
+    Yap_ArithError(TYPE_ERROR_INTEGER, t, "#/1");
  }
 }

@ -1566,7 +1571,7 @@ Yap_gmp_float_fractional_part(Term t)
 {
  CELL *pt = RepAppl(t);
  if (pt[1] == BIG_INT) {
-    return Yap_ArithError(TYPE_ERROR_FLOAT, t, "X is float_fractional_part(%f)", FloatOfTerm(t));
+    Yap_ArithError(TYPE_ERROR_FLOAT, t, "X is float_fractional_part(%f)", FloatOfTerm(t));
  } else {
    MP_RAT *b = Yap_BigRatOfTerm(t);
    MP_RAT new;
@ -1586,7 +1591,7 @@ Yap_gmp_float_integer_part(Term t)
 {
  CELL *pt = RepAppl(t);
  if (pt[1] == BIG_INT) {
-    return Yap_ArithError(TYPE_ERROR_FLOAT, t, "X is float_integer_part(%f)", FloatOfTerm(t));
+    Yap_ArithError(TYPE_ERROR_FLOAT, t, "X is float_integer_part(%f)", FloatOfTerm(t));
  } else {
    MP_RAT *b = Yap_BigRatOfTerm(t);
    MP_INT new;
@ -1602,6 +1607,7 @@ Yap_gmp_float_integer_part(Term t)
 Term
 Yap_gmp_sign(Term t)
 {
+  CACHE_REGS
  CELL *pt = RepAppl(t);
  if (pt[1] == BIG_INT) {
    return MkIntegerTerm(mpz_sgn(Yap_BigIntOfTerm(t)));
@ -1613,51 +1619,67 @@ Yap_gmp_sign(Term t)
 Term
 Yap_gmp_lsb(Term t)
 {
+  CACHE_REGS
  CELL *pt = RepAppl(t);
  if (pt[1] == BIG_INT) {
    MP_INT *big = Yap_BigIntOfTerm(t);
    if ( mpz_sgn(big) <= 0 ) {
-      return Yap_ArithError(DOMAIN_ERROR_NOT_LESS_THAN_ZERO, t,
+      Yap_ArithError(DOMAIN_ERROR_NOT_LESS_THAN_ZERO, t,
 			    "lsb/1 received negative bignum");
    }
    return MkIntegerTerm(mpz_scan1(big,0));
  } else {
-    return Yap_ArithError(TYPE_ERROR_INTEGER, t, "lsb");    
+    Yap_ArithError(TYPE_ERROR_INTEGER, t, "lsb");    
  }
 }

 Term
 Yap_gmp_msb(Term t)
 {
+  CACHE_REGS
  CELL *pt = RepAppl(t);
  if (pt[1] == BIG_INT) {
    MP_INT *big = Yap_BigIntOfTerm(t);
    if ( mpz_sgn(big) <= 0 ) {
-      return Yap_ArithError(DOMAIN_ERROR_NOT_LESS_THAN_ZERO, t,
+      Yap_ArithError(DOMAIN_ERROR_NOT_LESS_THAN_ZERO, t,
 			    "msb/1 received negative bignum");
    }
    return MkIntegerTerm(mpz_sizeinbase(big,2));
  } else {
-    return Yap_ArithError(TYPE_ERROR_INTEGER, t, "popcount");    
+    Yap_ArithError(TYPE_ERROR_INTEGER, t, "popcount");    
  }
 }

 Term
 Yap_gmp_popcount(Term t)
 {
+  CACHE_REGS
  CELL *pt = RepAppl(t);
  if (pt[1] == BIG_INT) {
    MP_INT *big = Yap_BigIntOfTerm(t);
    if ( mpz_sgn(big) <= 0 ) {
-      return Yap_ArithError(DOMAIN_ERROR_NOT_LESS_THAN_ZERO, t,
+      Yap_ArithError(DOMAIN_ERROR_NOT_LESS_THAN_ZERO, t,
 			    "popcount/1 received negative bignum");
    }
    return MkIntegerTerm(mpz_popcount(big));
  } else {
-    return Yap_ArithError(TYPE_ERROR_INTEGER, t, "popcount");    
+    Yap_ArithError(TYPE_ERROR_INTEGER, t, "popcount");    
  }
 }

+char * 
+Yap_mpz_to_string(	MP_INT *b, char *s, size_t sz, int base)
+{
+  if (s) {
+    size_t size = mpz_sizeinbase(b, base);
+    if (size+2 > sz) {
+      return NULL;
+    }
+    return mpz_get_str (s, base, b);
+  }
+  return NULL;
+}
+
 char * 
 Yap_gmp_to_string(Term t, char *s, size_t sz, int base)
 {
--- a/C/gprof.c
+++ b/C/gprof.c
@ -35,7 +35,7 @@
 * Revision 1.3  2006/01/17 14:10:40  vsc
 * YENV may be an HW register (breaks some tabling code)
 * All YAAM instructions are now brackedted, so Op introduced an { and EndOp introduces an }. This is because Ricardo assumes that.
-* Fix attvars when COROUTING is undefined.
+* Fix attvars 
 *
 * Revision 1.2  2005/12/23 00:20:13  vsc
 * updates to gprof
@ -47,6 +47,41 @@
 *									 *
 *************************************************************************/

+/// @file gprof.c
+
+/** @addtogroup Tick_Profiler
+ * @ingroup Profiling@{
+ * 
+ * The tick profiler works by interrupting the Prolog code every so often
+ * and checking at each point the code was. The pro/filer must be able to
+ * retrace the state of the abstract machine at every moment. The major
+ * advantage of this approach is that it gives the actual amount of time
+ * being spent per procedure, or whether garbage collection dominates
+ * execution time. The major drawback is that tracking down the state of
+ * the abstract machine may take significant time, and in the worst case
+ * may slow down the whole execution.
+ * 
+ * The following procedures are available:
+ * 
+ * + profinit/0 
+ *   Initialise the data-structures for the profiler. Unnecessary for
+ *   dynamic profiler.
+ * 
+ * + profon/0
+ *   Start profiling.
+ * 
+ * +  profoff/0
+ *    Stop profiling.
+ * 
+ * +  profoff/0
+ *    Stop profiling.
+ * 
+ * +  showprofres/0 and showprofres/1
+ *    Stop tick counts per predicate.
+ * 
+ *  
+  */
+
 #ifdef SCCS
 static char     SccsId[] = "%W% %G%";
 #endif
@ -63,6 +98,7 @@ typedef greg_t context_reg;

 #elif defined(__i386__) && defined (__linux__)

+
 #include <ucontext.h>

 typedef greg_t context_reg;
@ -102,8 +138,11 @@ typedef greg_t context_reg;

 #else

-#define CONTEXT_PC NULL
-#define CONTEXT_BP NULL
+#define CONTEXT_PC(scv) NULL
+#define CONTEXT_BP(scv) NULL
+#ifdef LOW_PROF
+#undef LOW_PROF
+#endif

 #endif

@ -120,8 +159,10 @@ typedef greg_t context_reg;
 #include <sys/time.h>
 #ifdef __APPLE__
 #else
+#ifdef UCONTEXT_H
 #include <ucontext.h>
 #endif
+#endif



@ -129,12 +170,22 @@ typedef greg_t context_reg;
 #define PROFILING_FILE 1
 #define PROFPREDS_FILE 2

+typedef struct {
+  char tag;
+  void *ptr;
+}  __attribute__ ((packed)) buf_ptr;

+typedef struct {
+  gprof_info inf;
+  void  *end;
+  PredEntry *pe;
+}  __attribute__ ((packed))  buf_extra;

 typedef struct RB_red_blk_node {
  yamop *key; /* first address */
  yamop *lim; /* end address */
  PredEntry *pe; /* parent predicate */
+  gprof_info source; /* how block was allocated */
  UInt pcs;  /* counter with total for each clause */
  int red; /* if red=0 then the node is black */
  struct RB_red_blk_node* left;
@ -168,10 +219,12 @@ RBTreeCreate(void) {
  temp->red=0;
  temp->key=temp->lim=NULL;
  temp->pe=NULL;
+  temp->source=GPROF_NO_EVENT;;
  temp = RBMalloc(sizeof(rb_red_blk_node));
  temp->parent=temp->left=temp->right=GLOBAL_ProfilerNil;
  temp->key=temp->lim=NULL;
  temp->pe=NULL;
+  temp->source=GPROF_NO_EVENT;
  temp->pcs=0;
  temp->red=0;
  return temp;
@ -199,7 +252,7 @@ RBTreeCreate(void) {
 static void
 LeftRotate(rb_red_blk_node* x) {
  rb_red_blk_node* y;
-  rb_red_blk_node* nil=GLOBAL_ProfilerNil;
+  rb_red_blk_node* rb_nil=GLOBAL_ProfilerNil;

  /*  I originally wrote this function to use the sentinel for */
  /*  nil to avoid checking for nil.  However this introduces a */
@ -214,7 +267,7 @@ LeftRotate(rb_red_blk_node* x) {
  y=x->right;
  x->right=y->left;

-  if (y->left != nil) y->left->parent=x; /* used to use sentinel here */
+  if (y->left != rb_nil) y->left->parent=x; /* used to use sentinel here */
  /* and do an unconditional assignment instead of testing for nil */
  
  y->parent=x->parent;   
@ -255,7 +308,7 @@ LeftRotate(rb_red_blk_node* x) {
 static void
 RightRotate(rb_red_blk_node* y) {
  rb_red_blk_node* x;
-  rb_red_blk_node* nil=GLOBAL_ProfilerNil;
+  rb_red_blk_node* rb_nil=GLOBAL_ProfilerNil;

  /*  I originally wrote this function to use the sentinel for */
  /*  nil to avoid checking for nil.  However this introduces a */
@ -270,7 +323,7 @@ RightRotate(rb_red_blk_node* y) {
  x=y->left;
  y->left=x->right;

-  if (nil != x->right)  x->right->parent=y; /*used to use sentinel here */
+  if (rb_nil != x->right)  x->right->parent=y; /*used to use sentinel here */
  /* and do an unconditional assignment instead of testing for nil */

  /* instead of checking if x->parent is the root as in the book, we */
@ -309,12 +362,12 @@ TreeInsertHelp(rb_red_blk_node* z) {
  /*  This function should only be called by InsertRBTree (see above) */
  rb_red_blk_node* x;
  rb_red_blk_node* y;
-  rb_red_blk_node* nil=GLOBAL_ProfilerNil;
+  rb_red_blk_node* rb_nil=GLOBAL_ProfilerNil;
  
-  z->left=z->right=nil;
+  z->left=z->right=rb_nil;
  y=GLOBAL_ProfilerRoot;
  x=GLOBAL_ProfilerRoot->left;
-  while( x != nil) {
+  while( x != rb_nil) {
    y=x;
    if (x->key > z->key) { /* x.key > z.key */
      x=x->left;
@ -429,18 +482,18 @@ RBTreeInsert(yamop *key, yamop *lim) {
 static rb_red_blk_node*
 RBExactQuery(yamop* q) {
  rb_red_blk_node* x;
-  rb_red_blk_node* nil=GLOBAL_ProfilerNil;
+  rb_red_blk_node* rb_nil=GLOBAL_ProfilerNil;

  if (!GLOBAL_ProfilerRoot) return NULL;
  x=GLOBAL_ProfilerRoot->left;
-  if (x == nil) return NULL;
+  if (x == rb_nil) return NULL;
  while(x->key != q) {/*assignemnt*/
    if (x->key > q) { /* x->key > q */
      x=x->left;
    } else {
      x=x->right;
    }
-    if ( x == nil) return NULL;
+    if ( x == rb_nil) return NULL;
  }
  return(x);
 }
@ -563,11 +616,11 @@ static void RBDeleteFixUp(rb_red_blk_node* x) {
 static rb_red_blk_node*
 TreeSuccessor(rb_red_blk_node* x) { 
  rb_red_blk_node* y;
-  rb_red_blk_node* nil=GLOBAL_ProfilerNil;
+  rb_red_blk_node* rb_nil=GLOBAL_ProfilerNil;
  rb_red_blk_node* root=GLOBAL_ProfilerRoot;

-  if (nil != (y = x->right)) { /* assignment to y is intentional */
-    while(y->left != nil) { /* returns the minium of the right subtree of x */
+  if (rb_nil != (y = x->right)) { /* assignment to y is intentional */
+    while(y->left != rb_nil) { /* returns the minium of the right subtree of x */
      y=y->left;
    }
    return(y);
@ -577,7 +630,7 @@ TreeSuccessor(rb_red_blk_node* x) {
      x=y;
      y=y->parent;
    }
-    if (y == root) return(nil);
+    if (y == root) return(rb_nil);
    return(y);
  }
 }
@ -602,11 +655,11 @@ static void
 RBDelete(rb_red_blk_node* z){
  rb_red_blk_node* y;
  rb_red_blk_node* x;
-  rb_red_blk_node* nil=GLOBAL_ProfilerNil;
+  rb_red_blk_node* rb_nil=GLOBAL_ProfilerNil;
  rb_red_blk_node* root=GLOBAL_ProfilerRoot;

-  y= ((z->left == nil) || (z->right == nil)) ? z : TreeSuccessor(z);
-  x= (y->left == nil) ? y->right : y->left;
+  y= ((z->left == rb_nil) || (z->right == rb_nil)) ? z : TreeSuccessor(z);
+  x= (y->left == rb_nil) ? y->right : y->left;
  if (root == (x->parent = y->parent)) { /* assignment of y->p to x->p is intentional */
    root->left=x;
  } else {
@ -652,7 +705,7 @@ RBDelete(rb_red_blk_node* z){

 char *set_profile_dir(char *);
 char *set_profile_dir(char *name){
-int size=0;
+    int size=0;

    if (name!=NULL) {
      size=strlen(name)+1;
@ -675,20 +728,18 @@ return GLOBAL_DIRNAME;

 char *profile_names(int);
 char *profile_names(int k) {
-static char *FNAME=NULL;
-int size=200;
+  char *FNAME=NULL;
+  int size=200;
   
  if (GLOBAL_DIRNAME==NULL) set_profile_dir(NULL);
  size=strlen(GLOBAL_DIRNAME)+40;
-  if (FNAME!=NULL) free(FNAME);
  FNAME=malloc(size);
  if (FNAME==NULL) { printf("Profiler Out of Mem\n"); exit(1); }
-  strcpy(FNAME,GLOBAL_DIRNAME);

  if (k==PROFILING_FILE) {
-    sprintf(FNAME,"%s/PROFILING_%d",FNAME,getpid());
+    sprintf(FNAME,"%s/PROFILING_%d",GLOBAL_DIRNAME,getpid());
  } else { 
-    sprintf(FNAME,"%s/PROFPREDS_%d",FNAME,getpid());
+    sprintf(FNAME,"%s/PROFPREDS_%d",GLOBAL_DIRNAME,getpid());
  }

  //  printf("%s\n",FNAME);
@ -704,18 +755,17 @@ void del_profile_files() {
 }

 void
-Yap_inform_profiler_of_clause(yamop *code_start, yamop *code_end, PredEntry *pe,int index_code) {
-static Int order=0;
- 
-  ProfPreds++;
+Yap_inform_profiler_of_clause__(void *code_start, void *code_end, PredEntry *pe,gprof_info index_code) {
+  buf_ptr b;
+  buf_extra e;
  GLOBAL_ProfOn = TRUE;
-  if (FPreds != NULL) {
-    Int temp;
-
-    order++;
-    if (index_code) temp=-order; else temp=order;
-    fprintf(FPreds,"+%p %p %p %ld\n",code_start,code_end, pe, (long int)temp);
-  }
+  b.tag = '+';
+  b.ptr= code_start;
+  e.inf= index_code;
+  e.end= code_end;
+  e.pe= pe;
+  fwrite(&b,sizeof(b),1,GLOBAL_FPreds);
+  fwrite(&e,sizeof(e),1,GLOBAL_FPreds);
  GLOBAL_ProfOn = FALSE;
 }

@ -753,54 +803,13 @@ InitProfTree(void)
    reset_tree();
  while (!(GLOBAL_ProfilerRoot = RBTreeCreate())) {
    if (!Yap_growheap(FALSE, 0, NULL)) {
-      Yap_Error(OUT_OF_HEAP_ERROR, TermNil, "while initialisating profiler");
+      Yap_Error(RESOURCE_ERROR_HEAP, TermNil, "while initializing profiler");
      return FALSE;
    }    
  }
  return TRUE;
 }

-static void LookupNode(yamop *current_p) {
-  rb_red_blk_node *node;
-
-  if ((node = RBLookup(current_p))) {
-    node->pcs++;
-    return;
-  } else {
-    PredEntry *pp = NULL;
-    CODEADDR start, end;
-
-    pp = Yap_PredEntryForCode(current_p, FIND_PRED_FROM_ANYWHERE, &start, &end);
-    if (!pp) {
-#if DEBUG
-      CACHE_REGS
-      fprintf(stderr,"lost %p, %d\n", P, Yap_op_from_opcode(P->opc));
-#endif
-      /* lost profiler event !! */
-      return;
-    }
-#if !USE_SYSTEM_MALLOC
-    /* add this clause as new node to the tree */
-    if (start < (CODEADDR)Yap_HeapBase || start > (CODEADDR)HeapTop ||
-	end < (CODEADDR)Yap_HeapBase || end > (CODEADDR)HeapTop) {
-#if DEBUG
-      fprintf(stderr,"Oops2: %p->%lu %p, %p\n", current_p, (unsigned long int)(current_p->opc), start, end);
-#endif
-      return;
-    }
-#endif
-    if (pp->ArityOfPE > 100) {
-#if DEBUG
-      fprintf(stderr,"%p(%lu)-->%p\n",current_p,(unsigned long int)Yap_op_from_opcode(current_p->opc),pp);
-#endif
-     return;
-    }
-    node = RBTreeInsert((yamop *)start, (yamop *)end);
-    node->pe = pp;
-    node->pcs = 1;
-  }
-}
-
 static void RemoveCode(CODEADDR clau)
 {
  rb_red_blk_node* x, *node;
@ -830,85 +839,87 @@ static void RemoveCode(CODEADDR clau)
  }  
 }

-#define MAX_LINE_SIZE 1024
-
-static int
+static Int
 showprofres( USES_REGS1 ) { 
-  char line[MAX_LINE_SIZE];
-  yamop *pr_beg, *pr_end;
-  PredEntry *pr_pp;
-  long int pr_count;
-  
+  buf_ptr buf;

  profend( PASS_REGS1 ); /* Make sure profiler has ended */

  /* First part: Read information about predicates and store it on yap trail */

  InitProfTree();
-  FProf=fopen(profile_names(PROFILING_FILE),"r"); 
-  if (FProf==NULL) { fclose(FProf); return FALSE; }
-  while (fgets(line, MAX_LINE_SIZE, FProf) != NULL) {
-    if (line[0] == '+') {
-      rb_red_blk_node *node;
-      sscanf(line+1,"%p %p %p %ld",&pr_beg,&pr_end,&pr_pp,&pr_count);
-      node = RBTreeInsert(pr_beg, pr_end);
-      node->pe = pr_pp;
-      node->pcs = 0;
-    } else if  (line[0] == '-') {
-      sscanf(line+1,"%p",&pr_beg);
-      RemoveCode((CODEADDR)pr_beg);
-    } else {
-      rb_red_blk_node *node;
+  GLOBAL_ProfGCs=0;
+  GLOBAL_ProfMallocs=0;
+  GLOBAL_ProfHGrows=0;
+  GLOBAL_ProfSGrows=0;
+  GLOBAL_ProfIndexing=0;
+  GLOBAL_FProf=fopen(profile_names(PROFILING_FILE),"r"); 
+  if (GLOBAL_FProf==NULL) { fclose(GLOBAL_FProf); return FALSE; }
+  while (fread(&buf, sizeof(buf), 1, GLOBAL_FProf)) {
+    switch (buf.tag) {
+    case '+':
+      {
+	rb_red_blk_node *node;
+	buf_extra e;

-      sscanf(line,"%p",&pr_beg);
-      node = RBLookup(pr_beg);
-      if (!node) {
+	if (fread(&e,sizeof(buf_extra),1,GLOBAL_FProf) == 0)
+	  return FALSE;;
+	node = RBTreeInsert(buf.ptr, e.end);
+	node->pe = e.pe;
+	node->source = e.inf;
+	node->pcs = 0;
+      }
+      break;
+    case '?':
+      {
+	prolog_exec_mode md;
+
+	md = (prolog_exec_mode)buf.ptr;
+	if (md & GCMode) {
+	  GLOBAL_ProfGCs++;
+	} else if (md & MallocMode) {
+	  GLOBAL_ProfMallocs++;
+	} else if (md & GrowHeapMode) {
+	  GLOBAL_ProfHGrows++;
+	} else if (md & GrowStackMode) {
+	  GLOBAL_ProfSGrows++;
+	}
+      }
+      break;
+    case '-':
+      RemoveCode(buf.ptr);
+      break;
+    default:
+      {
+	rb_red_blk_node *node;
+
+	node = RBLookup(buf.ptr);
+	if (!node) {
 #if DEBUG
-	fprintf(stderr,"Oops: %p\n", pr_beg);
+	  fprintf(stderr,"Oops: %p\n", buf.ptr);
 #endif
-      } else {
-	node->pcs++; 
+	} else {
+	  switch(node->source) {
+	  case GPROF_INDEX:
+	  case GPROF_INDEX_EXPAND:
+	  case GPROF_LU_INDEX:
+	  case GPROF_STATIC_INDEX:
+	  case GPROF_INIT_EXPAND:
+	  case GPROF_INIT_LOG_UPD_CLAUSE:
+	  case GPROF_NEW_LU_SWITCH:
+	  case GPROF_NEW_STATIC_SWITCH:
+	  case GPROF_NEW_EXPAND_BLOCK:
+	    GLOBAL_ProfIndexing++;
+	    break;
+	  default:
+	    break;
+	  }
+	  node->pcs++; 
+	}
      }
    }
  }
-  fclose(FProf);
-  if (GLOBAL_ProfCalls==0) 
-    return TRUE;
-  return TRUE;
-}
-
-static Int
-p_test( USES_REGS1 ) { 
-  char line[MAX_LINE_SIZE];
-  yamop *pr_beg, *pr_end;
-  PredEntry *pr_pp;
-  long int pr_count;
-
-
-  profend( PASS_REGS1 ); /* Make sure profiler has ended */
-
-  /* First part: Read information about predicates and store it on yap trail */
-
-  InitProfTree();
-  FProf=fopen("PROFILING_93920","r"); 
-  if (FProf==NULL) { fclose(FProf); return FALSE; }
-  while (fgets(line, MAX_LINE_SIZE, FProf) != NULL) {
-    if (line[0] == '+') {
-      rb_red_blk_node *node;
-      sscanf(line+1,"%p %p %p %ld",&pr_beg,&pr_end,&pr_pp,&pr_count);
-      node = RBTreeInsert(pr_beg, pr_end);
-      node->pe = pr_pp;
-      node->pcs = 0;
-    } else if  (line[0] == '-') {
-      sscanf(line+1,"%p",&pr_beg);
-      RemoveCode((CODEADDR)pr_beg);
-    } else {
-      rb_red_blk_node *node = RBTreeInsert(pr_beg, pr_end);
-      node->pe = pr_pp;
-      node->pcs = 1;
-    }
-  }
-  fclose(FProf);
+  fclose(GLOBAL_FProf);
  if (GLOBAL_ProfCalls==0) 
    return TRUE;
  return TRUE;
@ -922,8 +933,9 @@ static void
 prof_alrm(int signo, siginfo_t *si, void *scv)
 { 
  CACHE_REGS
-  void * oldpc=(void *) CONTEXT_PC(scv);
+  void * oldpc;
  yamop *current_p;
+  buf_ptr b;

  GLOBAL_ProfCalls++;
  /* skip an interrupt */
@ -932,34 +944,16 @@ prof_alrm(int signo, siginfo_t *si, void *scv)
    return;
  }
  GLOBAL_ProfOn = TRUE;
+  oldpc = (void *) CONTEXT_PC(scv);
  if (LOCAL_PrologMode & TestMode) {
-    if (LOCAL_PrologMode & GCMode) {
-      GLOBAL_ProfGCs++;
-      GLOBAL_ProfOn = FALSE;
-      return;
-    }

-    if (LOCAL_PrologMode & MallocMode) {
-      GLOBAL_ProfMallocs++;
-      GLOBAL_ProfOn = FALSE;
-      return;
-    }
-
-    if (LOCAL_PrologMode & GrowHeapMode) {
-      GLOBAL_ProfHGrows++;
-      GLOBAL_ProfOn = FALSE;
-      return;
-    }
-  
-    if (LOCAL_PrologMode & GrowStackMode) {
-      GLOBAL_ProfSGrows++;
-      GLOBAL_ProfOn = FALSE;
-      return;
-    }
-   
+    b.tag = '?';
+    b.ptr= (void *)LOCAL_PrologMode;
+    fwrite(&b,sizeof(b),1,GLOBAL_FPreds);
+    GLOBAL_ProfOn = FALSE;
+    return;
  }
  
-  
  if (oldpc>(void *) &Yap_absmi && oldpc <= (void *) &Yap_absmiEND) { 
    CACHE_REGS
    /* we are running emulator code */
@ -974,10 +968,10 @@ prof_alrm(int signo, siginfo_t *si, void *scv)
    
    if (oop == _call_cpred || oop == _call_usercpred) {
      /* doing C-code */
-      current_p = PREVOP(P,Osbpp)->u.Osbpp.p->CodeOfPred;
-    } else if ((oop = Yap_op_from_opcode(PREVOP(P,pp)->opc)) == _execute_cpred) {
+      current_p = PREVOP(P,Osbpp)->y_u.Osbpp.p->CodeOfPred;
+    } else if ((oop = Yap_op_from_opcode(P->opc)) == _execute_cpred) {
      /* doing C-code */
-      current_p = PREVOP(P,pp)->u.pp.p->CodeOfPred;
+      current_p = P->y_u.Osbpp.p->CodeOfPred;
    } else {
      current_p = P;
    }
@ -993,28 +987,27 @@ prof_alrm(int signo, siginfo_t *si, void *scv)
  }
 #endif

-  if (Yap_OffLineProfiler) {
-    fprintf(FProf,"%p\n", current_p);
-    GLOBAL_ProfOn = FALSE;
-    return;
-  }
-
-  LookupNode(current_p);
+  b.tag = '.';
+  b.ptr= current_p;
+  fwrite(&b,sizeof(b),1,GLOBAL_FPreds);
  GLOBAL_ProfOn = FALSE;
 }


 void
-Yap_InformOfRemoval(CODEADDR clau)
+Yap_InformOfRemoval(void *clau)
 {
  GLOBAL_ProfOn = TRUE;
-  if (FPreds != NULL) {
+  if (GLOBAL_FPreds != NULL) {
    /* just store info about what is going on  */
-    fprintf(FPreds,"-%p\n",clau);
+    buf_ptr b;
+    
+    b.tag = '-';
+    b.ptr= clau;
+    fwrite(&b,sizeof(b),1,GLOBAL_FPreds);
    GLOBAL_ProfOn = FALSE;
    return;
  }
-  RemoveCode(clau);
  GLOBAL_ProfOn = FALSE;
 }

@ -1064,85 +1057,41 @@ profglobs( USES_REGS1 ) {
    Yap_unify(ARG3,MkIntegerTerm(GLOBAL_ProfHGrows)) &&
    Yap_unify(ARG4,MkIntegerTerm(GLOBAL_ProfSGrows)) &&
    Yap_unify(ARG5,MkIntegerTerm(GLOBAL_ProfMallocs)) &&
-    Yap_unify(ARG6,MkIntegerTerm(GLOBAL_ProfOns)) ;
+    Yap_unify(ARG6,MkIntegerTerm(GLOBAL_ProfIndexing)) &&
+    Yap_unify(ARG7,MkIntegerTerm(GLOBAL_ProfOns)) ;
 }

 static Int
 do_profinit( USES_REGS1 )
 {
-  if (Yap_OffLineProfiler) {
-    //    FPreds=fopen(profile_names(PROFPREDS_FILE),"w+"); 
-    // if (FPreds == NULL) return FALSE;
-    FProf=fopen(profile_names(PROFILING_FILE),"w+"); 
-    if (FProf==NULL) { fclose(FProf); return FALSE; }
-    FPreds = FProf;
+  //    GLOBAL_FPreds=fopen(profile_names(PROFPREDS_FILE),"w+"); 
+  // if (GLOBAL_FPreds == NULL) return FALSE;
+  GLOBAL_FProf=fopen(profile_names(PROFILING_FILE),"w+"); 
+  if (GLOBAL_FProf==NULL) { fclose(GLOBAL_FProf); return FALSE; }
+  GLOBAL_FPreds = GLOBAL_FProf;

-    Yap_dump_code_area_for_profiler();
-  } else {
-    InitProfTree();
-  }
+  Yap_dump_code_area_for_profiler();
  return TRUE;
 }

 static Int profinit( USES_REGS1 )
 {
-  if (ProfilerOn!=0) return (FALSE);
+  if (GLOBAL_ProfilerOn!=0) return (FALSE);
  
  if (!do_profinit( PASS_REGS1 ))
    return FALSE;

-  ProfilerOn = -1; /* Inited but not yet started */
+  GLOBAL_ProfilerOn = -1; /* Inited but not yet started */
  return(TRUE);
 }

-static Int profinit1( USES_REGS1 )
-{
-  Term t = Deref(ARG1);
-
-  if (IsVarTerm(t)) {
-    if (Yap_OffLineProfiler) 
-      Yap_unify(ARG1,MkAtomTerm(AtomOffline));
-    else
-      Yap_unify(ARG1,MkAtomTerm(AtomOnline));
-  } else if (IsAtomTerm(t)) {
-    char *name = RepAtom(AtomOfTerm(t))->StrOfAE;
-    if (!strcmp(name,"offline"))
-      Yap_OffLineProfiler = TRUE;
-    else if (!strcmp(name,"online"))
-      Yap_OffLineProfiler = FALSE;
-    else {
-      Yap_Error(DOMAIN_ERROR_OUT_OF_RANGE,t,"profinit only allows offline,online");
-      return FALSE;
-    }
-  } else {
-      Yap_Error(TYPE_ERROR_ATOM,t,"profinit only allows offline,online");
-      return FALSE;
-  }
-  return profinit( PASS_REGS1 );
-}
-
-
-static Int proftype( USES_REGS1 )
-{
-  if (Yap_OffLineProfiler) 
-    return Yap_unify(ARG1,MkAtomTerm(AtomOffline));
-  else
-    return Yap_unify(ARG1,MkAtomTerm(AtomOnline));
-}
-
 static Int start_profilers(int msec)
 {
  struct itimerval t;
  struct sigaction sa;
  
-  if (ProfilerOn!=-1) {
-    if (Yap_OffLineProfiler) {
-      return FALSE; /* have to go through profinit */
-    } else {
-      CACHE_REGS
-      if (!do_profinit( PASS_REGS1 ))
-	return FALSE;
-    }
+  if (GLOBAL_ProfilerOn!=-1) {
+    return FALSE; /* have to go through profinit */
  }
  sa.sa_sigaction=prof_alrm;
  sigemptyset(&sa.sa_mask);
@ -1156,15 +1105,21 @@ static Int start_profilers(int msec)
  t.it_value.tv_usec=msec;
  setitimer(ITIMER_PROF,&t,NULL);

-  ProfilerOn = msec;
+  GLOBAL_ProfilerOn = msec;
  return TRUE;
 }


 static Int profoff( USES_REGS1 ) {
-  if (ProfilerOn>0) {
-    setitimer(ITIMER_PROF,NULL,NULL);
-    ProfilerOn = -1;
+  if (GLOBAL_ProfilerOn>0) {
+    struct itimerval t;
+    t.it_interval.tv_sec=0;
+    t.it_interval.tv_usec=0;
+    t.it_value.tv_sec=0;
+    t.it_value.tv_usec=0;
+
+    setitimer(ITIMER_PROF,&t,NULL);
+    GLOBAL_ProfilerOn = -1;
    return TRUE;
  }
  return FALSE;
@ -1183,23 +1138,22 @@ static Int ProfOn0( USES_REGS1 ) {
 }

 static Int profison( USES_REGS1 ) {
-  return (ProfilerOn > 0);
+  return (GLOBAL_ProfilerOn > 0);
 }

 static Int profalt( USES_REGS1 ) { 
-  if (ProfilerOn==0) return(FALSE);
-  if (ProfilerOn==-1) return ProfOn( PASS_REGS1 );
+  if (GLOBAL_ProfilerOn==0) return(FALSE);
+  if (GLOBAL_ProfilerOn==-1) return ProfOn( PASS_REGS1 );
  return profoff( PASS_REGS1 );
 }

 static Int profend( USES_REGS1 ) 
 {
-  if (ProfilerOn==0) return(FALSE);
+  if (GLOBAL_ProfilerOn==0) return(FALSE);
  profoff( PASS_REGS1 );         /* Make sure profiler is off */
-  ProfilerOn=0;
-  if (Yap_OffLineProfiler) {
-    fclose(FProf);
-  }
+  GLOBAL_ProfilerOn=0;
+  fclose(GLOBAL_FProf);
+  GLOBAL_FPreds = NULL;
  return TRUE;
 }

@ -1250,22 +1204,23 @@ Yap_InitLowProf(void)
 {
 #if LOW_PROF
  GLOBAL_ProfCalls = 0;
-  ProfilerOn = FALSE;
-  Yap_OffLineProfiler = FALSE;
+  GLOBAL_ProfilerOn = FALSE;
+
  Yap_InitCPred("profinit",0, profinit, SafePredFlag);
-  Yap_InitCPred("profinit",1, profinit1, SafePredFlag);
-  Yap_InitCPred("$proftype",1, proftype, SafePredFlag);
  Yap_InitCPred("profend" ,0, profend, SafePredFlag);
-  Yap_InitCPred("ProfOn" , 0, ProfOn0, SafePredFlag);
-  Yap_InitCPred("ProfOn" , 1, ProfOn, SafePredFlag);
+  Yap_InitCPred("profon" , 0, ProfOn0, SafePredFlag);
  Yap_InitCPred("profoff", 0, profoff, SafePredFlag);
  Yap_InitCPred("profalt", 0, profalt, SafePredFlag);
  Yap_InitCPred("$offline_showprofres", 0, profres0, SafePredFlag);
  Yap_InitCPred("$profnode", 6, profnode, SafePredFlag);
-  Yap_InitCPred("$profglobs", 6, profglobs, SafePredFlag);
+  Yap_InitCPred("$profglobs", 7, profglobs, SafePredFlag);
  Yap_InitCPred("$profison",0 , profison, SafePredFlag);
  Yap_InitCPred("$get_pred_pinfo", 4, getpredinfo, SafePredFlag);
  Yap_InitCPred("showprofres", 4, getpredinfo, SafePredFlag);
-  Yap_InitCPred("prof_test", 0, p_test, 0);
 #endif
 }
+
+
+/**
+@}
+*/
--- a/C/grow.c
+++ b/C/grow.c
--- a/C/heapgc.c
+++ b/C/heapgc.c
--- a/C/index.c
+++ b/C/index.c
--- a/C/index_absmi_insts.h
+++ b/C/index_absmi_insts.h
@ -0,0 +1,458 @@
+/************************************************************************\
+ *    Indexing in ARG1                                                *
+\************************************************************************/
+
+
+#ifdef INDENT_CODE
+{
+  {
+#endif /* INDENT_CODE */
+
+      BOp(user_switch, lp);
+      {
+        yamop *new = Yap_udi_search(PREG->y_u.lp.p);
+        if (!new) {
+          PREG = PREG->y_u.lp.l;
+          JMPNext();
+        }
+        PREG = new;
+        JMPNext();
+      }
+      ENDBOp();
+
+      BOp(switch_on_type, llll);
+      BEGD(d0);
+      d0 = CACHED_A1();
+      deref_head(d0, swt_unk);
+      /* nonvar */
+    swt_nvar:
+      if (IsPairTerm(d0)) {
+        /* pair */
+        SREG = RepPair(d0);
+        copy_jmp_address(PREG->y_u.llll.l1);
+        PREG = PREG->y_u.llll.l1;
+        JMPNext();
+      }
+      else if (!IsApplTerm(d0)) {
+        /* constant */
+        copy_jmp_address(PREG->y_u.llll.l2);
+        PREG = PREG->y_u.llll.l2;
+        I_R = d0;
+        JMPNext();
+      }
+      else {
+        /* appl */
+        copy_jmp_address(PREG->y_u.llll.l3);
+        PREG = PREG->y_u.llll.l3;
+        SREG = RepAppl(d0);
+        JMPNext();
+      }
+
+      BEGP(pt0);
+      deref_body(d0, pt0, swt_unk, swt_nvar);
+      /* variable */
+      copy_jmp_address(PREG->y_u.llll.l4);
+      PREG = PREG->y_u.llll.l4;
+      JMPNext();
+      ENDP(pt0);
+      ENDD(d0);
+      ENDBOp();
+
+      /* specialised case where the arguments may be:
+       * a list;
+       * the empty list;
+       * some other atom;
+       * a variable;
+       *
+       */
+      BOp(switch_list_nl, ollll);
+      ALWAYS_LOOKAHEAD(PREG->y_u.ollll.pop);
+      BEGD(d0);
+      d0 = CACHED_A1();
+#if UNIQUE_TAG_FOR_PAIRS
+      deref_list_head(d0, swlnl_unk_p);
+    swlnl_list_p:
+      {
+#else
+        deref_head(d0, swlnl_unk_p);
+        /* non variable */
+      swlnl_nvar_p:
+        if (__builtin_expect(IsPairTerm(d0),1)) {
+          /* pair */
+#endif
+          copy_jmp_address(PREG->y_u.ollll.l1);
+          PREG = PREG->y_u.ollll.l1;
+          SREG = RepPair(d0);
+          ALWAYS_GONext();
+        }
+#if UNIQUE_TAG_FOR_PAIRS
+      swlnl_nlist_p:
+#endif
+        if (d0 == TermNil) {
+          /* empty list */
+          PREG = PREG->y_u.ollll.l2;
+          JMPNext();
+        }
+        else {
+          /* appl or constant */
+          if (IsApplTerm(d0)) {
+            copy_jmp_address(PREG->y_u.ollll.l3);
+            PREG = PREG->y_u.ollll.l3;
+            SREG = RepAppl(d0);
+            JMPNext();
+          } else {
+            copy_jmp_address(PREG->y_u.ollll.l3);
+            PREG = PREG->y_u.ollll.l3;
+            I_R = d0;
+            JMPNext();
+          }
+        }
+
+        BEGP(pt0);
+#if UNIQUE_TAG_FOR_PAIRS
+      swlnl_unk_p:
+        deref_list_body(d0, pt0, swlnl_list_p, swlnl_nlist_p);
+#else
+        deref_body(d0, pt0, swlnl_unk_p, swlnl_nvar_p);
+#endif
+        ENDP(pt0);
+        /* variable */
+        copy_jmp_address(PREG->y_u.ollll.l4);
+        PREG = PREG->y_u.ollll.l4;
+        JMPNext();
+        ENDD(d0);
+      }
+      ENDBOp();
+
+      BOp(switch_on_arg_type, xllll);
+      BEGD(d0);
+      d0 = XREG(PREG->y_u.xllll.x);
+      deref_head(d0, arg_swt_unk);
+      /* nonvar */
+    arg_swt_nvar:
+      if (IsPairTerm(d0)) {
+        /* pair */
+        copy_jmp_address(PREG->y_u.xllll.l1);
+        PREG = PREG->y_u.xllll.l1;
+        SREG = RepPair(d0);
+        JMPNext();
+      }
+      else if (!IsApplTerm(d0)) {
+        /* constant */
+        copy_jmp_address(PREG->y_u.xllll.l2);
+        PREG = PREG->y_u.xllll.l2;
+        I_R = d0;
+        JMPNext();
+      }
+      else {
+        /* appl */
+        copy_jmp_address(PREG->y_u.xllll.l3);
+        PREG = PREG->y_u.xllll.l3;
+        SREG = RepAppl(d0);
+        JMPNext();
+      }
+
+      BEGP(pt0);
+      deref_body(d0, pt0, arg_swt_unk, arg_swt_nvar);
+      /* variable */
+      copy_jmp_address(PREG->y_u.xllll.l4);
+      PREG = PREG->y_u.xllll.l4;
+      JMPNext();
+      ENDP(pt0);
+      ENDD(d0);
+      ENDBOp();
+
+      BOp(switch_on_sub_arg_type, sllll);
+      BEGD(d0);
+      d0 = SREG[PREG->y_u.sllll.s];
+      deref_head(d0, sub_arg_swt_unk);
+      /* nonvar */
+    sub_arg_swt_nvar:
+      if (IsPairTerm(d0)) {
+        /* pair */
+        copy_jmp_address(PREG->y_u.sllll.l1);
+        PREG = PREG->y_u.sllll.l1;
+        SREG = RepPair(d0);
+        JMPNext();
+      }
+      else if (!IsApplTerm(d0)) {
+        /* constant */
+        copy_jmp_address(PREG->y_u.sllll.l2);
+        PREG = PREG->y_u.sllll.l2;
+        I_R = d0;
+        JMPNext();
+      }
+      else {
+        /* appl */
+        copy_jmp_address(PREG->y_u.sllll.l3);
+        PREG = PREG->y_u.sllll.l3;
+        SREG = RepAppl(d0);
+        JMPNext();
+      }
+
+      BEGP(pt0);
+      deref_body(d0, pt0, sub_arg_swt_unk, sub_arg_swt_nvar);
+      /* variable */
+      copy_jmp_address(PREG->y_u.sllll.l4);
+      PREG = PREG->y_u.sllll.l4;
+      JMPNext();
+      ENDP(pt0);
+      ENDD(d0);
+      ENDBOp();
+
+      BOp(jump_if_var, l);
+      BEGD(d0);
+      d0 = CACHED_A1();
+      deref_head(d0, jump_if_unk);
+      /* non var */
+    jump0_if_nonvar:
+      PREG = NEXTOP(PREG, l);
+      JMPNext();
+
+      BEGP(pt0);
+      deref_body(d0, pt0, jump_if_unk, jump0_if_nonvar);
+      /* variable */
+      copy_jmp_address(PREG->y_u.l.l);
+      PREG = PREG->y_u.l.l;
+      ENDP(pt0);
+      JMPNext();
+      ENDD(d0);
+      ENDBOp();
+
+      BOp(jump_if_nonvar, xll);
+      BEGD(d0);
+      d0 = XREG(PREG->y_u.xll.x);
+      deref_head(d0, jump2_if_unk);
+      /* non var */
+    jump2_if_nonvar:
+      copy_jmp_address(PREG->y_u.xll.l1);
+      PREG = PREG->y_u.xll.l1;
+      JMPNext();
+
+      BEGP(pt0);
+      deref_body(d0, pt0, jump2_if_unk, jump2_if_nonvar);
+      /* variable */
+      PREG = NEXTOP(PREG, xll);
+      ENDP(pt0);
+      JMPNext();
+      ENDD(d0);
+      ENDBOp();
+
+      BOp(if_not_then, clll);
+      BEGD(d0);
+      d0 = CACHED_A1();
+      deref_head(d0, if_n_unk);
+    if_n_nvar:
+      /* not variable */
+      if (d0 == PREG->y_u.clll.c) {
+        /* equal to test value */
+        copy_jmp_address(PREG->y_u.clll.l2);
+        PREG = PREG->y_u.clll.l2;
+        JMPNext();
+      }
+      else {
+        /* different from test value */
+        /* the case to optimise */
+        copy_jmp_address(PREG->y_u.clll.l1);
+        PREG = PREG->y_u.clll.l1;
+        JMPNext();
+      }
+
+      BEGP(pt0);
+      deref_body(d0, pt0, if_n_unk, if_n_nvar);
+      ENDP(pt0);
+      /* variable */
+      copy_jmp_address(PREG->y_u.clll.l3);
+      PREG = PREG->y_u.clll.l3;
+      JMPNext();
+      ENDD(d0);
+      ENDBOp();
+
+      /************************************************************************\
+       *    Indexing on ARG1                                                        *
+\************************************************************************/
+
+#define HASH_SHIFT 6
+
+      BOp(switch_on_func, sssl);
+      BEGD(d1);
+      d1 = *SREG++;
+      /* we use a very simple hash function to find elements in a
+       * switch table */
+      {
+        CELL
+          /* first, calculate the mask */
+          Mask = (PREG->y_u.sssl.s - 1) << 1,       /* next, calculate the hash function */
+          hash = d1 >> (HASH_SHIFT - 1) & Mask;
+        CELL *base;
+
+        base = (CELL *)PREG->y_u.sssl.l;
+        /* PREG now points at the beginning of the hash table */
+        BEGP(pt0);
+        /* pt0 will always point at the item */
+        pt0 = base + hash;
+        BEGD(d0);
+        d0 = pt0[0];
+        /* a match happens either if we found the value, or if we
+         * found an empty slot */
+        if (d0 == d1 || d0 == 0) {
+          copy_jmp_addressa(pt0+1);
+          PREG = (yamop *) (pt0[1]);
+          JMPNext();
+        }
+        else {
+          /* ooops, collision, look for other items   */
+          register CELL d = ((d1 | 1) << 1) & Mask;
+
+          while (1) {
+            hash = (hash + d) & Mask;
+            pt0 = base + hash;
+            d0 = pt0[0];
+            if (d0 == d1 || d0 == 0) {
+              copy_jmp_addressa(pt0+1);
+              PREG = (yamop *) pt0[1];
+              JMPNext();
+            }
+          }
+        }
+        ENDD(d0);
+        ENDP(pt0);
+      }
+      ENDD(d1);
+      ENDBOp();
+
+      BOp(switch_on_cons, sssl);
+      BEGD(d1);
+      d1 = I_R;
+      /* we use a very simple hash function to find elements in a
+       * switch table */
+      {
+        CELL
+          /* first, calculate the mask */
+          Mask = (PREG->y_u.sssl.s - 1) << 1,       /* next, calculate the hash function */
+          hash = d1 >> (HASH_SHIFT - 1) & Mask;
+        CELL *base;
+
+        base = (CELL *)PREG->y_u.sssl.l;
+        /* PREG now points at the beginning of the hash table */
+        BEGP(pt0);
+        /* pt0 will always point at the item */
+        pt0 = base + hash;
+        BEGD(d0);
+        d0 = pt0[0];
+        /* a match happens either if we found the value, or if we
+         * found an empty slot */
+        if (d0 == d1 || d0 == 0) {
+          copy_jmp_addressa(pt0+1);
+          PREG = (yamop *) (pt0[1]);
+          JMPNext();
+        }
+        else {
+          /* ooops, collision, look for other items   */
+          register CELL d = ((d1 | 1) << 1) & Mask;
+
+          while (1) {
+            hash = (hash + d) & Mask;
+            pt0 = base + hash;
+            d0 = pt0[0];
+            if (d0 == d1 || d0 == 0) {
+              copy_jmp_addressa(pt0+1);
+              PREG = (yamop *) pt0[1];
+              JMPNext();
+            }
+          }
+        }
+        ENDD(d0);
+        ENDP(pt0);
+      }
+      ENDD(d1);
+      ENDBOp();
+
+      BOp(go_on_func, sssl);
+      BEGD(d0);
+      {
+        CELL *pt = (CELL *)(PREG->y_u.sssl.l);
+
+        d0 = *SREG++;
+        if (d0 == pt[0]) {
+          copy_jmp_addressa(pt+1);
+          PREG = (yamop *) pt[1];
+          JMPNext();
+        } else {
+          copy_jmp_addressa(pt+3);
+          PREG = (yamop *) pt[3];
+          JMPNext();
+        }
+      }
+      ENDD(d0);
+      ENDBOp();
+
+      BOp(go_on_cons, sssl);
+      BEGD(d0);
+      {
+        CELL *pt = (CELL *)(PREG->y_u.sssl.l);
+
+        d0 = I_R;
+        if (d0 == pt[0]) {
+          copy_jmp_addressa(pt+1);
+          PREG = (yamop *) pt[1];
+          JMPNext();
+        } else {
+          copy_jmp_addressa(pt+3);
+          PREG = (yamop *) pt[3];
+          JMPNext();
+        }
+      }
+      ENDD(d0);
+      ENDBOp();
+
+      BOp(if_func, sssl);
+      BEGD(d1);
+      BEGP(pt0);
+      pt0 = (CELL *) PREG->y_u.sssl.l;
+      d1 = *SREG++;
+      while (pt0[0] != d1 && pt0[0] != (CELL)NULL ) {
+        pt0 += 2;
+      }
+      copy_jmp_addressa(pt0+1);
+      PREG = (yamop *) (pt0[1]);
+      JMPNext();
+      ENDP(pt0);
+      ENDD(d1);
+      ENDBOp();
+
+      BOp(if_cons, sssl);
+      BEGD(d1);
+      BEGP(pt0);
+      pt0 = (CELL *) PREG->y_u.sssl.l;
+      d1 = I_R;
+      while (pt0[0] != d1 && pt0[0] != 0L ) {
+	pt0 += 2;
+      }
+      copy_jmp_addressa(pt0+1);
+      PREG = (yamop *) (pt0[1]);
+      JMPNext();
+      ENDP(pt0);
+      ENDD(d1);
+      ENDBOp();
+
+      Op(index_dbref, e);
+      PREG = NEXTOP(PREG, e);
+      I_R = AbsAppl(SREG-1);
+      GONext();
+      ENDOp();
+
+      Op(index_blob, e);
+      PREG = NEXTOP(PREG, e);
+      I_R = Yap_DoubleP_key(SREG);
+      GONext();
+      ENDOp();
+
+      Op(index_long, e);
+      PREG = NEXTOP(PREG, e);
+      I_R = Yap_IntP_key(SREG);
+      GONext();
+      ENDOp();
+
+
+
--- a/C/init.c
+++ b/C/init.c
--- a/C/inlines.c
+++ b/C/inlines.c
@ -15,39 +15,111 @@
 *									 *
 *************************************************************************/

+
+/** 
+
+
+    @file inlines.c
+
+    @{
+
+    @defgroup YAP_Inlines Inlined Tests nad Ter Manipulation
+
+    @ingroup builtins
+
+
+*/
+
+
 #define IN_INLINES_C 1

 #include "absmi.h"

-#ifdef CUT_C
 #include "cut_c.h"
-#endif

-STATIC_PROTO(Int    p_atom, ( USES_REGS1 ));
-STATIC_PROTO(Int    p_atomic, ( USES_REGS1 ));
-STATIC_PROTO(Int    p_integer, ( USES_REGS1 ));
-STATIC_PROTO(Int    p_nonvar, ( USES_REGS1 ));
-STATIC_PROTO(Int    p_number, ( USES_REGS1 ));
-STATIC_PROTO(Int    p_var, ( USES_REGS1 ));
-STATIC_PROTO(Int    p_db_ref, ( USES_REGS1 ));
-STATIC_PROTO(Int    p_primitive, ( USES_REGS1 ));
-STATIC_PROTO(Int    p_compound, ( USES_REGS1 ));
-STATIC_PROTO(Int    p_float, ( USES_REGS1 ));
-STATIC_PROTO(Int    p_equal, ( USES_REGS1 ));
-STATIC_PROTO(Int    p_dif, ( USES_REGS1 ));
-STATIC_PROTO(Int    p_eq, ( USES_REGS1 ));
-STATIC_PROTO(Int    p_arg, ( USES_REGS1 ));
-STATIC_PROTO(Int    p_functor, ( USES_REGS1 ));
+static Int    p_atom( USES_REGS1 );
+static Int    p_atomic( USES_REGS1 );
+static Int    p_integer( USES_REGS1 );
+static Int    p_nonvar( USES_REGS1 );
+static Int    p_number( USES_REGS1 );
+static Int    p_var( USES_REGS1 );
+static Int    p_db_ref( USES_REGS1 );
+static Int    p_primitive( USES_REGS1 );
+static Int    p_compound( USES_REGS1 );
+static Int    p_float( USES_REGS1 );
+static Int    p_equal( USES_REGS1 );
+static Int    p_dif( USES_REGS1 );
+static Int    p_eq( USES_REGS1 );
+static Int    p_arg( USES_REGS1 );
+static Int    p_functor( USES_REGS1 );
+static Int    p_fail( USES_REGS1 );
+static Int    p_true( USES_REGS1 );
+
+/** @pred  fail is iso
+
+Always fails. Defined as if by:
+
+ ~~~~~
+ fail :- 2=1.
+ ~~~~~
+*/
+
+/** @pred  false is iso
+
+The same as fail. Defined as if by:
+
+ ~~~~~
+ false :- 2=1.
+ ~~~~~
+*/
+
+static Int    p_fail( USES_REGS1 )
+{
+    return false;
+}
+
+/** @pred true is iso
+Succeed.
+
+Succeeds once. Defined as if by:
+
+ ~~~~~
+ true :- true.
+ ~~~~~
+*/
+
+/** @pred otherwise is iso
+Succeed.
+
+Succeeds once. Defined as if by:
+
+ ~~~~~
+ otherwise.
+ ~~~~~
+*/


-static Int 
+static Int    p_true( USES_REGS1 )
+{
+    return true;
+}
+
+
+/** @pred  atom( _T_) is iso
+
+
+Succeeds if and only if  _T_ is currently instantiated to an  atom.
+
+
+*/
+static Int
 p_atom( USES_REGS1 )
 {				/* atom(?)	 */
      BEGD(d0);
      d0 = ARG1;
      deref_head(d0, atom_unk);
    atom_nvar:
-      if (IsAtomTerm(d0)) {
+      if (IsAtomTerm(d0)  && !IsBlob(AtomOfTerm(d0))) {
 	return(TRUE);
      }
      else {
@ -61,7 +133,14 @@ p_atom( USES_REGS1 )
      ENDD(d0);
 }

-static Int 
+/** @pred  atomic(T) is iso
+
+
+Checks whether  _T_ is an atomic symbol (atom or number).
+
+
+*/
+static Int
 p_atomic( USES_REGS1 )
 {				/* atomic(?)	 */
      BEGD(d0);
@ -82,7 +161,14 @@ p_atomic( USES_REGS1 )
      ENDD(d0);
 }

-static Int 
+/** @pred  integer( _T_) is iso
+
+
+Succeeds if and only if  _T_ is currently instantiated to an  integer.
+
+
+*/
+static Int
 p_integer( USES_REGS1 )
 {				/* integer(?,?)	 */
      BEGD(d0);
@ -96,10 +182,14 @@ p_integer( USES_REGS1 )
 	Functor f0 = FunctorOfTerm(d0);
 	if (IsExtensionFunctor(f0)) {
 	  switch ((CELL)f0) {
-	  case (CELL)FunctorLongInt:
-#ifdef USE_GMP
 	  case (CELL)FunctorBigInt:
-#endif
+	    { CELL *pt = RepAppl(d0);
+	      if ( pt[1] != BIG_INT ) {
+		return FALSE;
+	      }
+        return TRUE;
+	    }
+	  case (CELL)FunctorLongInt:
 	    return(TRUE);
 	  default:
 	    return(FALSE);
@ -117,7 +207,14 @@ p_integer( USES_REGS1 )
      ENDD(d0);
 }

-static Int 
+/** @pred  number( _T_) is iso
+
+
+Checks whether `T` is an integer, rational or a float.
+
+
+*/
+static Int
 p_number( USES_REGS1 )
 {				/* number(?)	 */
      BEGD(d0);
@ -131,11 +228,15 @@ p_number( USES_REGS1 )
 	Functor f0 = FunctorOfTerm(d0);
 	if (IsExtensionFunctor(f0)) {
 	  switch ((CELL)f0) {
+	  case (CELL)FunctorBigInt:
+	    { CELL *pt = RepAppl(d0);
+	      if (  pt[1] != BIG_RATIONAL || pt[1] != BIG_INT ) {
+		return FALSE;
+	      }
+        return(TRUE);
+    }
 	  case (CELL)FunctorLongInt:
 	  case (CELL)FunctorDouble:
-#ifdef USE_GMP
-	  case (CELL)FunctorBigInt:
-#endif
 	    return(TRUE);
 	  default:
 	    return(FALSE);
@ -153,7 +254,14 @@ p_number( USES_REGS1 )
      ENDD(d0);
 }

-static Int 
+/** @pred  db_reference( _T_)
+
+
+Checks whether  _T_ is a database reference.
+
+
+*/
+static Int
 p_db_ref( USES_REGS1 )
 {				/* db_reference(?,?)	 */
      BEGD(d0);
@ -174,7 +282,14 @@ p_db_ref( USES_REGS1 )
      ENDD(d0);
 }

-static Int 
+/** @pred  primitive( ?_T_)
+
+
+Checks whether  _T_ is an atomic term or a database reference.
+
+
+*/
+static Int
 p_primitive( USES_REGS1 )
 {				/* primitive(?)	 */
      BEGD(d0);
@ -195,7 +310,14 @@ p_primitive( USES_REGS1 )
      ENDD(d0);
 }

-static Int 
+/** @pred  float( _T_) is iso
+
+
+Checks whether  _T_ is a floating point number.
+
+
+*/
+static Int
 p_float( USES_REGS1 )
 {				/* float(?)	 */
      BEGD(d0);
@ -216,7 +338,14 @@ p_float( USES_REGS1 )
      ENDD(d0);
 }

-static Int 
+/** @pred  compound( _T_) is iso
+
+
+Checks whether  _T_ is a compound term.
+
+
+*/
+static Int
 p_compound( USES_REGS1 )
 {				/* compound(?)	 */
      BEGD(d0);
@ -243,7 +372,14 @@ p_compound( USES_REGS1 )
      ENDD(d0);
 }

-static Int 
+/** @pred  nonvar( _T_) is iso
+
+
+The opposite of `var( _T_)`.
+
+
+*/
+static Int
 p_nonvar( USES_REGS1 )
 {				/* nonvar(?)	 */
      BEGD(d0);
@ -251,7 +387,7 @@ p_nonvar( USES_REGS1 )
      deref_head(d0, nonvar_unk);
    nonvar_nvar:
      return(TRUE);
-	
+
      BEGP(pt0);
      deref_body(d0, pt0, nonvar_unk, nonvar_nvar);
      return(FALSE);
@ -259,7 +395,14 @@ p_nonvar( USES_REGS1 )
      ENDD(d0);
 }

-static Int 
+/** @pred  var( _T_) is iso
+
+
+Succeeds if  _T_ is currently a free variable, otherwise fails.
+
+
+*/
+static Int
 p_var( USES_REGS1 )
 {				/* var(?)	 */
      BEGD(d0);
@ -275,13 +418,20 @@ p_var( USES_REGS1 )
      ENDD(d0);
 }

-static Int 
+/** @pred  _X_ =  _Y_ is iso
+
+
+Tries to unify terms  _X_ and  _Y_.
+
+
+*/
+static Int
 p_equal( USES_REGS1 )
 {				/* ?=? */
  return(Yap_IUnify(ARG1, ARG2));
 }

-static Int 
+static Int
 eq(Term t1, Term t2 USES_REGS)
 {				/* ? == ? */
      BEGD(d0);
@ -319,6 +469,8 @@ eq(Term t1, Term t2 USES_REGS)
 	    return (d0 == d1);
 	  case (CELL)FunctorLongInt:
 	    return(LongIntOfTerm(d0) == LongIntOfTerm(d1));
+	  case (CELL)FunctorString:
+	    return(strcmp((char *)StringOfTerm(d0), (char *)StringOfTerm(d1)) == 0);
 #ifdef USE_GMP
 	  case (CELL)FunctorBigInt:
 	    return (Yap_gmp_tcmp_big_big(d0, d1) == 0);
@ -365,20 +517,58 @@ eq(Term t1, Term t2 USES_REGS)
      ENDD(d0);
 }

-static Int 
+
+
+/** @pred ?_X_ ==  ?_Y_ is iso
+
+Succeeds if terms  _X_ and  _Y_ are strictly identical. The
+difference between this predicate and =/2 is that, if one of the
+arguments is a free variable, it only succeeds when they have already
+been unified.
+
+~~~~~{.prolog}
+?- X == Y.
+~~~~~
+fails, but,
+
+~~~~~{.prolog}
+?- X = Y, X == Y.
+~~~~~
+succeeds.
+
+~~~~~{.prolog}
+?- X == 2.
+~~~~~
+fails, but,
+
+~~~~~{.prolog}
+?- X = 2, X == 2.
+~~~~~
+succeeds.
+
+
+*/
+static Int
 p_eq( USES_REGS1 )
 {				/* ? == ? */
  return eq(ARG1,ARG2 PASS_REGS);
 }

-int 
+int
 Yap_eq(Term t1, Term t2)
 {				/* ? == ? */
  CACHE_REGS
  return eq(t1,t2 PASS_REGS);
 }

-static Int 
+/** @pred  _X_ \=  _Y_ is iso
+
+
+Succeeds if terms  _X_ and  _Y_ are not unifiable.
+
+
+*/
+static Int
 p_dif( USES_REGS1 )
 {				/* ? \= ?  */
 #if SHADOW_HB
@ -417,9 +607,9 @@ p_dif( USES_REGS1 )
    /* make B and HB point to H to guarantee all bindings will
     * be trailed
     */
-    HBREG = H;
-    B = (choiceptr) H;
-    B->cp_h = H;
+    HBREG = HR;
+    B = (choiceptr) HR;
+    B->cp_h = HR;
    SET_BB(B);
    save_hb();
    d0 = Yap_IUnify(d0, d1);
@ -427,14 +617,14 @@ p_dif( USES_REGS1 )
    /* now restore Woken Goals to its old value */
    Yap_UpdateTimedVar(LOCAL_WokenGoals, OldWokenGoals);
    if (OldWokenGoals == TermNil) {
-      Yap_undo_signal(YAP_WAKEUP_SIGNAL);
+      Yap_get_signal(YAP_WAKEUP_SIGNAL);
    }
 #endif
    /* restore B */
    B = pt1;
    SET_BB(PROTECT_FROZEN_B(pt1));
 #ifdef COROUTINING
-    H = HBREG;
+    HR = HBREG;
 #endif
    HBREG = B->cp_h;
    /* untrail all bindings made by Yap_IUnify */
@ -456,7 +646,7 @@ p_dif( USES_REGS1 )
 	CELL *pt = RepAppl(d1);
 	/* AbsAppl means */
 	/* multi-assignment variable */
-	/* so the next cell is the old value */ 
+	/* so the next cell is the old value */
 #ifdef FROZEN_STACKS
 	pt[0] = TrailVal(--TR);
 #else
@ -486,7 +676,21 @@ p_dif( USES_REGS1 )
  ENDD(d0);
 }

-static Int 
+
+/** @pred  arg(+ _N_,+ _T_, _A_) is iso
+
+
+Succeeds if the argument  _N_ of the term  _T_ unifies with
+ _A_. The arguments are numbered from 1 to the arity of the term.
+
+The current version will generate an error if  _T_ or  _N_ are
+unbound, if  _T_ is not a compound term, of if  _N_ is not a positive
+integer. Note that previous versions of YAP would fail silently
+under these errors.
+
+
+*/
+static Int
 p_arg( USES_REGS1 )
 {				/* arg(?,?,?)	 */
 #if SHADOW_HB
@ -502,7 +706,8 @@ p_arg( USES_REGS1 )
      else if (IsLongIntTerm(d0)) {
 	d0 = LongIntOfTerm(d0);
      } else {
-	Yap_Error(TYPE_ERROR_INTEGER,d0,"arg 1 of arg/3");
+	if (!IsBigIntTerm( d0 ))
+	  Yap_Error(TYPE_ERROR_INTEGER,d0,"arg 1 of arg/3");
 	return(FALSE);
      }

@ -518,16 +723,17 @@ p_arg( USES_REGS1 )
 	pt0 = RepAppl(d1);
 	d1 = *pt0;
 	if (IsExtensionFunctor((Functor) d1)) {
+	  Yap_Error(TYPE_ERROR_COMPOUND, d1, "arg 2 of arg/3");
 	  return(FALSE);
 	}
 	save_hb();
 	if ((Int)d0 <= 0 ||
 	    (Int)d0 > ArityOfFunctor((Functor) d1) ||
 	    Yap_IUnify(pt0[d0], ARG3) == FALSE) {
-	  /* don't complain here for Prolog compatibility 
+	  /* don't complain here for Prolog compatibility
 	  if ((Int)d0 <= 0) {
 	    Yap_Error(DOMAIN_ERROR_NOT_LESS_THAN_ZERO,
-		  MkIntegerTerm(d0),"arg 1 of arg/3");	    
+		  MkIntegerTerm(d0),"arg 1 of arg/3");
 	  }
 	  */
 	  return(FALSE);
@ -555,13 +761,13 @@ p_arg( USES_REGS1 )
 	else {
 	  if ((Int)d0 < 0)
 	    Yap_Error(DOMAIN_ERROR_NOT_LESS_THAN_ZERO,
-		  MkIntegerTerm(d0),"arg 1 of arg/3");	 
+		  MkIntegerTerm(d0),"arg 1 of arg/3");
 	  return(FALSE);
 	}
 	ENDP(pt0);
      }
      else {
-	/* Yap_Error(TYPE_ERROR_COMPOUND, d1, "arg 2 of arg/3"); */
+	Yap_Error(TYPE_ERROR_COMPOUND, d1, "arg 2 of arg/3");
 	return(FALSE);
      }

@ -581,6 +787,26 @@ p_arg( USES_REGS1 )

 }

+/** @pred  functor( _T_, _F_, _N_) is iso
+
+
+The top functor of term  _T_ is named  _F_ and has  arity  _N_.
+
+When  _T_ is not instantiated,  _F_ and  _N_ must be. If
+ _N_ is 0,  _F_ must be an atomic symbol, which will be unified
+with  _T_. If  _N_ is not 0, then  _F_ must be an atom and
+ _T_ becomes instantiated to the most general term having functor
+ _F_ and arity  _N_. If  _T_ is instantiated to a term then
+ _F_ and  _N_ are respectively unified with its top functor name
+and arity.
+
+In the current version of YAP the arity  _N_ must be an
+integer. Previous versions allowed evaluable expressions, as long as the
+expression would evaluate to an integer. This feature is not available
+in the ISO Prolog standard.
+
+
+*/
 static Int
 p_functor( USES_REGS1 )			/* functor(?,?,?) */
 {
@ -605,6 +831,8 @@ p_functor( USES_REGS1 )			/* functor(?,?,?) */
 	d1 = MkIntTerm(0);
      } else if (d1 == (CELL)FunctorLongInt) {
 	d1 = MkIntTerm(0);
+      } else if (d1 == (CELL)FunctorString) {
+	d1 = MkIntTerm(0);
      } else
 	  return(FALSE);
    } else {
@ -623,7 +851,7 @@ p_functor( USES_REGS1 )			/* functor(?,?,?) */
  /* let's go and bind them */
  {
    register CELL arity = d1;
-    
+
    d1 = ARG2;
    deref_head(d1, func_nvar_unk);
  func_nvar_nvar:
@ -634,11 +862,11 @@ p_functor( USES_REGS1 )			/* functor(?,?,?) */
    /* have to buffer ENDP and label */
    d0 = arity;
    goto func_bind_x3;
-    
+
    BEGP(pt0);
    deref_body(d1, pt0, func_nvar_unk, func_nvar_nvar);
    /* A2 is a variable, go and bind it */
-    Bind(pt0, d0);
+    YapBind(pt0, d0);
    /* have to buffer ENDP and label */
    d0 = arity;
    ENDP(pt0);
@ -659,7 +887,7 @@ p_functor( USES_REGS1 )			/* functor(?,?,?) */
    BEGP(pt0);
    deref_body(d1, pt0, func_nvar3_unk, func_nvar3_nvar);
    /* A3 is a variable, go and bind it */
-    Bind(pt0, d0);
+    YapBind(pt0, d0);
    return(TRUE);

    ENDP(pt0);
@ -697,10 +925,10 @@ p_functor( USES_REGS1 )			/* functor(?,?,?) */
  /* We made it!!!!! we got in d0 the name, in d1 the arity and
   * in pt0 the variable to bind it to. */
  if (d0 == TermDot && d1 == 2) {
-    RESET_VARIABLE(H);
-    RESET_VARIABLE(H+1);
-    d0 = AbsPair(H);
-    H += 2;
+    RESET_VARIABLE(HR);
+    RESET_VARIABLE(HR+1);
+    d0 = AbsPair(HR);
+    HR += 2;
  }
  else if ((Int)d1 > 0) {
    /* now let's build a compound term */
@ -714,12 +942,12 @@ p_functor( USES_REGS1 )			/* functor(?,?,?) */
    }
    else
      d0 = (CELL) Yap_MkFunctor(AtomOfTerm(d0), (Int) d1);
-    pt1 = H;
+    pt1 = HR;
    *pt1++ = d0;
-    d0 = AbsAppl(H);
-    if (pt1+d1 > ENV - CreepFlag) {
+    d0 = AbsAppl(HR);
+    if (pt1+d1 > ENV - StackGap( PASS_REGS1 )) {
      if (!Yap_gcl((1+d1)*sizeof(CELL), 3, ENV, gc_P(P,CP))) {
-	Yap_Error(OUT_OF_STACK_ERROR, TermNil, LOCAL_ErrorMessage);
+	Yap_Error(RESOURCE_ERROR_STACK, TermNil, LOCAL_ErrorMessage);
 	return FALSE;
      }
      goto restart;
@ -729,15 +957,15 @@ p_functor( USES_REGS1 )			/* functor(?,?,?) */
      pt1++;
    }
    /* done building the term */
-    H = pt1;
+    HR = pt1;
    ENDP(pt1);
  } else if ((Int)d1  < 0) {
    Yap_Error(DOMAIN_ERROR_NOT_LESS_THAN_ZERO,MkIntegerTerm(d1),"functor/3");
    return(FALSE);
-  } 
+  }
  /* else if arity is 0 just pass d0 through */
  /* Ding, ding, we made it */
-  Bind(pt0, d0);
+  YapBind(pt0, d0);
  return(TRUE);


@ -760,6 +988,13 @@ p_functor( USES_REGS1 )			/* functor(?,?,?) */
  ENDD(d0);
 }

+static Term
+cp_as_integer(choiceptr cp USES_REGS)
+{
+  return(MkIntegerTerm(LCL0-(CELL *)cp));
+}
+
+
 static Int
 p_cut_by( USES_REGS1 )
 {
@ -780,14 +1015,12 @@ p_cut_by( USES_REGS1 )
 #else
  pt0 = (choiceptr)(LCL0-IntOfTerm(d0));
 #endif
-#ifdef CUT_C
  {
    while (POP_CHOICE_POINT(pt0))
      {
 	POP_EXECUTE();
      }
  }
-#endif /* CUT_C */
 #ifdef YAPOR
    CUT_prune_to(pt0);
 #endif /* YAPOR */
@ -819,29 +1052,69 @@ p_cut_by( USES_REGS1 )
 static Int
 p_erroneous_call( USES_REGS1 )
 {
-  Yap_Error(SYSTEM_ERROR, TermNil, "bad call to internal built-in");
+  Yap_Error(SYSTEM_ERROR_INTERNAL, TermNil, "bad call to internal built-in");
  return(FALSE);
 }

-static Int 
-init_genarg( USES_REGS1 )
-{				/* getarg(?Atom)		 */
-  Term t0 = Deref(ARG1);
-  Term t1 = Deref(ARG2);
-  CELL *pt, *end;
-  int res;
-  UInt arity;
+ static Int
+   p_save_cp( USES_REGS1 )
+{
+  Term t = Deref(ARG1);
+  Term td;
+#if SHADOW_HB
+  register CELL *HBREG = HB;
+#endif
+  if (!IsVarTerm(t)) return(FALSE);
+  td = cp_as_integer(B PASS_REGS);
+  YapBind((CELL *)t,td);
+  return(TRUE);
+}

-  if (!IsVarTerm(t0)) {
-    res = p_arg( PASS_REGS1 );
-    if (res) {
-      cut_succeed();
-    } else {
-      cut_fail();
-    }
-  }
-  if (IsVarTerm(t1)) {
-    Yap_Error(INSTANTIATION_ERROR,t1,"genarg/3");
+ /// @}
+
+ /** 
+  *
+  * @addtogroup args
+  *
+  * @{
+  *
+  *  @namespace args
+  *
+  * @pred genarg( ?Index, +Term , -Arg )
+  *
+  * 
+  * Similar to arg/3, but it can also backtrack through _T_'s arguments, that is:
+
+  ~~~~~~~~~
+  ?- arg:genarg(I, f(a,b), A).
+  A = a,
+  I = 1.
+  ;
+  A = b,
+  I = 2.
+  ~~~~~~~~~
+  * 
+  * Note: SWI-Prolog defines arg/3 as genarg/3.  
+  */
+ static Int
+   genarg( USES_REGS1 )
+ {				/* getarg(?Atom)		 */
+   Term t0 = Deref(ARG1);
+   Term t1 = Deref(ARG2);
+   CELL *pt, *end;
+   int res;
+   UInt arity;
+
+   if (!IsVarTerm(t0)) {
+     res = p_arg( PASS_REGS1 );
+     if (res) {
+       cut_succeed();
+     } else {
+       cut_fail();
+     }
+   }
+   if (IsVarTerm(t1)) {
+     Yap_Error(INSTANTIATION_ERROR,t1,"genarg/3");
    return FALSE;
  }
  if (IsPrimitiveTerm(t1)) {
@ -898,30 +1171,42 @@ cont_genarg( USES_REGS1 )
 }


-void 
-Yap_InitInlines(void)
-{
-  CACHE_REGS
-  Term cm = CurrentModule;
-  Yap_InitAsmPred("$$cut_by", 1, _cut_by, p_cut_by, SafePredFlag);
-  Yap_InitAsmPred("atom", 1, _atom, p_atom, SafePredFlag);
-  Yap_InitAsmPred("atomic", 1, _atomic, p_atomic, SafePredFlag);
-  Yap_InitAsmPred("integer", 1, _integer, p_integer, SafePredFlag);
-  Yap_InitAsmPred("nonvar", 1, _nonvar, p_nonvar, SafePredFlag);
-  Yap_InitAsmPred("number", 1, _number, p_number, SafePredFlag);
-  Yap_InitAsmPred("var", 1, _var, p_var, SafePredFlag);
-  Yap_InitAsmPred("db_reference", 1, _db_ref, p_db_ref, SafePredFlag);
-  Yap_InitAsmPred("primitive", 1, _primitive, p_primitive, SafePredFlag);
-  Yap_InitAsmPred("compound", 1, _compound, p_compound, SafePredFlag);
-  Yap_InitAsmPred("float", 1, _float, p_float, SafePredFlag);
-  Yap_InitAsmPred("=", 2, _equal, p_equal, SafePredFlag);
-  Yap_InitAsmPred("\\=", 2, _dif, p_dif, SafePredFlag);
-  Yap_InitAsmPred("==", 2, _eq, p_eq, SafePredFlag);
-  Yap_InitAsmPred("arg", 3, _arg, p_arg, SafePredFlag);
-  Yap_InitAsmPred("functor", 3, _functor, p_functor, 0);
-  Yap_InitAsmPred("$label_ctl", 2, _p_label_ctl, p_erroneous_call, SafePredFlag);
-  CurrentModule = ARG_MODULE;
-  Yap_InitCPredBack("genarg", 3, 3, init_genarg, cont_genarg,SafePredFlag);
-  CurrentModule = cm;
+ void
+   Yap_InitInlines(void)
+ {
+   CACHE_REGS
+     Term cm = CurrentModule;
+   Yap_InitAsmPred("$$cut_by", 1, _cut_by, p_cut_by, SafePredFlag);
+   Yap_InitAsmPred("$$save_by", 1, _save_by, p_save_cp, SafePredFlag);
+   Yap_InitAsmPred("atom", 1, _atom, p_atom, SafePredFlag);
+   Yap_InitAsmPred("atomic", 1, _atomic, p_atomic, SafePredFlag);
+   Yap_InitAsmPred("integer", 1, _integer, p_integer, SafePredFlag);
+   Yap_InitAsmPred("nonvar", 1, _nonvar, p_nonvar, SafePredFlag);
+   Yap_InitAsmPred("number", 1, _number, p_number, SafePredFlag);
+   Yap_InitAsmPred("var", 1, _var, p_var, SafePredFlag);
+   Yap_InitAsmPred("db_reference", 1, _db_ref, p_db_ref, SafePredFlag);
+   Yap_InitAsmPred("primitive", 1, _primitive, p_primitive, SafePredFlag);
+   Yap_InitAsmPred("compound", 1, _compound, p_compound, SafePredFlag);
+   Yap_InitAsmPred("float", 1, _float, p_float, SafePredFlag);
+   Yap_InitAsmPred("=", 2, _equal, p_equal, SafePredFlag);
+#if INLINE_BIG_COMPARISONS
+   Yap_InitAsmPred("\\=", 2, _dif, p_dif, SafePredFlag|TestPredFlag);
+   Yap_InitAsmPred("==", 2, _eq, p_eq, SafePredFlag|TestPredFlag);
+#else
+   Yap_InitCPred("\\=", 2, p_dif, SafePredFlag);
+   Yap_InitCPred("==", 2, p_eq, SafePredFlag);
+#endif
+   Yap_InitAsmPred("arg", 3, _arg, p_arg, SafePredFlag);
+   Yap_InitAsmPred("functor", 3, _functor, p_functor, 0);
+   Yap_InitAsmPred("$label_ctl", 2, _p_label_ctl, p_erroneous_call, SafePredFlag);
+   CurrentModule = ARG_MODULE;
+   Yap_InitCPredBack("genarg", 3, 3, genarg, cont_genarg,SafePredFlag);
+   CurrentModule = cm;
+     Yap_InitCPred("true", 0, p_true, SafePredFlag);
+     Yap_InitCPred("otherwise", 0, p_true, SafePredFlag);
+     Yap_InitCPred("false", 0, p_fail, SafePredFlag);
+     Yap_InitCPred("fail", 0, p_fail, SafePredFlag);
 }

+
+// @}
--- a/C/iopreds.c
+++ b/C/iopreds.c
--- a/C/learn2
+++ b/C/learn2
@ -0,0 +1,43 @@
+#!/usr/local/bin/python3.4
+import os, sys
+if 'LD_LIBRARY_PATH' not in os.environ:
+    os.environ['LD_LIBRARY_PATH'] = '/usr/local/lib'
+    try:
+        os.execv(sys.argv[0], sys.argv)
+    except Exception as exc:
+        print( 'Failed re-exec:', exc )
+        sys.exit(1)
+#
+# import yourmodule
+print( 'Success:', os.environ['LD_LIBRARY_PATH']
+# your program goes here
+
+import matplotlib
+matplotlib.use('Agg')
+
+
+#import sys, os
+sys.path = sys.path + [os.getcwd()]
+
+sys.druwid_root = os.path.abspath(os.path.dirname(__file__))
+
+
+import dru.druwid
+import dru.druplot
+from dru.shell import AlephShell
+
+cq = dru.druwid.ClauseQueue()
+
+learner = dru.druwid.Aleph( cq )
+
+#
+# initialize engine
+#
+def main():
+  if not learner:
+    print("Nothing to do, bye!")
+    exit(2)
+  AlephShell(learner).cmdloop()
+
+if __name__ == "__main__":
+  main()
--- a/C/load_aix.c
+++ b/C/load_aix.c
@ -26,9 +26,10 @@
 *   FindExecutable(argv[0]) should be called on yap initialization to
 *   locate the executable of Yap
 */
-void
-Yap_FindExecutable(char *name)
+char *
+Yap_FindExecutable(void)
 {
+  return NULL;
 }


@ -68,7 +69,7 @@ LoadForeign(StringList ofiles, StringList libs,
    strcpy(LOCAL_ErrorSay," Load Failed: in AIX you must load a single object file");
    return LOAD_FAILLED;
  }
-  if (!Yap_TrueFileName(AtomName(ofiles->name), LOCAL_FileNameBuf, TRUE)) {
+  if (!Yap_AbsoluteFileInBuffer(AtomName(ofiles->name), LOCAL_FileNameBuf, YAP_FILENAME_MAX, true)) {
    strcpy(LOCAL_ErrorSay, " Trying to open unexisting file in LoadForeign ");
    return LOAD_FAILLED;
  }
--- a/C/load_aout.c
+++ b/C/load_aout.c
@ -54,8 +54,8 @@ this code is no being maintained anymore
 *   YAP_FindExecutable(argv[0]) should be called on yap initialization to
 *   locate the executable of Yap
 */
-void
-Yap_FindExecutable(char *name)
+char *
+Yap_FindExecutable(void)
 {
  register char  *cp, *cp2;
  struct stat     stbuf;
@ -67,7 +67,8 @@ Yap_FindExecutable(char *name)
  if (*GLOBAL_argv[0] == '/') {
    if (oktox(GLOBAL_argv[0])) {
      strcpy(LOCAL_FileNameBuf, GLOBAL_argv[0]);
-      Yap_TrueFileName(LOCAL_FileNameBuf, GLOBAL_Executable, TRUE);
+      Yap_AbsoluteFileInBuffer(LOCAL_FileNameBuf, true);
+      strncpy( GLOBAL_Executable, LOCAL_FileNameBuf, YAP_MAXPATHLEN);
      return;
    }
  }
@ -87,16 +88,16 @@ Yap_FindExecutable(char *name)
      cp++;
    if (!oktox(LOCAL_FileNameBuf))
      continue;
-    Yap_TrueFileName(LOCAL_FileNameBuf, GLOBAL_Executable, TRUE);
+    Yap_AbsoluteFileInBuffer(Yap_AbsoluteFileInBuffer(LOCAL_FileNameBuf, GLOBAL_Executable, TRUE);
    return;
  }
  /* one last try for dual systems */
-  strcpy(LOCAL_FileNameBuf, GLOBAL_argv[0]);
-  Yap_TrueFileName(LOCAL_FileNameBuf, GLOBAL_Executable, TRUE);
+      strcpy(LOCAL_FileNameBuf, GLOBAL_argv[0]);
+    Yap_AbsoluteFileInBuffer(Yap_AbsoluteFileInBuffer(LOCAL_FileNameBuf, GLOBAL_Executable, TRUE);
  if (oktox(GLOBAL_Executable))
-    return;
+    return GLOBAL_Executable;
  else
-    Yap_Error(SYSTEM_ERROR,MkAtomTerm(Yap_LookupAtom(GLOBAL_Executable)),
+    Yap_Error(SYSTEM_ERROR_INTERNAL,MkAtomTerm(Yap_LookupAtom(GLOBAL_Executable)),
 	  "cannot find file being executed");
 }

--- a/C/load_coff.c
+++ b/C/load_coff.c
@ -50,8 +50,8 @@ this code is no being maintained anymore
 *   YAP_FindExecutable(argv[0]) should be called on yap initialization to
 *   locate the executable of Yap
 */
-void
-Yap_FindExecutable(char *name)
+char *
+Yap_FindExecutable(void)
 {
  register char  *cp, *cp2;
  struct stat     stbuf;
@ -64,7 +64,7 @@ Yap_FindExecutable(char *name)
    if (oktox(GLOBAL_argv[0])) {
      strcpy(LOCAL_FileNameBuf, GLOBAL_argv[0]);
      Yap_TrueFileName(LOCAL_FileNameBuf, GLOBAL_Executable, TRUE);
-      return;
+      return NULL;
    }
  }
  if (*cp == ':')
@ -84,16 +84,17 @@ Yap_FindExecutable(char *name)
    if (!oktox(LOCAL_FileNameBuf))
      continue;
    Yap_TrueFileName(LOCAL_FileNameBuf, GLOBAL_Executable, TRUE);
-    return;
+    return GLOBAL_Executable;
  }
  /* one last try for dual systems */
  strcpy(LOCAL_FileNameBuf, GLOBAL_argv[0]);
  Yap_TrueFileName(LOCAL_FileNameBuf, GLOBAL_Executable, TRUE);
  if (oktox(GLOBAL_Executable))
-    return;
+    return GLOBAL_Executable;
  else
-    Yap_Error(SYSTEM_ERROR,MkAtomTerm(Yap_LookupAtom(GLOBAL_Executable)),
+    Yap_Error(SYSTEM_ERROR_INTERNAL,MkAtomTerm(Yap_LookupAtom(GLOBAL_Executable)),
 	  "cannot find file being executed");
+  return NULL;
 }


--- a/C/load_dl.c
+++ b/C/load_dl.c
@ -1,183 +1,249 @@
 /*************************************************************************
-*									 *
-*	 YAP Prolog 							 *
-*									 *
-*	Yap Prolog was developed at NCCUP - Universidade do Porto	 *
-*									 *
-* Copyright L.Damas, V.S.Costa and Universidade do Porto 1985-1997	 *
-*									 *
-**************************************************************************
-*									 *
-* File:		load_dl.c						 *
-* comments:	dl based dynamic loaderr of external routines		 *
-*               tested on i486-linuxelf					 *
-*************************************************************************/
+ *									 *
+ *	 YAP Prolog 							 *
+ *									 *
+ *	Yap Prolog was developed at NCCUP - Universidade do Porto	 *
+ *									 *
+ * Copyright L.Damas, V.S.Costa and Universidade do Porto 1985-1997	 *
+ *									 *
+ **************************************************************************
+ *									 *
+ * File:		load_dl.c *
+ * comments:	dl based dynamic loaderr of external routines		 *
+ *               tested on i486-linuxelf *
+ *************************************************************************/

 #include "Yap.h"
-#include "Yatom.h"
 #include "YapHeap.h"
+#include "Yatom.h"
 #include "yapio.h"
+
 #include "Foreign.h"

 #if LOAD_DL

+// use SWI-Prolog code if all else fails
+char *findExecutable(const char *av0, char *buffer);
+
 #include <dlfcn.h>
-#include <string.h>
 #include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+#if defined(__APPLE__)
+#include <dlfcn.h>
+#include <mach-o/dyld.h>
+#endif
+
+typedef void (*prismf)(void);
+
+/* only works for dlls */
+int Yap_CallFunctionByName(const char *thing_string);
+
+int Yap_CallFunctionByName(const char *thing_string) {
+  void *handle = dlopen(NULL, RTLD_LAZY
+#ifndef __CYGWIN__
+#ifdef RTLD_NOLOAD
+                                  | RTLD_NOLOAD
+#endif
+#endif
+  );
+  // you could do RTLD_NOW as well.  shouldn't matter
+  if (!handle) {
+    CACHE_REGS
+    Yap_Error(SYSTEM_ERROR_INTERNAL, ARG1,
+              "Dynamic linking on main module : %s\n", dlerror());
+  }
+  prismf *addr = (prismf *)dlsym(handle, thing_string);
+  if (addr)
+    (*addr)();
+  dlclose(handle);
+  return TRUE;
+}

 /*
 *   YAP_FindExecutable(argv[0]) should be called on yap initialization to
 *   locate the executable of Yap
-*/
-void
-Yap_FindExecutable(char *name)
-{
+ */
+char *Yap_FindExecutable(void) {
+#if HAVE_GETEXECNAME
+  // Solaris
+  return getexecname();
+#elif __APPLE__
+  char *buf = malloc(YAP_FILENAME_MAX);
+
+  uint32_t size;
+  if (!_NSGetExecutablePath(buf, &size)) {
+    buf = realloc(buf, size + 1);
+    return buf;
+  }
+  return "yap";
+#elif defined(__linux__)
+  char *buf = malloc(YAP_FILENAME_MAX);
+  ssize_t len = readlink("/proc/self/exe", buf, YAP_FILENAME_MAX - 1);
+
+  if (len != -1) {
+    buf[len] = '\0';
+    return buf;
+  }
+// follow through to standard method
+#elif defined(__FreeBSD__) || defined(__DragonFly__)
+  enum { BUFFERSIZE = 1024 };
+  char *buf = malloc(BUFFERSIZE);
+  ssize_t len = readlink("/proc/curproc/file", buf, sizeof(buf) - 1);
+
+  if (len != -1) {
+    buf[len] = '\0';
+    return buf;
+  }
+  int mib[4];
+  mib[0] = CTL_KERN;
+  mib[1] = KERN_PROC;
+  mib[2] = KERN_PROC_PATHNAME;
+  mib[3] = -1; // current process
+  size_t cb = BUFFERSIZE;
+  sysctl(mib, 4, buf, &cb, NULL, 0);
+// follow through to standard method
+#endif
+  return NULL;
 }

-void *
-Yap_LoadForeignFile(char *file, int flags)
-{
+void *Yap_LoadForeignFile(char *file, int flags) {
+  CACHE_REGS
  int dlflag;
  void *out;

-  if (flags &  EAGER_LOADING)
+  if (flags & EAGER_LOADING)
    dlflag = RTLD_NOW;
  else
    dlflag = RTLD_LAZY;
-  if (flags &  GLOBAL_LOADING)
+  if (flags & GLOBAL_LOADING)
    dlflag |= RTLD_GLOBAL;
 #ifndef __CYGWIN__
-  else 
+  else
    dlflag |= RTLD_LOCAL;
 #endif
-  
-  out = (void *)dlopen(file,dlflag);
-  if (!out) {
-    CACHE_REGS
-    Yap_Error(SYSTEM_ERROR, ARG1, "dlopen error %s\n", dlerror());
+  out = (void *)dlopen(file, dlflag);
+  if (out == NULL) {
+    const char *m_os = dlerror();
+    if (m_os) {
+      LOCAL_ErrorMessage = malloc(MAX_ERROR_MSG_SIZE);
+      strncpy(LOCAL_ErrorMessage, m_os, MAX_ERROR_MSG_SIZE - 1);
+    } else {
+      LOCAL_ErrorMessage = "dlopen failed";
+    }
  }
  return out;
 }

-int
-Yap_CallForeignFile(void *handle, char *f)
-{
-  YapInitProc proc = (YapInitProc) dlsym(handle, f);
+int Yap_CallForeignFile(void *handle, char *f) {
+  YapInitProc proc = (YapInitProc)dlsym(handle, f);
  if (!proc) {
-    /* Yap_Error(SYSTEM_ERROR, ARG1, "dlsym error %s\n", dlerror());*/
+    /* Yap_Error(SYSTEM_ERROR_INTERNAL, ARG1, "dlsym error %s\n", dlerror());*/
    return FALSE;
  }
-  (*proc) ();
+  (*proc)();
  return TRUE;
 }

-int
-Yap_CloseForeignFile(void *handle)
-{
-  if ( dlclose(handle) < 0) {
+int Yap_CloseForeignFile(void *handle) {
+  if (dlclose(handle) < 0) {
    CACHE_REGS
-    Yap_Error(SYSTEM_ERROR, ARG1, "dlclose error %s\n", dlerror());
+    Yap_Error(SYSTEM_ERROR_INTERNAL, ARG1, "dlclose error %s\n", dlerror());
    return -1;
  }
  return 0;
 }

-
 /*
 * LoadForeign(ofiles,libs,proc_name,init_proc) dynamically loads foreign
 * code files and libraries and locates an initialization routine
-*/
-static Int
-LoadForeign(StringList ofiles, StringList libs,
-	       char *proc_name,	YapInitProc *init_proc)
-{
+ */
+static Int LoadForeign(StringList 
+  ofiles, StringList libs, char *proc_name,
+                       YapInitProc *init_proc) {
  CACHE_REGS
+  LOCAL_ErrorMessage = NULL;

  while (libs) {
-    if (!Yap_TrueFileName(AtomName(libs->name), LOCAL_FileNameBuf, TRUE)) {
-      /* use LD_LIBRARY_PATH */
-      strncpy(LOCAL_FileNameBuf, AtomName(libs->name), YAP_FILENAME_MAX);
-    }
-
+    const char *file = AtomName(libs->name);
 #ifdef __osf__
-    if((libs->handle=dlopen(LOCAL_FileNameBuf,RTLD_LAZY)) == NULL)
+    if ((libs->handle = dlopen(LOCAL_FileNameBuf, RTLD_LAZY)) == NULL)
 #else
-    if((libs->handle=dlopen(LOCAL_FileNameBuf,RTLD_LAZY|RTLD_GLOBAL)) == NULL)
+    if ((libs->handle = dlopen(file, RTLD_LAZY | RTLD_GLOBAL)) ==
+        NULL)
 #endif
    {
-      strcpy(LOCAL_ErrorSay,dlerror());
-      return LOAD_FAILLED;
+      if (LOCAL_ErrorMessage == NULL) {
+        LOCAL_ErrorMessage = malloc(MAX_ERROR_MSG_SIZE);
+        strcpy(LOCAL_ErrorMessage, dlerror());
+      }
    }
    libs = libs->next;
  }

  while (ofiles) {
-    void *handle;

-  /* load libraries first so that their symbols are available to
-     other routines */
+    /* load libraries first so that their symbols are available to
+       other routines */
+    const char *file = AtomName(ofiles->name);

-    /* dlopen wants to follow the LD_CONFIG_PATH */
-    if (!Yap_TrueFileName(AtomName(ofiles->name), LOCAL_FileNameBuf, TRUE)) {
-      strcpy(LOCAL_ErrorSay, "%% Trying to open unexisting file in LoadForeign");
-      return LOAD_FAILLED;
-    }
-#ifdef __osf__
-    if((handle=dlopen(LOCAL_FileNameBuf,RTLD_LAZY)) == 0)
-#else
-    if((handle=dlopen(LOCAL_FileNameBuf,RTLD_LAZY|RTLD_GLOBAL)) == 0)
-#endif
+    if ((ofiles->handle = dlopen(file, RTLD_LAZY | RTLD_GLOBAL)) ==
+        NULL)
    {
-      fprintf(stderr,"dlopen of %s failed with error %s\n", LOCAL_FileNameBuf, dlerror());
-/*      strcpy(LOCAL_ErrorSay,dlerror());*/
-      return LOAD_FAILLED;
+      if (LOCAL_ErrorMessage == NULL) {
+        LOCAL_ErrorMessage = malloc(MAX_ERROR_MSG_SIZE);
+        fprintf(stderr, "dlopen of image %s failed: %s\n", LOCAL_FileNameBuf,
+                dlerror());
+      }
    }

-    ofiles->handle = handle;
-
-    if (proc_name && !*init_proc)
-      *init_proc = (YapInitProc) dlsym(handle,proc_name);
-
+    if (ofiles->handle && proc_name && !*init_proc)
+      *init_proc = (YapInitProc)dlsym(ofiles->handle, proc_name);
    ofiles = ofiles->next;
  }

-  if(! *init_proc) {
-    strcpy(LOCAL_ErrorSay,"Could not locate initialization routine");
+  if (!*init_proc && LOCAL_ErrorMessage == NULL) {
+    char *buf = malloc(1058);
+    snprintf(buf, 1058 - 1, "Could not locate routine %s in %s: %s\n",
+             proc_name, LOCAL_FileNameBuf, dlerror());
    return LOAD_FAILLED;
  }

  return LOAD_SUCCEEDED;
 }

-Int
-Yap_LoadForeign(StringList ofiles, StringList libs,
-	       char *proc_name,	YapInitProc *init_proc)
-{
+Int Yap_LoadForeign(StringList ofiles, StringList libs, char *proc_name,
+                    YapInitProc *init_proc) {
  return LoadForeign(ofiles, libs, proc_name, init_proc);
 }

-void 
-Yap_ShutdownLoadForeign(void)
-{
+void Yap_ShutdownLoadForeign(void) {
  ForeignObj *f_code;

  f_code = ForeignCodeLoaded;
  while (f_code != NULL) {
-    StringList objs, libs;
+    StringList objs, libs, old;
+    ForeignObj *of_code = f_code;

    objs = f_code->objs;
    while (objs != NULL) {
+      old = objs;
      if (dlclose(objs->handle) != 0)
-      	return; /* ERROR */
+        return; /* ERROR */
      objs = objs->next;
+      Yap_FreeCodeSpace((ADDR)old);
    }
    libs = f_code->libs;
    while (libs != NULL) {
+      old = libs;
      if (dlclose(libs->handle) != 0)
-	return; /* ERROR */
-      objs = libs->next;
+        return; /* ERROR */
+      libs = libs->next;
+      Yap_FreeCodeSpace((ADDR)old);
    }
    f_code = f_code->next;
+    Yap_FreeCodeSpace((ADDR)of_code);
  }
  /*
    make sure that we don't try to close foreign code several times, eg,
@ -186,30 +252,19 @@ Yap_ShutdownLoadForeign(void)
  ForeignCodeLoaded = NULL;
 }

-Int
-Yap_ReLoadForeign(StringList ofiles, StringList libs,
-	       char *proc_name,	YapInitProc *init_proc)
-{
-  return(LoadForeign(ofiles,libs, proc_name, init_proc));
+Int Yap_ReLoadForeign(StringList ofiles, StringList libs, char *proc_name,
+                      YapInitProc *init_proc) {
+  return (LoadForeign(ofiles, libs, proc_name, init_proc));
 }

 #endif

 #if SIMICS

-void dlopen(void)
-{
-}
+void dlopen(void) {}

-void dlclose(void)
-{
-}
+void dlclose(void) {}

-void dlsym(void)
-{
-}
+void dlsym(void) {}

 #endif
-
-
-
--- a/C/load_dld.c
+++ b/C/load_dld.c
@ -26,15 +26,15 @@ this code is no being maintained anymore
 *   YAP_FindExecutable(argv[0]) should be called on yap initialization to
 *   locate the executable of Yap
 */
-void
-Yap_FindExecutable(char *name)
+char *
+Yap_FindExecutable(void)
 {
  /* use dld_find_executable */
  char *res;
  if(name != NULL && (res=dld_find_executable(name))) {
-    strcpy(GLOBAL_Executable,res);
+    return GLOBAL_Executable;
  } else {
-    strcpy(GLOBAL_Executable,"./yap");
+    return "yap";
  }
 }

--- a/C/load_dll.c
+++ b/C/load_dll.c
@ -19,7 +19,7 @@
 #include "yapio.h"
 #include "Foreign.h"

-#if LOAD_DLL
+#if _WIN32

 #include <windows.h>

@ -27,15 +27,30 @@
 *   YAP_FindExecutable(argv[0]) should be called on yap initialization to
 *   locate the executable of Yap
 */
-void
-Yap_FindExecutable(char *name)
+char *
+Yap_FindExecutable(void)
 {
+  enum { BUFFERSIZE = 1024 };
+  char *buf = malloc(BUFFERSIZE);
+
+  if (!GetModuleFileName(NULL, buf, BUFFERSIZE-1))
+    return NULL;
+
+  return buf;
 }

 void *
 Yap_LoadForeignFile(char *file, int flags)
 {
-  return (void *)LoadLibrary(file);
+  char *buf = malloc(1024);
+  void *ptr= (void *)LoadLibrary(file);
+ if (!ptr) {
+   FormatMessage(FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS,
+		 NULL, GetLastError(),
+		 MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), buf, 1023,
+		 NULL);
+		 }
+ return ptr;
 }

 int
@ -60,23 +75,34 @@ Yap_CloseForeignFile(void *handle)
 */
 static Int
 LoadForeign(StringList ofiles, StringList libs,
-	       char *proc_name,	YapInitProc *init_proc)
+	       const char *proc_name,	YapInitProc *init_proc)
 {
-
+  CACHE_REGS
  while (ofiles) {
    HINSTANCE handle;

-    if (Yap_TrueFileName(AtomName(ofiles->name), LOCAL_FileNameBuf, TRUE) &&
+    if (*init_proc == NULL &&
+      (*init_proc = (YapInitProc)GetProcAddress((HMODULE)handle, proc_name)))
+       {
+         YapInitProc f = *init_proc;
+        f();
+        return true;
+      }
+
+    const char *file = AtomName(ofiles->name);
+    if (Yap_findFile(file, NULL, NULL, LOCAL_FileNameBuf, true, YAP_OBJ, true, true) &&
 	(handle=LoadLibrary(LOCAL_FileNameBuf)) != 0)
      {
-	LOCAL_ErrorSay[0]=~'\0';
+       LOCAL_ErrorMessage = NULL;
 	if (*init_proc == NULL)
 	  *init_proc = (YapInitProc)GetProcAddress((HMODULE)handle, proc_name);
      } else {
-	FormatMessage(FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS,
-		      NULL, GetLastError(), 
-		      MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), LOCAL_ErrorSay, 256,
-		      NULL);
+      char *buf = malloc(1024);
+   FormatMessage(FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS,
+		 NULL, GetLastError(),
+		 MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), buf, 1023,
+		 NULL);
+	//fprintf(stderr,"WinError: %s\n", LOCAL_ErrorSay);
      }
    ofiles = ofiles->next;
  }
@ -84,7 +110,7 @@ LoadForeign(StringList ofiles, StringList libs,
     other routines */
  while (libs) {
    HINSTANCE handle;
-    char * s = AtomName(libs->name);
+    const char * s = AtomName(libs->name);

    if (s[0] == '-') {
      strcat(LOCAL_FileNameBuf,s+2);
@ -106,7 +132,7 @@ LoadForeign(StringList ofiles, StringList libs,
  }

  if(*init_proc == NULL) {
-    strcpy(LOCAL_ErrorSay,"Could not locate initialization routine");
+    LOCAL_ErrorMessage = "Could not locate initialization routine";
    return LOAD_FAILLED;
  }

@ -120,7 +146,7 @@ Yap_LoadForeign(StringList ofiles, StringList libs,
  return LoadForeign(ofiles, libs, proc_name, init_proc);
 }

-void 
+void
 Yap_ShutdownLoadForeign(void)
 {
 }
@ -133,4 +159,3 @@ Yap_ReLoadForeign(StringList ofiles, StringList libs,
 }

 #endif
-
--- a/C/load_dyld.c
+++ b/C/load_dyld.c
@ -62,9 +62,21 @@ mydlerror(void)
 *   YAP_FindExecutable(argv[0]) should be called on yap initialization to
 *   locate the executable of Yap
 */
-void
-Yap_FindExecutable(char *name)
+char *
+Yap_FindExecutable(void)
 {
+  char path[1024];
+  uint32_t size = sizeof(path);
+  if (_NSGetExecutablePath(path, &size) == 0) {
+    char *rc = malloc(size+1);
+    strncpy(rc, path, size);
+    return rc;
+  } else {
+    char *rc = malloc(size+1);
+    if (_NSGetExecutablePath(rc, &size) == 0)
+      return "yap";
+    return rc;
+  }
 }


@ -81,7 +93,8 @@ mydlopen(char *path)
      /* NSLinkModule will cause the run to abort on any link error's */
      /* not very friendly but the error recovery functionality is limited */
        handle = NSLinkModule(ofile, path, TRUE);
-    } return handle;
+    }
+    return handle;
 }

 static void *
@ -145,7 +158,8 @@ LoadForeign(StringList ofiles, StringList libs,
    void *handle;

    /* mydlopen wants to follow the LD_CONFIG_PATH */
-    if (!Yap_TrueFileName(AtomName(ofiles->name), LOCAL_FileNameBuf, TRUE)) {
+    iconst char *file = AtomName(ofiles->name);
+    if (!Yap_findFile(file, NULL, NULL, LOCAL_FileNameBuf, true, YAP_OBJ, true, true) ) {
      strcpy(LOCAL_ErrorSay, "%% Trying to open unexisting file in LoadForeign");
      return LOAD_FAILLED;
    }
--- a/C/load_foreign.c
+++ b/C/load_foreign.c
@ -13,13 +13,13 @@
 *									 *
 *************************************************************************/
 #ifdef SCCS
-static char     SccsId[] = "%W% %G%.2";
+static char SccsId[] = "%W% %G%.2";
 #endif

-
 #include "Yap.h"
-#include "Yatom.h"
 #include "YapHeap.h"
+#include "YapText.h"
+#include "Yatom.h"
 #include "yapio.h"
 #include <stdlib.h>
 #if HAVE_STRING_H
@ -29,33 +29,35 @@ static char     SccsId[] = "%W% %G%.2";
 #include "Foreign.h"

 #if _WIN32 || defined(__CYGWIN__)
-#ifndef YAP_SHLIB_SUFFIX
-#define YAP_SHLIB_SUFFIX ".dll"
+#ifndef SO_EXT
+#define SO_EXT "dll"
 #endif
 #endif

-STD_PROTO(Int p_load_foreign, ( USES_REGS1 ));
+Int p_load_foreign(USES_REGS1);

-Int
-p_load_foreign( USES_REGS1 )
-{
+Int p_load_foreign(USES_REGS1) {
  StringList ofiles = NULL;
  StringList libs = NULL;
  char *InitProcName;
  YapInitProc InitProc = NULL;
  Term t, t1;
  StringList new;
-  Int returncode = FALSE;
+  bool returncode = FALSE;
+  yhandle_t CurSlot = Yap_StartSlots();

-  strcpy(LOCAL_ErrorSay,"Invalid arguments");
+  //  Yap_DebugPlWrite(ARG1);  printf("%s\n", " \n");
+  // Yap_DebugPlWrite(ARG2);  printf("%s\n", " \n");
+  // ap_DebugPlWrite(ARG3);  printf("%s\n", " \n");

  /* collect the list of object files */
  t = Deref(ARG1);
-  while(1) {
-    if (t == TermNil) break;
+  while (1) {
+    if (t == TermNil)
+      break;
    t1 = HeadOfTerm(t);
    t = TailOfTerm(t);
-    new = (StringList) Yap_AllocCodeSpace(sizeof(StringListItem));
+    new = (StringList)Yap_AllocCodeSpace(sizeof(StringListItem));
    new->next = ofiles;
    new->name = AtomOfTerm(t1);
    ofiles = new;
@ -63,11 +65,12 @@ p_load_foreign( USES_REGS1 )

  /* collect the list of library files */
  t = Deref(ARG2);
-  while(1) {
-    if (t == TermNil) break;
+  while (1) {
+    if (t == TermNil)
+      break;
    t1 = HeadOfTerm(t);
    t = TailOfTerm(t);
-    new = (StringList) Yap_AllocCodeSpace(sizeof(StringListItem));
+    new = (StringList)Yap_AllocCodeSpace(sizeof(StringListItem));
    new->next = libs;
    new->name = AtomOfTerm(t1);
    libs = new;
@ -75,22 +78,39 @@ p_load_foreign( USES_REGS1 )

  /* get the initialization function name */
  t1 = Deref(ARG3);
-  InitProcName = RepAtom(AtomOfTerm(t1))->StrOfAE;
+  InitProcName = (char *)RepAtom(AtomOfTerm(t1))->StrOfAE;

-  
-  
-  /* call the OS specific function for dynamic loading */
-  if(Yap_LoadForeign(ofiles,libs,InitProcName,&InitProc)==LOAD_SUCCEEDED) {
+  // verify if it was waiting for initialization
+  if (Yap_LateInit(InitProcName)) {
+    returncode = true;
+  } else
+      /* call the OS specific function for dynamic loading */
+      if (Yap_LoadForeign(ofiles, libs, InitProcName, &InitProc) ==
+          LOAD_SUCCEEDED) {
+    if (InitProc == NULL) {
+      char *f;
+      if (ofiles) {
+        f = RepAtom(ofiles->name)->StrOfAE;
+      } else {
+        f = RepAtom(libs->name)->StrOfAE;
+      }
+     Yap_Error(SYSTEM_ERROR_OPERATING_SYSTEM, ARG3,
+                "Foreign module %s does not have initialization function %s", f,
+                InitProcName);
+      return false;
+    }
+    Yap_StartSlots();
    (*InitProc)();
-    returncode = TRUE;
+    Yap_CloseSlots(CurSlot);
+    returncode = true;
  }
-  
+
  /* I should recover space if load foreign fails */
  if (returncode == TRUE) {
    ForeignObj *f_code = (ForeignObj *)Yap_AllocCodeSpace(sizeof(ForeignObj));
    f_code->objs = ofiles;
    f_code->libs = libs;
-    f_code->f = InitProcName;
+    f_code->f = AtomOfTerm(t1);
    f_code->next = ForeignCodeLoaded;
    f_code->module = CurrentModule;
    ForeignCodeLoaded = f_code;
@ -109,59 +129,60 @@ p_load_foreign( USES_REGS1 )
  return returncode;
 }

-static Int
-p_open_shared_object( USES_REGS1 ) {
+static Int p_open_shared_object(USES_REGS1) {
  Term t = Deref(ARG1);
  Term tflags = Deref(ARG2);
  char *s;
  void *handle;

  if (IsVarTerm(t)) {
-    Yap_Error(INSTANTIATION_ERROR,t,"open_shared_object/3");
+    Yap_Error(INSTANTIATION_ERROR, t, "open_shared_object/3");
    return FALSE;
-  } 
+  }
  if (!IsAtomTerm(t)) {
-    Yap_Error(TYPE_ERROR_ATOM,t,"open_shared_object/3");
+    Yap_Error(TYPE_ERROR_ATOM, t, "open_shared_object/3");
    return FALSE;
  }
-  
+
  if (IsVarTerm(tflags)) {
-    Yap_Error(INSTANTIATION_ERROR,tflags,"open_shared_object/3");
-    return FALSE;
-  } 
-  if (!IsIntegerTerm(tflags)) {
-    Yap_Error(TYPE_ERROR_INTEGER,tflags,"open_shared_object/3");
+    Yap_Error(INSTANTIATION_ERROR, tflags, "open_shared_object/3");
    return FALSE;
  }
-  
-  s = RepAtom(AtomOfTerm(t))->StrOfAE;
-  if ((handle = Yap_LoadForeignFile(s, IntegerOfTerm(tflags)))==NULL) {
+  if (!IsIntegerTerm(tflags)) {
+    Yap_Error(TYPE_ERROR_INTEGER, tflags, "open_shared_object/3");
+    return FALSE;
+  }
+
+  s = (char *)RepAtom(AtomOfTerm(t))->StrOfAE;
+  if ((handle = Yap_LoadForeignFile(s, IntegerOfTerm(tflags))) == NULL) {
+    Yap_Error(EXISTENCE_ERROR_SOURCE_SINK, t,
+              "open_shared_object_failed for %s"
+              " with %s\n",
+              s, LOCAL_ErrorMessage);
    return FALSE;
  } else {
-    return Yap_unify(MkIntegerTerm((Int)handle),ARG3);
+    return Yap_unify(MkIntegerTerm((Int)handle), ARG3);
  }
 }

-static Int
-p_close_shared_object( USES_REGS1 ) {
+static Int p_close_shared_object(USES_REGS1) {
  Term t = Deref(ARG1);
  void *handle;

  if (IsVarTerm(t)) {
-    Yap_Error(INSTANTIATION_ERROR,t,"close_shared_object/1");
+    Yap_Error(INSTANTIATION_ERROR, t, "close_shared_object/1");
    return FALSE;
-  } 
+  }
  if (!IsIntegerTerm(t)) {
-    Yap_Error(TYPE_ERROR_INTEGER,t,"close_shared_object/1");
+    Yap_Error(TYPE_ERROR_INTEGER, t, "close_shared_object/1");
    return FALSE;
  }
  handle = (char *)IntegerOfTerm(t);
- 
+
  return Yap_CloseForeignFile(handle);
 }

-static Int
-p_call_shared_object_function( USES_REGS1 ) {
+static Int p_call_shared_object_function(USES_REGS1) {
  Term t = Deref(ARG1);
  Term tfunc = Deref(ARG2);
  Term tmod;
@ -170,76 +191,98 @@ p_call_shared_object_function( USES_REGS1 ) {
  Int res;

  tmod = CurrentModule;
- restart:
+restart:
  if (IsVarTerm(t)) {
-    Yap_Error(INSTANTIATION_ERROR,t,"call_shared_object_function/2");
+    Yap_Error(INSTANTIATION_ERROR, t, "call_shared_object_function/2");
    return FALSE;
  } else if (IsApplTerm(t)) {
-    Functor    fun = FunctorOfTerm(t);
+    Functor fun = FunctorOfTerm(t);
    if (fun == FunctorModule) {
      tmod = ArgOfTerm(1, t);
-      if (IsVarTerm(tmod) ) {
-	Yap_Error(INSTANTIATION_ERROR,t,"call_shared_object_function/2");
-	return FALSE;
+      if (IsVarTerm(tmod)) {
+        Yap_Error(INSTANTIATION_ERROR, t, "call_shared_object_function/2");
+        return FALSE;
      }
-      if (!IsAtomTerm(tmod) ) {
-	Yap_Error(TYPE_ERROR_ATOM,ARG1,"call_shared_object_function/2");
-	return FALSE;
+      if (!IsAtomTerm(tmod)) {
+        Yap_Error(TYPE_ERROR_ATOM, ARG1, "call_shared_object_function/2");
+        return FALSE;
      }
      t = ArgOfTerm(2, t);
      goto restart;
    }
  } else if (!IsIntegerTerm(t)) {
-    Yap_Error(TYPE_ERROR_INTEGER,t,"call_shared_object_function/2");
+    Yap_Error(TYPE_ERROR_INTEGER, t, "call_shared_object_function/2");
    return FALSE;
  }
  handle = (void *)IntegerOfTerm(t);
  if (IsVarTerm(tfunc)) {
-    Yap_Error(INSTANTIATION_ERROR,t,"call_shared_object_function/2");
+    Yap_Error(INSTANTIATION_ERROR, t, "call_shared_object_function/2");
    return FALSE;
-  } 
+  }
  if (!IsAtomTerm(tfunc)) {
-    Yap_Error(TYPE_ERROR_ATOM,t,"call_shared_object_function/2/3");
+    Yap_Error(TYPE_ERROR_ATOM, t, "call_shared_object_function/2/3");
    return FALSE;
  }
  CurrentModule = tmod;
-  res = Yap_CallForeignFile(handle, RepAtom(AtomOfTerm(tfunc))->StrOfAE);
+  res =
+      Yap_CallForeignFile(handle, (char *)RepAtom(AtomOfTerm(tfunc))->StrOfAE);
  CurrentModule = OldCurrentModule;
  return res;
 }

-static Int
-p_obj_suffix( USES_REGS1 ) {
-  return Yap_unify(Yap_StringToList(YAP_SHLIB_SUFFIX),ARG1);
+static Int p_obj_suffix(USES_REGS1) {
+  return Yap_unify(Yap_CharsToListOfCodes(SO_EXT, ENC_ISO_LATIN1 PASS_REGS),
+                   ARG1);
 }

-static Int
-p_open_shared_objects( USES_REGS1 ) {
-#ifdef YAP_SHLIB_SUFFIX
+static Int p_open_shared_objects(USES_REGS1) {
+#ifdef SO_EXT
  return TRUE;
 #else
  return FALSE;
 #endif
 }

-void
-Yap_InitLoadForeign( void )
+static Int check_embedded(USES_REGS1)
 {
-  if (GLOBAL_argv == NULL)
-    Yap_FindExecutable("yap");
-  else
-    Yap_FindExecutable(GLOBAL_argv[0]);
-  Yap_InitCPred("$load_foreign_files", 3, p_load_foreign, SafePredFlag|SyncPredFlag|HiddenPredFlag);
-  Yap_InitCPred("$open_shared_objects", 0, p_open_shared_objects, SafePredFlag|HiddenPredFlag);
-  Yap_InitCPred("$open_shared_object", 3, p_open_shared_object, SyncPredFlag|HiddenPredFlag);
-  Yap_InitCPred("close_shared_object", 1, p_close_shared_object, SyncPredFlag|SafePredFlag);
-  Yap_InitCPred("call_shared_object_function", 2, p_call_shared_object_function, SyncPredFlag);
-  Yap_InitCPred("$obj_suffix", 1, p_obj_suffix, SafePredFlag|HiddenPredFlag);
+  const char *s = Yap_TextTermToText(Deref(ARG1));
+  if (!s)
+    return false;
+#if EMBEDDED_MYDDAS
+  if (!strcmp("init_myddas",s)) {
+          init_myddas();
+return true;
+  }
+#endif
+#if EMBEDDED_SQLITE3
+  if (!strcmp("init_sqlite3",s)) {
+      init_sqlite3();
+return true;
+  }
+#endif
+return false;
 }

-void 
-Yap_ReOpenLoadForeign(void)
-{
+void Yap_InitLoadForeign(void) {
+  Yap_InitCPred("$check_embedded", 1, check_embedded, SafePredFlag);
+  Yap_InitCPred("$load_foreign_files", 3, p_load_foreign,
+                SafePredFlag | SyncPredFlag);
+  Yap_InitCPred("$open_shared_objects", 0, p_open_shared_objects, SafePredFlag);
+  Yap_InitCPred("$open_shared_object", 3, p_open_shared_object, SyncPredFlag);
+  Yap_InitCPred("close_shared_object", 1, p_close_shared_object,
+                SyncPredFlag | SafePredFlag);
+  /** @pred close_shared_object(+ _Handle_)
+
+  Detach the shared object identified by  _Handle_.
+
+
+  */
+  Yap_InitCPred("$call_shared_object_function", 2,
+                p_call_shared_object_function, SyncPredFlag);
+  Yap_InitCPred("$obj_suffix", 1, p_obj_suffix, SafePredFlag);
+}
+
+void Yap_ReOpenLoadForeign(void) {
  CACHE_REGS
  ForeignObj *f_code = ForeignCodeLoaded;
  Term OldModule = CurrentModule;
@ -248,19 +291,18 @@ Yap_ReOpenLoadForeign(void)
    YapInitProc InitProc = NULL;

    CurrentModule = f_code->module;
-    if(Yap_ReLoadForeign(f_code->objs,f_code->libs,f_code->f,&InitProc)==LOAD_SUCCEEDED) {
+    if (Yap_ReLoadForeign(f_code->objs, f_code->libs,
+                          (char *)RepAtom(f_code->f)->StrOfAE,
+                          &InitProc) == LOAD_SUCCEEDED) {
      if (InitProc)
-	(*InitProc)();
+        (*InitProc)();
    }
    f_code = f_code->next;
  }
  CurrentModule = OldModule;
 }

-
-
-
-
-
-
-
+X_API bool load_none(void)
+{
+  return true;
+}
--- a/C/load_none.c
+++ b/C/load_none.c
@ -26,9 +26,10 @@
 *   YAP_FindExecutable(argv[0]) should be called on yap initialization to
 *   locate the executable of Yap
 */
-void
-Yap_FindExecutable(char *name)
+char *
+Yap_FindExecutable(void)
 {
+  return NULL;
 }


--- a/C/load_shl.c
+++ b/C/load_shl.c
@ -16,7 +16,7 @@
 *   locate the executable of Yap
 */

-void Yap_FindExecutable(char *name)
+char * Yap_FindExecutable(void)
 {
 }

@ -51,7 +51,7 @@ LoadForeign( StringList ofiles, StringList libs,
 		 char *proc_name, YapInitProc *init_proc )
 {

-  /* *init_proc is initialised to NULL in load_foreign.c */
+  /* *init_proc is initialized to NULL in load_foreign.c */
  int init_missing = -1;

  int n, i;
@ -61,7 +61,8 @@ LoadForeign( StringList ofiles, StringList libs,
    int valid_fname;

    /* shl_load wants to follow the LD_CONFIG_PATH */
-    valid_fname = Yap_TrueFileName( AtomName(ofiles->name), LOCAL_FileNameBuf, TRUE );
+    const char *file = AtomName(ofiles->name);
+    valid_fname = Yap_findFile(file, NULL, NULL, LOCAL_FileNameBuf, true, YAP_OBJ, true, true);

    if( !valid_fname ) {
      strcpy( LOCAL_ErrorSay, "%% Trying to open non-existing file in LoadForeign" );
@ -167,7 +168,7 @@ Yap_ReLoadForeign(StringList ofiles, StringList libs,

 /*
 dunno what this one is supposed to do, no load_* defines it
-void	STD_PROTO(ReOpenLoadForeign,(void));
+void	 ReOpenLoadForeign(void);
 */

 #endif
--- a/C/lu_absmi_insts.h
+++ b/C/lu_absmi_insts.h
@ -0,0 +1,771 @@
+/************************************************************************\
+ *    Logical Updates                                                 *
+\************************************************************************/
+
+#ifdef INDENT_CODE
+{
+  {
+#endif /* INDENT_CODE */
+
+      /************************************************************************\
+       *        Logical Updates                                                 *
+\************************************************************************/
+
+      /* enter logical pred               */
+      BOp(enter_lu_pred, Illss);
+      check_trail(TR);
+      /* mark the indexing code */
+      {
+        LogUpdIndex *cl = PREG->y_u.Illss.I;
+        PredEntry *ap = cl->ClPred;
+
+        if (!cl) { FAIL(); } /* in case the index is empty */
+        if (ap->LastCallOfPred != LUCALL_EXEC) {
+          /*
+            only increment time stamp if we are working on current time
+            stamp
+          */
+          if (ap->TimeStampOfPred >= TIMESTAMP_RESET)
+            Yap_UpdateTimestamps(ap);
+          ap->TimeStampOfPred++;
+          ap->LastCallOfPred = LUCALL_EXEC;
+          /*      fprintf(stderr,"R %x--%d--%ul\n",ap,ap->TimeStampOfPred,ap->ArityOfPE);*/
+        }
+        *--YREG = MkIntegerTerm(ap->TimeStampOfPred);
+        /* fprintf(stderr,"> %p/%p %d %d\n",cl,ap,ap->TimeStampOfPred,PREG->y_u.Illss.s);*/
+        PREG = PREG->y_u.Illss.l1;
+        /* indicate the indexing code is being used */
+#if MULTIPLE_STACKS
+        /* just store a reference */
+        INC_CLREF_COUNT(cl);
+        TRAIL_CLREF(cl);
+#else
+        if (!(cl->ClFlags & InUseMask)) {
+          cl->ClFlags |= InUseMask;
+          TRAIL_CLREF(cl);
+        }
+#endif
+      }
+      JMPNext();
+      ENDBOp();
+
+      BOp(profiled_retry_logical, OtaLl);
+      check_trail(TR);
+      {
+        UInt timestamp;
+        CACHE_Y(B);
+
+#if defined(YAPOR) || defined(THREADS)
+        if (PP != PREG->y_u.OtaLl.d->ClPred) {
+          if (PP) UNLOCKPE(15,PP);
+          PP = PREG->y_u.OtaLl.d->ClPred;
+          PELOCK(15,PP);
+        }
+#endif
+        timestamp = IntegerOfTerm(((CELL *)(B_YREG+1))[PREG->y_u.OtaLl.s]);
+        if (!VALID_TIMESTAMP(timestamp, PREG->y_u.OtaLl.d)) {
+          /* jump to next instruction */
+          PREG=PREG->y_u.OtaLl.n;
+          JMPNext();
+        }
+        restore_yaam_regs(PREG->y_u.OtaLl.n);
+        restore_args(PREG->y_u.OtaLl.s);
+        LOCK(PREG->y_u.OtaLl.d->ClPred->StatisticsForPred->lock);
+        PREG->y_u.OtaLl.d->ClPred->StatisticsForPred->NOfRetries++;
+        UNLOCK(PREG->y_u.OtaLl.d->ClPred->StatisticsForPred->lock);
+#ifdef THREADS
+        PP = PREG->y_u.OtaLl.d->ClPred;
+#endif
+        PREG = PREG->y_u.OtaLl.d->ClCode;
+#ifdef FROZEN_STACKS
+        S_YREG = (CELL *) PROTECT_FROZEN_B(B_YREG);
+        set_cut(S_YREG, B->cp_b);
+#else
+        set_cut(S_YREG, B_YREG->cp_b);
+#endif /* FROZEN_STACKS */
+        SET_BB(B_YREG);
+        ENDCACHE_Y();
+      }
+      JMPNext();
+      ENDBOp();
+
+      BOp(profiled_trust_logical, OtILl);
+      CACHE_Y(B);
+      {
+        LogUpdIndex *cl = PREG->y_u.OtILl.block;
+        PredEntry *ap = cl->ClPred;
+        LogUpdClause *lcl = PREG->y_u.OtILl.d;
+        UInt timestamp = IntegerOfTerm(((CELL *)(B_YREG+1))[ap->ArityOfPE]);
+
+#if defined(YAPOR) || defined(THREADS)
+        if (PP != ap) {
+          if (PP) UNLOCKPE(16,PP);
+          PP = ap;
+          PELOCK(16,PP);
+        }
+#endif
+        if (!VALID_TIMESTAMP(timestamp, lcl)) {
+          /* jump to next alternative */
+          PREG = FAILCODE;
+        } else {
+          LOCK(ap->StatisticsForPred->lock);
+          ap->StatisticsForPred->NOfRetries++;
+          UNLOCK(ap->StatisticsForPred->lock);
+          PREG = lcl->ClCode;
+        }
+        /* HEY, leave indexing block alone!! */
+        /* check if we are the ones using this code */
+#if MULTIPLE_STACKS
+        DEC_CLREF_COUNT(cl);
+        /* clear the entry from the trail */
+        B->cp_tr--;
+        TR = B->cp_tr;
+        /* actually get rid of the code */
+        if (cl->ClRefCount == 0 && (cl->ClFlags & (ErasedMask|DirtyMask))) {
+          if (PREG != FAILCODE) {
+            /* I am the last one using this clause, hence I don't need a lock
+               to dispose of it
+            */
+            if (lcl->ClRefCount == 1) {
+              /* make sure the clause isn't destroyed */
+              /* always add an extra reference */
+              INC_CLREF_COUNT(lcl);
+              TRAIL_CLREF(lcl);
+            }
+          }
+          if (cl->ClFlags & ErasedMask) {
+            saveregs();
+            Yap_ErLogUpdIndex(cl);
+            setregs();
+          } else {
+            saveregs();
+            Yap_CleanUpIndex(cl);
+            setregs();
+          }
+          save_pc();
+        }
+#else
+        if (TrailTerm(B->cp_tr-1) == CLREF_TO_TRENTRY(cl) &&
+            B->cp_tr != B->cp_b->cp_tr) {
+          cl->ClFlags &= ~InUseMask;
+          --B->cp_tr;
+#if FROZEN_STACKS
+          if (B->cp_tr > TR_FZ)
+#endif
+            {
+              TR = B->cp_tr;
+            }
+          /* next, recover space for the indexing code if it was erased */
+          if (cl->ClFlags & (ErasedMask|DirtyMask)) {
+            if (PREG != FAILCODE) {
+              /* make sure we don't erase the clause we are jumping to,
+                 notice that we can erase a number of refs in one go. */
+              if (!(lcl->ClFlags & InUseMask)) {
+                lcl->ClFlags |= InUseMask;
+                TRAIL_CLREF(lcl);
+              }
+            }
+            if (cl->ClFlags & ErasedMask) {
+              saveregs();
+              Yap_ErLogUpdIndex(cl);
+              setregs();
+            } else {
+              saveregs();
+              Yap_CleanUpIndex(cl);
+              setregs();
+            }
+            save_pc();
+          }
+        }
+#endif
+#ifdef YAPOR
+        if (SCH_top_shared_cp(B)) {
+          SCH_last_alternative(PREG, B_YREG);
+          restore_args(ap->ArityOfPE);
+#ifdef FROZEN_STACKS
+          S_YREG = (CELL *) PROTECT_FROZEN_B(B_YREG);
+#else
+          S_YREG++;
+#endif /* FROZEN_STACKS */
+          set_cut(S_YREG, B->cp_b);
+        } else
+#endif  /* YAPOR */
+          {
+            pop_yaam_regs();
+            pop_args(ap->ArityOfPE);
+            S_YREG--;
+#ifdef FROZEN_STACKS
+            S_YREG = (CELL *) PROTECT_FROZEN_B(B_YREG);
+#endif /* FROZEN_STACKS */
+            set_cut(S_YREG, B);
+          }
+        SET_BB(B_YREG);
+        ENDCACHE_Y();
+        JMPNext();
+      }
+      ENDBOp();
+
+      BOp(try_logical, OtaLl);
+  check_trail(TR);
+  {
+    UInt timestamp;
+
+    CACHE_Y(YREG);
+    timestamp = IntegerOfTerm(S_YREG[0]);
+    /* fprintf(stderr,"+ %p/%p %d %d %d--%u\n",PREG,PREG->y_u.OtaLl.d->ClPred,timestamp,PREG->y_u.OtaLl.d->ClPred->TimeStampOfPred,PREG->y_u.OtaLl.d->ClTimeStart,PREG->y_u.OtaLl.d->ClTimeEnd);*/
+    /* Point AP to the code that follows this instruction */
+    /* always do this, even if we are not going to use it */
+    store_args(PREG->y_u.OtaLl.s);
+    store_yaam_regs(PREG->y_u.OtaLl.n, 0);
+    set_cut(S_YREG, B);
+    B = B_YREG;
+#ifdef YAPOR
+    SCH_set_load(B_YREG);
+#endif  /* YAPOR */
+#ifdef YAPOR
+    PP = PREG->y_u.OtaLl.d->ClPred;
+#endif  /* YAPOR */
+    if (!VALID_TIMESTAMP(timestamp, PREG->y_u.OtaLl.d)) {
+      /* jump to next alternative */
+      PREG=PREG->y_u.OtaLl.n;
+    } else {
+      PREG = PREG->y_u.OtaLl.d->ClCode;
+    }
+    SET_BB(B_YREG);
+    ENDCACHE_Y();
+  }
+  JMPNext();
+  ENDBOp();
+
+  BOp(count_retry_logical, OtaLl);
+  check_trail(TR);
+  {
+    UInt timestamp;
+    CACHE_Y(B);
+
+#if defined(YAPOR) || defined(THREADS)
+    if (PP != PREG->y_u.OtaLl.d->ClPred) {
+      if (PP) UNLOCKPE(15,PP);
+      PP = PREG->y_u.OtaLl.d->ClPred;
+      PELOCK(15,PP);
+    }
+#endif
+    timestamp = IntegerOfTerm(((CELL *)(B_YREG+1))[PREG->y_u.OtaLl.s]);
+    if (!VALID_TIMESTAMP(timestamp, PREG->y_u.OtaLl.d)) {
+      /* jump to next instruction */
+      PREG=PREG->y_u.OtaLl.n;
+      JMPNext();
+    }
+    restore_yaam_regs(PREG->y_u.OtaLl.n);
+    restore_args(PREG->y_u.OtaLl.s);
+    LOCAL_RetriesCounter--;
+    if (LOCAL_RetriesCounter == 0) {
+      saveregs();
+      Yap_NilError(RETRY_COUNTER_UNDERFLOW_EVENT,"");
+      setregs();
+      JMPNext();
+    }
+    LOCAL_PredEntriesCounter--;
+    if (LOCAL_PredEntriesCounter == 0) {
+      saveregs();
+      Yap_NilError(PRED_ENTRY_COUNTER_UNDERFLOW_EVENT,"");
+      setregs();
+      JMPNext();
+    }
+    LOCK(PREG->y_u.OtaLl.d->ClPred->StatisticsForPred->lock);
+    PREG->y_u.OtaLl.d->ClPred->StatisticsForPred->NOfRetries++;
+    UNLOCK(PREG->y_u.OtaLl.d->ClPred->StatisticsForPred->lock);
+#ifdef THREADS
+    PP = PREG->y_u.OtaLl.d->ClPred;
+#endif
+    PREG = PREG->y_u.OtaLl.d->ClCode;
+#ifdef FROZEN_STACKS
+    S_YREG = (CELL *) PROTECT_FROZEN_B(B_YREG);
+    set_cut(S_YREG, B->cp_b);
+#else
+    set_cut(S_YREG, B_YREG->cp_b);
+#endif /* FROZEN_STACKS */
+    SET_BB(B_YREG);
+    ENDCACHE_Y();
+  }
+  JMPNext();
+  ENDBOp();
+
+  BOp(count_trust_logical, OtILl);
+  CACHE_Y(B);
+  {
+    LogUpdIndex *cl = PREG->y_u.OtILl.block;
+    PredEntry *ap = cl->ClPred;
+    LogUpdClause *lcl = PREG->y_u.OtILl.d;
+    UInt timestamp = IntegerOfTerm(((CELL *)(B_YREG+1))[ap->ArityOfPE]);
+
+#if defined(YAPOR) || defined(THREADS)
+    if (PP != ap) {
+      if (PP) UNLOCKPE(16,PP);
+      PP = ap;
+      PELOCK(16,PP);
+    }
+#endif
+    if (!VALID_TIMESTAMP(timestamp, lcl)) {
+      /* jump to next alternative */
+      PREG = FAILCODE;
+    } else {
+      LOCAL_RetriesCounter--;
+      if (LOCAL_RetriesCounter == 0) {
+        saveregs();
+        Yap_NilError(RETRY_COUNTER_UNDERFLOW_EVENT,"");
+        setregs();
+        JMPNext();
+      }
+      LOCAL_PredEntriesCounter--;
+      if (LOCAL_PredEntriesCounter == 0) {
+        saveregs();
+        Yap_NilError(PRED_ENTRY_COUNTER_UNDERFLOW_EVENT,"");
+        setregs();
+        JMPNext();
+      }
+      LOCK(ap->StatisticsForPred->lock);
+      ap->StatisticsForPred->NOfRetries++;
+      UNLOCK(ap->StatisticsForPred->lock);
+      PREG = lcl->ClCode;
+    }
+    /* HEY, leave indexing block alone!! */
+    /* check if we are the ones using this code */
+#if MULTIPLE_STACKS
+    PELOCK(2, ap);
+    PP = ap;
+    DEC_CLREF_COUNT(cl);
+    /* clear the entry from the trail */
+    --B->cp_tr;
+    TR = B->cp_tr;
+    /* actually get rid of the code */
+    if (cl->ClRefCount == 0 && (cl->ClFlags & (ErasedMask|DirtyMask))) {
+      if (PREG != FAILCODE) {
+        /* I am the last one using this clause, hence I don't need a lock
+           to dispose of it
+        */
+        if (lcl->ClRefCount == 1) {
+          /* make sure the clause isn't destroyed */
+          /* always add an extra reference */
+          INC_CLREF_COUNT(lcl);
+          TRAIL_CLREF(lcl);
+        }
+      }
+      if (cl->ClFlags & ErasedMask) {
+        saveregs();
+        Yap_ErLogUpdIndex(cl);
+        setregs();
+      } else {
+        saveregs();
+        Yap_CleanUpIndex(cl);
+        setregs();
+      }
+      save_pc();
+    }
+#else
+    if (TrailTerm(B->cp_tr-1) == CLREF_TO_TRENTRY(cl) &&
+        B->cp_tr != B->cp_b->cp_tr) {
+      cl->ClFlags &= ~InUseMask;
+      --B->cp_tr;
+#if FROZEN_STACKS
+      if (B->cp_tr > TR_FZ)
+#endif
+        {
+          TR = B->cp_tr;
+        }
+      /* next, recover space for the indexing code if it was erased */
+      if (cl->ClFlags & (ErasedMask|DirtyMask)) {
+        if (PREG != FAILCODE) {
+          /* make sure we don't erase the clause we are jumping too */
+          if (!(lcl->ClFlags & InUseMask)) {
+            lcl->ClFlags |= InUseMask;
+            TRAIL_CLREF(lcl);
+          }
+        }
+        if (cl->ClFlags & ErasedMask) {
+          saveregs();
+          Yap_ErLogUpdIndex(cl);
+          setregs();
+        } else {
+          saveregs();
+          Yap_CleanUpIndex(cl);
+          setregs();
+        }
+        save_pc();
+      }
+    }
+#endif
+#ifdef YAPOR
+    if (SCH_top_shared_cp(B)) {
+      SCH_last_alternative(PREG, B_YREG);
+      restore_args(ap->ArityOfPE);
+#ifdef FROZEN_STACKS
+      S_YREG = (CELL *) PROTECT_FROZEN_B(B_YREG);
+#else
+      S_YREG++;
+#endif /* FROZEN_STACKS */
+      set_cut(S_YREG, B->cp_b);
+    } else
+#endif  /* YAPOR */
+      {
+        pop_yaam_regs();
+        pop_args(ap->ArityOfPE);
+        S_YREG--;
+#ifdef FROZEN_STACKS
+        S_YREG = (CELL *) PROTECT_FROZEN_B(B_YREG);
+#endif /* FROZEN_STACKS */
+        set_cut(S_YREG, B);
+      }
+    SET_BB(B_YREG);
+    ENDCACHE_Y();
+    JMPNext();
+  }
+  ENDBOp();
+
+
+
+  BOp(retry_logical, OtaLl);
+  check_trail(TR);
+  {
+    UInt timestamp;
+    CACHE_Y(B);
+
+#if defined(YAPOR) || defined(THREADS)
+    if (PP != PREG->y_u.OtaLl.d->ClPred) {
+      if (PP) UNLOCKPE(15,PP);
+      PP = PREG->y_u.OtaLl.d->ClPred;
+      PELOCK(15,PP);
+    }
+#endif
+    timestamp = IntegerOfTerm(((CELL *)(B_YREG+1))[PREG->y_u.OtaLl.s]);
+    /* fprintf(stderr,"^ %p/%p %d %d %d--%u\n",PREG,PREG->y_u.OtaLl.d->ClPred,timestamp,PREG->y_u.OtaLl.d->ClPred->TimeStampOfPred,PREG->y_u.OtaLl.d->ClTimeStart,PREG->y_u.OtaLl.d->ClTimeEnd);*/
+    if (!VALID_TIMESTAMP(timestamp, PREG->y_u.OtaLl.d)) {
+      /* jump to next instruction */
+      PREG=PREG->y_u.OtaLl.n;
+      JMPNext();
+    }
+    restore_yaam_regs(PREG->y_u.OtaLl.n);
+    restore_at_least_one_arg(PREG->y_u.OtaLl.s);
+#ifdef THREADS
+    PP = PREG->y_u.OtaLl.d->ClPred;
+#endif
+    PREG = PREG->y_u.OtaLl.d->ClCode;
+#ifdef FROZEN_STACKS
+    S_YREG = (CELL *) PROTECT_FROZEN_B(B_YREG);
+    set_cut(S_YREG, B->cp_b);
+#else
+    set_cut(S_YREG, B_YREG->cp_b);
+#endif /* FROZEN_STACKS */
+    SET_BB(B_YREG);
+    ENDCACHE_Y();
+  }
+  JMPNext();
+  ENDBOp();
+
+  BOp(trust_logical, OtILl);
+  CACHE_Y(B);
+  {
+    LogUpdIndex *cl = PREG->y_u.OtILl.block;
+    PredEntry *ap = cl->ClPred;
+    LogUpdClause *lcl = PREG->y_u.OtILl.d;
+    UInt timestamp = IntegerOfTerm(((CELL *)(B_YREG+1))[ap->ArityOfPE]);
+
+    /* fprintf(stderr,"- %p/%p %d %d %p\n",PREG,ap,timestamp,ap->TimeStampOfPred,PREG->y_u.OtILl.d->ClCode);*/
+#if defined(YAPOR) || defined(THREADS)
+    if (PP != ap) {
+      if (PP) UNLOCKPE(16,PP);
+      PP = ap;
+      PELOCK(16,PP);
+    }
+#endif
+    if (!VALID_TIMESTAMP(timestamp, lcl)) {
+      /* jump to next alternative */
+      PREG = FAILCODE;
+    } else {
+      PREG = lcl->ClCode;
+    }
+    /* HEY, leave indexing block alone!! */
+    /* check if we are the ones using this code */
+#if MULTIPLE_STACKS
+    DEC_CLREF_COUNT(cl);
+    /* clear the entry from the trail */
+    B->cp_tr--;
+    TR = B->cp_tr;
+    /* actually get rid of the code */
+    if (cl->ClRefCount == 0 && (cl->ClFlags & (ErasedMask|DirtyMask))) {
+      if (PREG != FAILCODE) {
+        if (lcl->ClRefCount == 1) {
+          /* make sure the clause isn't destroyed */
+          /* always add an extra reference */
+          INC_CLREF_COUNT(lcl);
+          TRAIL_CLREF(lcl);
+          B->cp_tr = TR;
+        }
+      }
+      if (cl->ClFlags & ErasedMask) {
+        saveregs();
+        Yap_ErLogUpdIndex(cl);
+        setregs();
+      } else {
+        saveregs();
+        Yap_CleanUpIndex(cl);
+        setregs();
+      }
+      save_pc();
+    }
+#else
+    if (TrailTerm(B->cp_tr-1) == CLREF_TO_TRENTRY(cl) &&
+        B->cp_tr != B->cp_b->cp_tr) {
+      cl->ClFlags &= ~InUseMask;
+      B->cp_tr--;
+#if FROZEN_STACKS
+      if (B->cp_tr > TR_FZ)
+#endif
+        {
+          TR = B->cp_tr;
+        }
+      /* next, recover space for the indexing code if it was erased */
+      if (cl->ClFlags & (ErasedMask|DirtyMask)) {
+        if (PREG != FAILCODE) {
+          /* make sure we don't erase the clause we are jumping too */
+          if (!(lcl->ClFlags & InUseMask)) {
+            lcl->ClFlags |= InUseMask;
+            TRAIL_CLREF(lcl);
+            B->cp_tr = TR;
+          }
+        }
+        if (cl->ClFlags & ErasedMask) {
+          saveregs();
+          Yap_ErLogUpdIndex(cl);
+          setregs();
+        } else {
+          saveregs();
+          Yap_CleanUpIndex(cl);
+          setregs();
+        }
+      }
+    }
+#endif
+#ifdef YAPOR
+    if (SCH_top_shared_cp(B)) {
+      SCH_last_alternative(PREG, B_YREG);
+      restore_args(ap->ArityOfPE);
+#ifdef FROZEN_STACKS
+      S_YREG = (CELL *) PROTECT_FROZEN_B(B_YREG);
+#else
+      S_YREG++;
+#endif /* FROZEN_STACKS */
+      set_cut(S_YREG, B->cp_b);
+    } else
+#endif  /* YAPOR */
+      {
+        pop_yaam_regs();
+        pop_args(ap->ArityOfPE);
+        S_YREG--;
+#ifdef FROZEN_STACKS
+        S_YREG = (CELL *) PROTECT_FROZEN_B(B_YREG);
+#endif /* FROZEN_STACKS */
+        set_cut(S_YREG, B);
+      }
+    SET_BB(B_YREG);
+    ENDCACHE_Y();
+#if defined(YAPOR) || defined(THREADS)
+    if (PREG == FAILCODE) {
+      UNLOCKPE(26,PP);
+      PP = NULL;
+    }
+#endif
+    JMPNext();
+  }
+  ENDBOp();
+
+
+
+  /*****************************************************************
+   *        enter a logical semantics dynamic predicate             *
+   *****************************************************************/
+
+  /* only meaningful with THREADS on! */
+  /* lock logical updates predicate.  */
+  Op(lock_lu, p);
+#if PARALLEL_YAP
+  if (PP) {
+    GONext();
+  }
+  PP = PREG->y_u.p.p;
+  PELOCK(3, PP);
+#endif
+  PREG = NEXTOP(PREG, p);
+  GONext();
+  ENDOp();
+
+  /* only meaningful with THREADS on! */
+  /* lock logical updates predicate.  */
+  Op(unlock_lu, e);
+#if defined(YAPOR) || defined(THREADS)
+  if (PP) {
+    UNLOCKPE(1,PP);
+    PP = NULL;
+  }
+#endif
+  PREG = NEXTOP(PREG, e);
+  GONext();
+  ENDOp();
+
+
+  /* enter logical pred               */
+  BOp(alloc_for_logical_pred, L);
+  check_trail(TR);
+  /* say that an environment is using this clause */
+  /* we have our own copy for the clause */
+#if MULTIPLE_STACKS
+  {
+    LogUpdClause *cl = PREG->y_u.L.ClBase;
+#if PARALLEL_YAP
+    PredEntry *ap = cl->ClPred;
+#endif
+
+    /* always add an extra reference */
+    INC_CLREF_COUNT(cl);
+    TRAIL_CLREF(cl);
+    UNLOCKPE(2,ap);
+    PP = NULL;
+  }
+#else
+  {
+    LogUpdClause *cl = (LogUpdClause *)PREG->y_u.L.ClBase;
+    if (!(cl->ClFlags & InUseMask)) {
+      cl->ClFlags |= InUseMask;
+      TRAIL_CLREF(cl);
+    }
+  }
+#endif
+  PREG = NEXTOP(PREG, L);
+  JMPNext();
+  ENDBOp();
+
+  /* copy database term               */
+  BOp(copy_idb_term, e);
+  {
+    LogUpdClause *cl = ClauseCodeToLogUpdClause(PREG);
+    Term t;
+
+    SET_ASP(YREG, E_CB*sizeof(CELL));
+    saveregs();
+    while ((t = Yap_FetchTermFromDB(cl->lusl.ClSource)) == 0L) {
+      if (PP) UNLOCKPE(3,PP);
+#if defined(YAPOR) || defined(THREADS)
+      PP = NULL;
+#endif
+      if (LOCAL_Error_TYPE == RESOURCE_ERROR_ATTRIBUTED_VARIABLES) {
+	LOCAL_Error_TYPE = YAP_NO_ERROR;
+	if (!Yap_growglobal(NULL)) {
+	  Yap_NilError(RESOURCE_ERROR_ATTRIBUTED_VARIABLES, LOCAL_ErrorMessage);
+	  FAIL();
+	}
+      } else {
+	LOCAL_Error_TYPE = YAP_NO_ERROR;
+	if (!Yap_gc(3, ENV, CP)) {
+	  Yap_NilError(RESOURCE_ERROR_STACK, LOCAL_ErrorMessage);
+	  FAIL();
+	}
+      }
+#if defined(YAPOR) || defined(THREADS)
+      PELOCK(5,ClauseCodeToLogUpdClause(PREG)->ClPred);
+      PP = ClauseCodeToLogUpdClause(PREG)->ClPred;
+#endif
+    }
+    if (!Yap_IUnify(ARG2, t)) {
+      setregs();
+#if defined(YAPOR) || defined(THREADS)
+      if (PP) UNLOCKPE(6,PP);
+      PP = NULL;
+#endif
+      FAIL();
+    }
+    if (!Yap_IUnify(ARG3, MkDBRefTerm((DBRef)cl))) {
+      setregs();
+#if defined(YAPOR) || defined(THREADS)
+      if (PP) UNLOCKPE(5,PP);
+      PP = NULL;
+#endif
+      FAIL();
+    }
+    setregs();
+
+#if MULTIPLE_STACKS
+    /* always add an extra reference */
+    INC_CLREF_COUNT(cl);
+    TRAIL_CLREF(cl);
+    if (PP) UNLOCKPE(7,PP);
+    PP = NULL;
+#else
+    if (!(cl->ClFlags & InUseMask)) {
+      /* Clause *cl = (Clause *)PREG->y_u.EC.ClBase;
+
+	 PREG->y_u.EC.ClTrail = TR-(tr_fr_ptr)LOCAL_TrailBase;
+	 PREG->y_u.EC.ClENV = LCL0-YREG;*/
+      cl->ClFlags |= InUseMask;
+      TRAIL_CLREF(cl);
+    }
+#endif
+  }
+  PREG = CPREG;
+  YREG = ENV;
+#ifdef DEPTH_LIMIT
+  DEPTH = YREG[E_DEPTH];
+#endif
+  JMPNext();
+  ENDBOp();
+
+
+  /* unify with database term               */
+  BOp(unify_idb_term, e);
+  {
+    LogUpdClause *cl = ClauseCodeToLogUpdClause(PREG);
+
+    saveregs();
+    if (!Yap_IUnify(ARG2, cl->lusl.ClSource->Entry)) {
+      setregs();
+      UNLOCKPE(8,PP);
+#if defined(YAPOR) || defined(THREADS)
+      PP = NULL;
+#endif
+      FAIL();
+    }
+    if (!Yap_IUnify(ARG3, MkDBRefTerm((DBRef)cl))) {
+      setregs();
+      UNLOCKPE(9,PP);
+#if defined(YAPOR) || defined(THREADS)
+      PP = NULL;
+#endif
+      FAIL();
+    }
+    setregs();
+
+    /* say that an environment is using this clause */
+    /* we have our own copy for the clause */
+#if MULTIPLE_STACKS
+    /* always add an extra reference */
+    INC_CLREF_COUNT(cl);
+    TRAIL_CLREF(cl);
+    UNLOCKPE(10,PP);
+    PP = NULL;
+#else
+    if (!(cl->ClFlags & InUseMask)) {
+      /* Clause *cl = (Clause *)PREG->y_u.EC.ClBase;
+
+	 PREG->y_u.EC.ClTrail = TR-(tr_fr_ptr)LOCAL_TrailBase;
+	 PREG->y_u.EC.ClENV = LCL0-YREG;*/
+      cl->ClFlags |= InUseMask;
+      TRAIL_CLREF(cl);
+    }
+#endif
+  }
+  PREG = CPREG;
+  YREG = ENV;
+#ifdef DEPTH_LIMIT
+  DEPTH = YREG[E_DEPTH];
+#endif
+  JMPNext();
+  ENDBOp();
--- a/C/mavar.c
+++ b/C/mavar.c
@ -15,20 +15,54 @@
 *									 *
 *************************************************************************/

+
+/** 
+
+@file mavar.c
+
+@defgroup Term_Modification Term Modification
+@ingroup builtins
+
+
+It is sometimes useful to change the value of instantiated
+variables. Although, this is against the spirit of logic programming, it
+is sometimes useful. As in other Prolog systems, YAP has
+several primitives that allow updating Prolog terms. Note that these
+primitives are also backtrackable.
+
+The setarg/3 primitive allows updating any argument of a Prolog
+compound terms. The _mutable_ family of predicates provides
+<em>mutable variables</em>. They should be used instead of setarg/3,
+as they allow the encapsulation of accesses to updatable
+variables. Their implementation can also be more efficient for long
+deterministic computations.
+
+@{
+ 
+*/
+
+
 #include "Yap.h"

 #ifdef MULTI_ASSIGNMENT_VARIABLES

 #include "Yatom.h"
 #include "YapHeap.h"
-#include "eval.h"
+#include "YapEval.h"

-STD_PROTO(static Int p_setarg, ( USES_REGS1 ));
-STD_PROTO(static Int p_create_mutable, ( USES_REGS1 ));
-STD_PROTO(static Int p_get_mutable, ( USES_REGS1 ));
-STD_PROTO(static Int p_update_mutable, ( USES_REGS1 ));
-STD_PROTO(static Int p_is_mutable, ( USES_REGS1 ));
+static Int p_setarg( USES_REGS1 );
+static Int p_create_mutable( USES_REGS1 );
+static Int p_get_mutable( USES_REGS1 );
+static Int p_update_mutable( USES_REGS1 );
+static Int p_is_mutable( USES_REGS1 );

+/** @pred  setarg(+ _I_,+ _S_,? _T_) 
+
+
+Set the value of the  _I_th argument of term  _S_ to term  _T_. 
+
+ 
+*/
 static Int
 p_setarg( USES_REGS1 )
 {
@ -36,7 +70,7 @@ p_setarg( USES_REGS1 )
  Int i;

  if (IsVarTerm(t3) &&
-      VarOfTerm(t3) > H &&VarOfTerm(t3) < ASP) {
+      VarOfTerm(t3) > HR &&VarOfTerm(t3) < ASP) {
    /* local variable */
    Term tn = MkVarTerm();
    Bind_Local(VarOfTerm(t3), tn);
@ -109,7 +143,7 @@ p_setarg( USES_REGS1 )

 */

-/* create and initialise a new timed var. The problem is: how to set
+/* create and initialize a new timed var. The problem is: how to set
   the clock?

   If I give it the current value of B->TR, we may have trouble if no
@ -124,17 +158,17 @@ NewTimedVar(CELL val USES_REGS)
  Term out;
  timed_var *tv;
  if (IsVarTerm(val) &&
-      VarOfTerm(val) > H) {
+      VarOfTerm(val) > HR) {
    Term nval = MkVarTerm();
    Bind_Local(VarOfTerm(val), nval);
    val = nval;
  }
-  out = AbsAppl(H);
-  *H++ = (CELL)FunctorMutable;
-  tv = (timed_var *)H;
+  out = AbsAppl(HR);
+  *HR++ = (CELL)FunctorMutable;
+  tv = (timed_var *)HR;
  RESET_VARIABLE(&(tv->clock));
  tv->value = val;
-  H += sizeof(timed_var)/sizeof(CELL);
+  HR += sizeof(timed_var)/sizeof(CELL);
  return(out);
 }

@ -149,13 +183,13 @@ Term
 Yap_NewEmptyTimedVar( void )
 {
  CACHE_REGS
-  Term out = AbsAppl(H);
+  Term out = AbsAppl(HR);
  timed_var *tv;
-  *H++ = (CELL)FunctorMutable;
-  tv = (timed_var *)H;
+  *HR++ = (CELL)FunctorMutable;
+  tv = (timed_var *)HR;
  RESET_VARIABLE(&(tv->clock));
  RESET_VARIABLE(&(tv->value));
-  H += sizeof(timed_var)/sizeof(CELL);
+  HR += sizeof(timed_var)/sizeof(CELL);
  return(out);
 }

@ -181,7 +215,7 @@ UpdateTimedVar(Term inv, Term new USES_REGS)
  CELL t = tv->value;
  CELL* timestmp = (CELL *)(tv->clock);
  if (IsVarTerm(new) &&
-      VarOfTerm(new) > H) {
+      VarOfTerm(new) > HR) {
    Term nnew = MkVarTerm();
    Bind_Local(VarOfTerm(new), nnew);
    new = nnew;
@ -200,9 +234,9 @@ UpdateTimedVar(Term inv, Term new USES_REGS)
 #endif
      tv->value = new;
  } else {
-    Term nclock = (Term)H;
+    Term nclock = (Term)HR;
    MaBind(&(tv->value), new);
-    *H++ = TermFoundVar;
+    *HR++ = TermFoundVar;
    MaBind(&(tv->clock), nclock);
  }
  return(t);
@ -216,6 +250,13 @@ Yap_UpdateTimedVar(Term inv, Term new)
  return UpdateTimedVar(inv, new PASS_REGS);
 }

+/** @pred  create_mutable(+ _D_,- _M_) 
+
+
+Create new mutable variable  _M_ with initial value  _D_.
+
+ 
+*/
 static Int
 p_create_mutable( USES_REGS1 )
 {
@ -223,6 +264,13 @@ p_create_mutable( USES_REGS1 )
  return(Yap_unify(ARG2,t));
 }

+/** @pred  get_mutable(? _D_,+ _M_) 
+
+
+Unify the current value of mutable term  _M_ with term  _D_.
+
+ 
+*/
 static Int
 p_get_mutable( USES_REGS1 )
 {
@ -243,6 +291,14 @@ p_get_mutable( USES_REGS1 )
  return(Yap_unify(ARG1, t));
 }

+/** @pred  update_mutable(+ _D_,+ _M_) 
+
+
+Set the current value of mutable term  _M_ to term  _D_.
+
+
+
+ */
 static Int
 p_update_mutable( USES_REGS1 )
 {
@ -263,6 +319,13 @@ p_update_mutable( USES_REGS1 )
  return(TRUE);
 }

+/** @pred  is_mutable(? _D_) 
+
+
+Holds if  _D_ is a mutable term.
+
+ 
+*/
 static Int
 p_is_mutable( USES_REGS1 )
 {
@ -285,7 +348,6 @@ void
 Yap_InitMaVarCPreds(void)
 {
 #ifdef MULTI_ASSIGNMENT_VARIABLES
-  /* The most famous contributions of SICStus to the Prolog language */
  Yap_InitCPred("setarg", 3, p_setarg, SafePredFlag);  
  Yap_InitCPred("create_mutable", 2, p_create_mutable, SafePredFlag);  
  Yap_InitCPred("get_mutable", 2, p_get_mutable, SafePredFlag);  
@ -293,3 +355,7 @@ Yap_InitMaVarCPreds(void)
  Yap_InitCPred("is_mutable", 1, p_is_mutable, SafePredFlag);  
 #endif
 }
+
+/**
+@}
+*/
--- a/C/meta_absmi_insts.h
+++ b/C/meta_absmi_insts.h
@ -0,0 +1,300 @@
+
+#ifdef INDENT_CODE
+{
+  {
+    {
+#endif /* INDENT_CODE */
+
+      /* join all the meta-call code into a single procedure with three entry points */
+      {
+	CACHE_Y_AS_ENV(YREG);
+	BEGD(d0);       /* term to be meta-called */
+	Term mod;       /* module to be used */
+	PredEntry *pen;  /* predicate */
+	choiceptr b_ptr;        /* cut point */
+	Functor f;
+
+	/* we are doing the rhs of a , */
+	BOp(p_execute_tail, Osbmp);
+
+	FETCH_Y_FROM_ENV(YREG);
+	/* place to cut to */
+	b_ptr = (choiceptr)ENV_YREG[E_CB];
+	/* original goal */
+	d0 = ENV_YREG[-EnvSizeInCells-1];
+	/* predicate we had used */
+	pen = RepPredProp(AddressOfTerm(ENV_YREG[-EnvSizeInCells-2]));
+	/* current module at the time */
+	mod = ENV_YREG[-EnvSizeInCells-3];
+	/* set YREG */
+	/* Try to preserve the environment */
+	ENV_YREG = (CELL *) (((char *) YREG) + PREG->y_u.Osbmp.s);
+#ifdef FROZEN_STACKS
+	{
+	  choiceptr top_b = PROTECT_FROZEN_B(B);
+#ifdef YAPOR_SBA
+	  if (ENV_YREG > (CELL *) top_b || ENV_YREG < HR) ENV_YREG = (CELL *) top_b;
+#else
+	  if (ENV_YREG > (CELL *) top_b) ENV_YREG = (CELL *) top_b;
+#endif /* YAPOR_SBA */
+	}
+#else
+	if (ENV_YREG > (CELL *) B) {
+	  ENV_YREG = (CELL *) B;
+	}
+#endif /* FROZEN_STACKS */
+	/* now, jump to actual execution */
+	if (pen->ArityOfPE) {
+	  f = pen->FunctorOfPred;
+	  /* reuse environment if we are continuining a comma, ie, (g1,g2,g3) */
+	  /* can only do it deterministically */
+	  /* broken
+	     if (f == FunctorComma && (CELL *)B >= ENV) {
+	     ENV_YREG = ENV;
+	     ENV = (CELL *)ENV[E_E];
+	     }
+	  */
+	  goto execute_pred_f;
+	} else
+	  goto execute_pred_a;
+	ENDBOp();
+
+	/* fetch the module from ARG2 */
+	BOp(p_execute2, Osbpp);
+
+	mod = ARG2;
+	deref_head(mod, execute2_unk0);
+      execute2_nvar0:
+	if (!IsAtomTerm(mod)) {
+	  saveregs();
+	  Yap_Error(TYPE_ERROR_ATOM, mod, "call/2");
+	  setregs();
+	}
+	goto start_execute;
+
+	BEGP(pt1);
+	deref_body(mod, pt1, execute2_unk0, execute2_nvar0);
+	saveregs();
+	Yap_Error(INSTANTIATION_ERROR, mod, "call/2");
+	setregs();
+	ENDP(pt1);
+	/* Oops, second argument was unbound too */
+	FAIL();
+	ENDBOp();
+
+	BOp(p_execute, Osbmp);
+	/* fetch the module from PREG */
+	mod = PREG->y_u.Osbmp.mod;
+      start_execute:
+	/* place to cut to */
+	b_ptr = B;
+	/* we have mod, and ARG1 has the goal, let us roll */
+	/* Try to preserve the environment */
+	ENV_YREG = (CELL *) (((char *) YREG) + PREG->y_u.Osbmp.s);
+#ifdef FROZEN_STACKS
+	{
+	  choiceptr top_b = PROTECT_FROZEN_B(B);
+#ifdef YAPOR_SBA
+	  if (ENV_YREG > (CELL *) top_b || ENV_YREG < HR) ENV_YREG = (CELL *) top_b;
+#else
+	  if (ENV_YREG > (CELL *) top_b) ENV_YREG = (CELL *) top_b;
+#endif /* YAPOR_SBA */
+	}
+#else
+	if (ENV_YREG > (CELL *) B) {
+	  ENV_YREG = (CELL *) B;
+	}
+#endif /* FROZEN_STACKS */
+	d0 = ARG1;
+      restart_execute:
+	deref_head(d0, execute_unk);
+      execute_nvar:
+	if (IsApplTerm(d0)) {
+	  f = FunctorOfTerm(d0);
+	  if (IsExtensionFunctor(f)) {
+	    goto execute_metacall;
+	  }
+	  pen = RepPredProp(PredPropByFunc(f, mod));
+	execute_pred_f:
+	  if (pen->PredFlags & (MetaPredFlag|UndefPredFlag)) {
+	    /* just strip all of M:G */
+	    if (f == FunctorModule) {
+	      Term tmod = ArgOfTerm(1,d0);
+	      /* loop on modules */
+	      if (!IsVarTerm(tmod) && IsAtomTerm(tmod)) {
+		d0 = ArgOfTerm(2,d0);
+		mod = tmod;
+		goto execute_nvar;
+	      }
+	      goto execute_metacall;
+	    }
+	    if (f == FunctorComma) {
+	      Term nmod = mod;
+
+	      /* optimise conj */
+	      SREG = RepAppl(d0);
+	      BEGD(d1);
+	      d1 = SREG[2];
+	      /* create an environment to execute the call */
+	      deref_head(d1, execute_comma_unk);
+	    execute_comma_nvar:
+	      if (IsAtomTerm(d1)) {
+		/* atomic goal is simpler */
+		ENV_YREG[-EnvSizeInCells-2]  = MkIntegerTerm((Int)PredPropByAtom(AtomOfTerm(d1),nmod));
+	      } else if (IsApplTerm(d1)) {
+		Functor f1 = FunctorOfTerm(d1);
+		if (IsExtensionFunctor(f1)) {
+		  goto execute_metacall;
+		} else {
+		  /* check for modules when looking up */
+		  if (f1 == FunctorModule) {
+		    Term tmod = ArgOfTerm(1,d1);
+		    /* loop on modules */
+		    if (!IsVarTerm(tmod) && IsAtomTerm(tmod)) {
+		      d1 = ArgOfTerm(2,d1);
+		      nmod = tmod;
+		      goto execute_comma_nvar;
+		    }
+		    goto execute_metacall;
+		  }
+		  ENV_YREG[-EnvSizeInCells-2]  = MkIntegerTerm((Int)PredPropByFunc(f1,nmod));
+		}
+	      } else {
+		goto execute_metacall;
+	      }
+	      ENV_YREG[-EnvSizeInCells-3]  = mod;
+	      /* now, we can create the new environment for the meta-call */
+	      /* notice that we are at a call, so we should ignore CP */
+	      ENV_YREG[E_CP] = (CELL)NEXTOP(PREG,Osbmp);
+	      ENV_YREG[E_CB] = (CELL)b_ptr;
+	      ENV_YREG[E_E]  = (CELL)ENV;
+#ifdef DEPTH_LIMIT
+	      ENV_YREG[E_DEPTH] = DEPTH;
+#endif  /* DEPTH_LIMIT */
+	      ENV_YREG[-EnvSizeInCells-1]  = d1;
+	      ENV = ENV_YREG;
+	      ENV_YREG -= EnvSizeInCells+3;
+	      CPREG = NEXTOP(PREG, Osbmp);
+	      PREG = COMMA_CODE;
+	      /* for profiler */
+	      save_pc();
+	      d0 = SREG[1];
+	      goto restart_execute;
+
+	      BEGP(pt1);
+	      deref_body(d1, pt1, execute_comma_unk, execute_comma_nvar);
+	      goto execute_metacall;
+	      ENDP(pt1);
+	      ENDD(d1);
+	    } else if (mod != CurrentModule) {
+	      goto execute_metacall;
+	    }
+	  }
+
+	  /* copy arguments of meta-call to XREGS */
+	  BEGP(pt1);
+	  pt1 = RepAppl(d0);
+	  BEGD(d2);
+	  for (d2 = ArityOfFunctor(f); d2; d2--) {
+#ifdef YAPOR_SBA
+	    BEGD(d1);
+	    d1 = pt1[d2];
+	    if (d1 == 0) {
+	      XREGS[d2] = (CELL)(pt1+d2);
+	    } else {
+	      XREGS[d2] = d1;
+	    }
+#else
+	    XREGS[d2] = pt1[d2];
+#endif
+	  }
+	  ENDD(d2);
+	  ENDP(pt1);
+	  CACHE_A1();
+	} else if (IsAtomTerm(d0)) {
+	  pen = RepPredProp(PredPropByAtom(AtomOfTerm(d0), mod));
+	execute_pred_a:
+	  /* handle extra pruning */
+	  if (pen->FunctorOfPred == (Functor)AtomCut) {
+	    if (b_ptr != B) {
+	      saveregs();
+	      prune(b_ptr PASS_REGS);
+	      setregs();
+	    }
+	  }
+	} else {
+	  goto execute_metacall;
+	}
+
+	/* execute, but test first for interrupts */
+      execute_end:
+	/* code copied from call */
+#ifndef NO_CHECKING
+	check_stack(NoStackPExecute, HR);
+#endif
+      execute_stack_checked:
+	CPREG = NEXTOP(PREG, Osbmp);
+	ALWAYS_LOOKAHEAD(pen->OpcodeOfPred);
+	PREG = pen->CodeOfPred;
+	/* for profiler */
+	save_pc();
+#ifdef DEPTH_LIMIT
+	if (DEPTH <= MkIntTerm(1)) {/* I assume Module==0 is primitives */
+	  if (pen->ModuleOfPred) {
+	    if (DEPTH == MkIntTerm(0)) {
+	      FAIL();
+	    } else {
+	      DEPTH = RESET_DEPTH();
+	    }
+	  }
+	} else if (pen->ModuleOfPred)
+	  DEPTH -= MkIntConstant(2);
+#endif  /* DEPTH_LIMIT */
+#ifdef LOW_LEVEL_TRACER
+	if (Yap_do_low_level_trace)
+	  low_level_trace(enter_pred,pen,XREGS+1);
+#endif  /* LOW_LEVEL_TRACER */
+	WRITEBACK_Y_AS_ENV();
+	/* setup GB */
+	ENV_YREG[E_CB] = (CELL) B;
+#ifdef YAPOR
+	SCH_check_requests();
+#endif  /* YAPOR */
+	CACHE_A1();
+	ALWAYS_GONext();
+	ALWAYS_END_PREFETCH();
+
+	/* meta-call: Prolog to the rescue */
+	BEGP(pt1);
+	deref_body(d0, pt1, execute_unk, execute_nvar);
+      execute_metacall:
+	ARG1 = ARG3 = d0;
+	pen = PredMetaCall;
+	ARG2 = Yap_cp_as_integer(b_ptr);
+	if (mod)
+	  ARG4 = mod;
+	else
+	  ARG4 = TermProlog;
+	goto execute_end;
+	ENDP(pt1);
+
+	/* at this point, we have the arguments all set in the argument registers, pen says who is the current predicate. don't remove. */
+      NoStackPExecute:
+	WRITEBACK_Y_AS_ENV();
+#ifdef SHADOW_S
+	Yap_REGS.S_ = SREG;
+#endif
+	saveregs_and_ycache();
+	d0 = interrupt_pexecute( pen PASS_REGS );
+	setregs_and_ycache();
+#ifdef SHADOW_S
+	SREG = Yap_REGS.S_;
+#endif
+	if (!d0) FAIL();
+	if (d0 == 2) goto execute_stack_checked;
+	goto execute_end;
+	ENDBOp();
+
+	ENDD(d0);
+	ENDCACHE_Y_AS_ENV();
+      }
--- a/C/modules.c
+++ b/C/modules.c
@ -14,22 +14,63 @@
 * comments:	module support						 *
 *									 *
 *************************************************************************/
-#ifdef SCCS
-static char     SccsId[] = "%W% %G%";
+
+
+#ifdef SCCSLookupSystemModule
+static char SccsId[] = "%W% %G%";
 #endif

 #include "Yap.h"
-#include "Yatom.h"
 #include "YapHeap.h"
+#include "Yatom.h"

-STATIC_PROTO(Int p_current_module, ( USES_REGS1 ));
-STATIC_PROTO(Int p_current_module1, ( USES_REGS1 ));
+static Int current_module(USES_REGS1);
+static Int current_module1(USES_REGS1);
+static ModEntry *LookupModule(Term a);
+static ModEntry *LookupSystemModule(Term a);
+static ModEntry *GetModuleEntry(Atom at USES_REGS);
+static ModEntry *FetchModuleEntry(Atom at);

+/**
+ * initialize module data-structure
+ *
+ * @param to parent module (CurrentModule)
+ * @param ae module name.
+ *
+ * @return a new module structure
+ */ /**               */
+static ModEntry *initMod(AtomEntry *toname, AtomEntry *ae) {
+  CACHE_REGS
+  ModEntry *n, *parent;

-inline static ModEntry *
-FetchModuleEntry(Atom at)
-/* get predicate entry for ap/arity; create it if neccessary.              */
-{
+  if (toname == NULL)
+    parent = NULL;
+  else {
+    parent = FetchModuleEntry(toname);
+  }
+  n = (ModEntry *)Yap_AllocAtomSpace(sizeof(*n));
+  INIT_RWLOCK(n->ModRWLock);
+  n->KindOfPE = ModProperty;
+  n->PredForME = NULL;
+  n->OpForME = NULL;
+  n->NextME = CurrentModules;
+  CurrentModules = n;
+  n->AtomOfME = ae;
+  n->NextOfPE = NULL;
+  n->OwnerFile = Yap_ConsultingFile(PASS_REGS1);
+  AddPropToAtom(ae, (PropEntry *)n);
+  Yap_setModuleFlags(n, parent);
+  return n;
+}
+
+/**
+ * get predicate entry for ap/arity; create it if neccessary
+ *
+ * @param[in] at
+ *
+ * @return module descriptorxs
+ */
+static ModEntry *GetModuleEntry(Atom at USES_REGS) {
  Prop p0;
  AtomEntry *ae = RepAtom(at);

@ -37,8 +78,28 @@ FetchModuleEntry(Atom at)
  p0 = ae->PropsOfAE;
  while (p0) {
    ModEntry *me = RepModProp(p0);
-    if ( me->KindOfPE == ModProperty
-	 ) {
+    if (me->KindOfPE == ModProperty) {
+      READ_UNLOCK(ae->ARWLock);
+      return me;
+    }
+    p0 = me->NextOfPE;
+  }
+  READ_UNLOCK(ae->ARWLock);
+
+  return initMod(
+      (CurrentModule == PROLOG_MODULE ? NULL : AtomOfTerm(CurrentModule)), at);
+}
+
+/** get  entry for ap/arity; assumes one is there.              */
+static ModEntry *FetchModuleEntry(Atom at) {
+  Prop p0;
+  AtomEntry *ae = RepAtom(at);
+
+  READ_LOCK(ae->ARWLock);
+  p0 = ae->PropsOfAE;
+  while (p0) {
+    ModEntry *me = RepModProp(p0);
+    if (me->KindOfPE == ModProperty) {
      READ_UNLOCK(ae->ARWLock);
      return me;
    }
@ -48,92 +109,117 @@ FetchModuleEntry(Atom at)
  return NULL;
 }

-inline static ModEntry *
-GetModuleEntry(Atom at)
-/* get predicate entry for ap/arity; create it if neccessary.              */
-{
-  Prop p0;
-  AtomEntry *ae = RepAtom(at);
-  ModEntry *new;
-
-  p0 = ae->PropsOfAE;
-  while (p0) {
-    ModEntry *me = RepModProp(p0);
-    if ( me->KindOfPE == ModProperty
-	 ) {
-      return me;
-    }
-    p0 = me->NextOfPE;
+Term Yap_getUnknownModule(ModEntry *m) {
+  if (m && m->flags & UNKNOWN_ERROR) {
+    return TermError;
+  } else if (m && m->flags & UNKNOWN_WARNING) {
+    return TermWarning;
+  } else if (m && m->flags & UNKNOWN_FAST_FAIL) {
+    return TermFastFail;
+  } else {
+    return TermFail;
  }
-  new = (ModEntry *) Yap_AllocAtomSpace(sizeof(*new));
-  INIT_RWLOCK(new->ModRWLock);
-  new->KindOfPE = ModProperty;
-  new->PredForME = NULL;
-  new->NextME = CurrentModules;
-  CurrentModules = new;
-  new->AtomOfME = ae;
-  AddPropToAtom(ae, (PropEntry *)new);
-  return new;
 }

+bool Yap_getUnknown(Term mod) {
+  ModEntry *m = LookupModule(mod);
+  return Yap_getUnknownModule(m);
+}

-#define ByteAdr(X) ((char *) &(X))
-Term 
-Yap_Module_Name(PredEntry *ap)
-{
+bool Yap_CharacterEscapes(Term mt) {
  CACHE_REGS
-  Term mod;
+  if (mt == PROLOG_MODULE)
+    mt = TermProlog;
+  return GetModuleEntry(AtomOfTerm(mt) PASS_REGS)->flags & M_CHARESCAPE;
+}
+
+#define ByteAdr(X) ((char *)&(X))
+Term Yap_Module_Name(PredEntry *ap) {
+  CACHE_REGS
+
+  if (!ap)
+    return TermUser;
  if (!ap->ModuleOfPred)
-    /* If the system predicate is a metacall I should return the
+    /* If the system predicate is a meta-call I should return the
       module for the metacall, which I will suppose has to be
       reachable from the current module anyway.

       So I will return the current module in case the system
       predicate is a meta-call. Otherwise it will still work.
    */
-    mod =  CurrentModule;
+    return TermProlog;
  else {
-    mod = ap->ModuleOfPred;
+    return ap->ModuleOfPred;
  }
-  if (mod) return mod;
-  return TermProlog;
 }

-static ModEntry * 
-LookupModule(Term a)
-{
+static ModEntry *LookupSystemModule(Term a) {
+  CACHE_REGS
  Atom at;
  ModEntry *me;

  /* prolog module */
-  if (a == 0)
-    return GetModuleEntry(AtomOfTerm(TermProlog));
+  if (a == 0) {
+    a = TermProlog;
+  }
  at = AtomOfTerm(a);
-  me = GetModuleEntry(at);
+  me = GetModuleEntry(at PASS_REGS);
+  if (!me)
+    return NULL;
+  me->flags |= M_SYSTEM;
+  me->OwnerFile = Yap_ConsultingFile(PASS_REGS1);
  return me;
 }

-Term
-Yap_Module(Term tmod)
-{
+static ModEntry *LookupModule(Term a) {
+  CACHE_REGS
+  Atom at;
+  ModEntry *me;
+
+  /* prolog module */
+  if (a == 0) {
+    return GetModuleEntry(AtomProlog PASS_REGS);
+  }
+  at = AtomOfTerm(a);
+  me = GetModuleEntry(at PASS_REGS);
+  return me;
+}
+
+bool Yap_isSystemModule(Term a) {
+  ModEntry *me = LookupModule(a);
+  return me != NULL && me->flags & M_SYSTEM;
+}
+
+Term Yap_Module(Term tmod) {
  LookupModule(tmod);
  return tmod;
 }

-struct pred_entry *
-Yap_ModulePred(Term mod)
-{
+ModEntry *Yap_GetModuleEntry(Term mod) {
+  ModEntry *me;
+
+  if (!(me = LookupModule(mod)))
+    return NULL;
+  return me;
+}
+
+Term Yap_GetModuleFromEntry(ModEntry *me) {
+  return MkAtomTerm(me->AtomOfME);
+  ;
+}
+
+struct pred_entry *Yap_ModulePred(Term mod) {
  ModEntry *me;
  if (!(me = LookupModule(mod)))
    return NULL;
  return me->PredForME;
 }

-void
-Yap_NewModulePred(Term mod, struct pred_entry *ap)
-{
+void Yap_NewModulePred(Term mod, struct pred_entry *ap) {
  ModEntry *me;

+  if (mod == 0)
+    mod = TermProlog;
  if (!(me = LookupModule(mod)))
    return;
  WRITE_LOCK(me->ModRWLock);
@ -142,13 +228,12 @@ Yap_NewModulePred(Term mod, struct pred_entry *ap)
  WRITE_UNLOCK(me->ModRWLock);
 }

-static Int 
-p_current_module( USES_REGS1 )
-{				/* $current_module(Old,New)		 */
-  Term            t;
-	
+static Int
+    current_module(USES_REGS1) { /* $current_module(Old,N)		 */
+  Term t;
+
  if (CurrentModule) {
-    if(!Yap_unify_constant(ARG1, CurrentModule))
+    if (!Yap_unify_constant(ARG1, CurrentModule))
      return FALSE;
  } else {
    if (!Yap_unify_constant(ARG1, TermProlog))
@ -160,172 +245,408 @@ p_current_module( USES_REGS1 )
  if (t == TermProlog) {
    CurrentModule = PROLOG_MODULE;
  } else {
+    // make it very clear that t inherits from cm.
+    LookupModule(t);
    CurrentModule = t;
-    LookupModule(CurrentModule);
  }
+  LOCAL_SourceModule = CurrentModule;
  return TRUE;
 }

-static Int
-p_current_module1( USES_REGS1 )
-{				/* $current_module(Old)		 */
+static Int change_module(USES_REGS1) { /* $change_module(N)		 */
+  Term mod = Deref(ARG1);
+  LookupModule(mod);
+  CurrentModule = mod;
+  LOCAL_SourceModule = mod;
+  return TRUE;
+}
+
+static Int current_module1(USES_REGS1) { /* $current_module(Old)
+                                          */
  if (CurrentModule)
    return Yap_unify_constant(ARG1, CurrentModule);
  return Yap_unify_constant(ARG1, TermProlog);
 }

-static Int
-p_change_module( USES_REGS1 )
-{				/* $change_module(New)		 */
-  Term mod = Deref(ARG1);
-  LookupModule(mod);
-  CurrentModule = mod;
-  return TRUE;
-}
-
-static Int 
-cont_current_module( USES_REGS1 )
-{
-  ModEntry  *imod = (ModEntry *)IntegerOfTerm(EXTRA_CBACK_ARG(1,1)), *next;
+static Int cont_current_module(USES_REGS1) {
+  ModEntry *imod = AddressOfTerm(EXTRA_CBACK_ARG(1, 1)), *next;
  Term t = MkAtomTerm(imod->AtomOfME);
  next = imod->NextME;

  /* ARG1 is unbound */
-  Yap_unify(ARG1,t);
+  Yap_unify(ARG1, t);
  if (!next)
    cut_succeed();
-  EXTRA_CBACK_ARG(1,1) = MkIntegerTerm((Int)next);
+  EXTRA_CBACK_ARG(1, 1) = MkAddressTerm(next);
  return TRUE;
 }

-static Int 
-init_current_module( USES_REGS1 )
-{				/* current_module(?ModuleName)		 */
+static Int init_current_module(
+    USES_REGS1) { /* current_module(?ModuleName)		 */
  Term t = Deref(ARG1);
  if (!IsVarTerm(t)) {
    if (!IsAtomTerm(t)) {
-      Yap_Error(TYPE_ERROR_ATOM,t,"module name must be an atom");
+      Yap_Error(TYPE_ERROR_ATOM, t, "module name must be an atom");
      return FALSE;
    }
    if (FetchModuleEntry(AtomOfTerm(t)) != NULL)
      cut_succeed();
    cut_fail();
  }
-  EXTRA_CBACK_ARG(1,1) = MkIntegerTerm((Int)CurrentModules);
-  return cont_current_module( PASS_REGS1 );
+  EXTRA_CBACK_ARG(1, 1) = MkIntegerTerm((Int)CurrentModules);
+  return cont_current_module(PASS_REGS1);
 }

-static Int
-p_strip_module( USES_REGS1 )
-{
-  Term t1 = Deref(ARG1), t2, tmod = CurrentModule;
+static Int cont_ground_module(USES_REGS1) {
+  ModEntry *imod = AddressOfTerm(EXTRA_CBACK_ARG(3, 1)), *next;
+  Term t2 = MkAtomTerm(imod->AtomOfME);
+  next = imod->NextME;
+
+  /* ARG2 is unbound */
+  if (!next)
+    cut_succeed();
+  EXTRA_CBACK_ARG(3, 1) = MkAddressTerm(next);
+  return Yap_unify(ARG2, t2);
+}
+
+static Int init_ground_module(USES_REGS1) {
+  /* current_module(?ModuleName)		 */
+  Term t1 = Deref(ARG1), tmod = CurrentModule, t3;
  if (tmod == PROLOG_MODULE) {
    tmod = TermProlog;
  }
-  if (IsVarTerm(t1) ||
-      !IsApplTerm(t1) ||
-      FunctorOfTerm(t1) != FunctorModule ||
-      IsVarTerm(t2 = ArgOfTerm(1,t1)) ||
-      !IsAtomTerm(t2)) {
-    return Yap_unify(ARG3, t1) &&
-      Yap_unify(ARG2, tmod);
+  t3 = Yap_YapStripModule(t1, &tmod);
+  if (!t3) {
+    Yap_Error(TYPE_ERROR_CALLABLE, t3, "trying to obtain module");
+    return FALSE;
  }
-  do {
-    tmod = t2;
-    t1 = ArgOfTerm(2,t1);
-  } while (!IsVarTerm(t1) &&
-	   IsApplTerm(t1) &&
-	   FunctorOfTerm(t1) == FunctorModule &&
-	   !IsVarTerm(t2 = ArgOfTerm(1,t1)) &&
-	   IsAtomTerm(t2));
-  return Yap_unify(ARG3, t1) &&
-    Yap_unify(ARG2, tmod);      
+  if (!IsVarTerm(tmod)) {
+    if (!IsAtomTerm(tmod)) {
+      Yap_Error(TYPE_ERROR_ATOM, tmod, "module name must be an atom");
+      cut_fail();
+    }
+    if (FetchModuleEntry(AtomOfTerm(tmod)) != NULL && Yap_unify(tmod, ARG2) &&
+        Yap_unify(t3, ARG3)) {
+      cut_succeed();
+    }
+    cut_fail();
+  }
+  if (!Yap_unify(ARG2, tmod) || !Yap_unify(ARG3, t3)) {
+    cut_fail();
+  }
+  // make sure we keep the binding
+  B->cp_tr = TR;
+  B->cp_h = HR;
+  EXTRA_CBACK_ARG(3, 1) = MkAddressTerm(CurrentModules);
+  return cont_ground_module(PASS_REGS1);
 }

-static Int
-p_context_module( USES_REGS1 )
-{
-  yamop *parentcp = P;
-  CELL *yenv;
-  PredEntry *ap = EnvPreg(parentcp);
-  if (ap->ModuleOfPred &&
-      !(ap->PredFlags & MetaPredFlag))
-    return Yap_unify(ARG1, ap->ModuleOfPred);
-  parentcp = CP;
-  yenv = ENV;
-  do {
-    ap = EnvPreg(parentcp);
-    if (ap->ModuleOfPred &&
-	!(ap->PredFlags & MetaPredFlag))
-      return Yap_unify(ARG1, ap->ModuleOfPred);
-    parentcp = (yamop *)yenv[E_CP];
-    yenv = (CELL *)yenv[E_E];
-  } while(yenv);
-  return Yap_unify(ARG1, CurrentModule);
+/**
+ * @pred system_module( + _Mod_)
+ *
+ * @param module
+ *
+ * @return
+ */
+static Int is_system_module(USES_REGS1) {
+  Term t;
+  if (IsVarTerm(t = Deref(ARG1))) {
+    return false;
+  }
+  if (!IsAtomTerm(t)) {
+    Yap_Error(TYPE_ERROR_ATOM, t, "load_files/2");
+    return false;
+  }
+  return Yap_isSystemModule(t);
 }

-Term
-Yap_StripModule(Term t,  Term *modp)
-{
+static Int new_system_module(USES_REGS1) {
+  ModEntry *me;
+  Term t;
+  if (IsVarTerm(t = Deref(ARG1))) {
+    Yap_Error(INSTANTIATION_ERROR, t, NULL);
+    return false;
+  }
+  if (!IsAtomTerm(t)) {
+    Yap_Error(TYPE_ERROR_ATOM, t, NULL);
+    return false;
+  }
+  if ((me = LookupSystemModule(t)))
+    me->OwnerFile = Yap_ConsultingFile(PASS_REGS1);
+  return me != NULL;
+}
+
+static Int strip_module(USES_REGS1) {
+  Term t1 = Deref(ARG1), tmod = CurrentModule;
+  if (tmod == PROLOG_MODULE) {
+    tmod = TermProlog;
+  }
+  t1 = Yap_StripModule(t1, &tmod);
+  if (!t1) {
+    Yap_Error(TYPE_ERROR_CALLABLE, t1, "trying to obtain module");
+    return FALSE;
+  }
+  return Yap_unify(ARG3, t1) && Yap_unify(ARG2, tmod);
+}
+
+static Int yap_strip_clause(USES_REGS1) {
+  Term t1 = Deref(ARG1), tmod = LOCAL_SourceModule;
+  if (tmod == PROLOG_MODULE) {
+    tmod = TermProlog;
+  }
+  t1 = Yap_StripModule(t1, &tmod);
+  if (IsVarTerm(t1) || IsVarTerm(tmod)) {
+    Yap_Error(INSTANTIATION_ERROR, t1, "trying to obtain module");
+    return false;
+  } else if (IsApplTerm(t1)) {
+    Functor f = FunctorOfTerm(t1);
+    if (IsExtensionFunctor(f)) {
+      Yap_Error(TYPE_ERROR_CALLABLE, t1, "trying to obtain module");
+      return false;
+    }
+    if (f == FunctorAssert || f == FunctorDoubleArrow) {
+      Term thmod = tmod;
+      Term th = ArgOfTerm(1, t1);
+      th = Yap_StripModule(th, &thmod);
+      if (IsVarTerm(th)) {
+        Yap_Error(INSTANTIATION_ERROR, t1, "trying to obtain module");
+        return false;
+      } else if (IsVarTerm(thmod)) {
+        Yap_Error(INSTANTIATION_ERROR, thmod, "trying to obtain module");
+        return false;
+      } else if (IsIntTerm(th) ||
+                 (IsApplTerm(th) && IsExtensionFunctor(FunctorOfTerm(t1)))) {
+        Yap_Error(TYPE_ERROR_CALLABLE, t1, "trying to obtain module");
+        return false;
+      } else if (!IsAtomTerm(thmod)) {
+        Yap_Error(TYPE_ERROR_ATOM, thmod, "trying to obtain module");
+        return false;
+      }
+    }
+
+  } else if (IsIntTerm(t1) || IsIntTerm(tmod)) {
+    Yap_Error(TYPE_ERROR_CALLABLE, t1, "trying to obtain module");
+    return false;
+  }
+  return Yap_unify(ARG3, t1) && Yap_unify(ARG2, tmod);
+}
+
+Term Yap_YapStripModule(Term t, Term *modp) {
  CACHE_REGS
  Term tmod;

-  tmod = CurrentModule;
- restart:
-  if (IsVarTerm(t)) {
-    return 0L;
-  } else if (IsAtomTerm(t) || IsPairTerm(t)) {
-    *modp = tmod;
+  if (modp) {
+    tmod = *modp;
+    if (tmod == PROLOG_MODULE) {
+      *modp = tmod = TermProlog;
+    }
+  } else {
+    tmod = CurrentModule;
+    if (tmod == PROLOG_MODULE) {
+      tmod = TermProlog;
+    }
+  }
+restart:
+  if (IsVarTerm(t) || !IsApplTerm(t)) {
+    if (modp)
+      *modp = tmod;
    return t;
-  } else if (IsApplTerm(t)) {
-    Functor    fun = FunctorOfTerm(t);
+  } else {
+    Functor fun = FunctorOfTerm(t);
    if (fun == FunctorModule) {
-      tmod = ArgOfTerm(1, t);
-      if (IsVarTerm(tmod) ) {
-	return 0L;
-      }
-      if (!IsAtomTerm(tmod) ) {
-	return 0L;
+      Term t1 = ArgOfTerm(1, t);
+      tmod = t1;
+      if (!IsVarTerm(tmod) && !IsAtomTerm(tmod)) {
+        if (modp)
+          *modp = tmod;
+        return t;
      }
      t = ArgOfTerm(2, t);
      goto restart;
    }
-    *modp = tmod;
+    if (modp)
+      *modp = tmod;
    return t;
  }
  return 0L;
 }

-
-
-void 
-Yap_InitModulesC(void)
-{
-  Yap_InitCPred("$current_module", 2, p_current_module, SafePredFlag|SyncPredFlag|HiddenPredFlag);
-  Yap_InitCPred("$current_module", 1, p_current_module1, SafePredFlag|SyncPredFlag|HiddenPredFlag);
-  Yap_InitCPred("$change_module", 1, p_change_module, SafePredFlag|SyncPredFlag|HiddenPredFlag);
-  Yap_InitCPred("strip_module", 3, p_strip_module, SafePredFlag|SyncPredFlag|HiddenPredFlag);
-  Yap_InitCPred("context_module", 1, p_context_module, 0);
-  Yap_InitCPredBack("$all_current_modules", 1, 1, init_current_module, cont_current_module,
-		SafePredFlag|SyncPredFlag|HiddenPredFlag);
+static Int yap_strip_module(USES_REGS1) {
+  Term t1 = Deref(ARG1), tmod = CurrentModule;
+  if (tmod == PROLOG_MODULE) {
+    tmod = TermProlog;
+  }
+  t1 = Yap_YapStripModule(t1, &tmod);
+  if (!t1 || (!IsVarTerm(tmod) && !IsAtomTerm(tmod))) {
+    Yap_Error(TYPE_ERROR_CALLABLE, t1, "trying to obtain module");
+    return FALSE;
+  }
+  return Yap_unify(ARG3, t1) && Yap_unify(ARG2, tmod);
 }

+static Int context_module(USES_REGS1) {
+  yamop *parentcp = P;
+  CELL *yenv;
+  PredEntry *ap = EnvPreg(parentcp);
+  if (ap->ModuleOfPred && !(ap->PredFlags & MetaPredFlag))
+    return Yap_unify(ARG1, ap->ModuleOfPred);
+  parentcp = CP;
+  yenv = ENV;
+  do {
+    ap = EnvPreg(parentcp);
+    if (ap->ModuleOfPred && !(ap->PredFlags & MetaPredFlag))
+      return Yap_unify(ARG1, ap->ModuleOfPred);
+    parentcp = (yamop *)yenv[E_CP];
+    yenv = (CELL *)yenv[E_E];
+  } while (yenv);
+  return Yap_unify(ARG1, CurrentModule);
+}

-void 
-Yap_InitModules(void)
-{
+/**
+ * @pred source_module(-Mod)
+ *
+ * @param Mod is the current text source module.
+ *
+ *  : _Mod_ is the current read-in or source module.
+ */
+static Int source_module(USES_REGS1) {
+  if (LOCAL_SourceModule == PROLOG_MODULE) {
+    return Yap_unify(ARG1, TermProlog);
+  }
+  return Yap_unify(ARG1, LOCAL_SourceModule);
+}
+
+/**
+ * @pred source_module(-Mod)
+ *
+ * @param Mod is the current text source module.
+ *
+ *  : _Mod_ is the current read-in or source module.
+ */
+static Int current_source_module(USES_REGS1) {
+  Term t;
+  if (LOCAL_SourceModule == PROLOG_MODULE) {
+    LOCAL_SourceModule = TermProlog;
+  }
+  if (!Yap_unify(ARG1, LOCAL_SourceModule)) {
+    return false;
+  };
+  if (IsVarTerm(t = Deref(ARG2))) {
+    Yap_Error(INSTANTIATION_ERROR, t, NULL);
+    return false;
+  }
+  if (!IsAtomTerm(t)) {
+    Yap_Error(TYPE_ERROR_ATOM, t, NULL);
+    return false;
+  }
+  LOCAL_SourceModule = CurrentModule = t;
+  return true;
+}
+
+/**
+ * @pred $copy_operators(+Mode, +ModTarget)
+ *
+ * Copy all operators in ModSource to ModTarget
+ *
+ *  : _Mod_ is the current read-in or source module.
+ */
+static Int copy_operators(USES_REGS1) {
+  ModEntry *me = LookupModule(Deref(ARG1));
+  if (!me)
+    return true;
+  ModEntry *she = LookupModule(Deref(ARG2));
+  if (!she)
+    return true;
+  OpEntry *op = me->OpForME;
+  while (op) {
+    if (!Yap_dup_op(op, she)) {
+      return false;
+    }
+    op = op->NextForME;
+  }
+  return true;
+}
+
+Term Yap_StripModule(Term t, Term *modp) {
  CACHE_REGS
-  LookupModule(MkAtomTerm(AtomProlog));
+  Term tmod;
+
+  if (modp)
+    tmod = *modp;
+  else {
+    tmod = CurrentModule;
+    if (tmod == PROLOG_MODULE) {
+      tmod = TermProlog;
+    }
+  }
+restart:
+  if (IsVarTerm(t) || !IsApplTerm(t)) {
+    if (modp)
+      *modp = tmod;
+    return t;
+  } else {
+    Functor fun = FunctorOfTerm(t);
+    if (fun == FunctorModule) {
+      Term t1 = ArgOfTerm(1, t);
+      if (IsVarTerm(t1)) {
+        *modp = tmod;
+        return t;
+      }
+      tmod = t1;
+      if (!IsVarTerm(tmod) && !IsAtomTerm(tmod)) {
+        return 0L;
+      }
+      t = ArgOfTerm(2, t);
+      goto restart;
+    }
+    if (modp)
+      *modp = tmod;
+    return t;
+  }
+  return 0L;
+}
+
+void Yap_InitModulesC(void) {
+  Yap_InitCPred("$current_module", 2, current_module,
+                SafePredFlag | SyncPredFlag);
+  Yap_InitCPred("$current_module", 1, current_module1,
+                SafePredFlag | SyncPredFlag);
+  Yap_InitCPred("$change_module", 1, change_module,
+                SafePredFlag | SyncPredFlag);
+  Yap_InitCPred("strip_module", 3, strip_module, SafePredFlag | SyncPredFlag);
+  Yap_InitCPred("$yap_strip_module", 3, yap_strip_module,
+                SafePredFlag | SyncPredFlag);
+  Yap_InitCPred("source_module", 1, source_module, SafePredFlag | SyncPredFlag);
+  Yap_InitCPred("current_source_module", 2, current_source_module,
+                SafePredFlag | SyncPredFlag);
+  Yap_InitCPred("$yap_strip_clause", 3, yap_strip_clause,
+                SafePredFlag | SyncPredFlag);
+  Yap_InitCPred("context_module", 1, context_module, 0);
+  Yap_InitCPred("$is_system_module", 1, is_system_module, SafePredFlag);
+  Yap_InitCPred("$copy_operators", 2, copy_operators, 0);
+  Yap_InitCPred("new_system_module", 1, new_system_module, SafePredFlag);
+  Yap_InitCPredBack("$all_current_modules", 1, 1, init_current_module,
+                    cont_current_module, SafePredFlag | SyncPredFlag);
+  Yap_InitCPredBack("$ground_module", 3, 1, init_ground_module,
+                    cont_ground_module, SafePredFlag | SyncPredFlag);
+}
+
+void Yap_InitModules(void) {
+  CACHE_REGS
+  CurrentModules = NULL;
+  LookupSystemModule(MkAtomTerm(AtomProlog));
+  LOCAL_SourceModule = MkAtomTerm(AtomProlog);
  LookupModule(USER_MODULE);
  LookupModule(IDB_MODULE);
  LookupModule(ATTRIBUTES_MODULE);
-  LookupModule(CHARSIO_MODULE);
-  LookupModule(TERMS_MODULE);
-  LookupModule(SYSTEM_MODULE);
-  LookupModule(READUTIL_MODULE);
-  LookupModule(HACKS_MODULE);
+  LookupSystemModule(CHARSIO_MODULE);
+  LookupSystemModule(TERMS_MODULE);
+  LookupSystemModule(SYSTEM_MODULE);
+  LookupSystemModule(READUTIL_MODULE);
+  LookupSystemModule(HACKS_MODULE);
  LookupModule(ARG_MODULE);
-  LookupModule(GLOBALS_MODULE);
-  LookupModule(DBLOAD_MODULE);
+  LookupSystemModule(GLOBALS_MODULE);
+  LookupSystemModule(DBLOAD_MODULE);
+  LookupSystemModule(RANGE_MODULE);
  CurrentModule = PROLOG_MODULE;
 }
--- a/C/or_absmi_insts.h
+++ b/C/or_absmi_insts.h
@ -0,0 +1,192 @@
+/************************************************************************       \
+ *   Instructions for implemeting 'or;'                                        *
+\************************************************************************/
+
+#ifdef INDENT_CODE
+{
+  {
+    {
+#endif /* INDENT_CODE */
+
+      BOp(jump, l);
+      PREG = PREG->y_u.l.l;
+      JMPNext();
+      ENDBOp();
+
+      /* This instruction is called when the previous goal
+         was interrupted when waking up goals
+      */
+      BOp(move_back, l);
+      PREG = (yamop *)(((char *)PREG)-(Int)(NEXTOP((yamop *)NULL,Osbpp)));
+      JMPNext();
+      ENDBOp();
+
+      /* This instruction is called when the previous goal
+         was interrupted when waking up goals
+      */
+      BOp(skip, l);
+      PREG = NEXTOP(PREG,l);
+      JMPNext();
+      ENDBOp();
+
+      Op(either, Osblp);
+#ifdef LOW_LEVEL_TRACER
+      if (Yap_do_low_level_trace) {
+        low_level_trace(try_or, PREG->y_u.Osblp.p0, NULL);
+      }
+#endif
+#ifdef COROUTINING
+      CACHE_Y_AS_ENV(YREG);
+      check_stack(NoStackEither, HR);
+      ENDCACHE_Y_AS_ENV();
+    either_notest:
+#endif
+      BEGD(d0);
+      /* Try to preserve the environment */
+      d0 = PREG->y_u.Osblp.s;
+      BEGCHO(pt1);
+      pt1 = (choiceptr) ((char *) YREG + (yslot) d0);
+#ifdef FROZEN_STACKS
+      {
+        choiceptr top_b = PROTECT_FROZEN_B(B);
+#ifdef YAPOR_SBA
+        if (pt1 > top_b || pt1 < (choiceptr)HR) pt1 = top_b;
+#else
+        if (pt1 > top_b) pt1 = top_b;
+#endif /* YAPOR_SBA */
+      }
+#else
+      if (pt1 > B) {
+        pt1 = B;
+      }
+#endif /* FROZEN_STACKS */
+      pt1 = (choiceptr)(((CELL *) pt1)-1);
+      *(CELL **) pt1 = YREG;
+      store_yaam_regs_for_either(PREG->y_u.Osblp.l, PREG);
+      SREG = (CELL *) (B = pt1);
+#ifdef YAPOR
+      SCH_set_load(pt1);
+#endif  /* YAPOR */
+      SET_BB(pt1);
+      ENDCHO(pt1);
+      /* skip the current instruction plus the next one */
+      PREG = NEXTOP(NEXTOP(PREG, Osblp),l);
+      GONext();
+      ENDD(d0);
+
+#ifdef COROUTINING
+    NoStackEither:
+      PROCESS_INT(interrupt_either, either_notest);
+#endif
+
+      ENDOp();
+
+      Op(or_else, Osblp);
+      HR = HBREG = PROTECT_FROZEN_H(B);
+      ENV = B->cp_env;
+      B->cp_cp = PREG;
+#ifdef DEPTH_LIMIT
+      DEPTH = B->cp_depth;
+#endif  /* DEPTH_LIMIT */
+      SET_BB(PROTECT_FROZEN_B(B));
+#ifdef YAPOR
+      if (SCH_top_shared_cp(B)) {
+        SCH_new_alternative(PREG, PREG->y_u.Osblp.l);
+      } else
+#endif  /* YAPOR */
+        B->cp_ap = PREG->y_u.Osblp.l;
+      PREG = NEXTOP(PREG, Osblp);
+      YREG = (CELL *) B->cp_a1;
+      GONext();
+      ENDOp();
+
+#ifdef YAPOR
+      Op(or_last, Osblp);
+#else
+      Op(or_last, p);
+#endif  /* YAPOR */
+      BEGCHO(pt0);
+      pt0 = B;
+#ifdef YAPOR
+      if (SCH_top_shared_cp(B)) {
+        HR = HBREG = PROTECT_FROZEN_H(pt0);
+        YREG = (CELL *) pt0->cp_a1;
+        ENV = pt0->cp_env;
+#ifdef DEPTH_LIMIT
+        DEPTH = pt0->cp_depth;
+#endif  /* DEPTH_LIMIT */
+        SCH_new_alternative(PREG, NULL);
+      }
+      else
+#endif  /* YAPOR */
+        {
+          B = pt0->cp_b;
+          HR = PROTECT_FROZEN_H(pt0);
+          YREG = (CELL *) pt0->cp_a1;
+          ENV = pt0->cp_env;
+#ifdef DEPTH_LIMIT
+          DEPTH = pt0->cp_depth;
+#endif  /* DEPTH_LIMIT */
+          HBREG = PROTECT_FROZEN_H(B);
+        }
+#ifdef YAPOR
+      PREG = NEXTOP(PREG, Osblp);
+#else
+      PREG = NEXTOP(PREG, p);
+#endif  /* YAPOR */
+      SET_BB(PROTECT_FROZEN_B(B));
+      GONext();
+      ENDCHO(pt0);
+      ENDOp();
+
+      /************************************************************************\
+       *    Pop operations                                                   *
+\************************************************************************/
+
+      OpRW(pop_n, s);
+      /* write mode might have been called from read mode */
+      BEGD(d0);
+      d0 = PREG->y_u.os.s;
+      SP = (CELL *) (((char *) SP) + d0);
+      ENDD(d0);
+      BEGD(d0);
+      d0 = SP[0];
+      if (d0) {
+        START_PREFETCH(s);
+        SREG = (CELL *) (SP[1]);
+        SP += 2;
+        PREG = NEXTOP(PREG, s);
+        GONext();
+        END_PREFETCH();
+      }
+      else {
+        START_PREFETCH_W(s);
+        SREG = (CELL *) (SP[1]);
+        SP += 2;
+        PREG = NEXTOP(PREG, s);
+        GONextW();
+	END_PREFETCH_W();
+      }
+      ENDD(d0);
+      ENDOpRW();
+
+      OpRW(pop, e);
+      BEGD(d0);
+      d0 = SP[0];
+      SREG = (CELL *) (SP[1]);
+      SP += 2;
+      if (d0) {
+	START_PREFETCH(e);
+	PREG = NEXTOP(PREG, e);
+	GONext();
+	END_PREFETCH();
+      }
+      else {
+	START_PREFETCH_W(e);
+	PREG = NEXTOP(PREG, e);
+	GONextW();
+	END_PREFETCH_W();
+      }
+      ENDD(d0);
+      ENDOpRW();
+
--- a/C/other.c
+++ b/C/other.c
@ -52,52 +52,58 @@ Term
 Yap_MkNewPairTerm(void)
 {
  CACHE_REGS
-  register CELL  *p = H;
+  register CELL  *p = HR;

-  RESET_VARIABLE(H);
-  RESET_VARIABLE(H+1);
-  H+=2;
+  RESET_VARIABLE(HR);
+  RESET_VARIABLE(HR+1);
+  HR+=2;
  return (AbsPair(p));
 }

+/**  compound term constructor, builds a compound term with functor f and n
+ * args.
+ *
+ *
+ * Room for the new term is allocated from the heap: the functor and arguments are copied there.
+ *
+*/
 Term
-Yap_MkApplTerm(Functor f, unsigned int n, register Term *a)	
-     /* build compound term with functor f and n
-      * args a */
-{
+Yap_MkApplTerm(Functor f, arity_t n,  const Term *a)
+ {
  CACHE_REGS
-  CELL           *t = H;
+  CELL           *t = HR;

  if (n == 0)
    return (MkAtomTerm(NameOfFunctor(f)));
  if (f == FunctorList)
    return MkPairTerm(a[0], a[1]);
-  *H++ = (CELL) f;
+  *HR++ = (CELL) f;
  while (n--)
-    *H++ = (CELL) * a++;
+    *HR++ =  * a++;
  return (AbsAppl(t));
 }

 Term 
-Yap_MkNewApplTerm(Functor f, unsigned int n)	
+
+Yap_MkNewApplTerm(Functor f, arity_t n)
     /* build compound term with functor f and n
      * args a */
 {
  CACHE_REGS
-  CELL           *t = H;
+  CELL           *t = HR;

  if (n == 0)
    return (MkAtomTerm(NameOfFunctor(f)));
  if (f == FunctorList) {
-    RESET_VARIABLE(H);
-    RESET_VARIABLE(H+1);
-    H+=2;
+    RESET_VARIABLE(HR);
+    RESET_VARIABLE(HR+1);
+    HR+=2;
    return (AbsPair(t));
  }
-  *H++ = (CELL) f;
+  *HR++ = (CELL) f;
  while (n--) {
-    RESET_VARIABLE(H);
-    H++;
+    RESET_VARIABLE(HR);
+    HR++;
  }
  return (AbsAppl(t));
 }
@ -113,7 +119,7 @@ Yap_Globalise(Term t)
  if (!IsVarTerm(t))
    return t;
  vt = VarOfTerm(t);
-  if (vt <= H && vt > H0)
+  if (vt <= HR && vt > H0)
    return t;
  tn = MkVarTerm();
  Yap_unify(t, tn);
--- a/C/parser.c
+++ b/C/parser.c
--- a/C/pl-yap.c
+++ b/C/pl-yap.c
--- a/C/prim_absmi_insts.h
+++ b/C/prim_absmi_insts.h
--- a/C/qlyr.c
+++ b/C/qlyr.c
--- a/C/qlyw.c
+++ b/C/qlyw.c
--- a/C/range.c
+++ b/C/range.c
@ -0,0 +1,129 @@
+/*************************************************************************
+*									 *
+*	 YAP Prolog 							 *
+*									 *
+*	Yap Prolog was developed at NCCUP - Universidade do Porto	 *
+*									 *
+* Copyright L.Damas, V. Santos Costa and Universidade do Porto 1985--	 *
+*									 *
+**************************************************************************
+*									 *
+* File:		range.c							 *
+* comments:	Arithmetic interval computation				 *
+*									 *
+*									 *
+*									 *
+*************************************************************************/
+#ifdef SCCS
+static char     SccsId[] = "%W% %G%";
+#endif
+
+#include "Yap.h"
+#include "Yatom.h"
+#include "YapHeap.h"
+#include "YapEval.h"
+
+static Int
+p_in_range( USES_REGS1 ) {
+  Term t;
+  double i,j;
+  double d1;
+  double d2;
+  double d3;
+
+  t = Deref(ARG1);
+  if (IsFloatTerm(t)) i = FloatOfTerm(t); else i = IntegerOfTerm(t); 
+  t = Deref(ARG4);
+  if (IsFloatTerm(t)) j = FloatOfTerm(t); else j = IntegerOfTerm(t);
+  d1 = i-j;
+  t = Deref(ARG2);
+  if (IsFloatTerm(t)) i = FloatOfTerm(t); else i = IntegerOfTerm(t); 
+  t = Deref(ARG5);
+  if (IsFloatTerm(t)) j = FloatOfTerm(t); else j = IntegerOfTerm(t);
+  d2 = i-j;
+  t = Deref(ARG3);
+  if (IsFloatTerm(t)) i = FloatOfTerm(t); else i = IntegerOfTerm(t); 
+  t = Deref(ARG6);
+  if (IsFloatTerm(t)) j = FloatOfTerm(t); else j = IntegerOfTerm(t);
+  d3 = i-j;
+  t = Deref(ARG7);
+  if (IsFloatTerm(t)) i = FloatOfTerm(t); else i = IntegerOfTerm(t); 
+  t = Deref(ARG8);
+  if (IsFloatTerm(t)) j = FloatOfTerm(t); else j = IntegerOfTerm(t);
+  
+  return fabs(sqrt(d1*d1 + d2*d2 + d3*d3)-i) <= j; 
+
+}
+
+static Int
+p_in_range2( USES_REGS1 ) {
+  CELL *p1, *p2;
+  Term t;
+  double i,j;
+  double d1;
+  double d2;
+  double d3;
+  UInt arity;
+  p1 = RepAppl(Deref(ARG1));
+  arity = ArityOfFunctor((Functor)*p1);
+  p1 += arity-2;
+  p2 = RepAppl(Deref(ARG2))+(arity-2);;
+
+  t = Deref(p1[0]);
+  if (IsFloatTerm(t)) i = FloatOfTerm(t); else i = IntegerOfTerm(t); 
+  t = Deref(p2[0]);
+  if (IsFloatTerm(t)) j = FloatOfTerm(t); else j = IntegerOfTerm(t);
+  d1 = i-j;
+  t = Deref(p1[1]);
+  if (IsFloatTerm(t)) i = FloatOfTerm(t); else i = IntegerOfTerm(t); 
+  t = Deref(p2[1]);
+  if (IsFloatTerm(t)) j = FloatOfTerm(t); else j = IntegerOfTerm(t);
+  d2 = i-j;
+  t = Deref(p1[2]);
+  if (IsFloatTerm(t)) i = FloatOfTerm(t); else i = IntegerOfTerm(t); 
+  t = Deref(p2[2]);
+  if (IsFloatTerm(t)) j = FloatOfTerm(t); else j = IntegerOfTerm(t);
+  d3 = i-j;
+  t = Deref(ARG3);
+  if (IsFloatTerm(t)) i = FloatOfTerm(t); else i = IntegerOfTerm(t); 
+  t = Deref(ARG4);
+  if (IsFloatTerm(t)) j = FloatOfTerm(t); else j = IntegerOfTerm(t);
+  
+  return fabs(sqrt(d1*d1 + d2*d2 + d3*d3)-i) <= j; 
+}
+
+static Int
+p_euc_dist( USES_REGS1 ) {
+  Term t1 = Deref(ARG1);
+  Term t2 = Deref(ARG2);
+  double d1 = (double)(IntegerOfTerm(ArgOfTerm(1,t1))-IntegerOfTerm(ArgOfTerm(1,t2)));
+  double d2 = (double)(IntegerOfTerm(ArgOfTerm(2,t1))-IntegerOfTerm(ArgOfTerm(2,t2)));
+  double d3 = (double)(IntegerOfTerm(ArgOfTerm(3,t1))-IntegerOfTerm(ArgOfTerm(3,t2)));
+  Int result = (Int)sqrt(d1*d1+d2*d2+d3*d3);
+  return(Yap_unify(ARG3,MkIntegerTerm(result)));
+}
+
+#if DEBUG
+volatile int loop_counter = 0;
+
+static Int
+p_loop( USES_REGS1 ) {
+  while (loop_counter == 0);
+  return(TRUE);
+}
+#endif
+
+void 
+Yap_InitRange(void)
+{
+  CACHE_REGS
+  Term cm = CurrentModule;
+  CurrentModule = RANGE_MODULE;
+  Yap_InitCPred("euclidean_distance", 3, p_euc_dist, SafePredFlag);
+#ifdef DEBUG
+  Yap_InitCPred("loop", 0, p_loop, SafePredFlag);
+#endif
+  Yap_InitCPred("in_range", 8, p_in_range, TestPredFlag|SafePredFlag);
+  Yap_InitCPred("in_range", 4, p_in_range2, TestPredFlag|SafePredFlag);
+  CurrentModule = cm;
+}
--- a/C/realpath.c
+++ b/C/realpath.c
@ -0,0 +1,178 @@
+<html>
+<head>
+  <title>/var/www/vhosts/netmite.com/android/mydroid/bionic/libc/bionic/realpath.c</title>
+</head>
+<body bgcolor="#ffffff" text="#000000">
+<pre>
+<font color="#444444">/*
+ * Copyright (c) 1994
+ *	The Regents of the University of California.  All rights reserved.
+ *
+ * This code is derived from software contributed to Berkeley by
+ * Jan-Simon Pendry.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 3. All advertising materials mentioning features or use of this software
+ *    must display the following acknowledgement:
+ *	This product includes software developed by the University of
+ *	California, Berkeley and its contributors.
+ * 4. Neither the name of the University nor the names of its contributors
+ *    may be used to endorse or promote products derived from this software
+ *    without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ */</font>
+
+<font color="0000ff"><strong>#if defined(LIBC_SCCS) &amp;&amp; !defined(lint)</strong></font>
+<strong>static</strong> <strong>char</strong> <font color="#2040a0">sccsid</font><font color="4444FF">[</font><font color="4444FF">]</font> <font color="4444FF">=</font> <font color="#008000">&quot;@(#)realpath.c	8.1 (Berkeley) 2/16/94&quot;</font><font color="4444FF">;</font>
+<strong>static</strong> <strong>char</strong> <font color="#2040a0">rcsid</font><font color="4444FF">[</font><font color="4444FF">]</font> <font color="4444FF">=</font>
+<font color="#008000">&quot;$FreeBSD: /repoman/r/ncvs/src/lib/libc/stdlib/realpath.c,v 1.6.2.1 2003/08/03 23:47:39 nectar Exp $&quot;</font><font color="4444FF">;</font>
+<font color="0000ff"><strong>#endif<font color="#444444"> /* LIBC_SCCS and not lint */</font></strong></font>
+
+<font color="0000ff"><strong>#include <font color="#008000">&lt;sys/param.h&gt;</font></strong></font>
+<font color="0000ff"><strong>#include <font color="#008000">&lt;sys/stat.h&gt;</font></strong></font>
+
+<font color="0000ff"><strong>#include <font color="#008000">&lt;errno.h&gt;</font></strong></font>
+<font color="0000ff"><strong>#include <font color="#008000">&lt;fcntl.h&gt;</font></strong></font>
+<font color="0000ff"><strong>#include <font color="#008000">&lt;stdlib.h&gt;</font></strong></font>
+<font color="0000ff"><strong>#include <font color="#008000">&lt;string.h&gt;</font></strong></font>
+<font color="0000ff"><strong>#include <font color="#008000">&lt;unistd.h&gt;</font></strong></font>
+
+<font color="#444444">/*
+ * char *realpath(const char *path, char resolved_path[MAXPATHLEN]);
+ *
+ * Find the real name of path, by removing all &quot;.&quot;, &quot;..&quot; and symlink
+ * components.  Returns (resolved) on success, or (NULL) on failure,
+ * in which case the path which caused trouble is left in (resolved).
+ */</font>
+<strong>char</strong> <font color="4444FF">*</font>
+<font color="#2040a0">realpath</font><font color="4444FF">(</font><font color="#2040a0">path</font>, <font color="#2040a0">resolved</font><font color="4444FF">)</font>
+	<strong>const</strong> <strong>char</strong> <font color="4444FF">*</font><font color="#2040a0">path</font><font color="4444FF">;</font>
+	<strong>char</strong> <font color="4444FF">*</font><font color="#2040a0">resolved</font><font color="4444FF">;</font>
+<font color="4444FF"><strong>{</strong></font>
+	<strong>struct</strong> <font color="#2040a0">stat</font> <font color="#2040a0">sb</font><font color="4444FF">;</font>
+	<strong>int</strong> <font color="#2040a0">fd</font>, <font color="#2040a0">n</font>, <font color="#2040a0">rootd</font>, <font color="#2040a0">serrno</font><font color="4444FF">;</font>
+	<strong>char</strong> <font color="4444FF">*</font><font color="#2040a0">p</font>, <font color="4444FF">*</font><font color="#2040a0">q</font>, <font color="#2040a0">wbuf</font><font color="4444FF">[</font><font color="#2040a0">MAXPATHLEN</font><font color="4444FF">]</font><font color="4444FF">;</font>
+      <strong>int</strong> <font color="#2040a0">symlinks</font> <font color="4444FF">=</font> <font color="#FF0000">0</font><font color="4444FF">;</font>
+
+	<font color="#444444">/* Save the starting point. */</font>
+	<strong>if</strong> <font color="4444FF">(</font><font color="4444FF">(</font><font color="#2040a0">fd</font> <font color="4444FF">=</font> <font color="#2040a0">open</font><font color="4444FF">(</font><font color="#008000">&quot;.&quot;</font>, <font color="#2040a0">O_RDONLY</font><font color="4444FF">)</font><font color="4444FF">)</font> <font color="4444FF">&lt;</font> <font color="#FF0000">0</font><font color="4444FF">)</font> <font color="4444FF"><strong>{</strong></font>
+		<font color="4444FF">(</font><strong>void</strong><font color="4444FF">)</font><font color="#2040a0">strcpy</font><font color="4444FF">(</font><font color="#2040a0">resolved</font>, <font color="#008000">&quot;.&quot;</font><font color="4444FF">)</font><font color="4444FF">;</font>
+		<strong>return</strong> <font color="4444FF">(</font><font color="#2040a0">NULL</font><font color="4444FF">)</font><font color="4444FF">;</font>
+	<font color="4444FF"><strong>}</strong></font>
+
+	<font color="#444444">/*
+	 * Find the dirname and basename from the path to be resolved.
+	 * Change directory to the dirname component.
+	 * lstat the basename part.
+	 *     if it is a symlink, read in the value and loop.
+	 *     if it is a directory, then change to that directory.
+	 * get the current directory name and append the basename.
+	 */</font>
+	<font color="4444FF">(</font><strong>void</strong><font color="4444FF">)</font><font color="#2040a0">strncpy</font><font color="4444FF">(</font><font color="#2040a0">resolved</font>, <font color="#2040a0">path</font>, <font color="#2040a0">MAXPATHLEN</font> <font color="4444FF">-</font> <font color="#FF0000">1</font><font color="4444FF">)</font><font color="4444FF">;</font>
+	<font color="#2040a0">resolved</font><font color="4444FF">[</font><font color="#2040a0">MAXPATHLEN</font> <font color="4444FF">-</font> <font color="#FF0000">1</font><font color="4444FF">]</font> <font color="4444FF">=</font> <font color="#008000">'<font color="#77dd77">\0</font>'</font><font color="4444FF">;</font>
+<font color="#2040a0">loop</font><font color="4444FF">:</font>
+	<font color="#2040a0">q</font> <font color="4444FF">=</font> <font color="#2040a0">strrchr</font><font color="4444FF">(</font><font color="#2040a0">resolved</font>, <font color="#008000">'/'</font><font color="4444FF">)</font><font color="4444FF">;</font>
+	<strong>if</strong> <font color="4444FF">(</font><font color="#2040a0">q</font> <font color="4444FF">!</font><font color="4444FF">=</font> <font color="#2040a0">NULL</font><font color="4444FF">)</font> <font color="4444FF"><strong>{</strong></font>
+		<font color="#2040a0">p</font> <font color="4444FF">=</font> <font color="#2040a0">q</font> <font color="4444FF">+</font> <font color="#FF0000">1</font><font color="4444FF">;</font>
+		<strong>if</strong> <font color="4444FF">(</font><font color="#2040a0">q</font> <font color="4444FF">=</font><font color="4444FF">=</font> <font color="#2040a0">resolved</font><font color="4444FF">)</font>
+			<font color="#2040a0">q</font> <font color="4444FF">=</font> <font color="#008000">&quot;/&quot;</font><font color="4444FF">;</font>
+		<strong>else</strong> <font color="4444FF"><strong>{</strong></font>
+			<strong>do</strong> <font color="4444FF"><strong>{</strong></font>
+				<font color="4444FF">-</font><font color="4444FF">-</font><font color="#2040a0">q</font><font color="4444FF">;</font>
+			<font color="4444FF"><strong>}</strong></font> <strong>while</strong> <font color="4444FF">(</font><font color="#2040a0">q</font> <font color="4444FF">&gt;</font> <font color="#2040a0">resolved</font> <font color="4444FF">&amp;</font><font color="4444FF">&amp;</font> <font color="4444FF">*</font><font color="#2040a0">q</font> <font color="4444FF">=</font><font color="4444FF">=</font> <font color="#008000">'/'</font><font color="4444FF">)</font><font color="4444FF">;</font>
+			<font color="#2040a0">q</font><font color="4444FF">[</font><font color="#FF0000">1</font><font color="4444FF">]</font> <font color="4444FF">=</font> <font color="#008000">'<font color="#77dd77">\0</font>'</font><font color="4444FF">;</font>
+			<font color="#2040a0">q</font> <font color="4444FF">=</font> <font color="#2040a0">resolved</font><font color="4444FF">;</font>
+		<font color="4444FF"><strong>}</strong></font>
+		<strong>if</strong> <font color="4444FF">(</font><font color="#2040a0">chdir</font><font color="4444FF">(</font><font color="#2040a0">q</font><font color="4444FF">)</font> <font color="4444FF">&lt;</font> <font color="#FF0000">0</font><font color="4444FF">)</font>
+			<strong>goto</strong> <font color="#2040a0">err1</font><font color="4444FF">;</font>
+	<font color="4444FF"><strong>}</strong></font> <strong>else</strong>
+		<font color="#2040a0">p</font> <font color="4444FF">=</font> <font color="#2040a0">resolved</font><font color="4444FF">;</font>
+
+	<font color="#444444">/* Deal with the last component. */</font>
+	<strong>if</strong> <font color="4444FF">(</font><font color="4444FF">*</font><font color="#2040a0">p</font> <font color="4444FF">!</font><font color="4444FF">=</font> <font color="#008000">'<font color="#77dd77">\0</font>'</font> <font color="4444FF">&amp;</font><font color="4444FF">&amp;</font> <font color="#2040a0">lstat</font><font color="4444FF">(</font><font color="#2040a0">p</font>, <font color="4444FF">&amp;</font><font color="#2040a0">sb</font><font color="4444FF">)</font> <font color="4444FF">=</font><font color="4444FF">=</font> <font color="#FF0000">0</font><font color="4444FF">)</font> <font color="4444FF"><strong>{</strong></font>
+		<strong>if</strong> <font color="4444FF">(</font><font color="#2040a0">S_ISLNK</font><font color="4444FF">(</font><font color="#2040a0">sb</font>.<font color="#2040a0">st_mode</font><font color="4444FF">)</font><font color="4444FF">)</font> <font color="4444FF"><strong>{</strong></font>
+                      <strong>if</strong> <font color="4444FF">(</font><font color="4444FF">+</font><font color="4444FF">+</font><font color="#2040a0">symlinks</font> <font color="4444FF">&gt;</font> <font color="#2040a0">MAXSYMLINKS</font><font color="4444FF">)</font> <font color="4444FF"><strong>{</strong></font>
+                              <font color="#2040a0">errno</font> <font color="4444FF">=</font> <font color="#2040a0">ELOOP</font><font color="4444FF">;</font>
+                              <strong>goto</strong> <font color="#2040a0">err1</font><font color="4444FF">;</font>
+                      <font color="4444FF"><strong>}</strong></font>
+			<font color="#2040a0">n</font> <font color="4444FF">=</font> <font color="#2040a0">readlink</font><font color="4444FF">(</font><font color="#2040a0">p</font>, <font color="#2040a0">resolved</font>, <font color="#2040a0">MAXPATHLEN</font> <font color="4444FF">-</font> <font color="#FF0000">1</font><font color="4444FF">)</font><font color="4444FF">;</font>
+			<strong>if</strong> <font color="4444FF">(</font><font color="#2040a0">n</font> <font color="4444FF">&lt;</font> <font color="#FF0000">0</font><font color="4444FF">)</font>
+				<strong>goto</strong> <font color="#2040a0">err1</font><font color="4444FF">;</font>
+			<font color="#2040a0">resolved</font><font color="4444FF">[</font><font color="#2040a0">n</font><font color="4444FF">]</font> <font color="4444FF">=</font> <font color="#008000">'<font color="#77dd77">\0</font>'</font><font color="4444FF">;</font>
+			<strong>goto</strong> <font color="#2040a0">loop</font><font color="4444FF">;</font>
+		<font color="4444FF"><strong>}</strong></font>
+		<strong>if</strong> <font color="4444FF">(</font><font color="#2040a0">S_ISDIR</font><font color="4444FF">(</font><font color="#2040a0">sb</font>.<font color="#2040a0">st_mode</font><font color="4444FF">)</font><font color="4444FF">)</font> <font color="4444FF"><strong>{</strong></font>
+			<strong>if</strong> <font color="4444FF">(</font><font color="#2040a0">chdir</font><font color="4444FF">(</font><font color="#2040a0">p</font><font color="4444FF">)</font> <font color="4444FF">&lt;</font> <font color="#FF0000">0</font><font color="4444FF">)</font>
+				<strong>goto</strong> <font color="#2040a0">err1</font><font color="4444FF">;</font>
+			<font color="#2040a0">p</font> <font color="4444FF">=</font> <font color="#008000">&quot;&quot;</font><font color="4444FF">;</font>
+		<font color="4444FF"><strong>}</strong></font>
+	<font color="4444FF"><strong>}</strong></font>
+
+	<font color="#444444">/*
+	 * Save the last component name and get the full pathname of
+	 * the current directory.
+	 */</font>
+	<font color="4444FF">(</font><strong>void</strong><font color="4444FF">)</font><font color="#2040a0">strcpy</font><font color="4444FF">(</font><font color="#2040a0">wbuf</font>, <font color="#2040a0">p</font><font color="4444FF">)</font><font color="4444FF">;</font>
+	<strong>if</strong> <font color="4444FF">(</font><font color="#2040a0">getcwd</font><font color="4444FF">(</font><font color="#2040a0">resolved</font>, <font color="#2040a0">MAXPATHLEN</font><font color="4444FF">)</font> <font color="4444FF">=</font><font color="4444FF">=</font> <font color="#FF0000">0</font><font color="4444FF">)</font>
+		<strong>goto</strong> <font color="#2040a0">err1</font><font color="4444FF">;</font>
+
+	<font color="#444444">/*
+	 * Join the two strings together, ensuring that the right thing
+	 * happens if the last component is empty, or the dirname is root.
+	 */</font>
+	<strong>if</strong> <font color="4444FF">(</font><font color="#2040a0">resolved</font><font color="4444FF">[</font><font color="#FF0000">0</font><font color="4444FF">]</font> <font color="4444FF">=</font><font color="4444FF">=</font> <font color="#008000">'/'</font> <font color="4444FF">&amp;</font><font color="4444FF">&amp;</font> <font color="#2040a0">resolved</font><font color="4444FF">[</font><font color="#FF0000">1</font><font color="4444FF">]</font> <font color="4444FF">=</font><font color="4444FF">=</font> <font color="#008000">'<font color="#77dd77">\0</font>'</font><font color="4444FF">)</font>
+		<font color="#2040a0">rootd</font> <font color="4444FF">=</font> <font color="#FF0000">1</font><font color="4444FF">;</font>
+	<strong>else</strong>
+		<font color="#2040a0">rootd</font> <font color="4444FF">=</font> <font color="#FF0000">0</font><font color="4444FF">;</font>
+
+	<strong>if</strong> <font color="4444FF">(</font><font color="4444FF">*</font><font color="#2040a0">wbuf</font><font color="4444FF">)</font> <font color="4444FF"><strong>{</strong></font>
+		<strong>if</strong> <font color="4444FF">(</font><font color="#2040a0">strlen</font><font color="4444FF">(</font><font color="#2040a0">resolved</font><font color="4444FF">)</font> <font color="4444FF">+</font> <font color="#2040a0">strlen</font><font color="4444FF">(</font><font color="#2040a0">wbuf</font><font color="4444FF">)</font> <font color="4444FF">+</font> <font color="4444FF">(</font><font color="#FF0000">1</font><font color="4444FF">-</font><font color="#2040a0">rootd</font><font color="4444FF">)</font> <font color="4444FF">+</font> <font color="#FF0000">1</font> <font color="4444FF">&gt;</font>
+		    <font color="#2040a0">MAXPATHLEN</font><font color="4444FF">)</font> <font color="4444FF"><strong>{</strong></font>
+			<font color="#2040a0">errno</font> <font color="4444FF">=</font> <font color="#2040a0">ENAMETOOLONG</font><font color="4444FF">;</font>
+			<strong>goto</strong> <font color="#2040a0">err1</font><font color="4444FF">;</font>
+		<font color="4444FF"><strong>}</strong></font>
+		<strong>if</strong> <font color="4444FF">(</font><font color="#2040a0">rootd</font> <font color="4444FF">=</font><font color="4444FF">=</font> <font color="#FF0000">0</font><font color="4444FF">)</font>
+			<font color="4444FF">(</font><strong>void</strong><font color="4444FF">)</font><font color="#2040a0">strcat</font><font color="4444FF">(</font><font color="#2040a0">resolved</font>, <font color="#008000">&quot;/&quot;</font><font color="4444FF">)</font><font color="4444FF">;</font>
+		<font color="4444FF">(</font><strong>void</strong><font color="4444FF">)</font><font color="#2040a0">strcat</font><font color="4444FF">(</font><font color="#2040a0">resolved</font>, <font color="#2040a0">wbuf</font><font color="4444FF">)</font><font color="4444FF">;</font>
+	<font color="4444FF"><strong>}</strong></font>
+
+	<font color="#444444">/* Go back to where we came from. */</font>
+	<strong>if</strong> <font color="4444FF">(</font><font color="#2040a0">fchdir</font><font color="4444FF">(</font><font color="#2040a0">fd</font><font color="4444FF">)</font> <font color="4444FF">&lt;</font> <font color="#FF0000">0</font><font color="4444FF">)</font> <font color="4444FF"><strong>{</strong></font>
+		<font color="#2040a0">serrno</font> <font color="4444FF">=</font> <font color="#2040a0">errno</font><font color="4444FF">;</font>
+		<strong>goto</strong> <font color="#2040a0">err2</font><font color="4444FF">;</font>
+	<font color="4444FF"><strong>}</strong></font>
+
+	<font color="#444444">/* It's okay if the close fails, what's an fd more or less? */</font>
+	<font color="4444FF">(</font><strong>void</strong><font color="4444FF">)</font><font color="#2040a0">close</font><font color="4444FF">(</font><font color="#2040a0">fd</font><font color="4444FF">)</font><font color="4444FF">;</font>
+	<strong>return</strong> <font color="4444FF">(</font><font color="#2040a0">resolved</font><font color="4444FF">)</font><font color="4444FF">;</font>
+
+<font color="#2040a0">err1</font><font color="4444FF">:</font>	<font color="#2040a0">serrno</font> <font color="4444FF">=</font> <font color="#2040a0">errno</font><font color="4444FF">;</font>
+	<font color="4444FF">(</font><strong>void</strong><font color="4444FF">)</font><font color="#2040a0">fchdir</font><font color="4444FF">(</font><font color="#2040a0">fd</font><font color="4444FF">)</font><font color="4444FF">;</font>
+<font color="#2040a0">err2</font><font color="4444FF">:</font>	<font color="4444FF">(</font><strong>void</strong><font color="4444FF">)</font><font color="#2040a0">close</font><font color="4444FF">(</font><font color="#2040a0">fd</font><font color="4444FF">)</font><font color="4444FF">;</font>
+	<font color="#2040a0">errno</font> <font color="4444FF">=</font> <font color="#2040a0">serrno</font><font color="4444FF">;</font>
+	<strong>return</strong> <font color="4444FF">(</font><font color="#2040a0">NULL</font><font color="4444FF">)</font><font color="4444FF">;</font>
+<font color="4444FF"><strong>}</strong></font>
+
+</pre>
+<hr>
+syntax highlighted by <a href="http://www.palfrader.org/code2html">Code2HTML</a>, v. 0.9.1
+</body>
+</html>
--- a/C/save.c
+++ b/C/save.c
--- a/C/scanner.c
+++ b/C/scanner.c
--- a/C/signals.c
+++ b/C/signals.c
@ -0,0 +1,451 @@
+/*************************************************************************
+ *									 *
+ *	 YAP Prolog 							 *
+ *									 *
+ *	Yap Prolog was developed at NCCUP - Universidade do Porto	 *
+ *									 *
+ * Copyright L.Damas, V. Santos Costa and Universidade do Porto 1985--	 *
+ *									 *
+ **************************************************************************
+ *									 *
+ * File:		signal.c *
+ * comments:	Signal Handling & Debugger Support			 *
+ *									 *
+ *									 *
+ *									 *
+ *************************************************************************/
+#ifdef SCCS
+static char SccsId[] = "%W% %G%";
+#endif
+
+#define HAS_CACHE_REGS 1
+
+#include "Yap.h"
+#if HAVE_UNISTD_H
+#include <unistd.h>
+#endif
+#if _WIN32
+#include <io.h>
+#include <stdio.h>
+#endif
+#include "YapEval.h"
+#include "YapHeap.h"
+#include "Yatom.h"
+#include "yapio.h"
+#ifdef TABLING
+#include "tab.macros.h"
+#endif /* TABLING */
+#include <stdio.h>
+#include <stdlib.h>
+#if HAVE_STRING_H
+#include <string.h>
+#endif
+#if HAVE_STRINGS_H
+#include <strings.h>
+#endif
+#if HAVE_MALLOC_H
+#include <malloc.h>
+#endif
+#include <wchar.h>
+#ifdef LOW_LEVEL_TRACER
+#include <tracer.h>
+#endif
+
+/*
+ * The InteractSIGINT function is called after a normal interrupt had been
+ * caught.
+ * It allows 6 possibilities: abort, continue, trace, debug, help, exit.
+ */
+static yap_signals InteractSIGINT(int ch) {
+#ifdef HAVE_SETBUF
+  /* make sure we are not waiting for the end of line */
+  setbuf(stdin, NULL);
+#endif
+  switch (ch) {
+  case 'a':
+/* abort computation */
+#if PUSH_REGS
+  // restore_absmi_regs(&Yap_standard_regs);
+#endif
+    return YAP_ABORT_SIGNAL;
+  case 'b':
+    /* continue */
+    return YAP_BREAK_SIGNAL;
+  case 'c':
+    /* continue */
+    return YAP_NO_SIGNAL;
+  case 'd':
+    /* enter debug mode */
+    return YAP_DEBUG_SIGNAL;
+  case 'e':
+    /* exit */
+    Yap_exit(1);
+    return YAP_EXIT_SIGNAL;
+  case 'g':
+    /* stack dump */
+    return YAP_STACK_DUMP_SIGNAL;
+  case 't':
+    /* start tracing */
+    return YAP_TRACE_SIGNAL;
+#ifdef LOW_LEVEL_TRACER
+  case 'T':
+    toggle_low_level_trace();
+    return YAP_NO_SIGNAL;
+#endif
+  case 's':
+    /* show some statistics */
+    return YAP_STATISTICS_SIGNAL;
+  case EOF:
+    return YAP_NO_SIGNAL;
+  case 'h':
+  case '?':
+  default:
+    /* show an helpful message */
+    fprintf(stderr, "Please press one of:\n");
+    fprintf(stderr, "  a for abort\n  c for continue\n  d for debug\n");
+    fprintf(stderr, "  e for exit\n  g for stack dump\n  s for statistics\n  t "
+                    "for trace\n");
+    fprintf(stderr, "  b for break\n");
+    return YAP_NO_SIGNAL;
+  }
+}
+
+/**
+  This function interacts with the user about a signal. We assume we are in
+  the context of the main Prolog thread (trivial in Unix, but hard in WIN32).
+
+
+ */
+static yap_signals ProcessSIGINT(void) {
+  CACHE_REGS
+  int ch, out;
+#if _WIN32
+  if (!_isatty(0)) {
+    return YAP_INT_SIGNAL;
+  }
+#elif HAVE_ISATTY
+  if (!isatty(0)) {
+    return YAP_INT_SIGNAL;
+  }
+#endif
+  LOCAL_PrologMode |= AsyncIntMode;
+  do {
+    ch = Yap_GetCharForSIGINT();
+  } while (!(out = InteractSIGINT(ch)));
+  LOCAL_PrologMode &= ~AsyncIntMode;
+  return (out);
+}
+
+inline static void do_signal(int wid, yap_signals sig USES_REGS) {
+#if THREADS
+  __sync_fetch_and_or(&REMOTE(wid)->Signals_, SIGNAL_TO_BIT(sig));
+  if (!REMOTE_InterruptsDisabled(wid)) {
+    REMOTE_ThreadHandle(wid).current_yaam_regs->CreepFlag_ =
+        Unsigned(REMOTE_ThreadHandle(wid).current_yaam_regs->LCL0_);
+  }
+#else
+  LOCAL_Signals |= SIGNAL_TO_BIT(sig);
+  if (!LOCAL_InterruptsDisabled) {
+    CreepFlag = Unsigned(LCL0);
+  }
+#endif
+}
+
+inline static bool get_signal(yap_signals sig USES_REGS) {
+#if THREADS
+  uint64_t old;
+
+  // first, clear the Creep Flag, now if someone sets it it is their problem
+  CalculateStackGap(PASS_REGS1);
+  // reset the flag
+  if ((old = __sync_fetch_and_and(&LOCAL_Signals, ~SIGNAL_TO_BIT(sig))) !=
+      SIGNAL_TO_BIT(sig)) {
+    if (!LOCAL_InterruptsDisabled && LOCAL_Signals != 0) {
+      CreepFlag = (CELL)LCL0;
+    }
+    if (!(old & SIGNAL_TO_BIT(sig))) {
+      // not there?
+      return FALSE;
+    }
+    // more likely case, we have other interrupts.
+    return TRUE;
+  }
+  // success, we are good
+  return TRUE;
+// should we set the flag?
+#else
+  if (LOCAL_Signals & SIGNAL_TO_BIT(sig)) {
+    LOCAL_Signals &= ~SIGNAL_TO_BIT(sig);
+    if (!LOCAL_InterruptsDisabled && LOCAL_Signals != 0) {
+      CreepFlag = (CELL)LCL0;
+    } else {
+      CalculateStackGap(PASS_REGS1);
+    }
+    return TRUE;
+  } else {
+    return FALSE;
+  }
+#endif
+}
+
+bool Yap_DisableInterrupts(int wid) {
+  LOCAL_InterruptsDisabled = true;
+  YAPEnterCriticalSection();
+  return true;
+}
+
+bool Yap_EnableInterrupts(int wid) {
+  LOCAL_InterruptsDisabled = false;
+  YAPLeaveCriticalSection();
+  return true;
+}
+
+/**
+  Function called to handle delayed interrupts.
+ */
+bool Yap_HandleSIGINT(void) {
+  CACHE_REGS
+  yap_signals sig;
+
+  do {
+    if ((sig = ProcessSIGINT()) != YAP_NO_SIGNAL)
+      do_signal(worker_id, sig PASS_REGS);
+    LOCAL_PrologMode &= ~InterruptMode;
+    return true;
+  } while (get_signal(YAP_INT_SIGNAL PASS_REGS));
+  return false;
+}
+
+static Int p_creep(USES_REGS1) {
+  Atom at;
+  PredEntry *pred;
+
+  at = AtomCreep;
+  pred = RepPredProp(PredPropByFunc(Yap_MkFunctor(at, 1), 0));
+  CreepCode = pred;
+  do_signal(worker_id, YAP_CREEP_SIGNAL PASS_REGS);
+  return TRUE;
+}
+
+static Int p_creep_fail(USES_REGS1) {
+  Atom at;
+  PredEntry *pred;
+
+  at = AtomCreep;
+  pred = RepPredProp(PredPropByFunc(Yap_MkFunctor(at, 1), 0));
+  CreepCode = pred;
+  do_signal(worker_id, YAP_CREEP_SIGNAL PASS_REGS);
+  return FALSE;
+}
+
+static Int stop_creeping(USES_REGS1) {
+  if (get_signal(YAP_CREEP_SIGNAL PASS_REGS)) {
+    return Yap_unify(ARG1, TermTrue);
+  }
+  return Yap_unify(ARG1, TermFalse);
+}
+
+static Int disable_debugging(USES_REGS1) {
+  get_signal(YAP_CREEP_SIGNAL PASS_REGS);
+  return true;
+}
+
+static Int creep_allowed(USES_REGS1) {
+  if (PP != NULL) {
+    get_signal(YAP_CREEP_SIGNAL PASS_REGS);
+    return true;
+  }
+  return false;
+}
+
+void Yap_signal(yap_signals sig) {
+  CACHE_REGS
+  do_signal(worker_id, sig PASS_REGS);
+}
+
+#ifdef DEBUG
+static Int p_debug(USES_REGS1);
+#endif
+
+void Yap_external_signal(int wid, yap_signals sig) {
+#if THREADS
+  REGSTORE *regcache = REMOTE_ThreadHandle(wid).current_yaam_regs;
+#endif
+  do_signal(wid, sig PASS_REGS);
+  LOCAL_PrologMode &= ~InterruptMode;
+}
+
+int Yap_get_signal__(yap_signals sig USES_REGS) {
+  return get_signal(sig PASS_REGS);
+}
+
+// the caller holds the lock.
+int Yap_has_signals__(yap_signals sig1, yap_signals sig2 USES_REGS) {
+  return LOCAL_Signals & (SIGNAL_TO_BIT(sig1) | SIGNAL_TO_BIT(sig2));
+}
+
+int Yap_only_has_signals__(yap_signals sig1, yap_signals sig2 USES_REGS) {
+  uint64_t sigs = LOCAL_Signals;
+  return sigs & (SIGNAL_TO_BIT(sig1) | SIGNAL_TO_BIT(sig2)) &&
+         !(sigs & ~(SIGNAL_TO_BIT(sig1) | SIGNAL_TO_BIT(sig2)));
+}
+
+#ifdef DEBUG
+
+volatile int volat = 0;
+
+static Int p_debug(USES_REGS1) { /* $debug(+Flag) */
+  int i = IntOfTerm(Deref(ARG1));
+  while (volat == 0) {
+  }
+  if (i >= 'a' && i <= 'z')
+    GLOBAL_Option[i - 96] = !GLOBAL_Option[i - 96];
+  return 1;
+}
+void Yap_loop(void);
+void Yap_debug_end_loop(void);
+
+void Yap_loop(void) {
+  while (volat == 0)
+    ;
+}
+
+void Yap_debug_end_loop(void) { volat = 1; }
+#endif
+
+static Int first_signal(USES_REGS1) {
+  Atom at;
+  yap_signals sig;
+
+  while (TRUE) {
+    uint64_t mask = LOCAL_Signals;
+    if (mask == 0)
+      return FALSE;
+#if HAVE___BUILTIN_FFSLL
+    sig = __builtin_ffsll(mask);
+#elif HAVE_FFSLL
+    sig = ffsll(mask);
+#else
+    sig = Yap_msb(mask PASS_REGS) + 1;
+#endif
+    if (get_signal(sig PASS_REGS)) {
+      break;
+    }
+  }
+loop:
+  switch (sig) {
+  case YAP_INT_SIGNAL:
+    sig = ProcessSIGINT();
+    if (sig == YAP_INT_SIGNAL) {
+      at = AtomSigInt;
+      break;
+    }
+    if (sig != YAP_NO_SIGNAL)
+      goto loop;
+    return FALSE;
+  case YAP_ABORT_SIGNAL:
+    /* abort computation */
+    LOCAL_PrologMode &= ~AsyncIntMode;
+    if (LOCAL_PrologMode & (GCMode | ConsoleGetcMode | CritMode)) {
+      LOCAL_PrologMode |= AbortMode;
+      return -1;
+    } else {
+      Yap_Error(ABORT_EVENT, TermNil, "abort from console");
+    }
+    Yap_RestartYap(1);
+    return FALSE;
+  case YAP_CREEP_SIGNAL:
+    at = AtomSigCreep;
+    break;
+  case YAP_TRACE_SIGNAL:
+    at = AtomSigTrace;
+    break;
+  case YAP_DEBUG_SIGNAL:
+    at = AtomSigDebug;
+    break;
+  case YAP_BREAK_SIGNAL:
+    at = AtomSigBreak;
+    break;
+  case YAP_FAIL_SIGNAL:
+    at = AtomFail;
+    break;
+  case YAP_STACK_DUMP_SIGNAL:
+    at = AtomSigStackDump;
+    break;
+  case YAP_STATISTICS_SIGNAL:
+    at = AtomSigStatistics;
+    break;
+#ifdef SIGALRM
+  case YAP_ALARM_SIGNAL:
+#endif
+  case YAP_WINTIMER_SIGNAL:
+    at = AtomSigAlarm;
+    break;
+#ifdef SIGVTALRM
+  case YAP_VTALARM_SIGNAL:
+    at = AtomSigVTAlarm;
+    break;
+#endif
+  case YAP_EXIT_SIGNAL:
+    Yap_exit(1);
+    return FALSE;
+  case YAP_WAKEUP_SIGNAL:
+    at = AtomSigWakeUp;
+    break;
+  case YAP_ITI_SIGNAL:
+    at = AtomSigIti;
+    break;
+#ifdef SIGPIPE
+  case YAP_PIPE_SIGNAL:
+    at = AtomSigPipe;
+    break;
+#endif
+#ifdef SIGHUP
+  case YAP_HUP_SIGNAL:
+    at = AtomSigHup;
+    break;
+#endif
+#ifdef SIGUSR1
+  case YAP_USR1_SIGNAL:
+    at = AtomSigUsr1;
+    break;
+#endif
+#ifdef SIGUSR2
+  case YAP_USR2_SIGNAL:
+    at = AtomSigUsr2;
+    break;
+#endif
+#ifdef SIGFPE
+  case YAP_FPE_SIGNAL:
+    at = AtomSigFPE;
+    break;
+#endif
+  default:
+    return FALSE;
+  }
+  return Yap_unify(ARG1, MkAtomTerm(at));
+}
+
+static Int continue_signals(USES_REGS1) { return first_signal(PASS_REGS1); }
+
+void Yap_InitSignalCPreds(void) {
+  /* Basic predicates for the debugger */
+  Yap_InitCPred("$creep", 0, p_creep, SafePredFlag);
+  Yap_InitCPred("$creep_fail", 0, p_creep_fail, SafePredFlag);
+  Yap_InitCPred("$stop_creeping", 1, stop_creeping,
+                NoTracePredFlag | HiddenPredFlag | SafePredFlag);
+  Yap_InitCPred("$disable_debugging", 0, disable_debugging,
+                NoTracePredFlag | HiddenPredFlag | SafePredFlag);
+  Yap_InitCPred("$first_signal", 1, first_signal, SafePredFlag | SyncPredFlag);
+  Yap_InitCPred("$continue_signals", 0, continue_signals,
+                SafePredFlag | SyncPredFlag);
+  Yap_InitCPred("creep_allowed", 0, creep_allowed, 0);
+#ifdef DEBUG
+  Yap_InitCPred("sys_debug", 1, p_debug, SafePredFlag | SyncPredFlag);
+#endif
+}
+
+void *Yap_InitSignals(int wid) {
+  void *ptr = (void *)malloc(sizeof(UInt) * REMOTE_MaxActiveSignals(wid));
+  return ptr;
+}
--- a/C/sort.c
+++ b/C/sort.c
@ -28,14 +28,14 @@
 #define M_EVEN  0
 #define M_ODD   1

-STATIC_PROTO(Int build_new_list, (CELL *, Term CACHE_TYPE));
-STATIC_PROTO(void simple_mergesort, (CELL *, Int, int));
-STATIC_PROTO(Int compact_mergesort, (CELL *, Int, int));
-STATIC_PROTO(int key_mergesort, (CELL *, Int, int, Functor));
-STATIC_PROTO(void adjust_vector, (CELL *, Int));
-STATIC_PROTO(Int p_sort, ( USES_REGS1 ));
-STATIC_PROTO(Int p_msort, ( USES_REGS1 ));
-STATIC_PROTO(Int p_ksort, ( USES_REGS1 ));
+static Int build_new_list(CELL *, Term CACHE_TYPE);
+static void simple_mergesort(CELL *, Int, int);
+static Int compact_mergesort(CELL *, Int, int);
+static int key_mergesort(CELL *, Int, int, Functor);
+static void adjust_vector(CELL *, Int);
+static Int p_sort( USES_REGS1 );
+static Int p_msort( USES_REGS1 );
+static Int p_ksort( USES_REGS1 );

 /* copy to a new list of terms */
 static Int
@ -58,12 +58,12 @@ build_new_list(CELL *pt, Term t USES_REGS)
    }
    pt += 2;
    if (pt > ASP - 4096) {
-      if (!Yap_gcl((ASP-H)*sizeof(CELL), 2, ENV, gc_P(P,CP))) {
-	Yap_Error(OUT_OF_STACK_ERROR, TermNil, LOCAL_ErrorMessage);
+      if (!Yap_gcl((ASP-HR)*sizeof(CELL), 2, ENV, gc_P(P,CP))) {
+	Yap_ThrowError(RESOURCE_ERROR_STACK, TermNil, LOCAL_ErrorMessage);
 	return(FALSE);
      }
      t = Deref(ARG1);
-      pt = H;
+      pt = HR;
      out = 0;
      goto restart;
    }
@ -267,14 +267,14 @@ Int compact_mergesort(CELL *pt, Int size, int my_p)
    while (pt_left < end_pt_left && pt_right < end_pt_right) {
      /* if the element to the left is larger than the one to the right */
      Int cmp = Yap_compare_terms(pt_left[0], pt_right[0]);
-      if (cmp < 0) {
+      if (cmp < (Int)0) {
 	/* copy the one to the left */
 	pt[0] = pt_left[0];
 	/* and avance the two pointers */
 	pt += 2;
 	size ++;
 	pt_left += 2;
-      } else if (cmp == 0) {
+      } else if (cmp == (Int)0) {
 	/* otherwise, just skip one of them, anyone */
 	pt_left += 2;
      } else {
@ -346,7 +346,7 @@ static Int
 p_sort( USES_REGS1 )
 {
  /* use the heap to build a new list */
-  CELL *pt = H;
+  CELL *pt = HR;
  Term out;
  /* list size */
  Int size;
@ -355,13 +355,13 @@ p_sort( USES_REGS1 )
    return(FALSE);
  if (size < 2)
     return(Yap_unify(ARG1, ARG2));
-  pt = H;            /* because of possible garbage collection */
+  pt = HR;            /* because of possible garbage collection */
  /* make sure no one writes on our temp data structure */
-  H += size*2;
+  HR += size*2;
  /* reserve the necessary space */
  size = compact_mergesort(pt, size, M_EVEN);
  /* reajust space */
-  H = pt+size*2;
+  HR = pt+size*2;
  adjust_vector(pt, size);
  out = AbsPair(pt);
  return(Yap_unify(out, ARG2));
@ -371,7 +371,7 @@ static Int
 p_msort( USES_REGS1 )
 {
  /* use the heap to build a new list */
-  CELL *pt = H;
+  CELL *pt = HR;
  Term out;
  /* list size */
  Int size;
@ -380,9 +380,9 @@ p_msort( USES_REGS1 )
    return(FALSE);
  if (size < 2)
     return(Yap_unify(ARG1, ARG2));
-  pt = H;            /* because of possible garbage collection */
+  pt = HR;            /* because of possible garbage collection */
  /* reserve the necessary space */
-  H += size*2;
+  HR += size*2;
  simple_mergesort(pt, size, M_EVEN);
  adjust_vector(pt, size);
  out = AbsPair(pt);
@ -393,7 +393,7 @@ static Int
 p_ksort( USES_REGS1 )
 {
  /* use the heap to build a new list */
-  CELL *pt = H;
+  CELL *pt = HR;
  Term out;
  /* list size */
  Int size;
@ -403,8 +403,8 @@ p_ksort( USES_REGS1 )
  if (size < 2)
     return(Yap_unify(ARG1, ARG2));
  /* reserve the necessary space */
-  pt = H;            /* because of possible garbage collection */
-  H += size*2;
+  pt = HR;            /* because of possible garbage collection */
+  HR += size*2;
  if (!key_mergesort(pt, size, M_EVEN, FunctorMinus))
    return(FALSE);
  adjust_vector(pt, size);
@ -415,7 +415,7 @@ p_ksort( USES_REGS1 )
 void 
 Yap_InitSortPreds(void)
 {
-  Yap_InitCPred("$sort", 2, p_sort, HiddenPredFlag);
-  Yap_InitCPred("$msort", 2, p_msort, HiddenPredFlag);
-  Yap_InitCPred("$keysort", 2, p_ksort, HiddenPredFlag);
+  Yap_InitCPred("$sort", 2, p_sort, 0);
+  Yap_InitCPred("$msort", 2, p_msort, 0);
+  Yap_InitCPred("$keysort", 2, p_ksort, 0);
 }
--- a/C/stack.c
+++ b/C/stack.c
--- a/C/stackinfo.c
+++ b/C/stackinfo.c
--- a/C/stdpreds.c
+++ b/C/stdpreds.c
--- a/C/sysbits.c
+++ b/C/sysbits.c
--- a/C/terms.c
+++ b/C/terms.c
--- a/C/text.c
+++ b/C/text.c
--- a/C/text.c.new
+++ b/C/text.c.new
--- a/C/threads.c
+++ b/C/threads.c
--- a/C/traced_absmi_insts.h
+++ b/C/traced_absmi_insts.h
--- a/Show More
+++ b/Show More