yapt.hh

Go to the documentation of this file.

 
#ifndef X_API
#define X_API
#endif
 
#include <vector>
 
#ifndef YAPT_HH
#define YAPT_HH 1
 
class YAPError;
 
extern "C" {
 
X_API extern Term YAP_MkCharPTerm(char *n);
}
 
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;
  friend class YAPConjunctiveTerm;
 
protected:
  yhandle_t hdl; 
 
public:
  Term gt() {
    CACHE_REGS
    // fprintf(stderr,"?%d,%lx,%p\n",t,LOCAL_HandleBase[t], HR);
    // Yap_DebugPlWriteln(LOCAL_HandleBase[t]);
    return Yap_GetFromSlot(hdl);
  };
 
  Term pop_t() {
    CACHE_REGS
    // fprintf(stderr,"?%d,%lx,%p\n",t,LOCAL_HandleBase[t], HR);
    // Yap_DebugPlWriteln(LOCAL_HandleBase[t]);
      return Deref(Yap_PopHandle(hdl));
  };
 
  void mk(Term t0) {
    CACHE_REGS hdl = Yap_InitSlot(t0);
    // fprintf(stderr,"+%d,%lx,%p,%p",t,t0,HR,ASP); Yap_DebugPlWriteln(t0);
  };
 
  void put(Term t0) {
    Yap_PutInHandle(hdl, t0);
    // fprintf(stderr,"+%d,%lx,%p,%p",t,t0,HR,ASP); Yap_DebugPlWriteln(t0);
  };
 
  YAPTerm(Term tn) { mk(tn); };
#ifdef SWIGPYTHON
//   YAPTerm(struct _object *inp) {
// Term tinp = pythonToYAP(inp);
//  t = Yap_InitSlot(tinp);
//}
#endif
  // do nothing constructor
  YAPTerm() { hdl = 0; };
  // YAPTerm(yhandle_t i) { t = i; };
  YAPTerm(void *ptr);
  YAPTerm(char *s) {
    Term tp = 0;
    mk(YAP_ReadBuffer(s, &tp));
  }
 
#if 1
  virtual ~YAPTerm(){
      //  fprintf(stderr,"-%d,%lx,%p ",t,LOCAL_HandleBase[t] ,HR);
      /*    if (!t)
            return;
          //          Yap_DebugPlWriteln(LOCAL_HandleBase[t]);
          LOCAL_HandleBase[t] = TermFreeTerm;
          while (LOCAL_HandleBase[LOCAL_CurSlot - 1] == TermFreeTerm) {
            LOCAL_CurSlot--;
          }
          */
  };
