diogo/yap-6.3
Archived
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

wheel/fixes/docs

Browse Source
This commit is contained in:
Vitor Santos Costa 2017-05-02 07:38:23 +01:00
parent a21dce7801
commit b54dd37ef9
24 changed files with 820 additions and 592 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
CXX/CMakeLists.txt
View File

@ -28,9 +28,9 @@ else()
MY_target_link_libraries(YAP++ ${CMAKE_DL_LIBS} libYap) MY_target_link_libraries(YAP++ ${CMAKE_DL_LIBS} libYap)
MY_install(TARGETS YAP++ MY_install(TARGETS YAP++
LIBRARY DESTINATION ${dlls} LIBRARY DESTINATION ${libdir}
RUNTIME DESTINATION ${dlls} RUNTIME DESTINATION ${dlls}
ARCHIVE DESTINATION ${dlls} ARCHIVE DESTINATION ${libdir}
) )
endif() endif()

43
CXX/yapdb.hh
View File

@ -134,7 +134,7 @@ protected:
PredEntry *ap; PredEntry *ap;
/// auxiliary routine to find a predicate in the current module. /// auxiliary routine to find a predicate in the current module.
PredEntry *getPred(Term &t, Term *&outp); PredEntry *getPred(YAPTerm &t, Term *&outp);
PredEntry *asPred() { return ap; }; PredEntry *asPred() { return ap; };
@ -143,23 +143,20 @@ protected:
/// It also communicates the array of arguments t[] /// It also communicates the array of arguments t[]
/// and the array of variables /// and the array of variables
/// back to yapquery /// back to yapquery
YAPPredicate(const char *s0, Term &out, Term &names) { YAPPredicate(const char *s0, Term &tout, Term &tnames) {
CACHE_REGS CACHE_REGS
BACKUP_MACHINE_REGS();
Term *modp = NULL; Term *modp = NULL;
names = MkVarTerm ();
const unsigned char *us = (const unsigned char *)s0; const unsigned char *us = (const unsigned char *)s0;
out = tnames = MkVarTerm();
Yap_BufferToTermWithPrioBindings(us, strlen(s0), TermNil, 1200, names); tout =
// extern char *s0; Yap_BufferToTermWithPrioBindings(us, strlen(s0), TermNil, 1200, tnames);
// fprintf(stderr,"ap=%p arity=%d text=%s", ap, ap->ArityOfPE, s); // fprintf(stderr,"ap=%p arity=%d text=%s", ap, ap->ArityOfPE, s);
// Yap_DebugPlWrite(out); // Yap_DebugPlWrite(out);
// delete [] ns; if (tout == 0L) {
if (out == 0L) Yap_ThrowError(TYPE_ERROR_PREDICATE_INDICATOR, MkStringTerm(s0), "YAPPredicate");
ap = nullptr; }
else YAPTerm tt = YAPTerm(tout);
ap = getPred(out, modp); ap = getPred(tt, modp);
RECOVER_MACHINE_REGS();
} }
/// Term constructor for predicates /// Term constructor for predicates
@ -167,7 +164,8 @@ protected:
/// It is just a call to getPred /// It is just a call to getPred
inline YAPPredicate(Term t) { inline YAPPredicate(Term t) {
CELL *v = NULL; CELL *v = NULL;
ap = getPred(t, v); YAPTerm tt = YAPTerm(t);
ap = getPred(tt, v);
} }
/// Term constructor for predicates /// Term constructor for predicates
@ -175,8 +173,7 @@ protected:
/// It is just a call to getPred /// It is just a call to getPred
inline YAPPredicate(YAPTerm t) { inline YAPPredicate(YAPTerm t) {
Term *v = nullptr; Term *v = nullptr;
Term tt = t.term(); ap = getPred(t, v);
ap = getPred(tt, v);
} }
/// Cast constructor for predicates, /// Cast constructor for predicates,
@ -197,13 +194,13 @@ public:
/// Functor constructor for predicates, is given a specific module. /// Functor constructor for predicates, is given a specific module.
/// ///
inline YAPPredicate(YAPFunctor f, YAPTerm mod) { inline YAPPredicate(YAPFunctor f, YAPTerm mod) {
ap = RepPredProp(PredPropByFunc(f.f, mod.t)); ap = RepPredProp(PredPropByFunc(f.f, mod.term()));
} }
/// Name/arity constructor for predicates. /// Name/arity constructor for predicates.
/// ///
inline YAPPredicate(YAPAtom at, YAPTerm mod) { inline YAPPredicate(YAPAtom at, YAPTerm mod) {
ap = RepPredProp(PredPropByAtom(at.a, mod.t)); ap = RepPredProp(PredPropByAtom(at.a, mod.term()));
} }
/// Name/0 constructor for predicates. /// Name/0 constructor for predicates.
@ -215,9 +212,9 @@ public:
inline YAPPredicate(YAPAtom at, uintptr_t arity, YAPModule mod) { inline YAPPredicate(YAPAtom at, uintptr_t arity, YAPModule mod) {
if (arity) { if (arity) {
Functor f = Yap_MkFunctor(at.a, arity); Functor f = Yap_MkFunctor(at.a, arity);
ap = RepPredProp(PredPropByFunc(f, mod.t())); ap = RepPredProp(PredPropByFunc(f, mod.term()));
} else { } else {
ap = RepPredProp(PredPropByAtom(at.a, mod.t())); ap = RepPredProp(PredPropByAtom(at.a, mod.term()));
} }
} }
@ -236,13 +233,13 @@ public:
/// ///
inline YAPPredicate(const char *at, uintptr_t arity, YAPTerm mod) { inline YAPPredicate(const char *at, uintptr_t arity, YAPTerm mod) {
ap = RepPredProp( ap = RepPredProp(
PredPropByFunc(Yap_MkFunctor(Yap_LookupAtom(at), arity), mod.t)); PredPropByFunc(Yap_MkFunctor(Yap_LookupAtom(at), arity), mod.term()));
}; };
/// char */module constructor for predicates. /// char */module constructor for predicates.
/// ///
inline YAPPredicate(const char *at, YAPTerm mod) { inline YAPPredicate(const char *at, YAPTerm mod) {
ap = RepPredProp(PredPropByAtom(Yap_LookupAtom(at), mod.t)); ap = RepPredProp(PredPropByAtom(Yap_LookupAtom(at), mod.term()));
} }
/// module of a predicate /// module of a predicate
@ -271,7 +268,7 @@ public:
YAPFunctor functor() { YAPFunctor functor() {
if (ap->ArityOfPE) if (ap->ArityOfPE)
return YAPFunctor(ap->FunctorOfPred); return YAPFunctor(ap->FunctorOfPred);
return NULL; Yap_ThrowError(DOMAIN_ERROR_OUT_OF_RANGE, MkIntTerm(0), "YAPFunctor::functor");
} }
/// arity of predicate /// arity of predicate

138
CXX/yapi.cpp
View File

