keep working on C++ interface.

CXX/yapi.cpp

@@ -408,7 +408,7 @@ int YAPPredicate::call(YAPTerm t[])
 	return ret;
 }
 
-YAP::YAP(YAPParams const& params)
+YAPEngine::YAPEngine(YAPParams const& params)
 { YAP_Init( (YAP_init_args *)&params.init_args ); }
 
 

CXX/yapi.hh

@@ -1,9 +1,26 @@
 
 #define YAP_CPP_INTERFACE 1
 
+/**
+ *
+ *   @defgroup yap-cplus-interface An object oriented interface for YAP.
+ *
+ *
+ *    @tableofcontents
+ *
+ *
+ * C++ interface to YAP. Designed to be object oriented and to fit naturally
+ * with the swig interface language generator. It uses ideas from the old YAP
+ * interface and from the SWI foreign language interface.
+ *
+ */
 #include <stdlib.h>
 
+#include <config.h>
+
+#if USE_GMP
 #include <gmp.h>
+#endif
 
 extern "C" {
 
@@ -43,18 +60,24 @@ extern "C" {
 #include <windows.h>
 #endif
 
-  // taken from yap_structs.h
+// taken from yap_structs.h
 #include "iopreds.h"
 
 // we cannot consult YapInterface.h, that conflicts with what we declare, though
 // it shouldn't
 }
 
+//#include <vector>
+
+class YAPEngine;
 class YAPTermHandle;
 class YAPAtom;
 class YAPFunctor;
 class YAPQuery;
 
+/**
+ * @brief Generic Prolog Term
+ */
 class YAPTerm {
 	friend class YAPPredicate;
 	friend class YAPTermHandle;
@@ -63,8 +86,7 @@ class YAPTerm {
 protected:
 	Term t;
 public:
-  YAPTerm() {} // do nothing constructor
-  YAPTerm(int i) { CACHE_REGS t = MkIntegerTerm( i ); }
+	YAPTerm() { t = TermNil; } // do nothing constructor
 	YAPTerm(void *ptr)  { CACHE_REGS t = MkIntegerTerm( (Int)ptr ); }
 	YAPTerm(Term tn) { t = tn; }
 	YAPTerm(char *s) { Term tp ; t = YAP_ReadBuffer(s,&tp); }
@@ -88,6 +110,9 @@ public:
 	bool isString() { return IsStringTerm(t); }
 };
 
+/**
+ * @brief Variable Term
+ */
 class YAPVarTerm: private YAPTerm {
 public:
 	YAPVarTerm(): YAPTerm() { CACHE_REGS t = MkVarTerm(); }
@@ -95,6 +120,9 @@ public:
 	bool unbound() { return IsUnboundVar(VarOfTerm(t)); }
 };
 
+/**
+ * @brief Compound Term
+ */
 class YAPApplTerm: private YAPTerm {
 public:
 	YAPApplTerm(YAPFunctor f, YAPTerm ts[]);
@@ -103,6 +131,9 @@ public:
 	YAPTerm getArg(unsigned int i);
 };
 
+/**
+ * @brief List Constructor Term
+ */
 class YAPPairTerm: private YAPTerm {
 public:
 	YAPPairTerm(YAPTerm hd, YAPTerm tl);
@@ -111,6 +142,31 @@ public:
 	YAPTerm getTail() { return  YAPTerm(TailOfTerm(t)); }
 };
 
+/**
+ * @brief Integer Term
+ */
+
+class YAPIntegerTerm: private YAPTerm {
+public:
+	YAPIntegerTerm(intptr_t i) { CACHE_REGS t = MkIntegerTerm( i ); }
+	intptr_t getInteger(YAPIntegerTerm t) { return  IntegerOfTerm(t.t); }
+	bool isTagged(YAPIntegerTerm i) { return IsIntTerm( t ); }
+};
+
+/*
+class YAPListTerm: private YAPPairTerm {
+public:
+	  YAPListTerm(YAPTerm ts[], size_t n);
+	  YAPListTerm(Term ts[], size_t n);
+	  YAPListTerm( vector<YAPTerm> v );
+	  size_t length() { Term *tailp; return Yap_SkipList(&t, &tailp); }
+	  vector<YAPTerm> toVector();
+};
+ */
+
+/**
+ * @brief Atom
+ */
 class YAPAtom {
 	friend class YAPPredicate;
 	friend class YAPFunctor;
@@ -125,6 +181,9 @@ public:
 	char *name(void);
 };
 
+/**
+ * @brief String Term
+ */
 class YAPStringTerm: private YAPTerm {
 public:
 	YAPStringTerm(char *s) ;
@@ -134,6 +193,9 @@ public:
 	const char *getString() { return StringOfTerm(t); }
 };
 
+/**
+ * @brief Atom Term
+ */
 class YAPAtomTerm: private YAPTerm {
 public:
 	YAPAtomTerm(YAPAtom a): YAPTerm() { t = MkAtomTerm(a.a); }
@@ -145,6 +207,9 @@ public:
 	YAPAtom getAtom() { return YAPAtom(AtomOfTerm(t)); }
 };
 
+/**
+ * @brief Functor
+ */
 class YAPFunctor {
 	friend class YAPApplTerm;
 	friend class YAPPredicate;
@@ -164,6 +229,9 @@ public:
 	}
 };
 
+/**
+ * @brief Term Handle
+ */
 class YAPTermHandle {
 	long int handle;
 public:
@@ -187,6 +255,9 @@ public:
 	}
 };
 
+/**
+ * @brief Predicate
+ */
 class YAPPredicate {
 	friend class YAPQuery;
 	PredEntry *ap;
@@ -259,8 +330,12 @@ public:
 	int call(YAPTerm ts[]);
 };
 
-/// interface to a YAP Query
-/// uses an SWI-like status info internally
+/**
+ * @brief Term Handle
+ *
+ * interface to a YAP Query;
+ * uses an SWI-like status info internally.
+ */
 class YAPQuery: private YAPPredicate {
 	int q_open;
 	int q_state;
@@ -286,13 +361,21 @@ public:
 
 class YAPParams;
 
-class YAP {
+/**
+ * @brief YAP Constructor
+ *
+ */
+class YAPEngine {
 public:
-  YAP(YAPParams const& params);
+	YAPEngine(YAPParams const& params);
 };
 
+/**
+ * @brief Parameters for YAP Constructor
+ *
+ */
 class YAPParams {
-  friend YAP;
+	friend class YAPEngine;
 	YAP_init_args init_args;
 public:
 	YAPParams();