improv C++ interface.

CXX/yapa.hh

@@ -0,0 +1,96 @@
+#ifndef YAPA_HH
+#define YAPA_HH 1
+
+/**
+   Prolog operates over constants, called atoms
+   YAP, like lisp, associates properties with atoms.
+*/
+enum PropTag {
+  /// predicate
+  PRED_TAG                  = PEProp, // 0x0000,
+  /// db key, may be associated with a functor
+    DB_TAG                    = DBProperty, // 0x8000,
+  /// generic functor, may include sub-properties
+    FUNCTOR_TAG               = FunctorProperty, // 0xBB00,
+  // SPARSE_FUNCTOR_TAG        = 0xFFDF,
+  /// arithmetic function
+    ARITHMETIC_PROPERTY_TAG   = ExpProperty, // 0xFFE3,
+  /// map the atom to an integer
+    TRANSLATION_TAG           = TranslationProperty, // 0xFFF4,
+  /// SWI-STYLE ATOM Extension
+    BLOB_TAG                  = BlobProperty, // 0xFFF5,
+  /// named mutEX
+    MUTEX_TAG                 = MutexProperty, // 0xFFF6,
+  /// A typed array, may be in-db or in-stack deped
+    ARRAY_TAG                 = ArrayProperty, // 0xFFF7,    
+  /// atom does not fit ISO-LATIN-1
+    WIDE_TAG                  = WideAtomProperty, // 0xFFF8,
+  /// module
+    MODULE_TAG                = ModProperty, // 0xFFFA,
+  /// the original SICStus blackboard
+    BLACKBOARD_TAG            = BBProperty, // 0xFFFB,
+  /// asociate an atomic value with the atom
+    VALUE_TAG                 = ValProperty, // 0xFFFC,
+  /// Demoen's proposal for gkobal variables
+    GLOBAL_VAR_TAG            = GlobalProperty, // 0xFFFD
+  /// ensure the atom may not be garbafe colected
+    HOLD_TAG                  = HoldProperty, // 0xFFF
+  /// Prolog operator,        
+    OPERATOR_TAG              = OpProperty, // 0xFFFF,  
+    };
+
+/**
+ * @brief Atom
+ * A YAP data-base is a collection of atoms, where each atom has a name
+ * and a set of Properties. Examples of properties include functors,
+ * predicates, operators, modules, almost everything.
+ *
+ */
+class YAPAtom {
+  friend class YAPModuleProp;
+  friend class YAPPredicate;
+  friend class YAPFunctor;
+  friend class YAPAtomTerm;
+  friend class YAProp;
+  friend class YAPModule;
+  Atom a;
+  /// construct new YAPAtom from Atom
+  YAPAtom( Atom at ) { a = at; }
+public:
+  /// construct new YAPAtom from string
+  YAPAtom( const char * s) { a = Yap_LookupAtom( s ); }
+  /// construct new YAPAtom from wide string
+YAPAtom( const wchar_t * s) { a = Yap_LookupMaybeWideAtom( s ); }
+  /// construct new YAPAtom from max-length string
+YAPAtom( const char * s, size_t len) { a = Yap_LookupAtomWithLength( s, len ); }
+  /// construct new YAPAtom from max-length wide string
+  YAPAtom( const wchar_t * s, size_t len) { a = Yap_LookupMaybeWideAtomWithLength( s, len ); }
+  /// get name of atom
+  char *getName(void);
+  /// get prop of type 
+  Prop getProp( PropTag tag ) { return Yap_GetAProp( a , (PropFlags)tag ); }  
+};
+
+/**
+ * @brief Prop
+ * A YAP Propery is  ameta-class for everything one can in a atom.
+ * Examples of properties include functors,
+ * predicates, operators, modules, almost everything.
+ *
+ */
+class YAPProp {
+  friend class YAPModuleProp;
+  friend class YAPFunctor;
+  /// does nothing, p is defined by the subclass
+  YAPProp() { }
+  /// get type of prop
+  PropTag tag( Prop p )  { return (PropTag)(p->KindOfPE); }
+public:
+  /// get name of property
+  virtual YAPAtom name() = 0;
+virtual ~YAPProp() {};
+  
+};
+
+
+#endif /* YAPA_HH */

CXX/yapdb.hh

