yapdb.hh

Go to the documentation of this file.

 
 
#ifndef _YAPDB_H
#define _YAPDB_H
 
#include <YapInterface.h>
 
#define YAP_CPP_DB_INTERFACE 1
 
class YAPTerm;
class YAPAtomTerm;
 
class YAPError;
 
class YAPModule;
 
class X_API YAPModule : protected YAPAtomTerm {
  friend class YAPPredicate;
  friend class YAPModuleProp;
  Term t() { return gt(); }
  Term curModule() { CACHE_REGS return Yap_CurrentModule(); }
 
public:
  YAPModule(YAP_Term t) : YAPAtomTerm(t){};
  YAPModule() : YAPAtomTerm(curModule()){};
  YAPModule(YAPAtom t) : YAPAtomTerm(t){};
  YAPModule(YAPStringTerm t) : YAPAtomTerm(t.getString()){};
  Term term() { return gt(); };
};
 
class X_API YAPModuleProp : public YAPProp {
  friend class YAPPredicate;
  ModEntry *m;
 
  YAPModuleProp(ModEntry *mod) { m = mod; };
  YAPModuleProp(Term tmod) { m = Yap_GetModuleEntry(tmod); };
 
public:
  YAPModuleProp(YAPModule tmod) { m = Yap_GetModuleEntry(tmod.gt()); };
  YAPModuleProp() { m = Yap_GetModuleEntry(Yap_CurrentModule()); };
  virtual YAPModule module() { return YAPModule(m->AtomOfME); };
};
 
class X_API YAPPredicate : public YAPModuleProp {
  friend class YAPQuery;
  friend class YAPEngine;
 
protected:
  PredEntry *ap;
 
 
  PredEntry *getPred(Term &t, Term &tm, CELL *&outp);
 
  PredEntry *asPred() { return ap; };
 
  inline YAPPredicate() {}
  YAPPredicate(Term &to, Term &tmod, CELL *&ts, const char *pname);
 
  inline YAPPredicate(Term t, CELL *&v) {
    if (t) {
      Term tm = Yap_CurrentModule();
      ap = getPred(t, tm, v);
    }
  }
 
  inline YAPPredicate(Term t) {
    if (t) {
      CELL *v = nullptr;
      Term tm = Yap_CurrentModule();
      ap = getPred(t, tm, v);
    }
  }
 
  inline YAPPredicate(YAPTerm t, CELL *&v) {
    Term tp = t.term(), tm = Yap_CurrentModule();
    ap = getPred(tp, tm, v);
  }
  inline YAPPredicate(YAPTerm t) {
    CELL *v = nullptr;
    Term tp = t.term();
    Term tm = Yap_CurrentModule();
    ap = getPred(tp, tm, v);
  }
 
  inline YAPPredicate(PredEntry *pe) { ap = pe; }
 
  inline YAPPredicate(Functor f, Term mod) {
    ap = RepPredProp(PredPropByFunc(f, mod));
  }
 
public:
  YAPPredicate(const char *s0, Term &tout, YAPPairTerm * &names, CELL *&nts) {
    CACHE_REGS
    const char *s = (const char *)s0;
    Term tnames = MkVarTerm(),
      parameters = TermNil;
    tout =
        Yap_BufferToTermWithPrioBindings(s, parameters, tnames, strlen(s0)+1, 1200);
    
    // fprintf(stderr,"ap=%p arity=%d text=%s", ap, ap->ArityOfPE, s);
    if (tout == 0L) {
      return;
      throw YAPError();
    }
    Term tm = Yap_CurrentModule();
    ap = getPred(tout, tm, nts);
    tout = Yap_SaveTerm(tout);
    
    names = new YAPPairTerm(tnames);
  }
 
  YAPPredicate(YAPFunctor f) {
    CACHE_REGS
    ap = RepPredProp(PredPropByFunc(f.f, Yap_CurrentModule()));
  }
 
  inline YAPPredicate(YAPFunctor f, YAPTerm mod) {
    ap = RepPredProp(PredPropByFunc(f.f, mod.term()));
  }
 
  inline YAPPredicate(YAPAtom at, YAPTerm mod) {
    ap = RepPredProp(PredPropByAtom(at.a, mod.term()));
  }
 
  YAPPredicate(YAPAtom at);
 
  inline YAPPredicate(YAPAtom at, uintptr_t arity, YAPModule mod) {
    if (arity) {
      Functor f = Yap_MkFunctor(at.a, arity);
      ap = RepPredProp(PredPropByFunc(f, mod.term()));
    } else {
      ap = RepPredProp(PredPropByAtom(at.a, mod.term()));
    }
  }
 
