varia

CXX/yapa.hh

@@ -121,4 +121,3 @@ public:
 
 #endif /* YAPA_HH */
 /// @}
-

CXX/yapi.cpp

@@ -27,8 +27,6 @@ X_API void YAP_UserBackCPredicate(const char *, YAP_UserCPred, YAP_UserCPred,
 
 }
 
-static YAPEngine *curren;
-
 YAPAtomTerm::YAPAtomTerm(char *s)
 { // build string
   BACKUP_H();
@@ -189,7 +187,6 @@ YAPApplTerm::YAPApplTerm(std::string f, std::vector<YAPTerm> ts)
   mk(o);
 }
 
-
 YAPApplTerm::YAPApplTerm(YAPFunctor f) : YAPTerm()
 {
   BACKUP_H();
@@ -652,19 +649,19 @@ YAPQuery::YAPQuery(YAPFunctor f, YAPTerm mod, YAPTerm ts[])
   /* ignore flags  for now */
   BACKUP_MACHINE_REGS();
     Term *nts;
-  Term tgoal;
+  Term goal;
   
   if ( ts) {
 
-  goal = new YAPApplTerm(f, ts);
+  goal = YAPApplTerm(f, ts).term();
-  nts = RepAppl(goal->term())+1;
+  nts = RepAppl(goal)+1;
 
 } else {
-  goal = new YAPVarTerm();
+  goal = MkVarTerm();
   nts = nullptr;
 }
-    openQuery(goal->term(), nts);
+    openQuery( nts);
-    names = new YAPPairTerm();
+  names = YAPPairTerm( TermNil );
   RECOVER_MACHINE_REGS();
 }
 
@@ -674,14 +671,13 @@ YAPQuery::YAPQuery(YAPFunctor f, YAPTerm ts[]) : YAPPredicate(f) {
   BACKUP_MACHINE_REGS();
   CELL *nts;
   if (ts) {
-  tgoal =  YAPApplTerm(f, nts);
+  goal =  YAPApplTerm(f, nts);
   } else {
-   tgoal = YAPVarTerm();
+   goal = YAPVarTerm();
    nts = nullptr;
   }
-     *names = new YAPPairTerm();
+  names = YAPPairTerm( TermNil );
-      *goal = new YAPTerm(tgoal);
+  openQuery(term(), nts);
-  openQuery(goal.term(), nts);
   RECOVER_MACHINE_REGS();
 }
 #endif
@@ -696,14 +692,14 @@ YAPQuery::YAPQuery(YAPTerm t) : YAPPredicate(t)
      Functor f = FunctorOfTerm(tt);
      if (IsExtensionFunctor(f))
        nts =                                              nullptr;
-     nts = RepAppl(tt)+1;
+     nts = RepAppl(goal.term())+1;
   } else if (IsPairTerm(tt)) {
          nts = RepPair(tt);
   } else {
     nts = nullptr;
   }
-    names = new YAPPairTerm();
+  openQuery( nts);
-    goal = new YAPTerm(t);
+  names =  YAPPairTerm( TermNil );
   RECOVER_MACHINE_REGS();
 }
 
@@ -712,14 +708,15 @@ YAPQuery::YAPQuery(YAPPredicate p, YAPTerm ts[]) : YAPPredicate(p.ap) {
   BACKUP_MACHINE_REGS();
   arity_t arity = p.ap->ArityOfPE;
   if (arity) {
-      goal = new YAPApplTerm(YAPFunctor(p.ap->FunctorOfPred), ts);
+    goal = YAPApplTerm(YAPFunctor(p.ap->FunctorOfPred), ts).term();
-    for (arity_t i =0; i < arity; i++) {
+    for (arity_t i =0; i < arity; i++)
       XREGS[i+1]=ts[i].term();
-    }
+    openQuery( nullptr);
   } else {
-    goal = new YAPAtomTerm((Atom)(p.ap->FunctorOfPred));  }
+    goal = YAPAtomTerm((Atom)(p.ap->FunctorOfPred));
-    openQuery(goal->term(), nullptr);
+    openQuery(nullptr);
-    names = new YAPPairTerm();
+  }
+  names = TermNil;
   RECOVER_MACHINE_REGS();
 }
 
@@ -729,21 +726,13 @@ bool YAPQuery::next()
     bool result = false;
     sigjmp_buf buf, *oldp = LOCAL_RestartEnv;
   Term terr;