@ -1,4 +1,6 @@
#define YAP_CPP_INTERFACE 1 #define YAP_CPP_INTERFACE 1
#include "yapi.hh" #include "yapi.hh"
@ -11,14 +13,21 @@ extern "C" {
#include "YapInterface.h" #include "YapInterface.h"
#include "blobs.h" #include "blobs.h"
X_API char *Yap_TermToString(Term t, size_t *length, encoding_t encodingp, X_API extern char *Yap_TermToString(Term t, size_t *length, encoding_t encodingp,
int flags); int flags);
X_API void YAP_UserCPredicate(const char *, YAP_UserCPred, arity_t arity); X_API extern void YAP_UserCPredicate(const char *, YAP_UserCPred, arity_t arity);
X_API void YAP_UserCPredicateWithArgs(const char *, YAP_UserCPred, arity_t, X_API extern void YAP_UserCPredicateWithArgs(const char *, YAP_UserCPred, arity_t,
YAP_Term); YAP_Term);
X_API void YAP_UserBackCPredicate(const char *, YAP_UserCPred, YAP_UserCPred, X_API extern void YAP_UserBackCPredicate(const char *, YAP_UserCPred, YAP_UserCPred,
arity_t, arity_t); arity_t, arity_t);
#if YAP_PYTHON
extern bool python_in_python;
X_API extern bool init_python(void);
extern X_API bool Py_IsInitialized();
#endif
} }
YAPAtomTerm::YAPAtomTerm(char *s) YAPAtomTerm::YAPAtomTerm(char *s)
@ -239,7 +248,7 @@ Term &YAPListTerm::operator[](arity_t i)
return RepPair(tf)[i]; return RepPair(tf)[i];
} }
YAPPairTerm::YAPPairTerm(YAPTerm th, YAPTerm tl) : YAPTerm() YAPPairTerm::YAPPairTerm(YAPTerm th, YAPTerm tl)
{ {
CACHE_REGS CACHE_REGS
BACKUP_H(); BACKUP_H();
@ -247,10 +256,10 @@ YAPPairTerm::YAPPairTerm(YAPTerm th, YAPTerm tl) : YAPTerm()
RECOVER_H(); RECOVER_H();
} }
YAPPairTerm::YAPPairTerm() : YAPTerm() YAPPairTerm::YAPPairTerm()
{ {
BACKUP_H(); BACKUP_H();
t = Yap_MkNewPairTerm(); mk(TermNil);
RECOVER_H(); RECOVER_H();
} }
@ -409,14 +418,13 @@ YAPVarTerm::YAPVarTerm()
const char *YAPAtom::getName(void) { return Yap_AtomToUTF8Text(a, nullptr); } const char *YAPAtom::getName(void) { return Yap_AtomToUTF8Text(a, nullptr); }
void YAPQuery::openQuery() void YAPQuery::openQuery(Term t)
{ {
CACHE_REGS CACHE_REGS
arity_t arity = ap->ArityOfPE; arity_t arity = ap->ArityOfPE;
if (arity) if (arity)
{ {
Term *ts; Term *ts;
Term t = goal;
if (IsPairTerm(t)) if (IsPairTerm(t))
{ {
ts = RepPair(t); ts = RepPair(t);
@ -439,7 +447,7 @@ void YAPQuery::openQuery()
q_p = P; q_p = P;
q_cp = CP; q_cp = CP;
// make sure this is safe // make sure this is safe
q_handles = Yap_StartSlots(); q_handles = LOCAL_CurSlot;
} }
bool YAPEngine::call(YAPPredicate ap, YAPTerm ts[]) bool YAPEngine::call(YAPPredicate ap, YAPTerm ts[])
@ -546,6 +554,11 @@ void YAPEngine::release()
RECOVER_MACHINE_REGS(); RECOVER_MACHINE_REGS();
} }
YAPTerm YAPEngine::fun(YAPTerm t)
{
return YAPTerm(fun(t.term()));
}
Term YAPEngine::fun(Term t) Term YAPEngine::fun(Term t)
{ {
CACHE_REGS CACHE_REGS
@ -560,6 +573,10 @@ Term YAPEngine::fun(Term t)
Atom name; Atom name;
BACKUP_MACHINE_REGS(); BACKUP_MACHINE_REGS();
fprintf(stderr," ++++ ");
Yap_DebugPlWriteln(t);
fprintf(stderr," ++++\n");
t = Yap_StripModule(t, &tmod);
if (IsApplTerm(t)) if (IsApplTerm(t))
{ {
ts = RepAppl(t) + 1; ts = RepAppl(t) + 1;
@ -585,7 +602,7 @@ Term YAPEngine::fun(Term t)
} }
else else
{ {
Yap_Error(TYPE_ERROR_CALLABLE, t, 0); Yap_ThrowError(TYPE_ERROR_CALLABLE, t, 0);
return 0L; return 0L;
} }
XREGS[arity + 1] = MkVarTerm(); XREGS[arity + 1] = MkVarTerm();
@ -614,6 +631,7 @@ Term YAPEngine::fun(Term t)
Yap_CloseHandles(q.CurSlot); Yap_CloseHandles(q.CurSlot);
RECOVER_MACHINE_REGS(); RECOVER_MACHINE_REGS();
return XREGS[arity]; return XREGS[arity];
Yap_DebugPlWriteln(XREGS[arity]);
} }
catch (YAPError e) catch (YAPError e)
{ {
@ -629,9 +647,9 @@ YAPQuery::YAPQuery(YAPFunctor f, YAPTerm mod, YAPTerm ts[])
{ {
/* ignore flags for now */ /* ignore flags for now */
BACKUP_MACHINE_REGS(); BACKUP_MACHINE_REGS();
goal = YAPApplTerm(f, ts).gt(); goal = YAPApplTerm(f, ts);
names = TermNil; names = YAPPairTerm( TermNil );
openQuery(); openQuery(goal.term());
RECOVER_MACHINE_REGS(); RECOVER_MACHINE_REGS();
} }
@ -639,9 +657,9 @@ YAPQuery::YAPQuery(YAPFunctor f, YAPTerm mod, YAPTerm ts[])
YAPQuery::YAPQuery(YAPFunctor f, YAPTerm ts[]) : YAPPredicate(f) { YAPQuery::YAPQuery(YAPFunctor f, YAPTerm ts[]) : YAPPredicate(f) {
/* ignore flags for now */ /* ignore flags for now */
BACKUP_MACHINE_REGS(); BACKUP_MACHINE_REGS();
goal = YAPApplTerm(f, ts).gt(); goal = YAPTerm( YAPApplTerm(f, ts).gt() );
names = TermNil; names.= YAPPairTerm( TermNil );
openQuery(); openQuery(goal.term());
RECOVER_MACHINE_REGS(); RECOVER_MACHINE_REGS();
} }
#endif #endif
@ -649,28 +667,12 @@ YAPQuery::YAPQuery(YAPFunctor f, YAPTerm ts[]) : YAPPredicate(f) {
YAPQuery::YAPQuery(YAPPredicate p, YAPTerm ts[]) : YAPPredicate(p.ap) YAPQuery::YAPQuery(YAPPredicate p, YAPTerm ts[]) : YAPPredicate(p.ap)
{ {
BACKUP_MACHINE_REGS(); BACKUP_MACHINE_REGS();
goal = YAPApplTerm(YAPFunctor(p.ap->FunctorOfPred), ts).term(); goal = YAPApplTerm(YAPFunctor(p.ap->FunctorOfPred), ts);
names = TermNil; names = YAPPairTerm( TermNil );
openQuery(); openQuery(goal.term());
RECOVER_MACHINE_REGS(); RECOVER_MACHINE_REGS();
} }
Term YAPQuery::namedVars()
{
CACHE_REGS
__android_log_print(ANDROID_LOG_INFO, "YAPDroid", "vnames %s %ld",
names.text(), LOCAL_CurSlot);
return (names); // should be o
}
Term YAPQuery::namedVarsCopy()
{
CACHE_REGS
__android_log_print(NDROID_LOG_INFO, "YAPDroid", "vnames %s %ld",
names.text(), LOCAL_CurSlot);
return (YAP_CopyTerm(names)); // should be o
}
bool YAPQuery::next() bool YAPQuery::next()
{ {
CACHE_REGS CACHE_REGS
@ -847,9 +849,19 @@ void Yap_displayWithJava(int c)
#endif #endif
void YAPEngineArgs::fetch_defaults()
{
Yap_InitDefaults(&init_args, NULL, 0, NULL);
#if YAP_PYTHON
init_args.Embedded = true;
python_in_python = Py_IsInitialized();
#endif
}
void YAPEngine::doInit(YAP_file_type_t BootMode) void YAPEngine::doInit(YAP_file_type_t BootMode)
{ {
if ((BootMode = YAP_Init(&init_args)) == YAP_FOUND_BOOT_ERROR)
if ((BootMode = YAP_Init(&engine_args.init_args)) == YAP_FOUND_BOOT_ERROR)
{ {
throw YAPError(); throw YAPError();
} }
@ -863,6 +875,9 @@ void YAPEngine::doInit(YAP_file_type_t BootMode)
#endif #endif
yerror = YAPError(); yerror = YAPError();
#ifdef YAP_PYTHON
init_python();
#endif
YAPQuery initq = YAPQuery(YAPAtom("$init_system")); YAPQuery initq = YAPQuery(YAPAtom("$init_system"));
if (initq.next()) if (initq.next())
{ {
@ -874,45 +889,21 @@ void YAPEngine::doInit(YAP_file_type_t BootMode)
} }
} }
YAPEngine::YAPEngine(char *savedState, char *bootFile, size_t stackSize, YAPEngine::YAPEngine(YAPEngineArgs &argp)
size_t trailSize, size_t maxStackSize, size_t maxTrailSize,
char *libDir, char *goal, char *topLevel, bool script,
bool fastBoot, bool embedded,
YAPCallback *cb)
: _callback(0) : _callback(0)
{ // a single engine can be active { // a single engine can be active
engine_args = argp;
YAP_file_type_t BootMode; YAP_file_type_t BootMode;
int Argc = 1;
char **Argv;
__android_log_print(ANDROID_LOG_INFO, "YAPDroid", "YAP %s ", bootFile); __android_log_print(ANDROID_LOG_INFO, "YAPDroid", "YAP %s ", bootFile);
// delYAPCallback()b // delYAPCallback()b
// if (cb) // if (cb)
// setYAPCallback(cb); // setYAPCallback(cb);
curren = this; curren = this;
{ BootMode = engine_args.init_args.boot_file_type;
size_t l1 = 2 * sizeof(char *);
if (!(Argv = (char **)malloc(l1)))
return;
Argv[0] = (char *)malloc(4);
strcpy(Argv[0], "yap");
Argv[1] = NULL;
}
BootMode = Yap_InitDefaults(&init_args, NULL, Argc, Argv);
init_args.SavedState = savedState;
init_args.StackSize = stackSize;
init_args.TrailSize = trailSize;
init_args.MaxStackSize = maxStackSize;
init_args.MaxTrailSize = maxTrailSize;
init_args.YapLibDir = libDir;
init_args.YapPrologBootFile = bootFile;
init_args.YapPrologGoal = goal;
init_args.YapPrologTopLevelGoal = topLevel;
init_args.HaltAfterConsult = script;
init_args.FastBoot = fastBoot;
init_args.Embedded = embedded;
doInit(BootMode); doInit(BootMode);
} }
YAPEngine::YAPEngine(int argc, char *argv[], YAPEngine::YAPEngine(int argc, char *argv[],
@ -920,8 +911,9 @@ YAPEngine::YAPEngine(int argc, char *argv[],
: _callback(0) : _callback(0)
{ // a single engine can be active { // a single engine can be active
engine_args = YAPEngineArgs();
YAP_file_type_t BootMode; YAP_file_type_t BootMode;
BootMode = YAP_parse_yap_arguments(argc, argv, &init_args); BootMode = YAP_parse_yap_arguments(argc, argv, &engine_args.init_args);
// delYAPCallback()b // delYAPCallback()b
// if (cb) // if (cb)
// setYAPCallback(cb); // setYAPCallback(cb);
@ -950,19 +942,20 @@ YAPPredicate::YAPPredicate(YAPAtom at, uintptr_t arity)
} }
/// auxiliary routine to find a predicate in the current module. /// auxiliary routine to find a predicate in the current module.
PredEntry *YAPPredicate::getPred(Term &t, Term *&outp) PredEntry *YAPPredicate::getPred(YAPTerm &tt, Term *&outp)
{ {
CACHE_REGS CACHE_REGS
Term m = Yap_CurrentModule(); Term m = Yap_CurrentModule(), t = tt.term();
t = Yap_StripModule(t, &m); t = Yap_StripModule(t, &m);
if (IsVarTerm(t) || IsNumTerm(t)) if (IsVarTerm(t) || IsNumTerm(t))
{ {
if (IsVarTerm(t)) if (IsVarTerm(t))
Yap_Error(INSTANTIATION_ERROR, t, 0); Yap_ThrowError(INSTANTIATION_ERROR, tt.term(), 0);
else if (IsNumTerm(t)) else if (IsNumTerm(t))
Yap_Error(TYPE_ERROR_CALLABLE, t, 0); Yap_ThrowError(TYPE_ERROR_CALLABLE, tt.term(), 0);
throw YAPError(); throw YAPError();
} }
tt.put(t);
if (IsAtomTerm(t)) if (IsAtomTerm(t))
{ {
ap = RepPredProp(PredPropByAtom(AtomOfTerm(t), m)); ap = RepPredProp(PredPropByAtom(AtomOfTerm(t), m));
@ -975,14 +968,13 @@ PredEntry *YAPPredicate::getPred(Term &t, Term *&outp)
ts[0] = t; ts[0] = t;
ts[1] = m; ts[1] = m;
t = Yap_MkApplTerm(FunctorCsult, 2, ts); t = Yap_MkApplTerm(FunctorCsult, 2, ts);
tt.put(t);
outp = RepAppl(t) + 1; outp = RepAppl(t) + 1;
} }
Functor f = FunctorOfTerm(t); Functor f = FunctorOfTerm(t);
if (IsExtensionFunctor(f)) if (IsExtensionFunctor(f))
{ {
Yap_Error(TYPE_ERROR_CALLABLE, t, 0); Yap_ThrowError(TYPE_ERROR_CALLABLE, t, 0);
;
throw YAPError();
} }
else else
{ {

6
CXX/yapi.hh
View File

@ -15,15 +15,13 @@
/*! /*!
* *
* @{
* @ingroup fli_c_cx * @ingroup fli_c_cx
* @defgroup yap-cplus-interface An object oriented interface for YAP. * @defgroup yap-cplus-interface An object oriented interface for YAP.
* *
* @tableofcontents * @{
* *
* *
* @short C++ wrapper to terms, predicates and queries * @brief C++ wrapper to terms, predicates and queries
*
* *
* This new interface is designed to be object oriented and to fit * This new interface is designed to be object oriented and to fit
* naturally with the swig interface language generator. It uses ideas * naturally with the swig interface language generator. It uses ideas

223
CXX/yapq.hh
View File

@ -1,17 +1,19 @@
/** /**
* @file yapq.hh * @file yapq.hh
^ *
* @defgroup yap-cplus-query-hanadlinge Query Handling in the YAP interface. * @defgroup yap-cplus-query-hanadlinge Query Handling in the YAP interface.
* @brief Engine and Query Management * @brief Engine and Query Management
* *
* @ingroup yap-cplus-interface * @ingroup yap-cplus-interface
* @tableofcontents
* *
* @{ * @{
* *
* These classes wrap engine ana of query.Ann engine is an environment where we can rum * These classes wrap engine and query. An engine is an environment where we can rum
* Prolog, that is, where we can run queries. * Prolog, that is, where we can run queries.
* *
* Also, supports callbacks and engine configuration.
*
*/ */
#ifndef YAPQ_HH #ifndef YAPQ_HH
@ -39,11 +41,12 @@ class YAPQuery : public YAPPredicate
int q_flags; int q_flags;
YAP_dogoalinfo q_h; YAP_dogoalinfo q_h;
YAPQuery *oq; YAPQuery *oq;
Term names; YAPPairTerm names;
Term goal; YAPTerm goal;
// temporaries // temporaries
Term tnames, tgoal ;
void openQuery(); void openQuery(Term t);
public: public:
/// main constructor, uses a predicate and an array of terms /// main constructor, uses a predicate and an array of terms
@ -54,6 +57,7 @@ public:
YAPQuery(YAPPredicate p, YAPTerm t[]); YAPQuery(YAPPredicate p, YAPTerm t[]);
/// full constructor, /// full constructor,
/// ///
///
/// It is given a functor, module, and an array of terms that must have at /// It is given a functor, module, and an array of terms that must have at
/// least /// least
/// the same arity as the functor. /// the same arity as the functor.
@ -68,16 +72,16 @@ public:
/// It is given a string, calls the parser and obtains a Prolog term that /// It is given a string, calls the parser and obtains a Prolog term that
/// should be a callable /// should be a callable
/// goal. /// goal.
inline YAPQuery(const char *s) : YAPPredicate(s, goal, names) inline YAPQuery(const char *s) : YAPPredicate(s, tgoal, tnames)
{ {
BACKUP_H();
__android_log_print(ANDROID_LOG_INFO, "YAPDroid", "got game %ld", __android_log_print(ANDROID_LOG_INFO, "YAPDroid", "got game %ld",
LOCAL_CurSlot); LOCAL_CurSlot);
if (!ap) if (!ap)
return; return;
__android_log_print(ANDROID_LOG_INFO, "YAPDroid", "%s", vnames.text()); __android_log_print(ANDROID_LOG_INFO, "YAPDroid", "%s", vnames.text());
openQuery(); goal = YAPTerm(tgoal);
RECOVER_H(); names = YAPPairTerm(tnames);
openQuery(tgoal);
}; };
/// string constructor with just an atom /// string constructor with just an atom
/// ///
@ -85,9 +89,9 @@ public:
/// goal, say `main`, `init`, `live`. /// goal, say `main`, `init`, `live`.
inline YAPQuery(YAPAtom g) : YAPPredicate(g) inline YAPQuery(YAPAtom g) : YAPPredicate(g)
{ {
goal = YAPAtomTerm(g).gt(); goal = YAPAtomTerm(g);
names = TermNil; names = YAPPairTerm( );
openQuery(); openQuery(goal.term());
}; };
/// set flags for query execution, currently only for exception handling /// set flags for query execution, currently only for exception handling
@ -112,9 +116,10 @@ public:
void close(); void close();
/// query variables. /// query variables.
void cut(); void cut();
Term namedVars(); Term namedVars() {return names.term(); };
/// query variables, but copied out /// query variables, but copied out
Term namedVarsCopy(); std::vector<Term> namedVarsVector() {
return names.listToArray(); };
/// convert a ref to a binding. /// convert a ref to a binding.
YAPTerm getTerm(yhandle_t t); YAPTerm getTerm(yhandle_t t);
/// simple YAP Query; /// simple YAP Query;
@ -141,6 +146,172 @@ public:
virtual void run(char *s) {} virtual void run(char *s) {}
}; };
class YAPEngine;
/// @brief Setup all arguments to a new engine
class YAPEngineArgs {
friend class YAPEngine;
YAP_init_args init_args;
void fetch_defaults();
public:
inline void setEmbedded( bool fl )
{
init_args.Embedded = fl;
};
inline bool getEmbedded( )
{
return init_args.Embedded;
};
inline void setSavedState( char *fl )
{
init_args.SavedState = fl;
};
inline const char * getSavedState( )
{
return init_args.SavedState;
};
inline void setStackSize( bool fl )
{
init_args.StackSize = fl;
};
inline bool getStackSize( )
{
return init_args.StackSize;
};
inline void setTrailSize( bool fl )
{
init_args.TrailSize = fl;
};
inline bool getTrailSize( )
{
return init_args.TrailSize;
};
inline bool getMStackSize( )
{
return init_args.StackSize;
};
inline void setMaxTrailSize( bool fl )
{
init_args.MaxTrailSize = fl;
};
inline bool getMaxTrailSize( )
{
return init_args.MaxTrailSize;
};
inline void setYapLibDir( const char * fl )
{
init_args.YapLibDir = fl;
};
inline const char * getYapLibDir( )
{
return init_args.YapLibDir;
};
inline void setYapShareDir( const char * fl )
{
init_args.YapShareDir = fl;
};
inline const char * getYapShareDir( )
{
return init_args.YapShareDir;
};
inline void setYapPrologBootFile( const char * fl )
{
init_args.YapPrologBootFile = fl;
};
inline const char * getYapPrologBootFile( )
{
return init_args.YapPrologBootFile;
};
inline void setYapPrologGoal( const char * fl )
{
init_args.YapPrologGoal = fl;
};
inline const char * getYapPrologGoal( )
{
return init_args.YapPrologGoal;
};
inline void setYapPrologTopLevelGoal( const char * fl )
{
init_args.YapPrologTopLevelGoal = fl;
};
inline const char * getYapPrologTopLevelGoal( )
{
return init_args.YapPrologTopLevelGoal;
};
inline void setHaltAfterConsult( bool fl )
{
init_args.HaltAfterConsult = fl;
};
inline bool getHaltAfterConsult( )
{
return init_args.HaltAfterConsult;
};
inline void setFastBoot( bool fl )
{
init_args.FastBoot = fl;
};
inline bool getFastBoot( )
{
return init_args.FastBoot;
};
inline void setArgc( int fl )
{
init_args.Argc = fl;
};
inline int getArgc( )
{
return init_args.Argc;
};
inline void setArgv( char ** fl )
{
init_args.Argv = fl;
};
inline char ** getArgv( )
{
return init_args.Argv;
};
YAPEngineArgs() {
fetch_defaults();
};
};
/** /**
* @brief YAP Engine: takes care of the execution environment * @brief YAP Engine: takes care of the execution environment
where we can go executing goals. where we can go executing goals.
@ -150,23 +321,15 @@ public:
class YAPEngine class YAPEngine
{ {
private: private:
YAPEngineArgs engine_args;
YAPCallback *_callback; YAPCallback *_callback;
YAP_init_args init_args;
YAPError yerror; YAPError yerror;
void doInit(YAP_file_type_t BootMode); void doInit(YAP_file_type_t BootMode);
YAP_dogoalinfo q; YAP_dogoalinfo q;
public: public:
/// construct a new engine; may use a variable number of arguments /// construct a new engine; may use a variable number of arguments
YAPEngine( YAPEngine(YAPEngineArgs &cargs); /// construct a new engine, including aaccess to callbacks
char *savedState = (char *)NULL, char *bootFile = (char *)NULL,
size_t stackSize = 0, size_t trailSize = 0, size_t maxStackSize = 0,
size_t maxTrailSize = 0, char *libDir = (char *)NULL,
char *goal = (char *)NULL, char *topLevel = (char *)NULL,
bool script = FALSE, bool fastBoot = FALSE,
bool embedded = true,
YAPCallback *callback = (YAPCallback *)
NULL); /// construct a new engine, including aaccess to callbacks
/// construct a new engine using argc/argv list of arguments /// construct a new engine using argc/argv list of arguments
YAPEngine(int argc, char *argv[], YAPEngine(int argc, char *argv[],
YAPCallback *callback = (YAPCallback *)NULL); YAPCallback *callback = (YAPCallback *)NULL);
@ -181,7 +344,7 @@ public:
_callback = cb; _callback = cb;
} }
/// execute the callback. /// execute the callback.
////void run() { if (_callback) _callback->run(); } ////void run() { if (_callback) _callback.run(); }
/// execute the callback with a text argument. /// execute the callback with a text argument.
void run(char *s) void run(char *s)
{ {
@ -213,7 +376,7 @@ public:
} }
/// reset Prolog state /// reset Prolog state
void reSet(); void reSet();
/// release: assune that there are no stack pointers, just release memory /// assune that there are no stack pointers, just release memory
// for last execution // for last execution
void release(); void release();
@ -229,11 +392,13 @@ public:
std::string s = Yap_version(); std::string s = Yap_version();
return s.c_str(); return s.c_str();
}; };
//> call a deterninistic predicate: the user will construct aterm of
//> arity N-1. YAP adds an extra variable which will have the
//> output.
YAPTerm fun(YAPTerm t);
Term fun(Term t); Term fun(Term t);
}; };
#endif /* YAPQ_HH */ #endif /* YAPQ_HH */
/// @} /// @}

55
CXX/yapt.hh
View File

@ -16,10 +16,11 @@
* terms must reside in the stack and may be moved around during * terms must reside in the stack and may be moved around during
* garbage collection. Term objects use an handle, in the SWI-Prolog style. * garbage collection. Term objects use an handle, in the SWI-Prolog style.
* *
* Nottce that terms are forcefully destroyed during backtracking. * Notice that terms are forcefully destroyed during backtracking.
* *
*/ */
#include <vector>
#ifndef YAPT_HH #ifndef YAPT_HH
#define YAPT_HH 1 #define YAPT_HH 1
@ -58,6 +59,11 @@ public:
// fprintf(stderr,"+%d,%lx,%p,%p",t,t0,HR,ASP); Yap_DebugPlWriteln(t0); // fprintf(stderr,"+%d,%lx,%p,%p",t,t0,HR,ASP); Yap_DebugPlWriteln(t0);
}; };
void put(Term t0) {
Yap_PutInHandle(t, t0);
// fprintf(stderr,"+%d,%lx,%p,%p",t,t0,HR,ASP); Yap_DebugPlWriteln(t0);
};
YAPTerm(Term tn) { mk(tn); }; YAPTerm(Term tn) { mk(tn); };
#ifdef SWIGPYTHON #ifdef SWIGPYTHON
// YAPTerm(struct _object *inp) { // YAPTerm(struct _object *inp) {
@ -68,7 +74,7 @@ public:
/// private method to convert from Term (internal YAP representation) to /// private method to convert from Term (internal YAP representation) to
/// YAPTerm /// YAPTerm
// do nothing constructor // do nothing constructor
YAPTerm() { mk(MkVarTerm()); }; YAPTerm() { t=0; };
// YAPTerm(yhandle_t i) { t = i; }; // YAPTerm(yhandle_t i) { t = i; };
/// pointer to term /// pointer to term
YAPTerm(void *ptr); YAPTerm(void *ptr);
@ -82,13 +88,14 @@ public:
/// Term destructor, tries to recover slot /// Term destructor, tries to recover slot
virtual ~YAPTerm() { virtual ~YAPTerm() {
// fprintf(stderr,"-%d,%lx,%p ",t,LOCAL_HandleBase[t] ,HR); // fprintf(stderr,"-%d,%lx,%p ",t,LOCAL_HandleBase[t] ,HR);
if (!t) /* if (!t)
return; return;
Yap_DebugPlWriteln(LOCAL_HandleBase[t]); Yap_DebugPlWriteln(LOCAL_HandleBase[t]);
LOCAL_HandleBase[t] = TermFreeTerm; LOCAL_HandleBase[t] = TermFreeTerm;
while (LOCAL_HandleBase[LOCAL_CurSlot - 1] == TermFreeTerm) { while (LOCAL_HandleBase[LOCAL_CurSlot - 1] == TermFreeTerm) {
LOCAL_CurSlot--; LOCAL_CurSlot--;
} }
*/
}; };
#endif #endif
@ -185,15 +192,19 @@ public:
BACKUP_MACHINE_REGS(); BACKUP_MACHINE_REGS();
Term tf = 0; Term tf = 0;
Term t0 = gt(); Term t0 = gt();
if (IsApplTerm(t0))
if (IsApplTerm(t0)) {
if (i > t) YAPError(DOMAIN_ERROR_OUT_OF_RANGE, t0, "t0.getArg()");
tf = (ArgOfTerm(i, t0)); tf = (ArgOfTerm(i, t0));
else if (IsPairTerm(t0)) { } else if (IsPairTerm(t0)) {
if (i == 1) if (i == 1)
tf = (HeadOfTerm(t0)); tf = (HeadOfTerm(t0));
else if (i == 2) else if (i == 2)
tf = (TailOfTerm(t0)); tf = (TailOfTerm(t0));
else
YAPError(DOMAIN_ERROR_OUT_OF_RANGE, t0, "t0.getArg()");
} else { } else {
tf = ((Term)0); YAPError(TYPE_ERROR_COMPOUND , t0, "t0.getArg()");
} }
RECOVER_MACHINE_REGS(); RECOVER_MACHINE_REGS();
return tf; return tf;
@ -276,9 +287,9 @@ public:
*/ */
class YAPApplTerm : public YAPTerm { class YAPApplTerm : public YAPTerm {
friend class YAPTerm; friend class YAPTerm;
YAPApplTerm(Term t0) { mk(t0); }
public: public:
YAPApplTerm(Term t0) { mk(t0); }
YAPApplTerm(Functor f, Term ts[]) { YAPApplTerm(Functor f, Term ts[]) {
BACKUP_MACHINE_REGS(); BACKUP_MACHINE_REGS();
Term t0 = Yap_MkApplTerm(f, f->ArityOfFE, ts); Term t0 = Yap_MkApplTerm(f, f->ArityOfFE, ts);
@ -314,18 +325,36 @@ public:
*/ */
class YAPPairTerm : public YAPTerm { class YAPPairTerm : public YAPTerm {
friend class YAPTerm; friend class YAPTerm;
YAPPairTerm(Term t0) {
if (IsPairTerm(t0))
mk(t0);
else
mk(0);
}
public: 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(YAPTerm hd, YAPTerm tl);
YAPPairTerm(); YAPPairTerm();
Term getHead() { return (HeadOfTerm(gt())); } Term getHead() { return (HeadOfTerm(gt())); }
Term getTail() { return (TailOfTerm(gt())); } Term getTail() { return (TailOfTerm(gt())); }
std::vector<Term> listToArray() {
Term *tailp;
Term t1 = gt();
Int l = Yap_SkipList(&t1, &tailp);
if (l < 0) {
throw YAPError(TYPE_ERROR_LIST, YAPTerm(t), "");
}
std::vector<Term> o = std::vector<Term>(l);
int i = 0;
Term t = gt();
while (t != TermNil) {
o[i++] = HeadOfTerm(t);
t = TailOfTerm(t);
}
return o;
}
}; };
/** /**

57
packages/python/CMakeLists.txt
View File

@ -3,57 +3,50 @@
if (PYTHONLIBS_FOUND) if (PYTHONLIBS_FOUND)
include(FindPythonModule) include(FindPythonModule)
set (PYTHON_SOURCES set (PYTHON_SOURCES python.c pl2py.c pybips.c py2pl.c pl2pl.c pypreds.c)
python.c pl2py.c pybips.c py2pl.c pl2pl.c pypreds.c)
set (PYTHON_HEADERS set (PYTHON_HEADERS python.h)
python.h)
set (CMAKE_POSITION_INDEPENDENT_CODE TRUE) set (CMAKE_POSITION_INDEPENDENT_CODE TRUE)
add_library (YAPPython SHARED ${PYTHON_SOURCES}) add_library (YAPPython SHARED ${PYTHON_SOURCES})
target_link_libraries(YAPPython libYap ${PYTHON_LIBRARY} target_link_libraries(YAPPython libYap ${PYTHON_LIBRARY} ${WINDLLS} ${GMP_LIBRARIES})
${WINDLLS}
${GMP_LIBRARIES})
set_property( SOURCE ${PYTHON_SOURCES} APPEND PROPERTY COMPILE_DEFINITIONS YAP_KERNEL=1)
set_property( SOURCE ${PYTHON_SOURCES} APPEND PROPERTY COMPILE_DEFINITIONS YAP_KERNEL=1) set (PYTHON_PL python.pl)
install(FILES python.pl DESTINATION ${libpl} )
install(FILES python.pl add_to_group( pl_library PYTHON_PL )
DESTINATION ${libpl}
)
configure_file ("setup.py.cmake" "setup.py" ) # configure_file ("setup.py.cmake" "setup.py" )
set(SETUP_PY "${CMAKE_CURRENT_BINARY_DIR}/setup.py") set(SETUP_PY "${CMAKE_CURRENT_BINARY_DIR}/setup.py")
#set_target_properties (YAPPython PROPERTIES PREFIX "") #set_target_properties (YAPPython PROPERTIES PREFIX "")
find_python_module( jupyter )
find_python_module( jupyter ) if (PY_JUPYTER)
if (PY_JUPYTER) add_subdirectory(yap_kernel)
add_subdirectory(yap_kernel) ENDIF()
ENDIF() IF(WIN32)
IF(WIN32)
install(TARGETS YAPPython
LIBRARY DESTINATION ${dlls}
RUNTIME DESTINATION ${bindir}
ARCHIVE DESTINATION ${dlls} )
else()
install(TARGETS YAPPython install(TARGETS YAPPython
LIBRARY DESTINATION ${dlls} LIBRARY DESTINATION ${libdir}
RUNTIME DESTINATION ${dlls} RUNTIME DESTINATION ${bindir}
ARCHIVE DESTINATION ${dlls} ) ARCHIVE DESTINATION ${libdir} )
else()
install(TARGETS YAPPython
LIBRARY DESTINATION ${libdir}
RUNTIME DESTINATION ${libdir}
ARCHIVE DESTINATION ${libdir} )
endif() endif()
endif (PYTHONLIBS_FOUND) endif (PYTHONLIBS_FOUND)

29
packages/python/pl2py.c
View File

@ -2,7 +2,7 @@
#include "python.h" #include "python.h"
PyObject *py_Local, *py_Global; extern PyObject *py_Local, *py_Global;
PyObject *YE(term_t t, int line, const char *file, const char *code) PyObject *YE(term_t t, int line, const char *file, const char *code)
{ {
@ -32,14 +32,15 @@ void YEM(const char * exp, int line, const char *file, const char *code)
PyObject *term_to_python(term_t t, bool eval, PyObject *o) { PyObject *term_to_python(term_t t, bool eval, PyObject *o) {
// o≈ // o≈
YAP_Term yt = YAP_GetFromSlot(t); YAP_Term yt = YAP_GetFromSlot(t);
// Yap_DebugPlWriteln(yt); Yap_DebugPlWriteln(yt);
switch (PL_term_type(t)) { switch (PL_term_type(t)) {
case PL_VARIABLE: { case PL_VARIABLE: {
YAP_Term i = YAP_MkIntTerm(t); if (t==0) {
PyObject *rc = term_to_nametuple( Yap_ThrowError(SYSTEM_ERROR_INTERNAL, yt, "in term_to_python");
"H", 1, YAP_InitSlot(YAP_MkApplTerm( }
YAP_MkFunctor(YAP_LookupAtom("H"), 1), 1, &i))); PyObject *out = PyTuple_New(1);
return CHECKNULL( t, rc ); PyTuple_SET_ITEM(out, 0, PyLong_FromLong(t));
return term_to_nametuple("v", 1, out);
}; };
case PL_ATOM: { case PL_ATOM: {
YAP_Atom at = YAP_AtomOfTerm(yt); YAP_Atom at = YAP_AtomOfTerm(yt);
@ -105,7 +106,7 @@ PyObject *term_to_python(term_t t, bool eval, PyObject *o) {
term_t tail = PL_new_term_ref(), arg; term_t tail = PL_new_term_ref(), arg;
size_t len, i; size_t len, i;
if (PL_skip_list(t, tail, &len) && PL_get_nil(tail)) { if (PL_skip_list(t, tail, &len) && PL_get_nil(tail)) {
PyObject *out; PyObject *out, *a;
arg = tail; arg = tail;
out = PyList_New(len); out = PyList_New(len);
@ -115,10 +116,14 @@ PyObject *term_to_python(term_t t, bool eval, PyObject *o) {
for (i = 0; i < len; i++) { for (i = 0; i < len; i++) {
if (!PL_get_list(t, arg, t)) { if (!PL_get_list(t, arg, t)) {
PL_reset_term_refs(tail); PL_reset_term_refs(tail);
return CHECKNULL(t,NULL); return Py_None;
} }
if (PyList_SetItem(out, i, term_to_python(arg, eval, o)) < 0) { a = term_to_python(arg, eval, o);
return CHECKNULL(t,NULL); if (a == NULL) {
a = Py_None;
}
if (PyList_SetItem(out, i, a) < 0) {
return Py_None;
} }
} }
PL_reset_term_refs(tail); PL_reset_term_refs(tail);
@ -144,6 +149,8 @@ PyObject *term_to_python(term_t t, bool eval, PyObject *o) {
} }
PyObject *yap_to_python(YAP_Term t, bool eval, PyObject *o) { PyObject *yap_to_python(YAP_Term t, bool eval, PyObject *o) {
if (t==0)
return NULL;
term_t yt = YAP_InitSlot(t); term_t yt = YAP_InitSlot(t);
o = term_to_python(yt, eval, o); o = term_to_python(yt, eval, o);
PL_reset_term_refs(yt); PL_reset_term_refs(yt);

125
packages/python/py2pl.c
View File

@ -6,7 +6,6 @@ static foreign_t repr_term(PyObject *pVal, term_t t) {
PL_put_pointer(t1, pVal); PL_put_pointer(t1, pVal);
PL_cons_functor(to, FUNCTOR_pointer1, t1); PL_cons_functor(to, FUNCTOR_pointer1, t1);
Py_INCREF(pVal); Py_INCREF(pVal);
PL_reset_term_refs(to);
return PL_unify(t, to); return PL_unify(t, to);
} }
@ -14,7 +13,6 @@ foreign_t assign_to_symbol(term_t t, PyObject *e);
foreign_t assign_to_symbol(term_t t, PyObject *e) { foreign_t assign_to_symbol(term_t t, PyObject *e) {
char *s = NULL; char *s = NULL;
PyErr_Clear();
if (!PL_get_atom_chars(t, &s)) { if (!PL_get_atom_chars(t, &s)) {
return false; return false;
} }
@ -25,58 +23,58 @@ foreign_t assign_to_symbol(term_t t, PyObject *e) {
} }
foreign_t python_to_term(PyObject *pVal, term_t t) { foreign_t python_to_term(PyObject *pVal, term_t t) {
bool rc = true;
term_t to = PL_new_term_ref();
fputs(" <<*** ",stderr); PyObject_Print(pVal,stderr,0); fputs("<<***\n",stderr);
if (pVal == Py_None) { if (pVal == Py_None) {
return PL_unify_atom(t, ATOM_none); fputs("<<*** ",stderr);Yap_DebugPlWrite(YAP_GetFromSlot(t)); fputs(" >>***\n",stderr);
rc= PL_unify_atom(t, ATOM_none); fputs("<<*** ",stderr);Yap_DebugPlWrite(YAP_GetFromSlot(t)); fputs(" >>***\n",stderr);
} }
if (PyBool_Check(pVal)) { if (PyBool_Check(pVal)) {
if (PyObject_IsTrue(pVal)) { if (PyObject_IsTrue(pVal)) {
return PL_unify_atom(t, ATOM_true); rc = PL_unify_atom(t, ATOM_true);
} else { } else {
return PL_unify_atom(t, ATOM_false); rc = PL_unify_atom(t, ATOM_false);
} }
} else if (PyLong_Check(pVal)) { } else if (PyLong_Check(pVal)) {
return PL_unify_int64(t, PyLong_AsLong(pVal)); rc = PL_unify_int64(t, PyLong_AsLong(pVal));
#if PY_MAJOR_VERSION < 3 #if PY_MAJOR_VERSION < 3
} else if (PyInt_Check(pVal)) { } else if (PyInt_Check(pVal)) {
return PL_unify_int64(t, PyInt_AsLong(pVal)); rc = PL_unify_int64(t, PyInt_AsLong(pVal));
#endif #endif
} else if (PyFloat_Check(pVal)) { } else if (PyFloat_Check(pVal)) {
return PL_unify_float(t, PyFloat_AsDouble(pVal)); rc = PL_unify_float(t, PyFloat_AsDouble(pVal));
} else if (PyComplex_Check(pVal)) { } else if (PyComplex_Check(pVal)) {
bool rc; term_t t1 = PL_new_term_ref(),
term_t to = PL_new_term_ref(), t1 = PL_new_term_ref(),
t2 = PL_new_term_ref(); t2 = PL_new_term_ref();
if (!PL_put_float(t1, PyComplex_RealAsDouble(pVal)) || if (!PL_put_float(t1, PyComplex_RealAsDouble(pVal)) ||
!PL_put_float(t2, PyComplex_ImagAsDouble(pVal)) || !PL_put_float(t2, PyComplex_ImagAsDouble(pVal)) ||
!PL_cons_functor(to, FUNCTOR_complex2, t1, t2)) { !PL_cons_functor(to, FUNCTOR_complex2, t1, t2)) {
rc = FALSE; rc = false;
} else { } else {
rc = PL_unify(t, to); rc = PL_unify(t, to);
} }
PL_reset_term_refs(to);
return rc;
} else if (PyUnicode_Check(pVal)) { } else if (PyUnicode_Check(pVal)) {
atom_t tmp_atom; atom_t tmp_atom;
#if PY_MAJOR_VERSION < 3 #if PY_MAJOR_VERSION < 3
= PyUnicode_GetSize(pVal) + 1; size_t sz = PyUnicode_GetSize(pVal) + 1;
wchar_t *ptr = malloc(sizeof(wchar_t) * sz); wchar_t *ptr = malloc(sizeof(wchar_t) * sz);
sz = PyUnicode_AsWideChar((PyUnicodeObject *)pVal, ptr, sz - 1); sz = PyUnicode_AsWideChar((PyUnicodeObject *)pVal, ptr, sz - 1);
tmp_atom = PL_new_atom_wchars(sz, ptr); tmp_atom = PL_new_atom_wchars(sz, ptr);
free(ptr); free(ptr);
return PL_unify_atom(t, tmp_atom);
#else #else
const char *s = PyUnicode_AsUTF8(pVal); const char *s = PyUnicode_AsUTF8(pVal);
tmp_atom = PL_new_atom( s); tmp_atom = PL_new_atom( s);
return PL_unify_atom(t, tmp_atom);
#endif #endif
rc = PL_unify_atom(t, tmp_atom);
} else if (PyByteArray_Check(pVal)) { } else if (PyByteArray_Check(pVal)) {
atom_t tmp_atom = PL_new_atom(PyByteArray_AsString(pVal)); atom_t tmp_atom = PL_new_atom(PyByteArray_AsString(pVal));
return PL_unify_atom(t, tmp_atom); rc = PL_unify_atom(t, tmp_atom);
#if PY_MAJOR_VERSION < 3 #if PY_MAJOR_VERSION < 3
} else if (PyString_Check(pVal)) { } else if (PyString_Check(pVal)) {
atom_t tmp_atom = PL_new_atom(PyString_AsString(pVal)); atom_t tmp_atom = PL_new_atom(PyString_AsString(pVal));
return PL_unify_atom(t, tmp_atom); rc = PL_unify_atom(t, tmp_atom);
#endif #endif
} else if (PyTuple_Check(pVal)) { } else if (PyTuple_Check(pVal)) {
Py_ssize_t i, sz = PyTuple_Size(pVal); Py_ssize_t i, sz = PyTuple_Size(pVal);
@ -85,12 +83,9 @@ foreign_t python_to_term(PyObject *pVal, term_t t) {
if ((s = (Py_TYPE(pVal)->tp_name))) { if ((s = (Py_TYPE(pVal)->tp_name))) {
if (!strcmp(s, "H")) { if (!strcmp(s, "H")) {
pVal = PyTuple_GetItem(pVal, 0); pVal = PyTuple_GetItem(pVal, 0);
if (PyLong_Check(pVal)) { if (pVal==NULL) {
return PyLong_AsLong(pVal); pVal = Py_None;
#if PY_MAJOR_VERSION < 3 PyErr_Clear();
} else if (PyInt_Check(pVal)) {
return PyInt_AsLong(pVal);
#endif
} }
} }
if (s[0] == '$') { if (s[0] == '$') {
@ -102,28 +97,44 @@ foreign_t python_to_term(PyObject *pVal, term_t t) {
} else { } else {
f = PL_new_functor(PL_new_atom(s), sz); f = PL_new_functor(PL_new_atom(s), sz);
} }
} else } else {
f = PL_new_functor(ATOM_t, sz); f = PL_new_functor(ATOM_t, sz);
if (!PL_unify_functor(t, f)) }
return FALSE; if (PL_unify_functor(t, f)) {
term_t to = PL_new_term_ref(); rc = true;
for (i = 0; i < sz; i++) { for (i = 0; i < sz; i++) {
if (!PL_get_arg(i + 1, t, to)) if (!PL_get_arg(i + 1, t, to))
return FALSE; rc = false;
if (!python_to_term(PyTuple_GetItem(pVal, i), to)) PyObject *p = PyTuple_GetItem(pVal, i);
return FALSE; if (p==NULL) {
PyErr_Clear();
p = Py_None;
} }
return true; rc = rc && python_to_term(p, to);
}
} else {
rc = false;
}
fputs(" ||*** ",stderr); Yap_DebugPlWrite(YAP_GetFromSlot(t)); fputs(" ||***\n",stderr);
} else if (PyList_Check(pVal)) { } else if (PyList_Check(pVal)) {
term_t to = PL_new_term_ref(); YAP_Term yt = YAP_GetFromSlot(t);
Py_ssize_t i, sz = PyList_GET_SIZE(pVal); Py_ssize_t i, sz = PyList_GET_SIZE(pVal);
for (i = 0; i < sz; i++) { for (i = 0; i < sz; i++) {
if (!PL_unify_list(t, to, t) || PyObject *obj;
!python_to_term(PyList_GetItem(pVal, i), to)) if (!PL_unify_list(t, to, t)) {
return FALSE; rc = false;
break;
} }
return PL_unify_nil(t); if ((obj = PyList_GetItem(pVal, i)) == NULL) {
obj = Py_None;
}
rc = rc && python_to_term(obj, to);
}
rc = rc && PL_unify_nil(t);
fputs("[***] ", stderr);
Yap_DebugPlWrite(yt); fputs("[***]\n", stderr);
} else if (PyDict_Check(pVal)) { } else if (PyDict_Check(pVal)) {
Py_ssize_t pos = 0; Py_ssize_t pos = 0;
term_t to = PL_new_term_ref(), ti = to; term_t to = PL_new_term_ref(), ti = to;
@ -135,40 +146,39 @@ foreign_t python_to_term(PyObject *pVal, term_t t) {
tnew = PL_new_term_ref(); tnew = PL_new_term_ref();
/* do something interesting with the values... */ /* do something interesting with the values... */
if (!python_to_term(key, tkey)) { if (!python_to_term(key, tkey)) {
PL_reset_term_refs(tkey); continue;
return FALSE;
} }
if (!python_to_term(value, tval)) { if (!python_to_term(value, tval)) {
PL_reset_term_refs(tkey); continue;
return FALSE;
} }
/* reuse */ /* reuse */
tint = tkey; tint = tkey;
if (!PL_cons_functor(tint, FUNCTOR_colon2, tkey, tval)) { if (!PL_cons_functor(tint, FUNCTOR_colon2, tkey, tval)) {
PL_reset_term_refs(tkey); rc = false;
return FALSE; continue;
} }
if (--left) { if (--left) {
if (!PL_cons_functor(tint, FUNCTOR_comma2, tint, tnew)) if (!PL_cons_functor(tint, FUNCTOR_comma2, tint, tnew))
PL_reset_term_refs(tkey); PL_reset_term_refs(tkey);
return FALSE; rc = false;
} }
if (!PL_unify(ti, tint)) { if (!PL_unify(ti, tint)) {
PL_reset_term_refs(tkey); rc = false; }
return FALSE;
}
ti = tnew; ti = tnew;
PL_reset_term_refs(tkey); PL_reset_term_refs(tkey);
} }
return PL_unify(t, to); rc = PL_unify(t, to);
} else { } else {
return repr_term(pVal, t); rc = repr_term(pVal, t);
} }
PL_reset_term_refs(to);
return rc;
} }
X_API YAP_Term pythonToYAP(PyObject *pVal) { X_API YAP_Term pythonToYAP(PyObject *pVal) {
term_t t = PL_new_term_ref(); term_t t = PL_new_term_ref();
if (!python_to_term(pVal, t)) if (pVal == NULL ||
!python_to_term(pVal, t))
return 0; return 0;
YAP_Term tt = YAP_GetFromSlot(t); YAP_Term tt = YAP_GetFromSlot(t);
PL_reset_term_refs(t); PL_reset_term_refs(t);
@ -222,20 +232,25 @@ bool python_assign(term_t t, PyObject *exp, PyObject *context) {
if (PL_skip_list(t, tail, &len) && if (PL_skip_list(t, tail, &len) &&
PL_get_nil(tail)) { // true list PL_get_nil(tail)) { // true list
bool o = true;
if (PySequence_Check(exp) && PySequence_Length(exp) == len) if (PySequence_Check(exp) && PySequence_Length(exp) == len)
for (i = 0; i < len; i++) { for (i = 0; i < len; i++) {
PyObject *p;
if (!PL_get_list(t, arg, t)) { if (!PL_get_list(t, arg, t)) {
PL_reset_term_refs(tail); PL_reset_term_refs(tail);
return false; o = false;
p = Py_None;
} }
if (!python_assign(arg, PySequence_GetItem(exp, i), context)) { if ((p = PySequence_GetItem(exp, i)) == NULL)
p = Py_None;
if (!python_assign(arg, p, context)) {
PL_reset_term_refs(tail); PL_reset_term_refs(tail);
return false; o = false;
} }
} }
PL_reset_term_refs(tail); PL_reset_term_refs(tail);
return true; return o;
} else { } else {
functor_t fun; functor_t fun;
@ -266,6 +281,8 @@ bool python_assign(term_t t, PyObject *exp, PyObject *context) {
} }
if (PyList_Check(i)) { if (PyList_Check(i)) {
i = PyList_GetItem(i, 0); i = PyList_GetItem(i, 0);
if (i==NULL)
i = Py_None;
long int j; long int j;
if (PyList_Check(o)) { if (PyList_Check(o)) {
#if PY_MAJOR_VERSION < 3 #if PY_MAJOR_VERSION < 3

121
packages/python/pybips.c
View File

@ -15,7 +15,9 @@
static PyObject *finalLookup(PyObject *i, const char *s) { static PyObject *finalLookup(PyObject *i, const char *s) {
PyObject *rc; PyObject *rc;
if (i == NULL) if (i == NULL)
return NULL; return Py_None;
if (strcmp(s,"none") == 0)
return Py_None;
if (PyDict_Check(i)) { if (PyDict_Check(i)) {
if ((rc = PyDict_GetItemString(i, s))) if ((rc = PyDict_GetItemString(i, s)))
return rc; return rc;
@ -31,6 +33,8 @@ static PyObject *finalLookup(PyObject *i, const char *s) {
} }
PyObject *PythonLookupSpecial(const char *s) { PyObject *PythonLookupSpecial(const char *s) {
if (s == NULL)
return Py_None;
if (strcmp(s, "true") == 0) { if (strcmp(s, "true") == 0) {
return Py_True; return Py_True;
} }
@ -51,7 +55,9 @@ PyObject *PythonLookupSpecial(const char *s) {
PyObject *lookupPySymbol(const char *sp, PyObject *pContext, PyObject **duc) { PyObject *lookupPySymbol(const char *sp, PyObject *pContext, PyObject **duc) {
PyObject *out = NULL; PyObject *out = NULL;
if (!sp) if (!sp)
return NULL; return Py_None;
if (strcmp(sp, "none") == 0)
return Py_None;
if ((out = finalLookup(pContext, sp))) { if ((out = finalLookup(pContext, sp))) {
return out; return out;
} }
@ -76,7 +82,7 @@ PyObject *lookupPySymbol(const char *sp, PyObject *pContext, PyObject **duc) {
if ((out = finalLookup(py_Main, sp))) { if ((out = finalLookup(py_Main, sp))) {
return out; return out;
} }
return NULL; return Py_None;
} }
int lookupPyModule(Py_mod *q) { int lookupPyModule(Py_mod *q) {
@ -120,10 +126,10 @@ PyObject *find_obj(PyObject *ob, term_t l, bool eval) {
yt = YAP_GetFromSlot(l); yt = YAP_GetFromSlot(l);
while (YAP_IsPairTerm(yt)) { while (YAP_IsPairTerm(yt)) {
hd = YAP_HeadOfTerm(yt); hd = YAP_HeadOfTerm(yt);
ob = yap_to_python(hd, true, ob); ob = yap_to_python(hd, eval, ob);
ob = CHECKNULL(yt, ob); ob = CHECKNULL(yt, ob);
if (!ob){ if (!ob){
return NULL; return Py_None;
} }
yt = YAP_TailOfTerm(yt); yt = YAP_TailOfTerm(yt);
@ -155,7 +161,7 @@ static PyObject *bip_abs(term_t t) {
* Python all * Python all
* *
* @param t Prolog term with a previously constructed Python iterator * @param t Prolog term with a previously constructed Python iterator
* > *
* @return the Python boolean `True` if all elements of the iterator are `True`, * @return the Python boolean `True` if all elements of the iterator are `True`,
* `False` otherwise. * `False` otherwise.
*/ */
@ -169,14 +175,14 @@ static PyObject *bip_all(term_t t) {
v = CHECKNULL( t, v); v = CHECKNULL( t, v);
it = PyObject_GetIter(v); it = PyObject_GetIter(v);
if (CHECKNULL( t, it) == NULL) if (CHECKNULL( t, it) == NULL)
return NULL; return Py_None;
iternext = *Py_TYPE(it)->tp_iternext; iternext = *Py_TYPE(it)->tp_iternext;
if (PyErr_Occurred()) { if (PyErr_Occurred()) {
if (PyErr_ExceptionMatches(PyExc_StopIteration)) if (PyErr_ExceptionMatches(PyExc_StopIteration))
PyErr_Clear(); PyErr_Clear();
else else
return NULL; return Py_None;
} }
// PyObject_Print(v, stderr, 0); // PyObject_Print(v, stderr, 0);
for (;;) { for (;;) {
@ -215,7 +221,7 @@ static PyObject *bip_any(term_t t) {
v = term_to_python(t, true, NULL); v = term_to_python(t, true, NULL);
it = PyObject_GetIter(v); it = PyObject_GetIter(v);
if (CHECKNULL(t,it) == NULL) if (CHECKNULL(t,it) == NULL)
return NULL; return Py_None;
iternext = *Py_TYPE(it)->tp_iternext; iternext = *Py_TYPE(it)->tp_iternext;
for (;;) { for (;;) {
@ -265,7 +271,7 @@ static PyObject *bip_float(term_t t, bool eval) {
} else if (PyFloat_Check(pVal)) { } else if (PyFloat_Check(pVal)) {
return pVal; return pVal;
} else } else
return NULL; return Py_None;
Py_DECREF(pVal); Py_DECREF(pVal);
return o; return o;
} }
@ -291,7 +297,7 @@ static PyObject *bip_int(term_t t) {
o = PyLong_FromDouble(PyFloat_AsDouble(pVal)); o = PyLong_FromDouble(PyFloat_AsDouble(pVal));
#endif #endif
} else } else
return NULL; return Py_None;
Py_DECREF(pVal); Py_DECREF(pVal);
return o; return o;
} }
@ -310,7 +316,7 @@ static PyObject *bip_long(term_t t) {
} else if (PyFloat_Check(pVal)) { } else if (PyFloat_Check(pVal)) {
o = pVal; o = pVal;
} else } else
return NULL; return Py_None;
Py_DECREF(pVal); Py_DECREF(pVal);
return o; return o;
} }
@ -344,19 +350,19 @@ static PyObject *bip_ord(term_t t) {
return PyLong_FromLong(ord); return PyLong_FromLong(ord);
#endif #endif
} }
return NULL; return Py_None;
} else if (PyByteArray_Check(pVal)) { } else if (PyByteArray_Check(pVal)) {
char *s = PyByteArray_AsString(pVal); char *s = PyByteArray_AsString(pVal);
if (s[1]) if (s[1])
return NULL; return Py_None;
#if PY_MAJOR_VERSION < 3 #if PY_MAJOR_VERSION < 3
return PyInt_FromLong(s[0]); return PyInt_FromLong(s[0]);
} else if (PyString_Check(pVal)) { } else if (PyString_Check(pVal)) {
char *s = PyString_AsString(pVal); char *s = PyString_AsString(pVal);
if (s[1]) if (s[1])
return NULL; return Py_None;
return PyInt_FromLong(s[0]); return PyInt_FromLong(s[0]);
#else #else
return PyLong_FromLong(s[0]); return PyLong_FromLong(s[0]);
@ -477,7 +483,7 @@ static PyObject *bip_sum(term_t t) {
} }
#if PY_MAJOR_VERSION < 3 #if PY_MAJOR_VERSION < 3
if (PyInt_CheckExact(item)) { if (PyInt_CheckExact(item)) {
PyFPE_START_PROTECT("add", Py_DECREF(item); Py_DECREF(iter); return 0) 764PyFPE_START_PROTECT("add", Py_DECREF(item); Py_DECREF(iter); return 0)
f_result += (double)PyInt_AS_LONG(item); f_result += (double)PyInt_AS_LONG(item);
PyFPE_END_PROTECT(f_result) Py_DECREF(item); PyFPE_END_PROTECT(f_result) Py_DECREF(item);
continue; continue;
@ -580,7 +586,7 @@ static long get_len_of_range(long lo, long hi, long step) {
return n; return n;
} }
#if PY_MAJOR_VERSION >= 3 && defined(USE_NAMEDTUPLES) #if PY_MAJOR_VERSION >= 3
static PyStructSequence_Field pnull[] = { static PyStructSequence_Field pnull[] = {
{"A1", NULL}, {"A2", NULL}, {"A3", NULL}, {"A4", NULL}, {"A1", NULL}, {"A2", NULL}, {"A3", NULL}, {"A4", NULL},
{"A5", NULL}, {"A6", NULL}, {"A7", NULL}, {"A8", NULL}, {"A5", NULL}, {"A6", NULL}, {"A7", NULL}, {"A8", NULL},
@ -719,9 +725,9 @@ static PyObject *structseq_repr(PyObject *iobj) {
} }
#endif #endif
PyObject *term_to_nametuple(const char *s, int arity, term_t t) { PyObject *term_to_nametuple(const char *s, arity_t arity, PyObject *tuple) {
PyObject *o; PyObject *o;
#if PY_MAJOR_VERSION >= 3 && 0 #if PY_MAJOR_VERSION >= 3
PyTypeObject *typp; PyTypeObject *typp;
PyObject *key = PyUnicode_FromString(s); PyObject *key = PyUnicode_FromString(s);
if (py_F2P && PyDict_Contains(py_F2P, key)) { if (py_F2P && PyDict_Contains(py_F2P, key)) {
@ -748,36 +754,21 @@ PyObject *term_to_nametuple(const char *s, int arity, term_t t) {
if (py_F2P) if (py_F2P)
PyDict_SetItem(py_F2P, key, (PyObject *)typp); PyDict_SetItem(py_F2P, key, (PyObject *)typp);
} }
#endif o = PyStructSequence_New(typp);
o = PyTuple_New(arity); for (arity_t i = 0; i < arity; i++) {
DebugPrintf("Tuple %p\n", o); PyObject *pArg = PyTuple_GET_ITEM(tuple, i);
if (o == NULL) if (pArg)
return o;
term_t tleft = PL_new_term_ref();
int i;
for (i = 0; i < arity; i++) {
PyObject *pArg;
if (!PL_get_arg(i + 1, t, tleft))
return NULL;
pArg = term_to_python(tleft, false, NULL );
if (CHECKNULL(tleft,pArg))
return NULL;
#if PY_MAJOR_VERSION >= 3
/* pArg reference stolen here: */
Py_INCREF(pArg);
PyStructSequence_SET_ITEM(o, i, pArg); PyStructSequence_SET_ITEM(o, i, pArg);
PyObject_Print(pArg,stderr,0);fputc('\n',stderr);
} }
((PyStructSequence *)o)->ob_base.ob_size = arity; ((PyStructSequence *)o)->ob_base.ob_size = arity;
PyObject_Print(o,stderr,0);fputc('\n',stderr);
return o; return o;
#else #else
/* pArg reference stolen here: */
PyTuple_SET_ITEM(o, i, pArg);
}
PyObject *o1; PyObject *o1;
o1 = PyTuple_New(2); o1 = PyTuple_New(2);
PyTuple_SET_ITEM(o1, 0, PyUnicode_FromString(s)); PyTuple_SET_ITEM(o1, 0, PyUnicode_FromString(s));
PyTuple_SET_ITEM(o1, 1, o); PyTuple_SET_ITEM(o1, 1, tuple);
return o1; return o1;
#endif #endif
} }
@ -820,7 +811,7 @@ static PyObject *bip_range(term_t t) {
v = PyList_New(n); v = PyList_New(n);
if (v == NULL) if (v == NULL)
return NULL; return Py_None;
for (i = 0; i < n; i++) { for (i = 0; i < n; i++) {
#if PY_MAJOR_VERSION < 3 #if PY_MAJOR_VERSION < 3
PyObject *w = PyInt_FromLong(ilow); PyObject *w = PyInt_FromLong(ilow);
@ -959,6 +950,8 @@ PyObject *compound_to_data(term_t t, PyObject *o, functor_t fun, bool exec) {
#else #else
if (PyLong_Check(ip)) { if (PyLong_Check(ip)) {
PyObject *o = PySequence_GetItem(v, PyLong_AsLong(ip)); PyObject *o = PySequence_GetItem(v, PyLong_AsLong(ip));
if (o == NULL)
o = Py_None;
if (CHECKNULL(t,o) == NULL) if (CHECKNULL(t,o) == NULL)
return NULL; return NULL;
Py_INCREF(o); Py_INCREF(o);
@ -967,6 +960,8 @@ PyObject *compound_to_data(term_t t, PyObject *o, functor_t fun, bool exec) {
#endif #endif
} else { } else {
o = PyObject_GetItem(v, ip); o = PyObject_GetItem(v, ip);
if (o == NULL)
o = Py_None;
Py_INCREF(o); Py_INCREF(o);
return o; return o;
} }
@ -1073,20 +1068,32 @@ PyObject *compound_to_pytree(term_t t, PyObject *context) {
} }
term_t tleft; term_t tleft;
int i; int i;
o = PyTuple_New(arity); PyObject *out = PyTuple_New(arity);
DebugPrintf("Tuple %p\n", o); DebugPrintf("Tuple %p\n", o);
tleft = PL_new_term_ref(); tleft = PL_new_term_ref();
for (i = 0; i < arity; i++) { for (i = 0; i < arity; i++) {
PyObject *pArg; PyObject *pArg;
AOK (PL_get_arg(i + 1, t, tleft), NULL ); AOK (PL_get_arg(i + 1, t, tleft), NULL );
pArg = term_to_python(tleft, false, NULL); pArg = term_to_python(tleft, false, NULL);
if (pArg == NULL) if (pArg) {
return NULL;
/* pArg reference stolen here: */ /* pArg reference stolen here: */
PyTuple_SET_ITEM(o, i, pArg); PyTuple_SET_ITEM(out, i, pArg);
Py_INCREF(pArg); Py_INCREF(pArg);
} }
return term_to_nametuple(s, arity, t); }
if (CHECKNULL(t, out) == NULL) {
PyErr_Print();
return NULL;
}
PyObject *c = lookupPySymbol(s, o, NULL);
if ( c && PyCallable_Check(c)) {
PyObject *n = PyTuple_New(arity);
PyTuple_SET_ITEM(n, 0, c);
PyTuple_SET_ITEM(n, 1, out);
return n;
}
return term_to_nametuple(s, arity, out);
} }
} }
@ -1218,9 +1225,6 @@ PyObject *compound_to_pyeval(term_t t, PyObject *context) {
PyErr_Print(); PyErr_Print();
return NULL; return NULL;
} }
if ( !PyCallable_Check(o)) {
return term_to_nametuple(s, arity, t);
}
PyObject *pArgs = PyTuple_New(arity); PyObject *pArgs = PyTuple_New(arity);
DebugPrintf("Tuple %p\n", pArgs); DebugPrintf("Tuple %p\n", pArgs);
int i; int i;
@ -1230,16 +1234,23 @@ PyObject *compound_to_pyeval(term_t t, PyObject *context) {
AOK (PL_get_arg(i + 1, t, tleft), NULL ); AOK (PL_get_arg(i + 1, t, tleft), NULL );
/* ignore (_) */ /* ignore (_) */
if (i == 0 && PL_is_variable(tleft)) { if (i == 0 && PL_is_variable(tleft)) {
Py_DECREF(pArgs); pArg = Py_None;
pArgs = Py_None; } else {
}
pArg = term_to_python(tleft, true, NULL); pArg = term_to_python(tleft, true, NULL);
pArg = CHECKNULL( tleft, pArg ); PyObject_Print(pArg,fdopen(2,"w"),0);
if (pArg == NULL) {
pArg = Py_None;
}
/* pArg reference stolen here: */ /* pArg reference stolen here: */
Py_INCREF(pArg); Py_INCREF(pArg);
}
PyTuple_SetItem(pArgs, i, pArg); PyTuple_SetItem(pArgs, i, pArg);
} }
PyObject *rc; if ( !PyCallable_Check(o)) {
return term_to_nametuple(s, arity, pArgs);
}
PyObject *rc;
//PyObject_Print(pArgs, stderr, 0); //PyObject_Print(pArgs, stderr, 0);
//PyObject_Print(o, stderr, 0); //PyObject_Print(o, stderr, 0);

37
packages/python/python.c
View File

@ -23,6 +23,23 @@ X_API PyObject *py_F2P;
bool python_in_python; bool python_in_python;
static void add_modules(void) {
py_Main = PyImport_AddModule("__main__");
Py_INCREF(py_Main);
py_Sys = PyImport_AddModule("sys");
Py_INCREF(py_Sys);
py_Builtin = PyImport_AddModule("__builtin__");
Py_INCREF(py_Builtin);
py_ModDict = PyObject_GetAttrString(py_Sys, "modules");
// py_Yapex = PyImport_ImportModule("yap4py.yapi");
// PyObject *py_Yap =
PyImport_ImportModule("yap");
if (py_Yapex)
Py_INCREF(py_Yapex);
//py_F2P = PyObject_GetAttrString(py_Yap, "globals");
py_F2P = NULL;
}
static void install_py_constants(void) { static void install_py_constants(void) {
FUNCTOR_dot2 = PL_new_functor(PL_new_atom("."), 2); FUNCTOR_dot2 = PL_new_functor(PL_new_atom("."), 2);
// FUNCTOR_equal2 = PL_new_functor(PL_new_atom("="), 2); // FUNCTOR_equal2 = PL_new_functor(PL_new_atom("="), 2);
@ -35,7 +52,6 @@ static void install_py_constants(void) {
ATOM_true = PL_new_atom("true"); ATOM_true = PL_new_atom("true");
ATOM_false = PL_new_atom("false"); ATOM_false = PL_new_atom("false");
ATOM_dot = PL_new_atom("."); ATOM_dot = PL_new_atom(".");
ATOM_none = PL_new_atom("none");
ATOM_self = PL_new_atom("self"); ATOM_self = PL_new_atom("self");
ATOM_t = PL_new_atom("t"); ATOM_t = PL_new_atom("t");
FUNCTOR_abs1 = PL_new_functor(PL_new_atom("abs"), 1); FUNCTOR_abs1 = PL_new_functor(PL_new_atom("abs"), 1);
@ -68,23 +84,10 @@ static void install_py_constants(void) {
FUNCTOR_comma2 = PL_new_functor(PL_new_atom(","), 2); FUNCTOR_comma2 = PL_new_functor(PL_new_atom(","), 2);
FUNCTOR_equal2 = PL_new_functor(PL_new_atom("="), 2); FUNCTOR_equal2 = PL_new_functor(PL_new_atom("="), 2);
FUNCTOR_sqbrackets2 = PL_new_functor(PL_new_atom("[]"), 2); FUNCTOR_sqbrackets2 = PL_new_functor(PL_new_atom("[]"), 2);
// if (python_in_python) { }
py_Main = PyImport_AddModule("__main__");
Py_INCREF(py_Main);
py_Sys = PyImport_AddModule("sys");
Py_INCREF(py_Sys);
py_Builtin = PyImport_AddModule("__builtin__");
Py_INCREF(py_Builtin);
py_ModDict = PyObject_GetAttrString(py_Sys, "modules");
py_Yapex = PyImport_ImportModule("yapex");
// PyObject *py_Yap =
PyImport_ImportModule("yap");
Py_INCREF(py_Yapex);
//py_F2P = PyObject_GetAttrString(py_Yap, "globals");
py_F2P = NULL;
}
foreign_t end_python(void) { foreign_t end_python(void) {
if (!python_in_python)
Py_Finalize(); Py_Finalize();
return true; return true;
@ -100,12 +103,14 @@ bool do_init_python(void) {
libpython_initialized = true; libpython_initialized = true;
// PyGILState_STATE gstate = PyGILState_Ensure(); // PyGILState_STATE gstate = PyGILState_Ensure();
term_t t = PL_new_term_ref(); term_t t = PL_new_term_ref();
if (!python_in_python)
Py_Initialize(); Py_Initialize();
install_py_constants(); install_py_constants();
PL_reset_term_refs(t); PL_reset_term_refs(t);
install_pypreds(); install_pypreds();
install_pl2pl(); install_pl2pl();
// PyGILState_Release(gstate); // PyGILState_Release(gstate);
add_modules();
return !python_in_python; return !python_in_python;
} }

2
packages/python/python.h
View File

@ -165,7 +165,7 @@ extern PyObject *compound_to_pytree(term_t t, PyObject *context);
extern PyObject *term_to_python(term_t t, bool eval, PyObject *contextxs); extern PyObject *term_to_python(term_t t, bool eval, PyObject *contextxs);
extern PyObject *term_to_nametuple(const char *s, int arity, term_t t); extern PyObject *term_to_nametuple(const char *s, arity_t arity, PyObject *);
extern foreign_t python_to_term(PyObject *pVal, term_t t); extern foreign_t python_to_term(PyObject *pVal, term_t t);
extern bool python_assign(term_t t, PyObject *exp, PyObject *context); extern bool python_assign(term_t t, PyObject *exp, PyObject *context);

2
packages/python/yap_kernel/setup.py.cmake
View File

@ -39,7 +39,7 @@ setup_args = dict(
name = 'yap_kernel', name = 'yap_kernel',
version = '0.0.1', version = '0.0.1',
packages = ["yap_kernel"], packages = ["yap_kernel"],
package_dir = {'': '${CMAKE_SOURCE_DIR}/packages/python' }, package_dir = {'': '${CMAKE_SOURCE_DIR}/packages/python/yap_kernel' },
description = "YAP Kernel for Jupyter", description = "YAP Kernel for Jupyter",
long_description="A simple YAP kernel for Jupyter/IPython", long_description="A simple YAP kernel for Jupyter/IPython",
url="https://github.com/vscosta/yap-6.3", url="https://github.com/vscosta/yap-6.3",

101
packages/python/yapex.py
View File

@ -1,101 +0,0 @@
import yap
import sys
# debugging support.
import pdb
def query_prolog(engine, s):
def answer(q):
try:
return q.next()
except Exception as e:
print(e.args[1])
return False
#
#construct a query from a one-line string
# q is opaque to Python
q = engine.query(s)
# vs is the list of variables
# you can print it out, the left-side is the variable name,
# the right side wraps a handle to a variable
vs = q.namedVars()
# atom match either symbols, or if no symbol exists, sttrings, In this case
# variable names should match strings
for eq in vs:
if not isinstance(eq[0],str):
print( "Error: Variable Name matches a Python Symbol")
return
ask = True
# launch the query
while answer(q):
# this new vs should contain bindings to vars
vs= q.namedVars()
#numbervars
i=0
# iteratw
for eq in vs:
name = eq[0]
# this is tricky, we're going to bind the variables in the term so thay we can
# output X=Y. The Python way is to use dictionares.
#Instead, we use the T function to tranform the Python term back to Prolog
binding = yap.T(eq[1])
if binding.isVar():
binding.unify(name)
else:
i = binding.numberVars(i, True)
print(name + " = " + binding.text())
#ok, that was Prolog code
print("yes")
# deterministic = one solution
if q.deterministic():
# done
q.close()
return
if ask:
s = input("more(;), all(*), no(\\n), python(#) ?").lstrip()
if s.startswith(';') or s.startswith('y'):
continue
elif s.startswith('#'):
try:
exec(s.lstrip('#'))
except:
raise
elif s.startswith('*') or s.startswith('a'):
ask = False
continue
else:
break
print("No (more) answers")
q.close()
return
def live():
engine = yap.YAPEngine()
loop = True
pdb.set_trace()
while loop:
try:
s = input("?- ")
if not s:
loop = False
query_prolog(engine, s)
except SyntaxError as err:
print("Syntax Error error: {0}".format(err))
except EOFError:
return
except RuntimeError as err:
print("YAP Execution Error: {0}".format(err))
except ValueError:
print("Could not convert data to an integer.")
except:
print("Unexpected error:", sys.exc_info()[0])
raise
engine.close()
#
# initialize engine
# engine = yap.YAPEngine();
# engine = yap.YAPEngine(yap.YAPParams());
#live()

92
packages/swig/python/CMakeLists.txt
View File

@ -1,24 +1,21 @@
# This is a CMake example for Python # This is a CMake example for Python
INCLUDE( NewUseSWIG ) INCLUDE(NewUseSWIG)
if (PYTHONLIBS_FOUND) if (PYTHONLIBS_FOUND)
include(FindPythonModule) include(FindPythonModule)
file(RELATIVE_PATH RELATIVE_SOURCE ${CMAKE_CURRENT_BINARY_DIR} ${CMAKE_SOURCE_DIR})
INCLUDE_DIRECTORIES(${PYTHON_INCLUDE_PATH}) INCLUDE_DIRECTORIES(${PYTHON_INCLUDE_PATH})
INCLUDE_DIRECTORIES( "${CMAKE_CURRENT_SOURCE_DIR}" "${CMAKE_SOURCE_DIR}/CXX" ) INCLUDE_DIRECTORIES("${CMAKE_CURRENT_SOURCE_DIR}" "${CMAKE_SOURCE_DIR}/CXX")
SET_SOURCE_FILES_PROPERTIES(../yap.i PROPERTIES CPLUSPLUS ON) SET_SOURCE_FILES_PROPERTIES(../yap.i PROPERTIES CPLUSPLUS ON)
SET_SOURCE_FILES_PROPERTIES(../yap.i PROPERTIES SWIG_FLAGS "-O;-py3") SET_SOURCE_FILES_PROPERTIES(../yap.i PROPERTIES SWIG_FLAGS "-O;-py3")
SET_SOURCE_FILES_PROPERTIES(../yap.i PROPERTIES SWIG_MODULE_NAME yap ) SET_SOURCE_FILES_PROPERTIES(../yap.i PROPERTIES SWIG_MODULE_NAME yap)
SET_SOURCE_FILES_PROPERTIES(../yap.i PROPERTIES OUTPUT_NAME yap ) SET_SOURCE_FILES_PROPERTIES(../yap.i PROPERTIES OUTPUT_NAME yap)
configure_file ("setup.py.cmake" ${CMAKE_CURRENT_BINARY_DIR}/setup.py )
# configure_file ("../yap.i" "yap.i" )
SWIG_ADD_LIBRARY(Py2YAP LANGUAGE python SHARED SOURCES ../yap.i ) SWIG_ADD_LIBRARY(Py2YAP LANGUAGE python SHARED SOURCES ../yap.i )
if (WIN32) if (WIN32)
@ -34,35 +31,66 @@
# inform we are compiling YAP # inform we are compiling YAP
# s used in MSYS # s used in MSYS
execute_process ( COMMAND ${PYTHON_EXECUTABLE} -c "import sysconfig; print( sysconfig.get_path( 'platlib' ) )" execute_process(COMMAND ${PYTHON_EXECUTABLE} -c "import sysconfig; print( sysconfig.get_path( 'platlib' ) )"
OUTPUT_VARIABLE _ABS_PYTHON_MODULE_PATH OUTPUT_VARIABLE _ABS_PYTHON_MODULE_PATH
OUTPUT_STRIP_TRAILING_WHITESPACE ) OUTPUT_STRIP_TRAILING_WHITESPACE)
get_filename_component ( ABS_PYTHON_MODULE_PATH ${_ABS_PYTHON_MODULE_PATH} ABSOLUTE ) configure_file("setup.py.cmake" ${CMAKE_CURRENT_BINARY_DIR}/setup.py)
file ( RELATIVE_PATH _REL_PYTHON_MODULE_PATH ${CMAKE_INSTALL_PREFIX} ${_ABS_PYTHON_MODULE_PATH} )
set ( PYTHON_MODULE_PATH get_filename_component(ABS_PYTHON_MODULE_PATH ${_ABS_PYTHON_MODULE_PATH} ABSOLUTE)
${ABS_PYTHON_MODULE_PATH} file(RELATIVE_PATH _REL_PYTHON_MODULE_PATH ${CMAKE_INSTALL_PREFIX} ${_ABS_PYTHON_MODULE_PATH})
#
# set ( PYTHON_MODULE_PATH
# ${ABS_PYTHON_MODULE_PATH}
# )
#
# INSTALL ( FILES ${CMAKE_CURRENT_BINARY_DIR}/yap.py DESTINATION ${PYTHON_MODULE_PATH} )
# INSTALL ( FILES ${CMAKE_CURRENT_SOURCE_DIR}/yapi.py DESTINATION ${PYTHON_MODULE_PATH} )
# INSTALL ( FILES ${CMAKE_CURRENT_SOURCE_DIR}/yapi.yap DESTINATION ${libpl} )
#
#
# INSTALL ( TARGETS ${SWIG_MODULE_Py2YAP_REAL_NAME}
# RUNTIME DESTINATION ${PYTHON_MODULE_PATH}
# ARCHIVE DESTINATION ${PYTHON_MODULE_PATH}
# LIBRARY DESTINATION ${PYTHON_MODULE_PATH}
# )
add_custom_target(Py2YAP ALL
DEPENDS ../yap.i libYap YAP++ YAPPython _Py2YAP
) )
set (dlls $<TARGET_FILE:matrix>
$<TARGET_FILE:regexp>
$<TARGET_FILE:yap_rl>
$<TARGET_FILE:tries>
$<TARGET_FILE:itries>
$<TARGET_FILE:sys>
$<TARGET_FILE:yap_random>)
if (TARGET real)
list( APPEND dlls $<TARGET_FILE:real>
)
endif()
INSTALL ( FILES ${CMAKE_CURRENT_BINARY_DIR}/yap.py DESTINATION ${PYTHON_MODULE_PATH} ) add_custom_command(TARGET Py2YAP
INSTALL ( FILES ${CMAKE_SOURCE_DIR}/packages/python/yapex.py DESTINATION ${PYTHON_MODULE_PATH} ) POST_BUILD
COMMAND ${CMAKE_COMMAND} -E make_directory yap4py/os
COMMAND ${CMAKE_COMMAND} -E make_directory yap4py/pl
COMMAND ${CMAKE_COMMAND} -E copy ${CMAKE_CURRENT_SOURCE_DIR}/__init__.py ${dlls} $<TARGET_FILE:libYap> $<TARGET_FILE:YAPPython> $<TARGET_FILE:YAP++> ${CMAKE_CURRENT_SOURCE_DIR}/yapi.yap ${pl_library} ${CMAKE_CURRENT_BINARY_DIR}/yap4py
COMMAND ${CMAKE_COMMAND} -E copy ${pl_os_library} ${CMAKE_CURRENT_BINARY_DIR}/yap4py/os
COMMAND ${CMAKE_COMMAND} -E copy ${pl_boot_library} ${CMAKE_CURRENT_BINARY_DIR}/yap4py/pl
COMMAND ${CMAKE_COMMAND} -E copy ${CMAKE_SOURCE_DIR}/README.md ${CMAKE_CURRENT_SOURCE_DIR}/MANIFEST.in ${CMAKE_CURRENT_BINARY_DIR}
COMMAND ${CMAKE_COMMAND} -E copy ${CMAKE_CURRENT_SOURCE_DIR}/yapi.py ${CMAKE_CURRENT_BINARY_DIR}/yap4py
COMMAND ${PYTHON_EXECUTABLE} setup.py sdist bdist_wheel
INSTALL ( TARGETS ${SWIG_MODULE_Py2YAP_REAL_NAME} VERBATIM
RUNTIME DESTINATION ${PYTHON_MODULE_PATH} WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}
ARCHIVE DESTINATION ${PYTHON_MODULE_PATH}
LIBRARY DESTINATION ${PYTHON_MODULE_PATH}
) )
if (WITH_DOCS AND DOXYGEN_FOUND)
if ( DOCUMENTATION AND DOXYGEN_FOUND )
set(CMAKE_SWIG_FLAGS -DDOXYGEN=${DOXYGEN_FOUND}) set(CMAKE_SWIG_FLAGS -DDOXYGEN=${DOXYGEN_FOUND})
# Run doxygen to only generate the xml # Run doxygen to only generate the xml
add_custom_command ( OUTPUT ${CMAKE_BINARY_DIR}/doc/xml/ftdi_8c.xml add_custom_command(OUTPUT ${CMAKE_BINARY_DIR}/doc/xml/ftdi_8c.xml
COMMAND ${CMAKE_COMMAND} -E make_directory ${CMAKE_BINARY_DIR}/doc COMMAND ${CMAKE_COMMAND} -E make_directory ${CMAKE_BINARY_DIR}/doc
COMMAND ${DOXYGEN_EXECUTABLE} ${CMAKE_BINARY_DIR}/Doxyfile.xml COMMAND ${DOXYGEN_EXECUTABLE} ${CMAKE_BINARY_DIR}/Doxyfile.xml
WORKING_DIRECTORY ${CMAKE_BINARY_DIR} WORKING_DIRECTORY ${CMAKE_BINARY_DIR}
@ -70,14 +98,14 @@
) )
# generate .i from doxygen .xml # generate .i from doxygen .xml
add_custom_command ( OUTPUT ${CMAKE_CURRENT_BINARY_DIR}/ftdi1_doc.i add_custom_command(OUTPUT ${CMAKE_CURRENT_BINARY_DIR}/ftdi1_doc.i
COMMAND ${PYTHON_EXECUTABLE} ${CMAKE_CURRENT_SOURCE_DIR}/doxy2swig.py -n COMMAND ${PYTHON_EXECUTABLE} ${CMAKE_CURRENT_SOURCE_DIR}/doxy2swig.py -n
${CMAKE_BINARY_DIR}/doc/xml/ftdi_8c.xml ${CMAKE_BINARY_DIR}/doc/xml/ftdi_8c.xml
${CMAKE_CURRENT_BINARY_DIR}/ftdi1_doc.i ${CMAKE_CURRENT_BINARY_DIR}/ftdi1_doc.i
DEPENDS ${CMAKE_BINARY_DIR}/doc/xml/ftdi_8c.xml DEPENDS ${CMAKE_BINARY_DIR}/doc/xml/ftdi_8c.xml
) )
add_custom_target ( doc_i DEPENDS ${CMAKE_CURRENT_BINARY_DIR}/ftdi1_doc.i ) add_custom_target(doc_i DEPENDS ${CMAKE_CURRENT_BINARY_DIR}/ftdi1_doc.i)
add_dependencies( ${SWIG_MODULE_ftdi1_REAL_NAME} doc_i ) add_dependencies(${SWIG_MODULE_ftdi1_REAL_NAME} doc_i)
ENDIF() ENDIF ()
ENDIF() ENDIF ()

17
packages/swig/python/__init__.py Normal file
View File

@ -0,0 +1,17 @@
import imp
import os
import ctypes
import glob
import os.path
import sys
global yap_lib_path
yap_lib_path = os.path.dirname(__file__)
def load( dll ):
dll = glob.glob(os.path.join(yap_lib_path,dll))[0]
dll = os.path.abspath(dll)
ctypes.CDLL(dll, mode=ctypes.RTLD_GLOBAL)
load('libYap*')

14
packages/swig/python/__main__.py Normal file
View File

@ -0,0 +1,14 @@
"""The main routine of the yap python project."""
import sys
import yapi
def main(args=None):
"""The main routine."""
if args is None:
args = sys.argv[1:]
yap.yapi.live(args)
if __name__ == "__main__":
main()

109
packages/swig/python/setup.py.cmake
View File

@ -1,38 +1,97 @@
from distutils.core import setup, Extension """A setuptools based setup module.
import sys
import os See:
https://packaging.python.org/en/latest/distributing.html
https://github.com/pypa/sampleproject
"""
# Always prefer setuptools over distutils
from setuptools import setup
from setuptools.extension import Extension
# To use a consistent encoding
from codecs import open
from os import path, makedirs, walk
from shutil import copytree, rmtree, copy2, move
from glob import glob
from pathlib import Path
import platform import platform
import os.path
my_extra_link_args = []
if platform.system() == 'Darwin': if platform.system() == 'Darwin':
my_extra_link_args = ['-Wl,-rpath','-Wl,${dlls}'] my_extra_link_args = ['-Wl,-rpath','-Wl,${_ABS_PYTHON_MODULE_PATH}']
else: so = 'dylib'
my_extra_link_args = [] #or dll in glob('yap/dlls/*'):
# move( dll ,'lib' )
pls = []
for (r,d,fs) in walk('yap/pl'):
for f in fs:
pls += [os.path.join(r, f)]
for (r,d,fs) in walk('yap'):
for f in fs:
pls += [os.path.join(r, f)]
# for f in glob( 'lib*.*' ):
# ofile.write(f+"\n")
cplus=['${RELATIVE_SOURCE}CXX/yapi.cpp']
py2yap=['${RELATIVE_SOURCE}packages/python/python.c',
'${RELATIVE_SOURCE}packages/python/pl2py.c',
'${RELATIVE_SOURCE}packages/python/pybips.c',
'${RELATIVE_SOURCE}packages/python/py2pl.c',
'${RELATIVE_SOURCE}packages/python/pl2pl.c',
'${RELATIVE_SOURCE}packages/python/pypreds.c'
]
python_sources = ['yapPYTHON_wrap.cxx']+py2yap+cplus
here = path.abspath(path.dirname(__file__))
python_sources = ['${CMAKE_CURRENT_SOURCE_DIR}/../yap.i'] # Get the long description from the README file
setup( extensions=[Extension('_yap', python_sources,
name = "yap",
version = "0.1",
ext_modules=[Extension('_yap', python_sources,
define_macros = [('MAJOR_VERSION', '1'), define_macros = [('MAJOR_VERSION', '1'),
('MINOR_VERSION', '0'), ('MINOR_VERSION', '0'),
('_YAP_NOT_INSTALLED_', '1'), ('_YAP_NOT_INSTALLED_', '1'),
('YAP_PYTHON', '1')], ('YAP_PYTHON', '1')],
runtime_library_dirs=[,'$(bindir)'], runtime_library_dirs=['yap4py','${libdir}','${bindir}'],
swig_opts=['-modern','-outcurrentdir', '-c++', '-py3','-I${CMAKE_SOURCE_DIR}/CXX'], swig_opts=['-modern', '-c++', '-py3','-I${RELATIVE_SOURCE}/CXX'],
library_dirs=["${dlls}","${bindir}", library_dirs=['../../..','../../../CXX','../../packages/python',"${dlls}","${bindir}", '.'],
'.'],
extra_link_args=my_extra_link_args, extra_link_args=my_extra_link_args,
libraries=['Yap','{GMP_LIBRARIES}'], extra_compile_args=['-g'],
libraries=['Yap','${GMP_LIBRARIES}'],
include_dirs=['../../..', include_dirs=['../../..',
'${GMP_INCLUDE_DIRS}', '${GMP_INCLUDE_DIRS}',
'${CMAKE_SOURCE_DIR}/H', '${RELATIVE_SOURCE}H',
'${CMAKE_SOURCE_DIR}/H/generated', '${RELATIVE_SOURCE}H/generated',
'${CMAKE_SOURCE_DIR}/OPTYap', '${RELATIVE_SOURCE}OPTYap',
'${CMAKE_SOURCE_DIR}/os', '${RELATIVE_SOURCE}os',
'${CMAKE_SOURCE_DIR}/include', '${RELATIVE_SOURCE}include',
'${CMAKE_SOURCE_DIR}/CXX', '.'] '${RELATIVE_SOURCE}CXX', '.']
)], )]
py_modules = ['yap', '${CMAKE_SOURCE_DIR}/packages/python/yapex']
)
setup(
name='YAP4Py',
version='${YAP_FULL_VERSION}',
description='The YAP Prolog compiler as a Python Library',
url='https://github.com/vscosta/yap-6.3',
author='Vitor Santos Costa',
author_email='vsc@dcc.fc.up.pt',
license='Artistic',
classifiers=[
'Development Status :: 4 - Beta',
'Intended Audience :: Developers',
'Topic :: Software Development :: Build Tools',
'License :: OSI Approved :: Artistic License',
'Programming Language :: Python :: 3',
'Programming Language :: Python :: 3.3',
'Programming Language :: Python :: 3.4',
'Programming Language :: Python :: 3.5',
'Programming Language :: Python :: 3.6',
'Programming Language :: Python :: 3.7'],
keywords=['Logic Programing'],
#spackage_data={'': ['yap']},
include_package_data=True,
ext_modules = extensions,
py_modules = ['yap'],
zip_safe=False,
eager_resources = ['yap4py'],
packages=['yap4py'] # find_packages()
#package_dir = {'':'yap4py'}
)

10
packages/swig/python/yap.egg-info/PKG-INFO
View File

@ -1,10 +0,0 @@
Metadata-Version: 1.0
Name: yap
Version: 0.1
Summary: UNKNOWN
Home-page: UNKNOWN
Author: UNKNOWN
Author-email: UNKNOWN
License: UNKNOWN
Description: UNKNOWN
Platform: UNKNOWN

14
packages/swig/python/yap.egg-info/SOURCES.txt
View File

@ -1,14 +0,0 @@
setup.py
yapPYTHON_wrap.cxx
/Users/vsc/github/yap-6.3/packages/python/pl2pl.c
/Users/vsc/github/yap-6.3/packages/python/pl2py.c
/Users/vsc/github/yap-6.3/packages/python/py2pl.c
/Users/vsc/github/yap-6.3/packages/python/pybips.c
/Users/vsc/github/yap-6.3/packages/python/pypreds.c
/Users/vsc/github/yap-6.3/packages/python/python.c
/Users/vsc/github/yap-6.3/packages/swig/yap.i
/Users/vsc/github/yap-6.3/packages/swig/python/yapex.py
/Users/vsc/github/yap-6.3/packages/swig/python/yap.egg-info/PKG-INFO
/Users/vsc/github/yap-6.3/packages/swig/python/yap.egg-info/SOURCES.txt
/Users/vsc/github/yap-6.3/packages/swig/python/yap.egg-info/dependency_links.txt
/Users/vsc/github/yap-6.3/packages/swig/python/yap.egg-info/top_level.txt

1
packages/swig/python/yap.egg-info/dependency_links.txt
View File

@ -1 +0,0 @@

2
packages/swig/python/yap.egg-info/top_level.txt
View File

@ -1,2 +0,0 @@
yap
yapex

53
packages/python/yapi.py → packages/swig/python/yapi.py
View File

@ -1,8 +1,22 @@
import yap import yap
import os.path
import sys import sys
# debugging support. # debugging support.
import pdb import pdb
from collections import namedtuple
yap_lib_path = os.path.dirname(__file__)
use_module = namedtuple( 'use_module', 'file')
bindvars = namedtuple( 'bindvars', 'list')
library = namedtuple( 'library', 'list')
v = namedtuple( '_', 'slot')
def numbervars( engine, l ):
return engine.fun(bindvars(l))
def query_prolog(engine, s): def query_prolog(engine, s):
@ -14,38 +28,39 @@ def query_prolog(engine, s):
return False return False
# #
#construct a query from a one-line string # construct a query from a one-line string
# q is opaque to Python # q is opaque to Python
q = engine.query(s) q = engine.query(s)
# vs is the list of variables # vs is the list of variables
# you can print it out, the left-side is the variable name, # you can print it out, the left-side is the variable name,
# the right side wraps a handle to a variable # the right side wraps a handle to a variable
# pdb.set_trace()
vs = q.namedVars() vs = q.namedVars()
#pdb.set_trace()
# atom match either symbols, or if no symbol exists, sttrings, In this case # atom match either symbols, or if no symbol exists, sttrings, In this case
# variable names should match strings # variable names should match strings
for eq in vs: #for eq in vs:
if not isinstance(eq[0],str): # if not isinstance(eq[0],str):
print( "Error: Variable Name matches a Python Symbol") # print( "Error: Variable Name matches a Python Symbol")
return # return
ask = True ask = True
# launch the query # launch the query
while answer(q): while answer(q):
# this new vs should contain bindings to vars # this new vs should contain bindings to vars
vs= q.namedVars() vs= q.namedVars()
#numbervars print( vs )
gs = numbervars( engine, vs)
print(gs)
i=0 i=0
# iteratw # iterate
for eq in vs: for eq in gs:
name = eq[0] name = eq[0]
binding = eq[1]
# this is tricky, we're going to bind the variables in the term so thay we can # this is tricky, we're going to bind the variables in the term so thay we can
# output X=Y. The Python way is to use dictionares. # output X=Y. The Python way is to use dictionares.
#Instead, we use the T function to tranform the Python term back to Prolog #Instead, we use the T function to tranform the Python term back to Prolog
binding = yap.T(eq[1]) if name != binding:
if binding.isVar(): print(name + " = " + str(binding))
binding.unify(name)
else:
i = binding.numberVars(i, True)
print(name + " = " + binding.text())
#ok, that was Prolog code #ok, that was Prolog code
print("yes") print("yes")
# deterministic = one solution # deterministic = one solution
@ -73,9 +88,13 @@ def query_prolog(engine, s):
def live(): def live():
engine = yap.YAPEngine() args = yap.YAPEngineArgs()
args.setYapLibDir(yap_lib_path)
args.setYapShareDir(yap_lib_path)
#args.setYapPrologBootFile(os.path.join(yap_lib_path."startup.yss"))
engine = yap.YAPEngine( args )
engine.goal( use_module( library('yapi') ) )
loop = True loop = True
pdb.set_trace()
while loop: while loop:
try: try:
s = input("?- ") s = input("?- ")
@ -98,4 +117,4 @@ def live():
# initialize engine # initialize engine
# engine = yap.YAPEngine(); # engine = yap.YAPEngine();
# engine = yap.YAPEngine(yap.YAPParams()); # engine = yap.YAPEngine(yap.YAPParams());
#live() live()

17
packages/swig/yap.i
View File

@ -29,7 +29,7 @@ class YAPEngine;
extern "C" { extern "C" {
extern X_API YAP_Term pythonToYAP(PyObject *pVal); extern X_API YAP_Term pythonToYAP(PyObject *pVal);
extern X_API PyObject * yap_to_python(YAP_Term t, bool eval); extern X_API PyObject * yap_to_python(YAP_Term t, bool eval, PyObject *ctx);
X_API extern bool init_python(void); X_API extern bool init_python(void);
extern X_API PyObject *py_Main; extern X_API PyObject *py_Main;
extern X_API PyObject *py_Builtin; extern X_API PyObject *py_Builtin;
@ -84,13 +84,14 @@ class YAPEngine;
$1 = true; $1 = true;
} }
%typemap(in) Term { $1 = pythonToYAP($input); } %typemap(in) Term { $1 = pythonToYAP($input); PyErr_Clear(); }
%typemap(in) YAPTerm { $1 = pythonToYAP($input); PyErr_Clear(); }
%typemap(out) YAP_Term { return $result = yap_to_python($1, false);} %typemap(out) YAP_Term { return $result = yap_to_python($1, false, 0); }
%typemap(out) Term { return $result = yap_to_python($1, false);}
%typemap(out) Term { return $result = yap_to_python($1, false, 0); }
%extend(out) Term{Term & __getitem__(size_t i){Term t0 = $self; %extend(out) Term{Term & __getitem__(size_t i){Term t0 = $self;
@ -103,6 +104,7 @@ class YAPEngine;
return HeadOfTerm(t0); return HeadOfTerm(t0);
else if (i == 1) else if (i == 1)
return TailOfTerm(t0); return TailOfTerm(t0);
else throw( DOMAIN_ERROR_OUT_OF_RANGE, MkIntegerTerm(i), "__getitem__");
} }
} }
} }
@ -126,7 +128,9 @@ class YAPEngine;
case DOMAIN_ERROR: { case DOMAIN_ERROR: {
switch (en) { switch (en) {
case DOMAIN_ERROR_OUT_OF_RANGE: case DOMAIN_ERROR_OUT_OF_RANGE:
case DOMAIN_ERROR_NOT_LESS_THAN_ZERO: pyerr = PyExc_GeneratorExit;
break;
case DOMAIN_ERROR_NOT_LESS_THAN_ZERO:
pyerr = PyExc_IndexError; pyerr = PyExc_IndexError;
break; break;
case DOMAIN_ERROR_CLOSE_OPTION: case DOMAIN_ERROR_CLOSE_OPTION:
@ -369,3 +373,4 @@ class YAPEngine;
%init %{ %init %{
%} %}