#endif
 
  YAP_tag_t tag();
  Term deepCopy();
  inline int numberVars(int start, bool singletons = false) {
    return Yap_NumberVars(gt(), start, singletons);
  }
  inline Term term() {
    return Deref(gt());
  } 
  YAPTerm arg(int i) {
    BACKUP_MACHINE_REGS();
    Term t0 = gt();
    YAPTerm tf;
    if (!IsApplTerm(t0) && !IsPairTerm(t0))
      return (Term)0;
    tf = YAPTerm(ArgOfTerm(i, t0));
    RECOVER_MACHINE_REGS();
    return tf;
  };
 
  inline void bind(Term b) { LOCAL_HandleBase[hdl] = b; }
  inline void bind(YAPTerm *b) { LOCAL_HandleBase[hdl] = b->term(); }
  Term &operator[](arity_t n);
  // const YAPTerm *vars();
  virtual bool exactlyEqual(YAPTerm t1) {
    bool out;
    BACKUP_MACHINE_REGS();
    out = Yap_eq(gt(), t1.term());
    RECOVER_MACHINE_REGS();
    return out;
  };
 
  virtual bool unify(YAPTerm t1) {
    intptr_t out;
    BACKUP_MACHINE_REGS();
    out = Yap_unify(gt(), t1.term());
    RECOVER_MACHINE_REGS();
    return out;
  };
 
  virtual bool unifiable(YAPTerm t1) {
    bool out;
    BACKUP_MACHINE_REGS();
    out = Yap_eq(gt(), t1.term());
    RECOVER_MACHINE_REGS();
    return out;
  };
 
  inline virtual YAP_Term variant(YAPTerm t1) {
    intptr_t out;
    BACKUP_MACHINE_REGS();
    out = Yap_Variant(gt(), t1.term());
    RECOVER_MACHINE_REGS();
    return out;
  };
 
  virtual intptr_t hashTerm(size_t sz, size_t depth, bool variant) {
    intptr_t out;
 
    BACKUP_MACHINE_REGS();
    out = Yap_TermHash(gt(), sz, depth, variant);
    RECOVER_MACHINE_REGS();
    return out;
  };
  virtual bool isVar() { return IsVarTerm(gt()); }   
  virtual bool isAtom() { return IsAtomTerm(gt()); } 
  virtual bool isInteger() {
    return IsIntegerTerm(gt());
  } 
  virtual bool isFloat() {
    return IsFloatTerm(gt());
  } 
  virtual bool isString() {
    return IsStringTerm(gt());
  } 
  virtual bool isCompound() {
    return !(IsVarTerm(gt()) || IsNumTerm(gt()));
  }                                                  
  virtual bool isAppl() { return IsApplTerm(gt()); } 
  virtual bool isPair() { return IsPairTerm(gt()); } 
  virtual bool isGround() { return Yap_IsGroundTerm(gt()); } 
  virtual bool isList() { return Yap_IsListTerm(gt()); }     
 
  virtual Term getArg(arity_t i);
 
  virtual inline arity_t arity() {
    Term t0 = gt();
 
    if (IsApplTerm(t0)) {
      Functor f = FunctorOfTerm(t0);
      if (IsExtensionFunctor(f))
        return 0;
      return ArityOfFunctor(f);
    } else if (IsPairTerm(t0)) {
      return 2;
    }
    return 0;
  }
 
  virtual const char *text() {
    CACHE_REGS
    char *os;
 
    BACKUP_MACHINE_REGS();
    if (!(os = Yap_TermToBuffer(Yap_GetFromSlot(hdl), Handle_vars_f))) {
      RECOVER_MACHINE_REGS();
      return 0;
    }
    RECOVER_MACHINE_REGS();
    return os;
  };
 
  inline yhandle_t handle() { return hdl; };
 
  inline bool initialized() { return hdl != 0; };
};
 
class X_API T : public YAPTerm {
 public:
  friend class YAPTerm;
};
  