  YAPPredicate(YAPAtom at, uintptr_t arity);
 
  inline YAPPredicate(const std::string at, uintptr_t arity, std::string mod="") {
  Term m;
  if (//mod != nullptr &&
      mod[0] != 0)
    m = MkAtomTerm(Yap_LookupAtom(mod.c_str()));
  else
    m =  Yap_CurrentModule();
  ap = RepPredProp(PredPropByFunc(Yap_MkFunctor(Yap_LookupAtom(at.c_str()), arity),
                m));
}
 
  inline YAPPredicate(const char *at, uintptr_t arity) {
    ap = RepPredProp(PredPropByFunc(Yap_MkFunctor(Yap_LookupAtom(at), arity),
                                    Yap_CurrentModule()));
  };
 
  inline YAPPredicate(const char *at, uintptr_t arity, YAPTerm mod) {
    ap = RepPredProp(
        PredPropByFunc(Yap_MkFunctor(Yap_LookupAtom(at), arity), mod.term()));
  };
 
  inline YAPPredicate(const char *at, YAPTerm mod) {
    ap = RepPredProp(PredPropByAtom(Yap_LookupAtom(at), mod.term()));
  }
 
  YAPModule module() {
    if (ap->ModuleOfPred == PROLOG_MODULE)
      return YAPModule(AtomProlog);
    else
      return YAPModule(AtomOfTerm(ap->ModuleOfPred));
  }
 
  YAPAtom name() {
    if (ap->ArityOfPE)
      return YAPAtom((Atom)ap->FunctorOfPred);
    else
      return YAPAtom(NameOfFunctor(ap->FunctorOfPred));
  }
 
  YAPFunctor functor() {
    if (ap->ArityOfPE)
      return YAPFunctor(ap->FunctorOfPred);
    Yap_ThrowError(DOMAIN_ERROR_OUT_OF_RANGE, MkIntTerm(0),
                   "YAPFunctor::functor");
  }
 
  uintptr_t getArity() { return ap->ArityOfPE; }
  arity_t arity() { return ap->ArityOfPE; }
  PredEntry *predEntry() { return ap; }
};
 
class X_API YAPPrologPredicate : public YAPPredicate {
public:
  YAPPrologPredicate(YAPTerm t) : YAPPredicate(t){};
  YAPPrologPredicate(const char *s, arity_t arity) : YAPPredicate(s, arity){};
  YAPPrologPredicate(YAPAtom s, arity_t arity) : YAPPredicate(s, arity){};
  bool assertClause(YAPTerm clause, bool last = true,
                    YAPTerm source = YAPTerm());
  bool assertFact(YAPTerm *tuple, bool last = true);
  void *retractClause(YAPTerm skeleton, bool all = false);
  // YAPTerm clause(size_t index, YAPPredicate p) { return YAPTerm(); };
  YAPTerm *nextClause() { return nullptr; };
};
 
class X_API YAPFLIP : public YAPPredicate {
public:
  YAPFLIP(YAP_UserCPred call, std::string name, YAP_Arity arity,
          const std::string module = std::string(RepAtom(AtomOfTerm(CurrentModule))->StrOfAE), YAP_UserCPred retry = 0,
          YAP_UserCPred cut = 0, YAP_Arity extra = 0, bool test = false)
    : YAPPredicate(name.c_str(), arity, MkAtomTerm(Yap_LookupAtom(module.c_str()))) {
    if (retry) {
      YAP_UserBackCutCPredicate(name.c_str(), call, retry, cut, arity, extra);
    } else {
      if (test) {
        YAP_UserCPredicate(name.c_str(), call, arity);
      } else {
        YAP_UserCPredicate(name.c_str(), call, arity);
      }
    }
  };
  YAPFLIP(const char *name, uintptr_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); }
 
  //> access to input argument i as a term
  Term x(int i) { return XREGS[i]; }
  //>  access to input argument as a YAPTerm
  YAPTerm X(int i) { return YAPTerm(XREGS[i]); }
 
  //> unify term t with argumentr i
  bool output( Term t, int i) { return Yap_unify(XREGS[i], t); };
  bool output( YAPTerm t, int i) { return t.unify(XREGS[i]); };
 
  //> ensure at least cells cells are available
  bool ensureStorage( size_t cells) { return Yap_dogcl(cells*sizeof(CELL) PASS_REGS); }
  //>  ensure memory but take care to first save the terms in
  //>  ts. YAPTerms do no require this.
  bool ensureStorage( size_t cells, std::vector<Term> ts)
  { return Yap_dogcl(cells*sizeof(CELL) PASS_REGS); };
};
 
#endif