python

CXX/yapi.cpp

@@ -603,14 +603,19 @@ Term YAPEngine::fun(Term t)
     // don't forget, on success these guys may create slots
     __android_log_print(ANDROID_LOG_INFO, "YAPDroid", "exec  ");
 
-    if (YAP_EnterGoal(ap, nullptr, &q) == 0)
+    if (YAP_EnterGoal(ap, nullptr, &q) == 0) {
+#if DEBUG
+      fprintf(stderr,"function call failed:\n");
+#endif
       return 0;
-    XREGS[arity] = Yap_GetFromSlot(o);
+    }
+    DBTerm *pt = Yap_StoreTermInDB(Yap_GetFromSlot(o), arity);
     __android_log_print(ANDROID_LOG_INFO, "YAPDroid", "out  %ld", o);
     YAP_LeaveGoal(false, &q);
     Yap_CloseHandles(q.CurSlot);
+    Term rc = Yap_PopTermFromDB(pt);
     RECOVER_MACHINE_REGS();
-    return XREGS[arity];
+    return rc;
   }
   catch (YAPError e)
   {

CXX/yapq.hh

@@ -439,8 +439,9 @@ private:
   //> 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) { return YAPTerm(fun(t.term())); };
+  YAPTerm funCall(YAPTerm t) { return YAPTerm(fun(t.term())); };
   Term fun(Term t);
+  Term fun(YAPTerm t) { return fun(t.term()); };
   //> set a StringFlag, usually a path
   //>
   bool setStringFlag(std::string arg, std::string path)

H/YapHandles.h

@@ -216,7 +216,9 @@ INLINE_ONLY inline EXTERN yhandle_t Yap_InitHandle__(Term t USES_REGS) {
   yhandle_t old_slots = LOCAL_CurHandle;
 
   ensure_slots(1 PASS_REGS);
-  if (IsVarTerm(t) && (H0 > (CELL*)t || (CELL*)t > HR)) {
+  if (t==0) {
+    t = MkVarTerm();
+  } else if (IsVarTerm(t) && (H0 > (CELL*)t || (CELL*)t > HR)) {
     RESET_VARIABLE(HR); 
     Yap_unify(t,(CELL)HR); t = (CELL)HR++;
   }

packages/python/pl2py.c

@@ -112,7 +112,10 @@ PyObject *term_to_python(term_t t, bool eval, PyObject *o) {
     } else
 #endif
     {
-      PyObject *pobj = PyUnicode_DecodeUTF8(s, strlen(s), NULL);
+      //      char *p = malloc(strlen(s)+1);
+      //strcpy(p, s);
+      PyObject *pobj = PyUnicode_FromString(s);
+      Py_IncRef(pobj);
       return CHECKNULL(t, pobj);
     }
   } break;

packages/python/swig/yap4py/yapi.py

@@ -1,48 +1,98 @@
 
-import yap
 import os.path
 import sys
 # debugging support.
-import pdb
+# import pdb
 from collections import namedtuple
 
+from yap import *
+
+class Engine(  ):
+    def __init__(self, args=None):
+        
+    def run(self, g, m=None):
+        if m:
+            self.mgoal(g, m)
+        else:
+            self.goal(g)
+
+    def f(self, g):
+        self.E.fun(g)
+
+
+class EngineArgs( YAPEngineArgs ):
+    """ Interface to Engine Options class"""
+
+    
+class Predicate( YAPPredicate ):
+    """ Interface to Generic Predicate"""
+
+    
+class PrologPredicate( YAPPrologPredicate ):
+    """ Interface to Prolog  Predicate"""
+
+    
+    
+global engine, handler
+
 yap_lib_path = os.path.dirname(__file__)
 
-use_module = namedtuple( 'use_module', 'file')
+use_module = namedtuple('use_module', 'file')
-bindvars = namedtuple( 'bindvars', 'list')
+bindvars = namedtuple('bindvars', 'list')
-library = namedtuple( 'library', 'list')
+library = namedtuple('library', 'list')
-v = namedtuple( '_', 'slot')
+v = namedtuple( 'v', 'slot')
+yap_query = namedtuple( 'yap_query', 'query owner')
+jupyter_query = namedtuple( 'jupyter_query', 'vars dict')
+python_query = namedtuple( 'python_query', 'vars dict')
+yapi_query = namedtuple( 'yapi_query', 'vars dict')
+show_answer = namedtuple( 'show_answer', 'vars dict')
+set_prolog_flag = namedtuple('set_prolog_flag', 'flag new_value')
 
+def v():
+    return yap.YAPVarTerm()
 
-def numbervars(  engine, l ):
+def numbervars(  q ):
-    rc = engine.fun(bindvars(l))
+    Dict = {}
+    if True:
+        engine.goal(show_answer( q.namedVars(), Dict))
+        return Dict
+    rc = q.namedVarsVector()
+    q.r = q.goal().numbervars()
+    print( rc )
     o = []
     for i  in rc:
-        if i[0] == "=":
+        if len(i) == 2:
-            o = o + [i[1]]
+            do = str(i[0]) + " = " + str( i[1] ) + "\n"
-        else:   
+            o += do
-            o = o +[i]
+            print(do)
+        else:
+            do = str(i[0]) + " = " + str( i[1] ) + "\n"
+            o += do
+            print(do)
     return o
 
+def answer(q):
+    try:
+        v = q.next()
+        if v:
+            print( bindings )
+        return v
+    except Exception as e:
+        print(e.args[1])
+        return False
+
 def query_prolog(engine, s):
-
+    import pdb; pdb.set_trace()
-    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)
+    bindings = {}
+    q = engine.query(python_query(s, bindings))
     # 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
     # pdb.set_trace()
-    vs = q.namedVars()
+    #     #pdb.set_trace()
-    #pdb.set_trace()
     # atom match either symbols, or if no symbol exists, sttrings, In this case
     # variable names should match strings
     #for eq in vs:
@@ -52,28 +102,11 @@ def query_prolog(engine, s):
     ask = True
     # launch the query
     while answer(q):
-        # this new vs should contain bindings to vars
-        vs=  q.namedVars()
-        if vs != []:
-            gs = numbervars( engine, vs)
-            i=0
-            # iterate
-            for eq in gs:
-                name = eq[0]
-                binding = eq[1]
-                # 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
-                if name != binding:
-                    print(name + " = " + str(binding))
-                    #ok, that was Prolog code
-        else:
-            print("yes")
         # deterministic = one solution
         if q.deterministic():
             # done
             q.close()
-            return
+            return True, True
         if ask:
             s = input("more(;),  all(*), no(\\n), python(#) ?").lstrip()
             if s.startswith(';') or s.startswith('y'):
@@ -92,15 +125,7 @@ def query_prolog(engine, s):
     q.close()
     return
 
-
+def live(**kwargs):
-def live():
-    yap_lib_path = os.path.dirname(__file__)
-    args = yap.YAPEngineArgs()
-    args.setYapShareDir(os.path.join(yap_lib_path,"prolog"))
-    args.setYapLibDir(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
     while loop:
         try:
@@ -121,6 +146,18 @@ def live():
             print("Unexpected error:", sys.exc_info()[0])
             raise
     engine.close()
+
+def boot_yap(**kwargs):
+    args = EngineArgs()
+    yap_lib_path = os.path.dirname(__file__)
+    args.setYapShareDir(os.path.join(yap_lib_path,"prolog"))
+    args.setYapLibDir(yap_lib_path)
+    args.setSavedState(os.path.join(yap_lib_path,"startup.yss"))
+    engine = YAPEngine(args)
+    engine.goal( set_prolog_flag('verbose', 'silent' ) )
+    engine.goal( use_module(library('yapi') ) )
+    retun engine
+    
 #
 # initialize engine
 # engine = yap.YAPEngine();
@@ -129,4 +166,6 @@ def live():
 #
 
 if __name__ == "__main__":
-     live()
+    engine = boot_yap()
+    handler = numbervars
+    live()

packages/python/swig/yapi.yap

@@ -1,4 +1,4 @@
-%% @file yapi.yap
+drye%% @file yapi.yap
 %% @brief support yap shell
 %%
 :- module(yapi, [python_query/2,
@@ -75,7 +75,7 @@ bind_qv(V=V0, V1 = V01, Vs, Vs, Vs1-RB, Vs1-RB) :-
 	!,
 	'$VAR'(V) = V0,
 	V1 = V01.
-%	atom_string(V1, V01). 
+%	atom_string(V1, V01).
 bind_qv(V='$VAR'(Vi), V1=S1, Vs, [V='$VAR'(Vi)|Vs], D0-RB, D-RB) :- !,
 	add2dict(D0, V1:S1, D).
 bind_qv(V=S, V1=S1, Vs, [V=S|Vs], D0-RB0, D-RB0) :-
@@ -113,6 +113,3 @@ output([V=B], S) :-
 output([V=B|_Ns], S) :-
 	format( S, '~a = ~q.~n', [V, B]),
 	fail.
-
-
-