-  __android_log_print(ANDROID_LOG_INFO, "YAPDroid", "next  %d %ld",
-                      q_state, LOCAL_CurSlot);
-  __android_log_print(ANDROID_LOG_INFO, "YAPDroid", "next  %d %s %ld",
-                      q_state, names->text(), LOCAL_CurSlot);
-
-  if (ap == NULL || ap->OpcodeOfPred == UNDEF_OPCODE) {
-    ap = rewriteUndefQuery();
-  }
-  LOCAL_RestartEnv = &q_env;
  try
   {
     BACKUP_MACHINE_REGS();
     if (!q_open)
       return false;
-    if (false && sigsetjmp(q_env, false))
+    LOCAL_RestartEnv = &buf;
+    if (sigsetjmp(*LOCAL_RestartEnv, false))
     {
       //throw YAPError();
       return false;
@@ -762,8 +751,8 @@ bool YAPQuery::next()
     }
     if (result)
     {
-      __android_log_print(ANDROID_LOG_INFO, "YAPDroid", "names  %d %s %ld",
+      __android_log_print(ANDROID_LOG_INFO, "YAPDroid", "vnames  %d %s %ld",
-                          q_state, names->text(), LOCAL_CurSlot);
+                          q_state, vnames.text(), LOCAL_CurSlot);
     }
     else
     {
@@ -774,6 +763,7 @@ bool YAPQuery::next()
     {
       if ((terr = Yap_GetException()))
       {
+	LOCAL_RestartEnv = &buf;
         throw YAPError();
       }
     }
@@ -802,6 +792,7 @@ bool YAPQuery::next()
     Yap_CloseHandles(q_handles);
     q_open = false;
     std::cerr << "Exception received by  " << __func__ << "( " << YAPTerm(terr).text() << ").\n Forwarded...\n\n";
+        LOCAL_RestartEnv = oldp;
     throw e;
   }
 }
@@ -810,10 +801,10 @@ PredEntry *
 YAPQuery::rewriteUndefQuery()
 {
   Term ts[3];
-  ARG1 = ts[0] = goal->term();
+  ARG1 = ts[0] = goal.term();
   ARG2 = ts[1] = ap->ModuleOfPred;
   ARG3 = ts[2] = Yap_cp_as_integer(B PASS_REGS);
-  goal = new YAPApplTerm(FunctorUndefinedQuery, ts);
+  goal = YAPApplTerm(FunctorUndefinedQuery, ts);
   return ap = PredUndefinedQuery;
 }
 
@@ -895,6 +886,39 @@ JNIEXPORT jint JNICALL JNI_MySQLOnLoad(JavaVM *vm, void *reserved)
   return JNI_VERSION_1_6;
 }
 
+char *Yap_AndroidBufp;
+
+static size_t Yap_AndroidMax, Yap_AndroidSz;
+
+extern void (*Yap_DisplayWithJava)(int c);
+
+void Yap_displayWithJava(int c)
+{
+  char *ptr = Yap_AndroidBufp;
+  if (!ptr)
+    ptr = Yap_AndroidBufp = (char *)malloc(Yap_AndroidSz);
+  ptr[Yap_AndroidSz++] = c;
+  if (Yap_AndroidMax - 1 == Yap_AndroidSz)
+  {
+    if (Yap_AndroidMax < 32 * 1024)
+    {
+      Yap_AndroidMax *= 2;
+    }
+    else
+    {
+      Yap_AndroidMax += 32 * 1024;
+    }
+    Yap_AndroidBufp = (char *)realloc(ptr, Yap_AndroidMax);
+  }
+  Yap_AndroidBufp[Yap_AndroidSz] = '\0';
+  if (c == '\n')
+  {
+    Yap_AndroidBufp[Yap_AndroidSz] = '\0';
+    curren->run(Yap_AndroidBufp);
+    Yap_AndroidSz = 0;
+  }
+}
+
 #endif
 
 
@@ -908,7 +932,11 @@ void YAPEngine::doInit(YAP_file_type_t BootMode)
   /* Begin preprocessor code */
   /* live */
   __android_log_print(ANDROID_LOG_INFO, "YAPDroid", "initialize_prolog");
- curren = this;
+#if __ANDROID__
+  Yap_AndroidBufp = (char *)malloc(Yap_AndroidMax = 4096);
+  Yap_AndroidBufp[0] = '\0';
+  Yap_AndroidSz = 0;
+#endif
   //yerror = YAPError();
 #if YAP_PYTHON
     do_init_python();

CXX/yapi.hh

@@ -6,13 +6,12 @@
 
 */
 
-
 #define YAP_CPP_INTERFACE 1
 
 #include <gmpxx.h>
-#include <vector>
-#include <string>
 #include <iostream>
+#include <string>
+#include <vector>
 
 /*!
  *
@@ -77,15 +76,20 @@ extern "C" {
 // taken from yap_structs.h
 #include "iopreds.h"
 
-  X_API extern void YAP_UserCPredicate(const char *, YAP_UserCPred, YAP_Arity arity);
+X_API extern void YAP_UserCPredicate(const char *, YAP_UserCPred,
+                                     YAP_Arity arity);
 
-  /*  extern void UserCPredicateWithArgs(const char *name, int *fn(), unsigned int arity)
+/*  extern void UserCPredicateWithArgs(const char *name, int *fn(), unsigned int
+ * arity)
  */