@@ -0,0 +1,318 @@
+
+#define YAP_CPP_DB_INTERFACE 1
+
+//! @{
+
+/**
+ *
+ *   @defgroup yap-cplus-db-interface Data-Base Component of YAP interface.
+ *
+ *   @ingroup yap-cplus-interface
+ *    @tableofcontents
+ *
+ *
+ * Data-base component of C++ interface to YAP. It manipulates sets of
+ * atoms, each one containing a number of props.
+ */
+
+class YAPTerm;
+
+class YAPError;
+
+class YAPModule;
+
+extern "C" {
+  static inline Term
+  Yap_CurrentModule( void )
+  {
+    CACHE_REGS
+      return CurrentModule;
+  }
+}
+
+/**
+ * @brief YAPModule
+ * A YAPModule describes a bare module, which in YAP is just a name.
+ *
+ * Info about the module is in YAPModuleProp
+ *
+ */
+class YAPModule : protected YAPAtomTerm {
+  friend class YAPPredicate;
+  YAPModule( Term t ): YAPAtomTerm( t ) {};
+  Term t() { return gt(); }
+public:
+  ~YAPModule( ) {};
+  YAPModule( ): YAPAtomTerm( Yap_CurrentModule() ) {};
+  YAPModule( YAPAtom t ): YAPAtomTerm( t ) {};
+};
+
+/**
+ * @brief YAPModuleProp
+ * A YAPModuleProp controls access to a module property.
+ *
+ */
+class YAPModuleProp: public YAPProp {
+  friend class YAPPredicate;
+  ModEntry *m;
+  
+  YAPModuleProp(ModEntry *mod)   {m = mod;};  
+  YAPModuleProp(Term tmod)  { m = Yap_GetModuleEntry(tmod); };  
+public:  
+  YAPModuleProp()  { m = Yap_GetModuleEntry(Yap_CurrentModule()); }; 
+  YAPModuleProp(YAPModule tmod) ;
+  virtual YAPModule module() { return YAPModule(m->AtomOfME); };
+};
+
+/**
+ * @brief YAPFunctor represents Prolog functors Name/Arity
+ */
+    class YAPFunctor: public YAPProp {
+    friend class YAPApplTerm;
+    friend class YAPPredicate;
+    Functor f;
+    /// Constructor: receives Prolog functor and casts it to YAPFunctor
+    ///
+    /// Notice that this is designed for internal use only.
+      YAPFunctor( Functor ff)  { f = ff; }
+    public:
+      ~YAPFunctor( )  {  };
+    /// Constructor: receives name as a string plus arity
+    ///
+    /// Notice that this is designed for ISO-LATIN-1 right now
+      YAPFunctor( char * s, arity_t arity)  { 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
+      YAPFunctor( wchar_t * s, arity_t arity) { f = Yap_MkFunctor( Yap_LookupWideAtom( s ), arity ) ; }
+    /// Constructor: receives name as an atom, plus arity
+    ///
+    /// This is the default method, and the most popi;at
+      YAPFunctor( YAPAtom at, arity_t arity)  { f = Yap_MkFunctor( at.a, arity ); }
+
+    /// Getter: extract name of functor as an atom
+    ///
+    /// this is for external usage.
+    YAPAtom name(void) {
+      return YAPAtom( NameOfFunctor( f ) );
+    }
+
+    /// Getter: extract arity of functor as an unsigned integer
+    ///
+    /// this is for external usage.
+      arity_t arity(void) {
+	return ArityOfFunctor( f );
+      }
+      
+  };
+
+/**
+ * @brief Predicates
+ *
+ * This class interfaces with PredEntry in Yatom.
+ */
+class YAPPredicate: public YAPModuleProp {
+  friend class YAPQuery;
+
+protected:
+  PredEntry *ap;
+
+  /// auxiliary routine to find a predicate in the current module.
+  PredEntry  *getPred( Term t, Term* &outp ) ;
+
+  /// String constructor for predicates
+  ///
+  /// It also communicates the array of arguments t[]
+  /// and the array of variables
+  /// back to yapquery
+  YAPPredicate(const char *s, Term* &out, Term& vnames ) throw (int);
+
+  /// Term constructor for predicates
+  ///
+  /// It is just a call to getPred
+  inline YAPPredicate(Term t) {
+    CELL *  v = NULL;
+    ap = getPred( t , v );
+  }
+
+  /// Cast constructor for predicates,
+  /// if we have the implementation data.
+  ///
+  inline YAPPredicate(PredEntry *pe) {
+    ap = pe;
+  }
+
+public:
+  ~YAPPredicate() {};
+
+  /// Functor constructor for predicates
+  ///
+  /// Asssumes that we use the current module.
+  YAPPredicate(YAPFunctor f)  {
+    ap = RepPredProp(PredPropByFunc(f.f,Yap_CurrentModule()));
+  };
+
+  /// Functor constructor for predicates, is given a specific module.
+  ///
+  inline YAPPredicate(YAPFunctor f, YAPTerm mod) {
+    ap = RepPredProp(PredPropByFunc(f.f,mod.t));
+  }
+
+  /// Name/arity constructor for predicates.
+  ///
+  inline YAPPredicate(YAPAtom at, YAPTerm mod) {
+    ap = RepPredProp(PredPropByAtom(at.a,mod.t));
+  }
+
+
+  /// Name/0 constructor for predicates.
+  ///
+  YAPPredicate(YAPAtom at);
+
+  /// Mod:Name/Arity constructor for predicates.
+  ///
+  inline YAPPredicate(YAPAtom at, arity_t arity, YAPModule mod) {
+    if (arity) {
+      Functor f = Yap_MkFunctor(at.a, arity);
+      ap = RepPredProp(PredPropByFunc(f,mod.t()));
+    } else {
+      ap = RepPredProp(PredPropByAtom(at.a,mod.t()));
+    }
+  }
+
+  /// Atom/Arity constructor for predicates.
+  ///
+  YAPPredicate(YAPAtom at, arity_t arity);
+
+
+  /// String constructor for predicates.
+  ///
+  /// String is a Prolog term, we extract the main functor after considering the module qualifiers.
+  inline YAPPredicate(const char *s) throw (int) {
+    Term t, tp;
+    t = YAP_ReadBuffer(s,&tp);
+    if (t == 0L)
+      throw YAPError::YAP_SYNTAX_ERROR;
+    CELL *  v;
+    ap = getPred( t, v);
+  }
+
+
+  /// String constructor for predicates, also keeps arguments in tp[]
+  ///
+  /// String is a Prolog term, we extract the main functor after considering the module qualifiers.
+  inline YAPPredicate(const char *s, Term* outp) throw (int) {
+    Term t, tp;
+    t = YAP_ReadBuffer(s,&tp);
+    if (t == 0L)
+      throw YAPError::YAP_SYNTAX_ERROR;
+    ap = getPred( t, outp );
+  }
+
+  /// module of a predicate
+  ///
+  /// notice that modules are currently treated as atoms, this should change.
+  YAPModule module() {
+    if (ap->ModuleOfPred == PROLOG_MODULE)
+      return  YAPModule(AtomProlog);
+    else
+      return  YAPModule(AtomOfTerm(ap->ModuleOfPred));
+  }
+
+  /// name of predicate
+  ///
+  /// notice that we return the atom, not a string.
+  YAPAtom name() { if (ap->ArityOfPE)
+      return  YAPAtom((Atom)ap->FunctorOfPred);
+    else
+      return  YAPAtom(NameOfFunctor(ap->FunctorOfPred));
+  }
+
+  /// arity of predicate
+  ///
+  /// we return a positive number.
+  arity_t getArity() { return ap->ArityOfPE; }
+};
+
+/**
+ * @brief PrologPredicate
+ *
+ * This class interfaces with Predicates Implemented in Prolog.
+ */
+class YAPPrologPredicate: public YAPPredicate {
+public:
+  YAPPrologPredicate(YAPAtom name,
+		     arity_t arity,
+		     YAPModule module = YAPModule(),
+		     bool tabled = false,
+		     bool logical_updates = false,
+                     bool local = false,
+		     bool sourced = true,
+		     bool discontiguous = false,
+                     bool multiFile = false,
+                     bool hidden = false,
+		     bool untraceable = false,
+		     bool unspyable = false,
+                     bool meta = false,
+                     bool sync = false,
+		     bool quasi_quotable = false,
+		     size_t mega_clause = 0
+		     );
+  void *assertClause( YAPTerm clause, bool last=true, YAPTerm source= YAPTerm(TermNil));
+  void *retractClause( YAPTerm skeleton, bool all=false);
+  void *clause( YAPTerm skeleton, YAPTerm &body );
+};
+
+/**
+ * @brief PrologPredicate
+ *
+ * This class interfaces with Predicates Implemented in Prolog.
+ */
+class YAPFLIP: public YAPPredicate {
+public:
+  YAPFLIP(CPredicate call,
+	  YAPAtom name,
+	  arity_t arity,
+	  YAPModule module = YAPModule(),
+	  CPredicate retry = 0,
+	  CPredicate cut = 0,
+	  size_t extra = 0,
+	  bool test = false
+	  ) : YAPPredicate( name, arity, module) {
+    if (retry) {
+      Yap_InitCPredBackCut(name.getName(), arity, extra, call, retry, cut, UserCPredFlag);
+    } else {
+      if (test) {
+        YAP_UserCPredicate (name.getName(),
+                            call, arity);
+      } else {
+        YAP_UserCPredicate (name.getName(),
+                            call, arity);
+      }
+    }
+      
+  };
+  YAPFLIP(const char *name,
+	  arity_t arity,
+          YAPModule module = YAPModule(),
+	  bool backtrackable = false
+	  ) : YAPPredicate( YAPAtom(name), arity, module) {
+    if (backtrackable) {
+      Yap_InitCPredBackCut(name, arity, 0, 0, 0, 0, UserCPredFlag);
+    } else {
+      YAP_UserCPredicate (name,
+                            0, arity);
+     }
+  };
+  bool addCall(CPredicate call) {
+    return Yap_AddCallToFli( ap, call );
+  }
+  bool addRetry(CPredicate call) {
+    return Yap_AddRetryToFli( ap, call );
+  }
+  bool addCut(CPredicate call) {
+    return Yap_AddCutToFli( ap, call );
+  }
+  
+};
+

CXX/yapi.cpp

@@ -5,11 +5,12 @@
 #include "SWI-Stream.h"
 
 
+
 YAPAtomTerm::YAPAtomTerm(char *s) { // build string
   BACKUP_H();
 
   CACHE_REGS
-  seq_tv_t inp, out;
+    seq_tv_t inp, out;
   inp.val.c = s;
   inp.type = YAP_STRING_CHARS;
   out.type = YAP_STRING_ATOM;
@@ -267,7 +268,7 @@ intptr_t YAPTerm::hashTerm(size_t sz, size_t depth, bool variant) {
   return out;
 }
 
-char *YAPTerm::text(void) {
+char *YAPTerm::text() {
   size_t sze = 4096, length;
   char *os;
   int enc;
@@ -281,7 +282,7 @@ char *YAPTerm::text(void) {
   return os;
 }
 
-char *YAPQuery::text(void) {
+char *YAPQuery::text() {
   size_t sze = 4096, length;
   char *os;
   int enc;
@@ -387,81 +388,18 @@ char *YAPAtom::getName(void) {
   }
 }
 
-
-YAPPredicate::YAPPredicate(const char *s, Term* &outp, YAPTerm &vnames) throw (int) {
-  CACHE_REGS
-  vnames = Yap_NewSlots(1 PASS_REGS);
-  Term t = Yap_StringToTerm(s, strlen(s)+1, Yap_GetFromSlot( vnames.t PASS_REGS));
-  if (t == 0L)
-    throw YAPError::YAP_SYNTAX_ERROR;
-  ap = getPred( t, outp );
-}
-
-YAPPredicate::YAPPredicate(YAPAtom at) {
-  CACHE_REGS
-  ap = RepPredProp(PredPropByAtom(at.a,CurrentModule));
-}
-
-YAPPredicate::YAPPredicate(YAPAtom at, arity_t arity) {
-  CACHE_REGS
-  if (arity) {
-      Functor f = Yap_MkFunctor(at.a, arity);
-      ap = RepPredProp(PredPropByFunc(f,CurrentModule));
-  } else {
-      ap = RepPredProp(PredPropByAtom(at.a,CurrentModule));
-  }
-}
-
-/// auxiliary routine to find a predicate in the current module.
-PredEntry  *YAPPredicate::getPred( Term t, Term* &outp ) {
-  CACHE_REGS
-  Term m = CurrentModule ;
-  { CACHE_REGS __android_log_print(ANDROID_LOG_ERROR,  __FUNCTION__, "H= %p, outp=%p", HR, outp) ; }
-  t = Yap_StripModule(t, &m);
-  if (IsVarTerm(t) || IsNumTerm(t)) {
-      ap = (PredEntry  *)NULL;
-      outp = (Term  *)NULL;
-  }
-  if (IsAtomTerm(t)) {
-      ap = RepPredProp(PredPropByAtom(AtomOfTerm(t), m));
-      if (outp) outp = (Term  *)NULL;
-  }  else if (IsPairTerm(t)) {
-      ap = RepPredProp(PredPropByFunc(FunctorCsult, PROLOG_MODULE));
-       outp = HR;
-      HR[0] = RepPair(t)[0];
-      HR[1] = m;
-      HR+=2;
-  } else {
-      Functor f = FunctorOfTerm(t);
-      if (IsExtensionFunctor(f)) {
-	  ap = (PredEntry  *)NULL;
-	  outp = (Term *)NULL;
-      } else {
-      ap = RepPredProp(PredPropByFunc(f, m));
-       outp = RepAppl(t)+1;
-      }
-  }
-  { CACHE_REGS __android_log_print(ANDROID_LOG_ERROR,  __FUNCTION__, "done H= %p, outp=%p", HR, outp) ; }
- return ap;
-}
-
-YAPPredicate::YAPPredicate(YAPFunctor f) {
-  CACHE_REGS
-  ap = RepPredProp(PredPropByFunc(f.f,CurrentModule));
-}
-
-
 void
 YAPQuery::initQuery( Term *ts )
 {
   CACHE_REGS
-
+    this->oq = (YAPQuery *)LOCAL_execution;
-  this->oq = (YAPQuery *)LOCAL_execution;
   LOCAL_execution = (struct open_query_struct *)this;
   this->q_open=1;
   this->q_state=0;
   this->q_flags = PL_Q_PASS_EXCEPTION;
-  this->q_g = ts;
+  this->q_g = ts;  
+  this->q_p = P;  
+  this->q_cp = CP;  
 }
 
 void
@@ -502,6 +440,7 @@ bool YAPQuery::next()
 {
   CACHE_REGS
   int result;
+  
   if (q_open != 1) return false;
   if (setjmp(((YAPQuery *)LOCAL_execution)->q_env))
     return false;
@@ -549,17 +488,6 @@ void YAPQuery::close()
   LOCAL_execution = (struct open_query_struct *)this->oq;
 }
 
-int YAPPredicate::call(YAPTerm t[])
-{
-  YAPQuery q = YAPQuery(*this, t);
-  int ret;
-
-  ret = q.next();
-  q.cut();
-  q.close();
-  return ret;
-}
-
 static YAPEngine *curren;
 
 #if __ANDROID__
@@ -644,3 +572,153 @@ YAPQuery *YAPEngine::query( char *s ) {
 }
 
 
+
+YAPPredicate::YAPPredicate(const char *s, Term* &outp, Term &vnames) throw (int) {
+  CACHE_REGS
+  yhandle_t sl  = Yap_NewSlots(1 PASS_REGS);
+  Term t = Yap_StringToTerm(s, strlen(s)+1,  sl );
+  if (t == 0L)
+    throw YAPError::YAP_SYNTAX_ERROR;
+  vnames = Yap_GetFromSlot( sl PASS_REGS );
+  ap = getPred( t, outp );
+}
+
+YAPPredicate::YAPPredicate(YAPAtom at) {
+  CACHE_REGS
+    ap = RepPredProp(PredPropByAtom(at.a,CurrentModule));
+}
+
+YAPPredicate::YAPPredicate(YAPAtom at, arity_t arity) {
+  CACHE_REGS
+    if (arity) {
+      Functor f = Yap_MkFunctor(at.a, arity);
+      ap = RepPredProp(PredPropByFunc(f,CurrentModule));
+    } else {
+      ap = RepPredProp(PredPropByAtom(at.a,CurrentModule));
+    }
+}
+
+/// auxiliary routine to find a predicate in the current module.
+PredEntry  *YAPPredicate::getPred( Term t, Term* &outp ) {
+  CACHE_REGS
+    Term m = CurrentModule ;
+  { CACHE_REGS __android_log_print(ANDROID_LOG_ERROR,  __FUNCTION__, "H= %p, outp=%p", HR, outp) ; }
+  t = Yap_StripModule(t, &m);
+  if (IsVarTerm(t) || IsNumTerm(t)) {
+    ap = (PredEntry  *)NULL;
+    outp = (Term  *)NULL;
+  }
+  if (IsAtomTerm(t)) {
+    ap = RepPredProp(PredPropByAtom(AtomOfTerm(t), m));
+    if (outp) outp = (Term  *)NULL;
+  }  else if (IsPairTerm(t)) {
+    ap = RepPredProp(PredPropByFunc(FunctorCsult, PROLOG_MODULE));
+    outp = HR;
+    HR[0] = RepPair(t)[0];
+    HR[1] = m;
+    HR+=2;
+  } else {
+    Functor f = FunctorOfTerm(t);
+    if (IsExtensionFunctor(f)) {
+      ap = (PredEntry  *)NULL;
+      outp = (Term *)NULL;
+    } else {
+      ap = RepPredProp(PredPropByFunc(f, m));
+      outp = RepAppl(t)+1;
+    }
+  }
+  { CACHE_REGS __android_log_print(ANDROID_LOG_ERROR,  __FUNCTION__, "done H= %p, outp=%p", HR, outp) ; }
+  return ap;
+}
+
+
+YAPPrologPredicate::YAPPrologPredicate(YAPAtom name,
+                                       arity_t arity,
+                                       YAPModule mod,
+                                       bool tabled,
+                                       bool logical_updates,
+                                       bool thread_local,
+                                       bool sourced,
+                                       bool discontiguous,
+                                       bool multiFile,
+                                       bool hidden,
+                                       bool untraceable,
+                                       bool unspyable,
+                                       bool meta,
+                                       bool moduleTransparent,
+                                       bool quasiQuotable,
+                                       size_t mega_clause
+                                       ) : YAPPredicate(name, arity, mod) {
+  if (!ap) return;
+  if (thread_local) {
+    if (ap->cs.p_code.NOfClauses || tabled)
+      return;
+    ap->PredFlags |= (ThreadLocalPredFlag|LogUpdatePredFlag);
+  } else if (logical_updates) {
+    if (ap->cs.p_code.NOfClauses || tabled)
+      return;
+    ap->PredFlags |= LogUpdatePredFlag;
+    ap->CodeOfPred = FAILCODE;
+    ap->OpcodeOfPred = FAILCODE->opc;
+  }
+  if (tabled) {
+    ap->PredFlags |= TabledPredFlag;
+    if (ap->cs.p_code.NOfClauses || tabled)
+      return;
+    ap->PredFlags |= TabledPredFlag;
+  }
+  if (sourced) {
+    ap->PredFlags |= SourcePredFlag;
+  }
+  if (discontiguous) {
+    ap->PredFlags |= DiscontiguousPredFlag;
+  }
+  if (multiFile) {
+    ap->PredFlags |= MultiFileFlag;
+  }
+  if (hidden) {
+    ap->PredFlags |= HiddenPredFlag;
+  }
+  if (untraceable) {
+    ap->PredFlags |= SourcePredFlag;
+  }
+  if (unspyable) {
+    ap->PredFlags |= NoSpyPredFlag;
+  }
+  if (meta) {
+    ap->PredFlags |= MetaPredFlag;
+  } else if (moduleTransparent) {
+    ap->PredFlags |= ModuleTransparentPredFlag;
+  }
+  if (quasiQuotable) {
+    ap->PredFlags |= QuasiQuotationPredFlag;
+  }
+  if (untraceable) {
+    ap->PredFlags |= SourcePredFlag;
+  }
+  if (hidden) {
+    ap->PredFlags |= SourcePredFlag;
+  }
+}
+
+void *YAPPrologPredicate::assertClause( YAPTerm clause, bool last, YAPTerm source) {
+  CACHE_REGS
+
+    Term tt = clause.gt();
+  Term sourcet  = source.gt();
+  yamop *codeaddr = Yap_cclause(tt, PP->ArityOfPE, CurrentModule, sourcet); /* vsc: give the number of arguments
+                                                                               to cclause in case there is overflow */
+  Term ntt = clause.gt();
+  if (LOCAL_ErrorMessage)
+    return 0;
+  Term *tref = &ntt;
+  if (Yap_addclause(ntt, codeaddr, (last ? 0 : 2), CurrentModule, tref))
+    return tref;
+  return 0;
+}
+void* YAPPrologPredicate::retractClause( YAPTerm skeleton, bool all) {
+  return 0;
+}
+void* YAPPrologPredicate::clause( YAPTerm skeleton, YAPTerm &body ) {
+  return 0;
+}

CXX/yapi.hh

@@ -31,15 +31,7 @@
 extern "C" {
 
 #include <stddef.h>
-#ifdef __cplusplus
+  
-#define old_cplusplus __cplusplus
-#undef __cplusplus
-#endif
-#ifdef  old_cplusplus
-#define __cplusplus old_cplusplus
-#undef old_cplusplus
-#endif
-
 #include "Yap.h"
 
 #include "Yatom.h"
@@ -60,8 +52,6 @@ extern "C" {
 
 #include "YapText.h"
 
-#include "yapie.hh"
-
 #if HAVE_STDARG_H
 #include <stdarg.h>
 #endif
@@ -88,6 +78,7 @@ extern "C" {
   // it shouldn't
 }
 
+
 //#include <vector>
 
 
@@ -97,503 +88,19 @@ class YAPFunctor;
 class YAPApplTerm;
 class YAPPairTerm;
 class YAPQuery;
+class YAPModule;
+class YAPError;
+class YAPPredicate;
 
-/**
+#include "yapa.hh"
- * @brief Generic Prolog Term
- */
-class YAPTerm {
-  friend class YAPPredicate;
-  friend class YAPApplTerm;
-  friend class YAPPairTerm;
-  friend class YAPListTerm;
-  friend class YAPQuery;
-protected:
-  yhandle_t t; /// handle to term, equivalent to term_t
-  void mk(Term t0); /// internal method to convert from term to handle
-  Term gt(); /// get handle and obtain term
-  YAPTerm(Term tn) {  mk( tn ); } /// private method to convert from Term (internal YAP representation) to YAPTerm
-  inline Term term() { return gt(); } /// private method to convert from YAPTerm to Term (internal YAP representation)
-public:
-  // do nothing constructor
-  YAPTerm() { mk(TermNil); }
-  /// integer to term
-  YAPTerm(intptr_t i);
-  /// pointer to term
-  YAPTerm(void *ptr);
-  /// parse string s and construct a term.
-  YAPTerm(char *s) { Term tp ; mk( YAP_ReadBuffer(s,&tp) );  }
-  /// extract the tag of a term, after dereferencing.
-  YAP_tag_t  tag();
-  /// copy the term ( term copy )
-  YAPTerm  deepCopy();
-  //const YAPTerm *vars();
-  /// this term is == to t1
-  bool exactlyEqual(YAPTerm t1);
-  bool unify(YAPTerm t1);     /// t = t1
-  bool unifiable(YAPTerm t1);  /// we can unify t and t1
-  bool variant(YAPTerm t1);   /// t =@= t1, the two terms are equal up to variable renaming
-  intptr_t hashTerm(size_t sz, size_t depth, bool variant); /// term hash,
-  bool isVar() { return IsVarTerm( gt() ); }   /// type check for unbound
-  bool isAtom() { return IsAtomTerm( gt() ); } ///  type check for atom
-  bool isInteger() { return IsIntegerTerm( gt() ); } /// type check for integer
-  bool isFloat() { return IsFloatTerm( gt() ); } /// type check for floating-point
-  bool isString() { return IsStringTerm( gt() ); } /// type check for a string " ... "
-  bool isCompound() { return !(IsVarTerm( gt() ) || IsNumTerm( gt() )); } /// is a primitive term
-  bool isAppl() { return IsApplTerm( gt() ); } /// is a structured term
-  bool isPair() { return IsPairTerm( gt() ); } /// is a pair term
-  bool isGround() { return Yap_IsGroundTerm( gt() ); } /// term is ground
-  bool isList() { return Yap_IsListTerm( gt() ); } /// term is a list
 
-  /// extract the argument i of the term, where i in 1...arity
+#include "yapie.hh"
-  inline YAPTerm getArg(int i) {
-   Term t0 = gt();
-    if (IsApplTerm(t0))
-      return YAPTerm(ArgOfTerm(i, t0));
-    else if (IsPairTerm(t0)) {
-	if (i==1)
-	  return YAPTerm(HeadOfTerm(t0));
-	if (i==2)
-	  return YAPTerm(TailOfTerm(t0));
-    }
-    return YAPTerm((Term)0);
-  }
 
-  /// return a string with a textual representation of the term
+#include "yapt.hh"
-  char *text();
-};
 
-/**
+#include "yapdb.hh"
- * @brief Variable Term
- */
-class YAPVarTerm: public YAPTerm {
-  YAPVarTerm(Term t) { if (IsVarTerm(t)) mk( t ); }
-public:
-  /// constructor
-  YAPVarTerm();
-  /// get the internal representation
-  CELL *getVar() { return VarOfTerm( gt() ); }
-  /// is the variable bound to another one
-  bool unbound() { return IsUnboundVar(VarOfTerm( gt() )); }
-};
 
-/**
+#include "yapq.hh"
- * @brief Compound Term
- */
-class YAPApplTerm: public YAPTerm {
-  friend class YAPTerm;
-  YAPApplTerm(Term t0) { mk(t0); }
-public:
-  YAPApplTerm(YAPTerm t0) { mk(t0.term()); }
-  YAPApplTerm(YAPFunctor f, YAPTerm ts[]);
-  YAPApplTerm(YAPFunctor f);
-  YAPFunctor getFunctor();
-  YAPTerm getArg(int i);
-};
-
-/**
- * @brief List Constructor Term
- */
-class YAPPairTerm: public YAPTerm {
-  friend class YAPTerm;
-  YAPPairTerm(Term t0) { if (IsPairTerm(t0)) mk( t0 );  else mk(0); }
-public:
-  YAPPairTerm(YAPTerm hd, YAPTerm tl);
-  YAPPairTerm();
-  YAPTerm getHead() { return  YAPTerm(HeadOfTerm( gt() )); }
-  YAPTerm getTail() { return  YAPTerm(TailOfTerm( gt() )); }
-};
-
-/**
- * @brief Integer Term
- */
-
-class YAPIntegerTerm: public YAPTerm {
-public:
-  YAPIntegerTerm(intptr_t i);
-  intptr_t getInteger() { return  IntegerOfTerm( gt() ); }
-  bool isTagged() { return IsIntTerm( gt() ); }
-};
-
-class YAPListTerm: public YAPTerm {
-public:
-  /// Create a list term out of a standard term. Check if a valid operation.
-  ///
-  /// @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() { Term *tailp; Term t1 = gt(); return Yap_SkipList(&t1, &tailp); }
-  /// Extract the first element of a list.
-  ///
-  /// @param[in] the list
-  YAPTerm car();
-  /// Extract the tail elements of a list.
-  ///
-  /// @param[in] the list
-  YAPListTerm cdr()
-  {
-    Term to = gt();
-    if (IsPairTerm( to ))
-      return YAPListTerm(TailOfTerm( to ));
-    else
-      return MkIntTerm(-1);
-  }
-
-  /// Check if the list is empty.
-  ///
-  /// @param[in] the list
-  bool nil();
-};
-
-/**
- * @brief Atom
- */
-class YAPAtom {
-  friend class YAPPredicate;
-  friend class YAPFunctor;
-  friend class YAPAtomTerm;
-  Atom a;
-  /// construct new YAPAtom from Atom
-  YAPAtom( Atom at ) { a = at; }
-public:
-  /// construct new YAPAtom from string
-  YAPAtom( char * s) { a = Yap_LookupAtom( s ); }
-  /// construct new YAPAtom from wide string
-  YAPAtom( wchar_t * s) { a = Yap_LookupMaybeWideAtom( s ); }
-  /// construct new YAPAtom from max-length string
-  YAPAtom( char * s, size_t len) { a = Yap_LookupAtomWithLength( s, len ); }
-  /// construct new YAPAtom from max-length wide string
-  YAPAtom( wchar_t * s, size_t len) { a = Yap_LookupMaybeWideAtomWithLength( s, len ); }
-  /// get name of atom
-  char *getName(void);
-};
-
-/**
- * @brief String Term
- */
-class 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() ); }
-};
-
-/**
- * @brief Atom Term
- */
-class YAPAtomTerm: public YAPTerm {
-public:
-  YAPAtomTerm(YAPAtom a): YAPTerm() { mk( MkAtomTerm(a.a) ); }
-  YAPAtomTerm(Atom a): YAPTerm()  { mk( MkAtomTerm(a) ); }
-  YAPAtomTerm(char *s) ;
-  YAPAtomTerm(char *s, size_t len);
-  YAPAtomTerm(wchar_t *s) ;
-  YAPAtomTerm(wchar_t *s, size_t len);
-  YAPAtom getAtom() { return YAPAtom(AtomOfTerm( gt() )); }
-};
-
-/**
- * @brief YAPFunctor represents Prolog functors Name/Arity
- */
-class YAPFunctor {
-  friend class YAPApplTerm;
-  friend class YAPPredicate;
-  Functor f;
-  /// Constructor: receives Prolog functor and casts it to YAPFunctor
-  ///
-  /// Notice that this is designed for internal use only.
-  YAPFunctor( Functor ff) { f = ff; }
-public:
-  /// Constructor: receives name as a string plus arity
-  ///
-  /// Notice that this is designed for ISO-LATIN-1 right now
-  YAPFunctor( char * s, arity_t arity) { 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
-  YAPFunctor( wchar_t * s, arity_t arity) { f = Yap_MkFunctor( Yap_LookupWideAtom( s ), arity ); }
-  /// Constructor: receives name as an atom, plus arity
-  ///
-  /// This is the default method, and the most popi;at
-  YAPFunctor( YAPAtom at, arity_t arity) { f = Yap_MkFunctor( at.a, arity ); }
-
-  /// Getter: extract name of functor as an atom
-  ///
-  /// this is for external usage.
-  YAPAtom name(void) {
-  return YAPAtom( NameOfFunctor( f ) );
-  }
-
-  /// Getter: extract arity of functor as an unsigned integer
-  ///
-  /// this is for external usage.
-  arity_t arity(void) {
-    return ArityOfFunctor( f );
-  }
-};
-
-/**
- * @brief Predicates
- *
- * This class interfaces with PredEntry in Yatom.g
- */
-class YAPPredicate {
-  friend class YAPQuery;
-
-private:
-  PredEntry *ap;
-
-  /// auxiliary routine to find a predicate in the current module.
-   PredEntry  *getPred( Term t, Term* &outp ) ;
-
-  /// String constructor for predicates
-  ///
-  /// It also communicates the array of arguments t[]  abd the array of variables
-  /// back to yapquery
-  YAPPredicate(const char *s, Term* &outp, YAPTerm& vnames ) throw (int);
-
-  /// Term constructor for predicates
-  ///
-  /// It is just a call to getPred
-  inline YAPPredicate(Term t) {
-	CELL *  v = NULL;
-    ap = getPred( t , v );
-  }
-
-  /// Cast constructor for predicates,
-  /// if we have the implementation data.
-  ///
-  inline YAPPredicate(PredEntry *pe) {
-    ap = pe;
-  }
-
-public:
-
-  /// Functor constructor for predicates
-  ///
-  /// Asssumes that we use the current module.
-  YAPPredicate(YAPFunctor f);
-
-  /// Functor constructor for predicates, is given a specific module.
-  ///
-  inline YAPPredicate(YAPFunctor f, YAPTerm mod) {
-    ap = RepPredProp(PredPropByFunc(f.f,mod.t));
-  }
-
-  /// Name/arity constructor for predicates.
-  ///
-  inline YAPPredicate(YAPAtom at, YAPTerm mod) {
-    ap = RepPredProp(PredPropByAtom(at.a,mod.t));
-  }
-
-
-  /// Name/0 constructor for predicates.
-  ///
-  YAPPredicate(YAPAtom at);
-
-  /// Mod:Name/Arity constructor for predicates.
-  ///
-  inline YAPPredicate(YAPAtom at, arity_t arity, YAPTerm mod) {
-    if (arity) {
-	Functor f = Yap_MkFunctor(at.a, arity);
-	ap = RepPredProp(PredPropByFunc(f,mod.t));
-    } else {
-	ap = RepPredProp(PredPropByAtom(at.a,mod.t));
-    }
-  }
-
-  /// Atom/Arity constructor for predicates.
-  ///
-   YAPPredicate(YAPAtom at, arity_t arity);
-
-
-  /// String constructor for predicates.
-  ///
-  /// String is a Prolog term, we extract the main functor after considering the module qualifiers.
-  inline YAPPredicate(char *s) throw (int) {
-    Term t, tp;
-    t = YAP_ReadBuffer(s,&tp);
-    if (t == 0L)
-      throw YAPError::YAP_SYNTAX_ERROR;
-	CELL *  v;
-    ap = getPred( t, v);
-  }
-
-
-  /// String constructor for predicates, also keeps arguments in tp[]
-  ///
-  /// String is a Prolog term, we extract the main functor after considering the module qualifiers.
- inline YAPPredicate(char *s, Term* &outp) throw (int) {
-    Term t, tp;
-    t = YAP_ReadBuffer(s,&tp);
-    if (t == 0L)
-      throw YAPError::YAP_SYNTAX_ERROR;
-    ap = getPred( t, outp );
-  }
-
- /// meta-call this predicate, with arguments ts[]
- ///
- int call(YAPTerm ts[]);
-
-  /// module of a predicate
-  ///
-  /// notice that modules are currently treated as atoms, this should change.
-  YAPAtom module() {
-    if (ap->ModuleOfPred == PROLOG_MODULE)
-      return  YAPAtom(AtomProlog);
-    else
-      return  YAPAtom(AtomOfTerm(ap->ModuleOfPred));
-  }
-
-  /// name of predicate
-  ///
-  /// notice that we return the atom, not a string.
-  YAPAtom name() { if (ap->ArityOfPE)
-    return  YAPAtom((Atom)ap->FunctorOfPred);
-  else
-    return  YAPAtom(NameOfFunctor(ap->FunctorOfPred));
-  }
-
-  /// arity of predicate
-  ///
-  /// we return a positive number.
-  arity_t getArity() { return ap->ArityOfPE; }
-
-};
-
-/**
- * @brief Queries
- *
- * interface to a YAP Query;
- * uses an SWI-like status info internally.
- */
-class YAPQuery: public YAPPredicate {
-  int q_open;
-  int q_state;
-  Term *q_g;
-  yamop *q_p, *q_cp;
-  jmp_buf q_env;
-  int q_flags;
-  YAP_dogoalinfo q_h;
-  YAPQuery *oq;
-  YAPTerm vnames;
-  void initQuery( Term ts[] );
-  void initQuery( YAPTerm t[], arity_t arity  );
-public:
-  /// main constructor, uses a predicate and an array of terms
-  ///
-  /// It is given a YAPPredicate _p_ , and an array of terms that must have at least
-  /// the same arity as the functor.
-  YAPQuery(YAPPredicate p, YAPTerm t[]);
-  /// full constructor,
-  ///
-  /// It is given a functor, module, and an array of terms that must have at least
-  /// the same arity as the functor.
-  YAPQuery(YAPFunctor f, YAPTerm mod, YAPTerm t[]);
-  /// functor/term constructor,
-  ///
-  /// It is given a functor, and an array of terms that must have at least
-  /// the same arity as the functor. Works within the current module.
-  YAPQuery(YAPFunctor f, YAPTerm t[]);
-  /// string constructor without varnames
-  ///
-  /// It is given a string, calls the parser and obtains a Prolog term that should be a callable
-  /// goal. It does not ask for a list of variables.
-  inline YAPQuery(char *s): YAPPredicate(s, q_g)
-  {
-    initQuery( q_g );
-  }
-  /// string constructor with varnames
-  ///
-  /// It is given a string, calls the parser and obtains a Prolog term that should be a callable
-  /// goal and a list of variables. Useful for top-level simulation. Works within the current module.
-  inline YAPQuery(char *s, YAPTerm &vnames): YAPPredicate(s, q_g, vnames)
-  {
-    initQuery( q_g );
-  }
-  /// set flags for query execution, currently only for exception handling
-  void setFlag(int flag) {q_flags |= flag; }
-  /// reset flags for query execution, currently only for exception handling
-  void resetFlag(int flag) {q_flags &= ~flag; }
-  ///  first query
-  ///
-  /// actually implemented by calling the next();
-  inline bool first() { return next(); }
-  /// ask for the next solution of the current query
-  /// same call for every solution
-  bool next();
-  /// represent the top-goal
-  char *text();
-  /// remove alternatives in the current search space, and finish the current query
-  void cut();
-  /// finish the current query: undo all bindings.
-  void close();
-  /// query variables.
-  YAPListTerm namedVars();
-};
-
-// Java support
-
-/// This class implements a callback Prolog-side. It will be inherited by the Java or Python
-/// class that actually implements the callback.
-class YAPCallback {
-public:
-      virtual ~YAPCallback() { printf("~YAPCallback\n"); }
-      virtual void run() { __android_log_print(ANDROID_LOG_INFO, __FUNCTION__, "callback");  }
-      virtual void run(char *s) {  }
-};
-
-/**
- * @brief YAP Engine: takes care of the execution environment
-   where we can go executing goals.
- *
- *
- */
-class YAPEngine {
-private:
-  YAPCallback *_callback;
-  YAP_init_args init_args;
-  YAPError yerror;
-public:
-  YAPEngine(char *savedState = (char *)NULL,
-            size_t stackSize = 0,
-            size_t trailSize = 0,
-            size_t maxStackSize = 0,
-            size_t maxTrailSize = 0,
-            char *libDir = (char *)NULL,
-            char *bootFile = (char *)NULL,
-            char *goal = (char *)NULL,
-            char *topLevel = (char *)NULL,
-            bool script = FALSE,
-            bool fastBoot = FALSE,
-            YAPCallback *callback=(YAPCallback *)NULL);  /// construct a new engine, including aaccess to callbacks
-  /// kill engine
-  ~YAPEngine() { delYAPCallback(); }
-  /// remove current callback
-  void delYAPCallback() { _callback = 0; }
-  /// set a new callback
-  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) {  if (_callback) _callback->run(s); }
-  /// execute the callback with a text argument.
-  YAPError hasError( ) {  return yerror; }
-  /// build a query on the engine
-  YAPQuery *query( char *s );
-};
 
 /**
  * @}

CXX/yapq.hh

@@ -0,0 +1,127 @@
+#ifndef YAPQ_HH
+#define YAPQ_HH 1
+
+/**
+   Queries and engines
+*/
+
+/**
+ * @brief Queries
+ *
+ * interface to a YAP Query;
+ * uses an SWI-like status info internally.
+ */
+class YAPQuery: public YAPPredicate {
+  int q_open;
+  int q_state;
+  Term *q_g;
+  yamop *q_p, *q_cp;
+  jmp_buf q_env;
+  int q_flags;
+  Term vs;
+  YAP_dogoalinfo q_h;
+  YAPQuery *oq;
+  YAPTerm vnames;
+  void initQuery( Term ts[] );
+  void initQuery( YAPTerm t[], arity_t arity  );
+public:
+  /// main constructor, uses a predicate and an array of terms
+  ///
+  /// It is given a YAPPredicate _p_ , and an array of terms that must have at least
+  /// the same arity as the functor.
+  YAPQuery(YAPPredicate p, YAPTerm t[]);
+  /// full constructor,
+  ///
+  /// It is given a functor, module, and an array of terms that must have at least
+  /// the same arity as the functor.
+  YAPQuery(YAPFunctor f, YAPTerm mod, YAPTerm t[]);
+  /// functor/term constructor,
+  ///
+  /// It is given a functor, and an array of terms that must have at least
+  /// the same arity as the functor. Works within the current module.
+  YAPQuery(YAPFunctor f, YAPTerm t[]);
+  /// string constructor without varnames
+  ///
+  /// It is given a string, calls the parser and obtains a Prolog term that should be a callable
+  /// goal. It does not ask for a list of variables.
+  inline YAPQuery(const char *s): YAPPredicate(s, q_g, vs)
+  {
+    vnames = YAPTerm( vs );
+    initQuery( q_g );
+  }
+ 
+  /// set flags for query execution, currently only for exception handling
+  void setFlag(int flag) {q_flags |= flag; }
+  /// reset flags for query execution, currently only for exception handling
+  void resetFlag(int flag) {q_flags &= ~flag; }
+  ///  first query
+  ///
+  /// actually implemented by calling the next();
+  inline bool first() { return next(); }
+  /// ask for the next solution of the current query
+  /// same call for every solution
+  bool next();
+  /// represent the top-goal
+  char *text();
+  /// remove alternatives in the current search space, and finish the current query
+  void cut();
+  /// finish the current query: undo all bindings.
+  void close();
+  /// query variables.
+  YAPListTerm namedVars();
+};
+
+// Java support
+
+/// This class implements a callback Prolog-side. It will be inherited by the Java or Python
+/// class that actually implements the callback.
+class YAPCallback {
+public:
+  virtual ~YAPCallback() { printf("~YAPCallback\n"); }
+  virtual void run() { __android_log_print(ANDROID_LOG_INFO, __FUNCTION__, "callback");  }
+  virtual void run(char *s) {  }
+};
+
+/**
+ * @brief YAP Engine: takes care of the execution environment
+ where we can go executing goals.
+ *
+ *
+ */
+class YAPEngine {
+private:
+  YAPCallback *_callback;
+  YAP_init_args init_args;
+  YAPError yerror;
+public:
+  YAPEngine(char *savedState = (char *)NULL,
+            size_t stackSize = 0,
+            size_t trailSize = 0,
+            size_t maxStackSize = 0,
+            size_t maxTrailSize = 0,
+            char *libDir = (char *)NULL,
+            char *bootFile = (char *)NULL,
+            char *goal = (char *)NULL,
+            char *topLevel = (char *)NULL,
+            bool script = FALSE,
+            bool fastBoot = FALSE,
+            YAPCallback *callback=(YAPCallback *)NULL);  /// construct a new engine, including aaccess to callbacks
+  /// kill engine
+  ~YAPEngine() { delYAPCallback(); }
+  /// remove current callback
+  void delYAPCallback() { _callback = 0; }
+  /// set a new callback
+  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) {  if (_callback) _callback->run(s); }
+  /// execute the callback with a text argument.
+  YAPError hasError( ) {  return yerror; }
+  /// build a query on the engine
+  YAPQuery *query( char *s );
+  /// current module for the engine
+  YAPModule currentModule( ) { return YAPModule( ) ; }
+};
+
+#endif /* YAPQ_HH */

CXX/yapt.hh

@@ -0,0 +1,202 @@
+#ifndef YAPT_HH
+#define YAPT_HH 1
+
+/**
+ * @brief Generic Prolog Term
+ */
+class YAPTerm {
+  friend class YAPPredicate;
+  friend class YAPPrologPredicate;
+  friend class YAPQuery;
+  friend class YAPModule;
+  friend class YAPModuleProp;
+protected:
+  yhandle_t t; /// handle to term, equivalent to term_t
+  void mk(Term t0); /// internal method to convert from term to handle
+  Term gt(); /// get handle and obtain term
+public:
+  ~YAPTerm() {};
+  YAPTerm(Term tn) {  mk( tn ); } /// private method to convert from Term (internal YAP representation) to YAPTerm
+  // do nothing constructor
+  YAPTerm() { mk(TermNil); }
+  /// integer to term
+  YAPTerm(intptr_t i);
+  /// pointer to term
+  YAPTerm(void *ptr);
+  /// parse string s and construct a term.
+  YAPTerm(char *s) { Term tp ; mk( YAP_ReadBuffer(s,&tp) );  }
+  /// extract the tag of a term, after dereferencing.
+  YAP_tag_t  tag();
+  /// copy the term ( term copy )
+  YAPTerm  deepCopy();
+  inline Term term() { return gt(); } /// private method to convert from YAPTerm to Term (internal YAP representation)
+  //const YAPTerm *vars();
+  /// this term is == to t1
+  bool exactlyEqual(YAPTerm t1);
+  bool unify(YAPTerm t1);     /// t = t1
+  bool unifiable(YAPTerm t1);  /// we can unify t and t1
+  bool variant(YAPTerm t1);   /// t =@= t1, the two terms are equal up to variable renaming
+  intptr_t hashTerm(size_t sz, size_t depth, bool variant); /// term hash,
+  bool isVar() { return IsVarTerm( gt() ); }   /// type check for unbound
+  bool isAtom() { return IsAtomTerm( gt() ); } ///  type check for atom
+  bool isInteger() { return IsIntegerTerm( gt() ); } /// type check for integer
+  bool isFloat() { return IsFloatTerm( gt() ); } /// type check for floating-point
+  bool isString() { return IsStringTerm( gt() ); } /// type check for a string " ... "
+  bool isCompound() { return !(IsVarTerm( gt() ) || IsNumTerm( gt() )); } /// is a primitive term
+  bool isAppl() { return IsApplTerm( gt() ); } /// is a structured term
+  bool isPair() { return IsPairTerm( gt() ); } /// is a pair term
+  bool isGround() { return Yap_IsGroundTerm( gt() ); } /// term is ground
+  bool isList() { return Yap_IsListTerm( gt() ); } /// term is a list
+
+  /// extract the argument i of the term, where i in 1...arity
+  inline YAPTerm getArg(int i) {
+    Term t0 = gt();
+    if (IsApplTerm(t0))
+      return YAPTerm(ArgOfTerm(i, t0));
+    else if (IsPairTerm(t0)) {
+      if (i==1)
+        return YAPTerm(HeadOfTerm(t0));
+      if (i==2)
+        return YAPTerm(TailOfTerm(t0));
+    }
+    return YAPTerm((Term)0);
+  }
+
+  /// return a string with a textual representation of the term
+  char *text();
+};
+
+/**
+ * @brief Variable Term
+ */
+class YAPVarTerm: private YAPTerm {
+  YAPVarTerm(Term t) { if (IsVarTerm(t)) mk( t ); }
+public:
+  /// constructor
+  YAPVarTerm();
+  /// get the internal representation
+  CELL *getVar() { return VarOfTerm( gt() ); }
+  /// is the variable bound to another one
+  bool unbound() { return IsUnboundVar(VarOfTerm( gt() )); }
+};
+
+/**
+ * @brief Compound Term
+ */
+class YAPApplTerm: YAPTerm {
+  friend class YAPTerm;
+  YAPApplTerm(Term t0) { mk(t0); }
+public:
+  ~YAPApplTerm() {  }
+  YAPApplTerm(YAPFunctor f, YAPTerm ts[]);
+  YAPApplTerm(YAPFunctor f);
+  YAPFunctor getFunctor();
+  YAPTerm getArg(int i);
+};
+
+/**
+ * @brief List Constructor Term
+ */
+class YAPPairTerm: YAPTerm {
+  friend class YAPTerm;
+  YAPPairTerm(Term t0) { if (IsPairTerm(t0)) mk( t0 );  else mk(0); }
+public:
+  YAPPairTerm(YAPTerm hd, YAPTerm tl);
+  YAPPairTerm();
+  YAPTerm getHead() { return  YAPTerm(HeadOfTerm( gt() )); }
+  YAPTerm getTail() { return  YAPTerm(TailOfTerm( gt() )); }
+};
+
+/**
+ * @brief Integer Term
+ */
+
+class YAPIntegerTerm: private YAPTerm {
+public:
+  YAPIntegerTerm(intptr_t i);
+  intptr_t getInteger() { return  IntegerOfTerm( gt() ); }
+  bool isTagged() { return IsIntTerm( gt() ); }
+};
+
+class YAPListTerm: private YAPTerm {
+public:
+  /// Create a list term out of a standard term. Check if a valid operation.
+  ///
+  /// @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() { Term *tailp; Term t1 = gt(); return Yap_SkipList(&t1, &tailp); }
+  /// Extract the first element of a list.
+  ///
+  /// @param[in] the list
+  YAPTerm car();
+  /// Extract the tail elements of a list.
+  ///
+  /// @param[in] the list
+  YAPListTerm cdr()
+  {
+    Term to = gt();
+    if (IsPairTerm( to ))
+      return YAPListTerm(TailOfTerm( to ));
+    else
+      return MkIntTerm(-1);
+  }
+
+  /// Check if the list is empty.
+  ///
+  /// @param[in] the list
+  bool nil();
+};
+
+/**
+ * @brief String Term
+ */
+class YAPStringTerm: private 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() ); }
+};
+
+/**
+ * @brief Atom Term
+ * Term Representation of an Atom
+ */
+class YAPAtomTerm: YAPTerm {
+  friend class YAPModule;
+  // Constructor: receives a C-atom;
+  YAPAtomTerm(Atom a)  { mk( MkAtomTerm(a) ); }
+  YAPAtomTerm(Term t): YAPTerm(t)  { IsAtomTerm(t); }
+  // Getter for Prolog atom
+  Term getTerm() { return t; }
+public:
+  // 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);
+  // Getter: outputs the atom;  
+  YAPAtom getAtom() { return YAPAtom(AtomOfTerm( gt() )); }
+  // Getter: outputs the name as a sequence of ISO-LATIN1 codes;  
+  const char *getName() { return AtomOfTerm( gt() )->StrOfAE; }
+};
+
+#endif /* YAPT_HH */