class X_API YAPApplTerm : public YAPTerm {
  friend class YAPTerm;
 
public:
  YAPApplTerm(Term t0) { if (IsApplTerm(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<Term> ts);
  YAPApplTerm(const std::string s, std::vector<YAPTerm> ts);
#if 0
  template<typename... T>
    YAPApplTerm(const Functor f, std::initializer_list<Term> list ) {
     BACKUP_MACHINE_REGS();
     *HR++ = (CELL)f;
   for( auto elem : list )
    {
      RESET_VARIABLE(HR);
      Yap_unify( elem, (CELL)HR );
      HR++;
    }
      RECOVER_MACHINE_REGS();
  };
  YAPApplTerm(const std::string s, std::initializer_list<Term> list ) {
     BACKUP_MACHINE_REGS();
     Term *o = HR++;
   for( auto elem : list )
    {
      RESET_VARIABLE(HR);
      Yap_unify( elem, (CELL)HR );
      HR++;
    }
   o[0] = (CELL)Yap_MkFunctor(Yap_LookupAtom(s.c_str()), (HR-(o+1)));
 mk(AbsAppl(o));
      RECOVER_MACHINE_REGS();
  };
   YAPApplTerm(const char s[], std::initializer_list<Term> list ) {
     BACKUP_MACHINE_REGS();
     Term *o = HR++;
   for( auto elem : list )
   {
   RESET_VARIABLE(HR);
     Yap_unify( elem, (CELL)HR );
     HR++;
     }
    o[0] = (CELL)Yap_MkFunctor(Yap_LookupAtom(s), (HR-(o+1)));
 mk(AbsAppl(o));
      RECOVER_MACHINE_REGS();
  };
 
   YAPApplTerm(const std::string s, std::initializer_list<YAPTerm> list ) {
    BACKUP_MACHINE_REGS();
    Term *o = HR++;
   for( auto elem : list )
    {
      RESET_VARIABLE(HR);
      Yap_unify( elem.gt(), (CELL)HR );
      HR++;
    }
   o[0] = (CELL)Yap_MkFunctor(Yap_LookupAtom(s.c_str()), (HR-(o+1)));
   mk(AbsAppl(o));
      RECOVER_MACHINE_REGS();
  };
#else
   YAPApplTerm(const std::string s, Term a1 ) {
   BACKUP_MACHINE_REGS();
   Term *o = HR;
   RESET_VARIABLE(HR+1);
Yap_unify( a1, (CELL)(HR+1) );
HR+=2;
 
o[0] = (CELL)Yap_MkFunctor(Yap_LookupAtom(s.c_str()), 1);
mk(AbsAppl(o));
RECOVER_MACHINE_REGS();
};
YAPApplTerm(const std::string s, Term a1, Term a2 ) {
BACKUP_MACHINE_REGS();
Term *o = HR;
RESET_VARIABLE(HR+1);
Yap_unify( a1, (CELL)(HR+1) );
RESET_VARIABLE(HR+2);
Yap_unify( a2, (CELL)(HR+2) );
HR+=3;
 
o[0] = (CELL)Yap_MkFunctor(Yap_LookupAtom(s.c_str()), 2);
mk(AbsAppl(o));
RECOVER_MACHINE_REGS();
};
YAPApplTerm(const std::string s, Term a1, Term a2, Term a3 ) {
BACKUP_MACHINE_REGS();
Term *o = HR;
RESET_VARIABLE(HR+1);
Yap_unify( a1, (CELL)(HR+1) );
RESET_VARIABLE(HR+2);
Yap_unify( a2, (CELL)(HR+2) );
RESET_VARIABLE(HR+3);
Yap_unify( a3, (CELL)(HR+3) );
HR+=4;
o[0] = (CELL)Yap_MkFunctor(Yap_LookupAtom(s.c_str()),3);
mk(AbsAppl(o));
RECOVER_MACHINE_REGS();
};
#endif
  YAPApplTerm(const std::string s, unsigned int arity) {
    mk(Yap_MkNewApplTerm(Yap_MkFunctor(Yap_LookupAtom(s.c_str()), arity),
                         arity));
  };
  YAPApplTerm(YAPFunctor f);
  inline Functor functor() { return FunctorOfTerm(gt()); }
  inline YAPFunctor getFunctor() { return YAPFunctor(FunctorOfTerm(gt())); }
 
    Term getArg(arity_t i) {
 
    Term t0 = gt();
    Term tf;
    tf = ArgOfTerm(i, t0);
    RECOVER_MACHINE_REGS();
    return tf;
  };
  void putArg(int i, Term targ) {
    // BACKUP_MACHINE_REGS();
    Term t0 = gt();
    RepAppl(t0)[i] = Deref(targ);
    // RECOVER_MACHINE_REGS();
  };
  void putArg(int i, YAPTerm t) {
    // BACKUP_MACHINE_REGS();
    Term t0 = gt();
    RepAppl(t0)[i] = t.term();
    // RECOVER_MACHINE_REGS();
  };
  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
  virtual bool isFloat() { return false; }   //> type check for floating-point
  virtual bool isString() { return false; }  //> type check for a string " ... "
  virtual bool isCompound() { return true; } //> is a primitive term
  virtual bool isAppl() { return true; }     //> is a structured term
  virtual bool isPair() { return false; }    //> is a pair term
  virtual bool isGround() { return true; }   //> term is ground
  virtual bool isList() { return false; }    //> term is a list
};
 
class X_API YAPPairTerm : public YAPTerm {
  friend class YAPTerm;
 
public:
  YAPPairTerm(Term t0) {
    t0 = Deref(t0);
    if (IsPairTerm(t0) || t0 == TermNil)
      mk(t0);
    else
      Yap_ThrowError(TYPE_ERROR_LIST, t0, "YAPPairTerms");
  }
  YAPPairTerm(YAPTerm hd, YAPTerm tl);
  YAPPairTerm();
  Term getHead() { return (HeadOfTerm(gt())); }
  Term getTail() { return (TailOfTerm(gt())); }
  YAPTerm car() { return YAPTerm(HeadOfTerm(gt())); }
  bool nil() { return gt() == TermNil; }
  YAPPairTerm cdr() { return YAPPairTerm(TailOfTerm(gt())); }
  std::vector<Term> listToArray();
  std::vector<YAPTerm> listToVector();
};
 
class X_API YAPNumberTerm : public YAPTerm {
public:
  YAPNumberTerm(){};
  bool isTagged() { return IsIntTerm(gt()); }
};
 
class X_API YAPIntegerTerm : public YAPNumberTerm {
public:
  YAPIntegerTerm(intptr_t i);
  intptr_t getInteger() { return IntegerOfTerm(gt()); };
};
 
class X_API YAPFloatTerm : public YAPNumberTerm {
public:
  YAPFloatTerm(double dbl) { mk(MkFloatTerm(dbl)); };
 
  double getFl() { return FloatOfTerm(gt()); };
};
 
class X_API YAPListTerm : public YAPTerm {
public:
  //> Create a list term out of a standard term. Check if a valid operation.
  YAPListTerm() { mk(TermNil); /* else type_error */ }
  YAPListTerm(Term t0) { mk(t0); /* else type_error */ }
  YAPListTerm(Term ts[], size_t n);
  YAPListTerm(std::vector<Term>);
  //      YAPListTerm( vector<YAPTerm> v );
  size_t length() {
    Term *tailp;
    Term t1 = gt();
    return Yap_SkipList(&t1, &tailp);
  }
  Term &operator[](size_t n);
  Term car();
  Term cdr();
  Term dup();
 
  inline bool nil() {
    return gt() == TermNil;
  }
 
  ;
};
 
class X_API YAPConjunctiveTerm : public YAPTerm {
public:
  //> Create a list term out of a standard term. Check if a valid operation.
  YAPConjunctiveTerm() { mk(TermNil); /* else type_error */ }
  YAPConjunctiveTerm(Term t0) { mk(t0); /* else type_error */ }
  YAPConjunctiveTerm(const Term ts[], size_t n);
  YAPConjunctiveTerm(std::vector<Term>);
  //      YAPConjunctiveTerm( vector<YAPTerm> v );
  size_t length() {
    Term *tailp;
    Term t1 = gt();
    size_t cnt = 1;
    while (IsApplTerm(t1) && FunctorOfTerm(t1)==FunctorComma) {
      t1 = ArgOfTerm(2,t1);
      cnt++;
    }
    return Yap_SkipList(&t1, &tailp);
  }
  Term &operator[](size_t n);
  Term car();
  Term cdr();
};
 
class X_API YAPStringTerm : public YAPTerm {
public:
  YAPStringTerm(char *s);
  YAPStringTerm(char *s, size_t len);
  YAPStringTerm(wchar_t *s);
  YAPStringTerm(wchar_t *s, size_t len);
  const char *getString() { return StringOfTerm(gt()); }
};
 
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 UTF-8 codes;
  YAPAtomTerm(char s[]);
  // Constructor: receives a sequence of up to n UTF-8 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);
  // Constructor: receives a std::string;
  //   YAPAtomTerm(std::string s) { mk(MkAtomTerm(Yap_LookupAtom(s.c_str())));
  //   };
  bool isVar() { return false; }           
  bool isAtom() { return true; }           
  bool isInteger() { return false; }       
  bool isFloat() { return false; }         
  bool isString() { return false; }        
  bool isCompound() { return false; }      
  bool isAppl() { return false; }          
  bool isPair() { return false; }          
  virtual bool isGround() { return true; } 
  virtual bool isList() { return gt() == TermNil; } 
  // 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; }
};
 
class X_API YAPVarTerm : public YAPTerm {
  friend class YAPTerm;
 
public:
  YAPVarTerm() { mk(MkVarTerm()); };
  CELL *getVar() { return VarOfTerm(gt()); }
  YAPVarTerm(Term t) {
    if (IsVarTerm(t)) {
      mk(t);
    }
  }
  bool unbound() { return IsUnboundVar(VarOfTerm(gt())); }
  inline bool isVar() { return true; }      
  inline bool isAtom() { return false; }     //>  type check for atom
  inline bool isInteger() { return false; }  //> type check for integer
  inline bool isFloat() { return false; }    //> type check for floating-point
  inline bool isString() { return false; }   //> type check for a string " ... "
  inline bool isCompound() { return false; } //> is a primitive term
  inline bool isAppl() { return false; }     //> is a structured term
  inline bool isPair() { return false; }     //> is a pair term
  inline bool isGround() { return false; }   //> term is ground
  inline bool isList() { return false; }     //> term is a list
};
 
    extern "C" {
      X_API extern  Term MkErrorTerm(yap_error_descriptor_t *);
    }
 
class X_API YAPErrorTerm : public YAPTerm {
    friend class YAPTerm;
public:
    YAPErrorTerm() : YAPTerm( MkErrorTerm(LOCAL_ActiveError)) {};
    YAPErrorTerm(yap_error_descriptor_t *err) :YAPTerm( MkErrorTerm(err) ) {};
};
 
#endif /* YAPT_HH */