-  X_API extern void YAP_UserCPredicateWithArgs(const char *, YAP_UserCPred, YAP_Arity,
+X_API extern void YAP_UserCPredicateWithArgs(const char *, YAP_UserCPred,
-					       YAP_Term);
+                                             YAP_Arity, YAP_Term);
+
+X_API extern void UserBackCPredicate(const char *name, int *init(), int *cont(),
+                                     int arity, int extra);
+
+X_API extern YAP_Term YAP_ReadBuffer(const char *s, YAP_Term *tp);
 
-  X_API extern void UserBackCPredicate(const char *name, int *init(), int *cont(), int
-				       arity, int extra);
 #if YAP_PYTHON
 
 #include <Python.h>

CXX/yapq.hh

@@ -9,8 +9,8 @@
  *
  * @{
  *
- * These classes wrap  engine and query. An engine is an environment where we
+ * These classes wrap  engine and query. An engine is an environment where we can rum
- * can rum Prolog, that is, where we can run queries.
+ * Prolog, that is, where we can run queries.
  *
  * Also, supports callbacks and engine configuration.
  *
@@ -31,7 +31,8 @@ class X_API YAPPredicate;
  * interface to a YAP Query;
  * uses an SWI-like status info internally.
  */
-class X_API YAPQuery : public YAPPredicate {
+class X_API YAPQuery : public YAPPredicate
+{
   bool q_open;
   int q_state;
   yhandle_t q_g, q_handles;
@@ -40,8 +41,8 @@ class X_API YAPQuery : public YAPPredicate {
   int q_flags;
   YAP_dogoalinfo q_h;
   YAPQuery *oq;
-  YAPPairTerm *names;
+  YAPPairTerm names;
-  YAPTerm *goal;
+  YAPTerm goal;
   // temporaries
   Term tnames, tgoal ;
 
@@ -54,11 +55,10 @@ class X_API YAPQuery : public YAPPredicate {
   q_p = P;
   q_cp = CP;
   // make sure this is safe
-    names = new YAPPairTerm();
-    goal = new YAPTerm();
   q_handles = LOCAL_CurSlot;
 };
 
+
   void openQuery( Term *ts);
 
 PredEntry *rewriteUndefQuery();
@@ -91,23 +91,26 @@ public:
   /// It is given a string, calls the parser and obtains a Prolog term that
   /// should be a callable
   /// goal.
-  inline YAPQuery(const char *s) : YAPPredicate(s, tgoal, tnames) {
+  inline YAPQuery(const char *s) : YAPPredicate(s, tgoal, tnames)
+  {
     CELL *qt = nullptr;
       __android_log_print(ANDROID_LOG_INFO, "YAPDroid", "got game %ld",
                           LOCAL_CurSlot);
       if (!ap)
           return;
-    __android_log_print(ANDROID_LOG_INFO, "YAPDroid", "ŸAPQuery");
+      __android_log_print(ANDROID_LOG_INFO, "YAPDroid", "%s", vnames.text());
+      goal = YAPTerm(tgoal);
       if (IsPairTerm(tgoal)) {
         qt = RepPair(tgoal);
-      tgoal =
+        tgoal = Yap_MkApplTerm(Yap_MkFunctor(Yap_LookupAtom("consult"), 1),1,qt);
-          Yap_MkApplTerm(Yap_MkFunctor(Yap_LookupAtom("consult"), 1), 1, qt);
       } else if (IsApplTerm(tgoal)) {
         Functor f = FunctorOfTerm(tgoal);
         if (!IsExtensionFunctor(f)) {
           qt = RepAppl(tgoal)+1;
         }
       }
+      names = YAPPairTerm(tnames);
+      openQuery(qt);
   };
   // inline YAPQuery() : YAPPredicate(s, tgoal, tnames)
   // {
@@ -115,7 +118,7 @@ public:
   //                         LOCAL_CurSlot);
   //     if (!ap)
   //         return;
-  //     __android_log_print(ANDROID_LOG_INFO, "YAPDroid", "%s", names->text());
+  //     __android_log_print(ANDROID_LOG_INFO, "YAPDroid", "%s", vnames.text());
   //     goal = YAPTerm(tgoal);
   //     names = YAPPairTerm(tnames);
   //     openQuery(tgoal);
@@ -141,20 +144,23 @@ public:
 bool deterministic();
 /// represent the top-goal
 const char *text();
-  /// remove alternatives in the current search space, and finish tnamedyaphe
+/// remove alternatives in the current search space, and finish the current
-  /// current query finish the current query: undo all bindings.
+/// query
+/// finish the current query: undo all bindings.
 void close();
 /// query variables.
 void cut();
-
+Term namedVars() {return  names.term(); };
-  Term namedVars() { return names->term(); };
-  YAPPairTerm *namedYAPVars() { return names; };
 /// query variables, but copied out
+std::vector<Term> namedVarsVector() {
+  return names.listToArray(); };
+/// convert a ref to a binding.
 YAPTerm getTerm(yhandle_t t);
 /// simple YAP Query;
 /// just calls YAP and reports success or failure, Useful when we just
 /// want things done, eg YAPCommand("load_files(library(lists), )")
-  inline bool command() {
+inline bool command()
+{
   bool rc = next();
   close();
   return rc;
@@ -166,96 +172,170 @@ public:
 /// This class implements a callback Prolog-side. It will be inherited by the
 /// Java or Python
 /// class that actually implements the callback.
-class X_API YAPCallback {
+class X_API YAPCallback
+{
 public:
   virtual ~YAPCallback() {}
   virtual void run() { LOG("callback"); }
   virtual void run(char *s) {}
 };
 
+
 /// @brief Setup all arguments to a new engine
 class X_API YAPEngineArgs {
 
 public:
+
   YAP_init_args init_args;
 
-  inline void setEmbedded(bool fl) { init_args.Embedded = fl; };
+  inline void setEmbedded( bool fl )
+  {
+    init_args.Embedded = fl;
+  };
 
-  inline bool getEmbedded() { return init_args.Embedded; };
+  inline bool getEmbedded(  )
+  {
+    return init_args.Embedded;
+  };
 
-  inline void setStackSize(bool fl) { init_args.StackSize = fl; };
+  inline void setStackSize( bool fl )
+  {
+    init_args.StackSize = fl;
+  };
 
-  inline bool getStackSize() { return init_args.StackSize; };
+  inline bool getStackSize(  )
+  {
+    return init_args.StackSize;
+  };
 
-  inline void setTrailSize(bool fl) { init_args.TrailSize = fl; };
+  inline void setTrailSize( bool fl )
+  {
+    init_args.TrailSize = fl;
+  };
 
-  inline bool getTrailSize() { return init_args.TrailSize; };
+  inline bool getTrailSize(  )
+  {
+    return init_args.TrailSize;
+  };
 
-  inline bool getMStackSize() { return init_args.StackSize; };
+  inline bool getMStackSize(  )
+  {
+    return init_args.StackSize;
+  };
 
-  inline void setMaxTrailSize(bool fl) { init_args.MaxTrailSize = fl; };
+  inline void setMaxTrailSize( bool fl )
+  {
+    init_args.MaxTrailSize = fl;
+  };
 
-  inline bool getMaxTrailSize() { return init_args.MaxTrailSize; };
+  inline bool getMaxTrailSize(  )
+  {
+    return init_args.MaxTrailSize;
+  };
 
-  inline void setYapLibDir(const char *fl) {
+  inline void setYapLibDir( const char * fl )
+  {
     init_args.YapLibDir = (const char *)malloc(strlen(fl)+1);
     strcpy((char *)init_args.YapLibDir, fl);
   };
 
-  inline const char *getYapLibDir() { return init_args.YapLibDir; };
+  inline const char * getYapLibDir(  )
+  {
+    return init_args.YapLibDir;
+  };
 
-  inline void setYapShareDir(const char *fl) {
+    inline void setYapShareDir( const char * fl )
+  {
     init_args.YapShareDir = (const char *)malloc(strlen(fl)+1);
     strcpy((char *)init_args.YapShareDir, fl);
   };
 
-  inline const char *getYapShareDir() { return init_args.YapShareDir; };
+  inline const char * getYapShareDir(  )
+  {
+    return init_args.YapShareDir;
+  };
 
-  inline void setSavedState(const char *fl) {
+  inline void setSavedState( const char * fl )
+  {
     init_args.SavedState = (const char *)malloc(strlen(fl)+1);
     strcpy((char *)init_args.SavedState, fl);
   };
 
-  inline const char *getSavedState() { return init_args.SavedState; };
+  inline const char * getSavedState(  )
+  {
+    return init_args.SavedState;
+  };
 
-  inline void setYapPrologBootFile(const char *fl) {
+  inline void setYapPrologBootFile( const char * fl )
+  {
     init_args.YapPrologBootFile = (const char *)malloc(strlen(fl)+1);
     strcpy((char *)init_args.YapPrologBootFile, fl);
 };
 
-  inline const char *getYapPrologBootFile() {
+  inline const char * getYapPrologBootFile(  )
+  {
     return init_args.YapPrologBootFile;
   };
 
-  inline void setYapPrologGoal(const char *fl) {
+  inline void setYapPrologGoal( const char * fl )
+  {
     init_args.YapPrologGoal = fl;
   };
 
-  inline const char *getYapPrologGoal() { return init_args.YapPrologGoal; };
+  inline const char * getYapPrologGoal(  )
+  {
+    return init_args.YapPrologGoal;
+  };
 
-  inline void setYapPrologTopLevelGoal(const char *fl) {
+  inline void setYapPrologTopLevelGoal( const char * fl )
+  {
     init_args.YapPrologTopLevelGoal = fl;
   };
 
-  inline const char *getYapPrologTopLevelGoal() {
+  inline const char * getYapPrologTopLevelGoal(  )
+  {
     return init_args.YapPrologTopLevelGoal;
   };
 
-  inline void setHaltAfterConsult(bool fl) { init_args.HaltAfterConsult = fl; };
+  inline void setHaltAfterConsult( bool fl )
+  {
+    init_args.HaltAfterConsult = fl;
+  };
 
-  inline bool getHaltAfterConsult() { return init_args.HaltAfterConsult; };
+  inline bool getHaltAfterConsult(  )
+  {
+    return init_args.HaltAfterConsult;
+  };
 
-  inline void setFastBoot(bool fl) { init_args.FastBoot = fl; };
+  inline void setFastBoot( bool fl )
+  {
+    init_args.FastBoot = fl;
+  };
 
-  inline bool getFastBoot() { return init_args.FastBoot; };
+  inline bool getFastBoot(  )
+  {
+    return init_args.FastBoot;
+  };
 
-  inline void setArgc(int fl) { init_args.Argc = fl; };
+  inline void setArgc( int  fl )
+  {
+    init_args.Argc = fl;
+  };
 
-  inline int getArgc() { return init_args.Argc; };
+  inline int getArgc(  )
+  {
+    return init_args.Argc;
+  };
 
-  inline void setArgv(char **fl) { init_args.Argv = fl; };
+  inline void setArgv( char ** fl )
+  {
+    init_args.Argv = fl;
+  };
 
-  inline char **getArgv() { return init_args.Argv; };
+  inline char ** getArgv(  )
+  {
+    return init_args.Argv;
+  };
 
   YAPEngineArgs() {
     Yap_InitDefaults(&init_args, NULL, 0, NULL);
@@ -266,13 +346,15 @@ public:
   };
 };
 
+
 /**
  * @brief YAP Engine: takes care of the execution environment
  where we can go executing goals.
  *
  *
  */
-class YAPEngine {
+  class YAPEngine
+{
 private:
   YAPEngineArgs *engine_args;
   YAPCallback *_callback;
@@ -283,7 +365,8 @@ private:
 
       public :
       /// construct a new engine; may use a variable number of arguments
-  YAPEngine(YAPEngineArgs *cargs) {
+      YAPEngine(YAPEngineArgs *cargs)
+  {
     engine_args = cargs;
     //doInit(cargs->init_args.boot_file_type);
     doInit(YAP_QLY);
@@ -296,14 +379,16 @@ public:
   /// remove current callback
   void delYAPCallback() { _callback = 0; };
   /// set a new callback
-  void setYAPCallback(YAPCallback *cb) {
+  void setYAPCallback(YAPCallback *cb)
+  {
     delYAPCallback();
     _callback = cb;
   };
   /// execute the callback.
   ////void run() { if (_callback) _callback.run(); }
   /// execute the callback with a text argument.
-  void run(char *s) {
+  void run(char *s)
+  {
     if (_callback)
       _callback->run(s);
   }
@@ -330,20 +415,25 @@ public:
   bool mgoal(Term t, Term tmod);
   /// current directory for the engine
 
-  bool goal(Term t) { return mgoal(t, CurrentModule); }
+  bool goal(Term t)
+  {
+    return mgoal(t, CurrentModule);
+  }
   /// reset Prolog state
   void reSet();
   /// assune that there are no stack pointers, just release memory
   // for last execution
   void release();
 
-  const char *currentDir() {
+  const char *currentDir()
+  {
     char dir[1024];
     std::string s = Yap_getcwd(dir, 1024 - 1);
     return s.c_str();
   };
   /// report YAP version as a string
-  const char *version() {
+  const char *version()
+  {
     std::string s = Yap_version();
     return s.c_str();
   };
@@ -355,13 +445,14 @@ public:
   Term fun(YAPTerm t) { return fun(t.term()); };
   //> set a StringFlag, usually a path
   //>
-  bool setStringFlag(std::string arg, std::string path) {
+  bool setStringFlag(std::string arg, std::string path)
-    return setYapFlag(MkAtomTerm(Yap_LookupAtom(arg.data())),
+  {
-                      MkAtomTerm(Yap_LookupAtom(path.data())));
+    return setYapFlag(MkAtomTerm(Yap_LookupAtom(arg.data())), MkAtomTerm(Yap_LookupAtom(path.data())));
   };
 
   Term  top_level( std::string s);
   Term next_answer(YAPQuery * &Q);
+
   };
 
 #endif /* YAPQ_HH */

CXX/yapt.hh

@@ -20,17 +20,11 @@
  *
  */
 
-
 #include <vector>
 
 #ifndef YAPT_HH
 #define YAPT_HH 1
 
-extern "C" {
-
-X_API Term YAP_ReadBuffer(const char *s, Term *tp);
-}
-
 class YAPError;
 
 /**
@@ -38,17 +32,11 @@ class YAPError;
  */
 class X_API YAPTerm {
   friend class YAPPredicate;
-
   friend class YAPPrologPredicate;
-
   friend class YAPQuery;
-
   friend class YAPModule;
-
   friend class YAPModuleProp;
-
   friend class YAPApplTerm;
-
   friend class YAPListTerm;
 
 protected:
@@ -79,16 +67,13 @@ public:
 //  t = Yap_InitSlot(tinp);
 //}
 #endif
-
   /// private method to convert from Term (internal YAP representation) to
   /// YAPTerm
   // do nothing constructor
   YAPTerm() { t = 0; };
-
   // YAPTerm(yhandle_t i) { t = i; };
   /// pointer to term
   YAPTerm(void *ptr);
-
   /// parse string s and construct a term.
   YAPTerm(char *s) {
     Term tp;
@@ -96,7 +81,6 @@ public:
   }
 
 #if 1
-
   /// Term destructor, tries to recover slot
   virtual ~YAPTerm(){
       //  fprintf(stderr,"-%d,%lx,%p ",t,LOCAL_HandleBase[t] ,HR);
@@ -121,24 +105,18 @@ public:
   /// YAPTerm(YAPFunctor f, YAPTerm ts[]);
   /// extract the tag of a term, after dereferencing.
   YAP_tag_t tag();
-
   /// copy the term ( term copy )
   Term deepCopy();
-
   /// numbervars ( int start, bool process=false )
   intptr_t numberVars(intptr_t start, bool skip_singletons = false);
-
   inline Term term() {
     return gt();
   } /// from YAPTerm to Term (internal YAP representation)
   inline void bind(Term b) { LOCAL_HandleBase[t] = b; }
-
   inline void bind(YAPTerm *b) { LOCAL_HandleBase[t] = b->term(); }
-
   /// from YAPTerm to Term (internal YAP representation)
   /// fetch a sub-term
   Term &operator[](arity_t n);
-
   // const YAPTerm *vars();
   /// this term is == to t1
   virtual bool exactlyEqual(YAPTerm t1) {
@@ -185,7 +163,6 @@ public:
     RECOVER_MACHINE_REGS();
     return out;
   };
-
   /// term hash,
   virtual bool isVar() { return IsVarTerm(gt()); }   /// type check for unound
   virtual bool isAtom() { return IsAtomTerm(gt()); } ///  type check for atom
@@ -206,52 +183,6 @@ public:
   virtual bool isGround() { return Yap_IsGroundTerm(gt()); } /// term is ground
   virtual bool isList() { return Yap_IsListTerm(gt()); }     /// term is a list
 
-
-    std::vector<YAPTerm> YAPTermToJavaArray()
-    {
-        BACKUP_H();
-         Term pt = gt();
-        if (IsApplTerm(t)) {
-            arity_t arity = ArityOfFunctor(FunctorOfTerm(pt));
-            std::vector<YAPTerm> o = std::vector<YAPTerm>(arity);
-            for (arity_t i=0; i < arity; i++) {
-                o[i] = YAPTerm( ArgOfTerm(i+1, pt) );
-            }
-            return o;
-
-        }
-        if (IsPairTerm(t)) {
-            std::vector<YAPTerm> o = std::vector<YAPTerm>(2);
-            o[0] = YAPTerm( HeadOfTerm(pt) );
-            o[1] = YAPTerm( TailOfTerm(pt) );
-            return o;
-
-        }
-        return std::vector<YAPTerm>(0);
-    }
-
-    std::vector<Term> YAPTermToVector()
-    {
-        BACKUP_H();
-        Term pt = gt();
-        if (IsApplTerm(t)) {
-            arity_t arity = ArityOfFunctor(FunctorOfTerm(pt));
-            std::vector<Term> o = std::vector<Term>(arity);
-            for (arity_t i=0; i < arity; i++) {
-                o[i] = ( ArgOfTerm(i+1, pt) );
-            }
-            return o;
-
-        }
-        if (IsPairTerm(t)) {
-            std::vector<Term> o = std::vector<Term>(2);
-            o[0] = ( HeadOfTerm(pt) );
-            o[1] = ( TailOfTerm(pt) );
-            return o;
-
-        }
-        return std::vector<Term>(0);
-    }
   /// extract the argument i of the term, where i in 1...arity
   virtual Term getArg(arity_t i) {
     BACKUP_MACHINE_REGS();
@@ -275,9 +206,7 @@ public:
     RECOVER_MACHINE_REGS();
     return tf;
   }
-    virtual YAPTerm getYAPArg(int i) {
+
-        return YAPTerm(getArg((arity_t)i));
-    }
   /// extract the arity of the term
   /// variables have arity 0
   virtual inline arity_t arity() {
@@ -326,15 +255,10 @@ public:
  */
 class X_API YAPFunctor : public YAPProp {
   friend class YAPApplTerm;
-
   friend class YAPTerm;
-
   friend class YAPPredicate;
-
   friend class YAPQuery;
-
   Functor f;
-
   /// Constructor: receives Prolog functor and casts it to YAPFunctor
   ///
   /// Notice that this is designed for internal use only.
@@ -354,7 +278,6 @@ public:
   inline YAPFunctor(const char *s, uintptr_t arity, bool isutf8 = true) {
     f = Yap_MkFunctor(Yap_LookupAtom(s), arity);
   }
-
   /// Constructor: receives name as a  wide string plus arity
   ///
   /// Notice that this is designed for UNICODE right now
@@ -364,7 +287,6 @@ public:
   inline YAPFunctor(const wchar_t *s, uintptr_t arity) {
     CACHE_REGS f = Yap_MkFunctor(UTF32ToAtom(s PASS_REGS), arity);
   }
-
   /// Getter: extract name of functor as an atom
   ///
   /// this is for external usage.
@@ -384,22 +306,16 @@ class X_API YAPApplTerm : public YAPTerm {
 
 public:
   YAPApplTerm(Term t0) { mk(t0); }
-
   YAPApplTerm(Functor f, Term ts[]) {
     BACKUP_MACHINE_REGS();
     Term t0 = Yap_MkApplTerm(f, f->ArityOfFE, ts);
     mk(t0);
     RECOVER_MACHINE_REGS();
   };
-
   YAPApplTerm(YAPFunctor f, YAPTerm ts[]);
-
   YAPApplTerm(const std::string s, std::vector<YAPTerm> ts);
-
   YAPApplTerm(YAPFunctor f);
-
   inline Functor functor() { return FunctorOfTerm(gt()); }
-
   inline YAPFunctor getFunctor() { return YAPFunctor(FunctorOfTerm(gt())); }
 
   Term getArg(arity_t i) {
@@ -410,7 +326,6 @@ public:
     RECOVER_MACHINE_REGS();
     return tf;
   };
-
   virtual bool isVar() { return false; }     /// type check for unbound
   virtual bool isAtom() { return false; }    ///  type check for atom
   virtual bool isInteger() { return false; } /// type check for integer
@@ -429,7 +344,6 @@ public:
 class X_API YAPPairTerm : public YAPTerm {
   friend class YAPTerm;
 
-
 public:
   YAPPairTerm(Term t0) {
     t0 = Deref(t0);
@@ -438,23 +352,10 @@ public:
     else
       Yap_ThrowError(TYPE_ERROR_LIST, t0, "YAPPairTerms");
   }
-
-    /// cons
   YAPPairTerm(YAPTerm hd, YAPTerm tl);
-
-    /// null constructor, or empty list
   YAPPairTerm();
-
-    bool empty() { return gt() == TermNil; }
-
   Term getHead() { return (HeadOfTerm(gt())); }
-
   Term getTail() { return (TailOfTerm(gt())); }
-
-    YAPTerm car() { return YAPTerm(HeadOfTerm(gt())); }
-
-    YAPPairTerm cdr() { return YAPPairTerm(TailOfTerm(gt())); }
-
   std::vector<Term> listToArray() {
     Term *tailp;
     Term t1 = gt();
@@ -471,23 +372,6 @@ public:
     }
     return o;
   }
-
-    std::vector<YAPTerm> listToYAPArray() {
-        Term *tailp;
-        Term t1 = gt();
-        Int l = Yap_SkipList(&t1, &tailp);
-        if (l < 0) {
-            throw YAPError(TYPE_ERROR_LIST, YAPTerm(t), "");
-        }
-        std::vector<YAPTerm> o = std::vector<YAPTerm>(l);
-        int i = 0;
-        Term t = gt();
-        while (t != TermNil) {
-            o[i++] = YAPTerm(HeadOfTerm(t));
-            t = TailOfTerm(t);
-        }
-        return o;
-    }
 };
 
 /**
@@ -497,7 +381,6 @@ public:
 class X_API YAPNumberTerm : public YAPTerm {
 public:
   YAPNumberTerm(){};
-
   bool isTagged() { return IsIntTerm(gt()); }
 };
 
@@ -508,7 +391,6 @@ public:
 class X_API YAPIntegerTerm : public YAPNumberTerm {
 public:
   YAPIntegerTerm(intptr_t i);
-
   intptr_t getInteger() { return IntegerOfTerm(gt()); };
 };
 
@@ -529,18 +411,15 @@ public:
   ///
   /// @param[in] the term
   YAPListTerm() { mk(TermNil); /* else type_error */ }
-
   /// Create an empty list term.
   ///
   /// @param[in] the term
   YAPListTerm(Term t0) { mk(t0); /* else type_error */ }
-
   /// Create a list term out of an array of terms.
   ///
   /// @param[in] the array of terms
   /// @param[in] the length of the array
   YAPListTerm(YAPTerm ts[], size_t n);
-
   //      YAPListTerm( vector<YAPTerm> v );
   /// Return the number of elements in a list term.
   size_t length() {
@@ -548,15 +427,12 @@ public:
     Term t1 = gt();
     return Yap_SkipList(&t1, &tailp);
   }
-
   /// Extract the nth element.
   Term &operator[](size_t n);
-
   /// Extract the first element of a list.
   ///
   /// @param[in] the list
   Term car();
-
   /// Extract the tail elements of a list.
   ///
   /// @param[in] the list
@@ -569,7 +445,6 @@ public:
     /* error */
     throw YAPError(TYPE_ERROR_LIST, YAPTerm(to), "");
   }
-
   /// copy a list.
   ///
   /// @param[in] the list
@@ -580,7 +455,9 @@ public:
   /// @param[in] the list
   inline bool nil() {
     return gt() == TermNil;
-    };
+  }
+
+  ;
 };
 
 /**
@@ -590,16 +467,12 @@ class X_API YAPStringTerm : public YAPTerm {
 public:
   /// your standard constructor
   YAPStringTerm(char *s);
-
   /// use this one to construct length limited strings
   YAPStringTerm(char *s, size_t len);
-
   /// construct using wide chars
   YAPStringTerm(wchar_t *s);
-
   /// construct using length-limited wide chars
   YAPStringTerm(wchar_t *s, size_t len);
-
   const char *getString() { return StringOfTerm(gt()); }
 };
 
@@ -609,28 +482,21 @@ public:
  */
 class X_API YAPAtomTerm : public YAPTerm {
   friend class YAPModule;
-
   // Constructor: receives a C-atom;
   YAPAtomTerm(Term t) : YAPTerm(t) { IsAtomTerm(t); }
 
 public:
   YAPAtomTerm(Atom a) { mk(MkAtomTerm(a)); }
-
   // Constructor: receives an atom;
   YAPAtomTerm(YAPAtom a) : YAPTerm() { mk(MkAtomTerm(a.a)); }
-
   // Constructor: receives a sequence of ISO-LATIN1 codes;
   YAPAtomTerm(char s[]);
-
   // Constructor: receives a sequence of up to n ISO-LATIN1 codes;
   YAPAtomTerm(char *s, size_t len);
-
   // Constructor: receives a sequence of wchar_ts, whatever they may be;
   YAPAtomTerm(wchar_t *s);
-
   // Constructor: receives a sequence of n wchar_ts, whatever they may be;
   YAPAtomTerm(wchar_t *s, size_t len);
-
   bool isVar() { return false; }           /// type check for unbound
   bool isAtom() { return true; }           ///  type check for atom
   bool isInteger() { return false; }       /// type check for integer
@@ -643,14 +509,11 @@ public:
   virtual bool isList() { return gt() == TermNil; } /// [] is a list
   // Getter: outputs the atom;
   YAPAtom getAtom() { return YAPAtom(AtomOfTerm(gt())); }
-
   // Getter: outputs the name as a sequence of ISO-LATIN1 codes;
   const char *text() { return (const char *)AtomOfTerm(gt())->StrOfAE; }
 };
-
 #endif /* YAPT_HH */
 
-
 /**
  * @brief Variable Term
  */
@@ -660,19 +523,15 @@ class X_API YAPVarTerm : public YAPTerm {
 public:
   /// constructor
   YAPVarTerm() { mk(MkVarTerm()); };
-
   /// get the internal representation
   CELL *getVar() { return VarOfTerm(gt()); }
-
   /// is the variable bound to another one
   YAPVarTerm(Term t) {
     if (IsVarTerm(t)) {
       mk(t);
     }
   }
-
   bool unbound() { return IsUnboundVar(VarOfTerm(gt())); }
-
   inline bool isVar() { return true; }       /// type check for unbound
   inline bool isAtom() { return false; }     ///  type check for atom
   inline bool isInteger() { return false; }  /// type check for integer